Add rendering API fallback logic and improve PNG rendering robustness

kdroidFilter · kdroidFilter · commit cf577d0ab251 · 2025-09-15T20:00:12.000+03:00
- Introduced rendering API fallback mechanism for DirectX12, OpenGL, and Software rendering in `ComposableIconUtils`.
- Enhanced error handling during composable rendering to automatically retry with alternative APIs.
- Improved cleanup of resources to prevent memory leaks.
- Added logging for debug and error scenarios related to rendering.
- Enabled native tray logging in the demo application for better diagnostics.

Signed-off-by: Elie G. &lt;elyahou.hadass@gmail.com&gt;
diff --git a/demo/src/jvmMain/kotlin/com/kdroid/composetray/demo/TrayAppDemo.kt b/demo/src/jvmMain/kotlin/com/kdroid/composetray/demo/TrayAppDemo.kt
@@ -5,7 +5,6 @@ import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Book
 import androidx.compose.material.icons.filled.Window
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
@@ -18,9 +17,9 @@ import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
 import androidx.compose.ui.window.rememberWindowState
 import com.kdroid.composetray.tray.api.ExperimentalTrayAppApi
-import com.kdroid.composetray.tray.api.Tray
 import com.kdroid.composetray.tray.api.TrayApp
 import com.kdroid.composetray.utils.WindowRaise
+import com.kdroid.composetray.utils.allowComposeNativeTrayLogging
 import composenativetray.demo.generated.resources.Res
 import composenativetray.demo.generated.resources.icon
 import io.github.kdroidfilter.platformtools.darkmodedetector.isSystemInDarkMode
@@ -30,6 +29,7 @@ import org.jetbrains.compose.resources.painterResource
 
 @OptIn(ExperimentalTrayAppApi::class)
 fun main() {
+    allowComposeNativeTrayLogging = true
     setMacOsAdaptiveTitleBar()
     application {
         var isWindowVisible by remember { mutableStateOf(true) }
diff --git a/src/commonMain/kotlin/com/kdroid/composetray/utils/ComposableIconUtils.kt b/src/commonMain/kotlin/com/kdroid/composetray/utils/ComposableIconUtils.kt
@@ -2,14 +2,8 @@ package com.kdroid.composetray.utils
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.ImageComposeScene
-import androidx.compose.ui.use
 import kotlinx.coroutines.Dispatchers
-import org.jetbrains.skia.Bitmap
-import org.jetbrains.skia.EncodedImageFormat
-import org.jetbrains.skia.FilterMipmap
-import org.jetbrains.skia.FilterMode
-import org.jetbrains.skia.Image
-import org.jetbrains.skia.MipmapMode
+import org.jetbrains.skia.*
 import java.io.File
 import java.util.zip.CRC32
 
@@ -18,76 +12,222 @@ import java.util.zip.CRC32
  */
 object ComposableIconUtils {
 
+    private var currentRenderApi: RenderApi = RenderApi.AUTO
+
+    enum class RenderApi {
+        AUTO,
+        DIRECTX12,
+        OPENGL,
+        SOFTWARE
+    }
+
+    init {
+        // Start with automatic detection, will fallback if needed
+        configureRenderingApi(RenderApi.AUTO)
+    }
+
+    /**
+     * Configure Skiko rendering API with fallback mechanism
+     */
+    private fun configureRenderingApi(api: RenderApi) {
+        try {
+            when (api) {
+                RenderApi.AUTO -> {
+                    // Let Skiko choose automatically (usually tries DirectX12 first on Windows)
+                    System.clearProperty("skiko.renderApi")
+                    debugln { "[ComposableIconUtils] Using automatic rendering API selection" }
+                }
+                RenderApi.DIRECTX12 -> {
+                    System.setProperty("skiko.renderApi", "DIRECT3D")
+                    debugln { "[ComposableIconUtils] Configured DirectX12 rendering" }
+                }
+                RenderApi.OPENGL -> {
+                    System.setProperty("skiko.renderApi", "OPENGL")
+                    System.setProperty("skiko.rendering.api", "OPENGL")
+                    debugln { "[ComposableIconUtils] Configured OpenGL rendering" }
+                }
+                RenderApi.SOFTWARE -> {
+                    System.setProperty("skiko.renderApi", "SOFTWARE")
+                    System.setProperty("skiko.softwareRendering", "true")
+                    System.setProperty("skiko.rendering.api", "SOFTWARE")
+                    System.setProperty("skiko.rendering.useGpu", "false")
+                    System.setProperty("skiko.directx.disabled", "true")
+                    debugln { "[ComposableIconUtils] Configured software rendering" }
+                }
+            }
+            currentRenderApi = api
+        } catch (e: Exception) {
+            errorln { "[ComposableIconUtils] Failed to configure rendering API: ${e.message}" }
+        }
+    }
+
+    /**
+     * Try the next rendering API in the fallback chain
+     */
+    private fun tryNextRenderApi(): Boolean {
+        return when (currentRenderApi) {
+            RenderApi.AUTO, RenderApi.DIRECTX12 -> {
+                debugln { "[ComposableIconUtils] Falling back from $currentRenderApi to OpenGL" }
+                configureRenderingApi(RenderApi.OPENGL)
+                true
+            }
+            RenderApi.OPENGL -> {
+                debugln { "[ComposableIconUtils] Falling back from OpenGL to Software rendering" }
+                configureRenderingApi(RenderApi.SOFTWARE)
+                true
+            }
+            RenderApi.SOFTWARE -> {
+                errorln { "[ComposableIconUtils] Already using software rendering, no more fallbacks available" }
+                false
+            }
+        }
+    }
+
     /**
      * Renders a Composable to a PNG file and returns the path to the file.
      *
      * @param iconRenderProperties Properties for rendering the icon
      * @param content The Composable content to render
      * @return Path to the generated PNG file
+     * @throws Exception if rendering fails after all fallback attempts
      */
     fun renderComposableToPngFile(
         iconRenderProperties: IconRenderProperties,
         content: @Composable () -> Unit
     ): String {
         val tempFile = createTempFile(suffix = ".png")
-        val pngData = renderComposableToPngBytes(iconRenderProperties, content)
+        val pngData = renderComposableToPngBytesWithFallback(iconRenderProperties, content)
         tempFile.writeBytes(pngData)
         return tempFile.absolutePath
     }
 
+    /**
+     * Renders a Composable to PNG bytes with automatic fallback between rendering APIs
+     */
+    private fun renderComposableToPngBytesWithFallback(
+        iconRenderProperties: IconRenderProperties,
+        content: @Composable () -> Unit
+    ): ByteArray {
+        var attempts = 0
+        val maxAttempts = 3 // Try DirectX/Auto, then OpenGL, then Software
+        var lastException: Exception? = null
+
+        while (attempts < maxAttempts) {
+            try {
+                debugln { "[ComposableIconUtils] Render attempt ${attempts + 1} with $currentRenderApi" }
+                return renderComposableToPngBytes(iconRenderProperties, content)
+            } catch (e: Exception) {
+                lastException = e
+                val errorMessage = e.message ?: ""
+                val errorClassName = e.javaClass.simpleName
+
+                errorln { "[ComposableIconUtils] $errorClassName with ${currentRenderApi}: $errorMessage" }
+
+                // Check if the error is related to DirectX, OpenGL, or rendering in general
+                val isDirectXError = errorMessage.contains("DirectX12", ignoreCase = true) ||
+                        errorMessage.contains("D3D12", ignoreCase = true) ||
+                        errorMessage.contains("Direct3D", ignoreCase = true) ||
+                        errorMessage.contains("choose DirectX12 adapter", ignoreCase = true) ||
+                        errorClassName.contains("RenderException", ignoreCase = true)
+
+                val isOpenGLError = errorMessage.contains("OpenGL", ignoreCase = true) ||
+                        errorMessage.contains("GL", ignoreCase = true)
+
+                val isRenderingError = errorClassName.contains("Render", ignoreCase = true) ||
+                        errorMessage.contains("render", ignoreCase = true)
+
+                // If it's a rendering-related error, try the next API
+                if (isDirectXError || isOpenGLError || isRenderingError) {
+                    if (tryNextRenderApi()) {
+                        attempts++
+                        continue // Try again with the next API
+                    }
+                }
+
+                // If we can't identify the error or no more fallbacks, throw the exception
+                break
+            }
+        }
+
+        // If all attempts failed, throw the last exception
+        throw lastException ?: Exception("Failed to render composable after $attempts attempts")
+    }
+
     /**
      * Renders a Composable to a PNG image and returns the result as a byte array.
      *
-     * This function creates an [ImageComposeScene] based on the provided [IconRenderProperties],
-     * renders the Composable content, and encodes the output into PNG format.
-     * If scaling is required based on the [IconRenderProperties], the rendered content is scaled before encoding.
-     *
      * @param iconRenderProperties Properties for rendering the icon
      * @param content The Composable content to render
      * @return A byte array containing the rendered PNG image data.
+     * @throws Exception if rendering fails
      */
+    @Throws(Exception::class)
     fun renderComposableToPngBytes(
         iconRenderProperties: IconRenderProperties,
         content: @Composable () -> Unit
     ): ByteArray {
-        val scene = ImageComposeScene(
-            width = iconRenderProperties.sceneWidth,
-            height = iconRenderProperties.sceneHeight,
-            density = iconRenderProperties.sceneDensity,
-            coroutineContext = Dispatchers.Unconfined
-        ) {
-            content()
-        }
-
-        val renderedIcon = scene.use { it.render() }
+        var scene: ImageComposeScene? = null
+        var renderedIcon: Image? = null
+        var scaledBitmap: Bitmap? = null
+        var scaledImage: Image? = null
 
-        val iconData = if (iconRenderProperties.requiresScaling) {
-            val scaledIcon = Bitmap().apply {
-                allocN32Pixels(iconRenderProperties.targetWidth, iconRenderProperties.targetHeight)
-            }
-            renderedIcon.use {
-                it.scalePixels(scaledIcon.peekPixels()!!, FilterMipmap(FilterMode.LINEAR, MipmapMode.LINEAR), true)
+        try {
+            // Create the scene - this is where DirectX/OpenGL errors typically occur
+            scene = ImageComposeScene(
+                width = iconRenderProperties.sceneWidth,
+                height = iconRenderProperties.sceneHeight,
+                density = iconRenderProperties.sceneDensity,
+                coroutineContext = Dispatchers.Unconfined
+            ) {
+                content()
             }
-            scaledIcon.use { bitmap ->
-                Image.makeFromBitmap(bitmap).use { image ->
-                    image.encodeToData(EncodedImageFormat.PNG)!!
+
+            // Render the scene - this may also trigger rendering API errors
+            renderedIcon = scene.render()
+
+            val iconData = if (iconRenderProperties.requiresScaling) {
+                scaledBitmap = Bitmap().apply {
+                    allocN32Pixels(iconRenderProperties.targetWidth, iconRenderProperties.targetHeight)
                 }
+
+                renderedIcon.scalePixels(
+                    scaledBitmap.peekPixels()!!,
+                    FilterMipmap(FilterMode.LINEAR, MipmapMode.LINEAR),
+                    true
+                )
+
+                scaledImage = Image.makeFromBitmap(scaledBitmap)
+                scaledImage.encodeToData(EncodedImageFormat.PNG)
+                    ?: throw Exception("Failed to encode scaled image to PNG")
+            } else {
+                renderedIcon.encodeToData(EncodedImageFormat.PNG)
+                    ?: throw Exception("Failed to encode image to PNG")
             }
-        } else {
-            renderedIcon.use { image ->
-                image.encodeToData(EncodedImageFormat.PNG)!!
+
+            return iconData.bytes
+        } catch (e: Exception) {
+            // Re-throw to be handled by the fallback wrapper
+            throw e
+        } finally {
+            // Ensure proper cleanup
+            try {
+                scaledImage?.close()
+                scaledBitmap?.close()
+                renderedIcon?.close()
+                scene?.close()
+            } catch (e: Exception) {
+                debugln { "[ComposableIconUtils] Error during cleanup: ${e.message}" }
             }
         }
-
-        return iconData.bytes
     }
 
     /**
      * Renders a Composable to an ICO file and returns the path to the file.
      *
      * @param iconRenderProperties Properties for rendering the icon
      * @param content The Composable content to render
-     * @return Path to the generated PNG file
+     * @return Path to the generated ICO file
+     * @throws Exception if rendering fails after all fallback attempts
      */
     fun renderComposableToIcoFile(
         iconRenderProperties: IconRenderProperties,
@@ -107,13 +247,14 @@ object ComposableIconUtils {
      * @param iconRenderProperties Properties for rendering the icon
      * @param content The Composable content to render
      * @return Byte array containing the ICO data
+     * @throws Exception if rendering fails after all fallback attempts
      */
     fun renderComposableToIcoBytes(
         iconRenderProperties: IconRenderProperties,
         content: @Composable () -> Unit
     ): ByteArray {
-        // First render to PNG format (which is supported)
-        val pngBytes = renderComposableToPngBytes(iconRenderProperties, content)
+        // First render to PNG format (with fallback support)
+        val pngBytes = renderComposableToPngBytesWithFallback(iconRenderProperties, content)
 
         // Create a simple ICO format wrapper around the PNG data
         // ICO header (6 bytes) + ICO directory entry (16 bytes) + PNG data
@@ -159,6 +300,20 @@ object ComposableIconUtils {
         return icoData
     }
 
+    /**
+     * Resets the rendering API to try again from the beginning of the fallback chain.
+     * Useful when creating new instances or after configuration changes.
+     */
+    fun resetRenderingApi() {
+        debugln { "[ComposableIconUtils] Resetting rendering API to AUTO" }
+        configureRenderingApi(RenderApi.AUTO)
+    }
+
+    /**
+     * Gets the current rendering API being used
+     */
+    fun getCurrentRenderApi(): String = currentRenderApi.name
+
     /**
      * Creates a temporary file that will be deleted when the JVM exits.
      */
@@ -181,12 +336,18 @@ object ComposableIconUtils {
         iconRenderProperties: IconRenderProperties,
         content: @Composable () -> Unit
     ): Long {
-        // Render the composable to PNG bytes
-        val pngBytes = renderComposableToPngBytes(iconRenderProperties, content)
+        return try {
+            // Render the composable to PNG bytes (with fallback support)
+            val pngBytes = renderComposableToPngBytesWithFallback(iconRenderProperties, content)
 
-        // Calculate CRC32 hash of the PNG bytes
-        val crc = CRC32()
-        crc.update(pngBytes)
-        return crc.value
+            // Calculate CRC32 hash of the PNG bytes
+            val crc = CRC32()
+            crc.update(pngBytes)
+            crc.value
+        } catch (e: Exception) {
+            errorln { "[ComposableIconUtils] Failed to calculate content hash: ${e.message}" }
+            // Return a time-based hash as fallback
+            System.currentTimeMillis()
+        }
     }
-}
+}
