Make sure the camera bitmap is not going above the memory limit (#6658)

Author: TimoPtr

app/src/main/kotlin/io/homeassistant/companion/android/widgets/camera/CameraWidget.kt

@@ -14,7 +14,6 @@ import coil3.imageLoader
 import coil3.request.CachePolicy
 import coil3.request.ImageRequest
 import coil3.request.allowHardware
-import coil3.size.Dimension
 import coil3.size.Precision
 import coil3.size.Size
 import coil3.toBitmap
@@ -32,6 +31,7 @@ import io.homeassistant.companion.android.widgets.ACTION_APPWIDGET_CREATED
 import io.homeassistant.companion.android.widgets.BaseWidgetProvider.Companion.UPDATE_WIDGETS
 import io.homeassistant.companion.android.widgets.EXTRA_WIDGET_ENTITY
 import javax.inject.Inject
+import kotlin.math.sqrt
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -82,8 +82,7 @@ class CameraWidget : AppWidgetProvider() {
             Timber.d("Skipping widget update since network connection is not active")
             return
         }
-        val views = getWidgetRemoteViews(context, appWidgetId)
-        views?.let { appWidgetManager.updateAppWidget(appWidgetId, it) }
+        appWidgetManager.updateAppWidget(appWidgetId, getWidgetRemoteViews(context, appWidgetId))
     }
 
     private suspend fun updateAllWidgets(context: Context) {
@@ -108,7 +107,7 @@ class CameraWidget : AppWidgetProvider() {
         }
     }
 
-    private suspend fun getWidgetRemoteViews(context: Context, appWidgetId: Int): RemoteViews? {
+    private suspend fun getWidgetRemoteViews(context: Context, appWidgetId: Int): RemoteViews {
         val updateCameraIntent = Intent(context, CameraWidget::class.java).apply {
             action = UPDATE_IMAGE
             putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
@@ -174,7 +173,7 @@ class CameraWidget : AppWidgetProvider() {
                                 .diskCachePolicy(CachePolicy.DISABLED)
                                 .memoryCachePolicy(CachePolicy.DISABLED)
                                 .networkCachePolicy(CachePolicy.READ_ONLY)
-                                .size(Size(getScreenWidth(), Dimension.Undefined))
+                                .size(getWidgetBitmapSize(AppWidgetManager.getInstance(context), appWidgetId))
                                 .precision(Precision.INEXACT)
                                 .build(),
                         ).image?.toBitmap()?.let {
@@ -270,7 +269,56 @@ class CameraWidget : AppWidgetProvider() {
         // Enter relevant functionality for when the last widget is disabled
     }
 
-    private fun getScreenWidth(): Int {
-        return Resources.getSystem().displayMetrics.widthPixels
+    /**
+     * Returns a [Size] based on the widget's allocated dimensions, capped to stay within the
+     * RemoteViews bitmap memory limit. Falls back to the full screen width and height when the
+     * widget manager does not report a size.
+     *
+     * The system computes the limit as `6 * screenWidth * screenHeight`
+     * (1.5× screen area × 4 bytes/pixel) in `AppWidgetServiceImpl.computeMaximumWidgetBitmapMemory`.
+     * https://cs.android.com/android/platform/superproject/+/8b289e3d7cf7fd9242870758a894c6e9b4c3e655:frameworks/base/services/appwidget/java/com/android/server/appwidget/AppWidgetServiceImpl.java;l=513
+     * There is no public API for this, so we replicate the formula and keep the camera bitmap
+     * under roughly 90% of that limit to leave headroom for other bitmap work in the same
+     * RemoteViews.
+     */
+    private fun getWidgetBitmapSize(appWidgetManager: AppWidgetManager, appWidgetId: Int): Size {
+        val res = Resources.getSystem()
+        val screenWidth = res.displayMetrics.widthPixels
+        val screenHeight = res.displayMetrics.heightPixels
+        // System limit = 1.5 × screen area × 4 bytes/pixel (ARGB_8888).
+        // Bytes-per-pixel cancels out when converting to pixels: 1.5 * w * h * 4 * 0.9 / 4 = 1.35 * w * h.
+        // The 0.9 factor keeps a 10% margin for RemoteViews overhead.
+        val maxPixels = (1.35 * screenWidth * screenHeight).toInt()
+
+        val options = appWidgetManager.getAppWidgetOptions(appWidgetId)
+        val widthDp = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, 0)
+        val heightDp = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, 0)
+
+        val widthPx: Int
+        val heightPx: Int
+        if (widthDp <= 0) {
+            widthPx = screenWidth
+            heightPx = screenHeight
+        } else {
+            val density = res.displayMetrics.density
+            widthPx = (widthDp * density).toInt()
+            heightPx = if (heightDp > 0) (heightDp * density).toInt() else 0
+        }
+
+        if (heightPx <= 0) {
+            // Height unknown, derive a max height from the pixel budget so the
+            // bitmap stays within limits even if the source image is unusually tall.
+            val cappedWidth = minOf(widthPx, maxPixels / maxOf(screenHeight, 1)).coerceAtLeast(1)
+            val maxHeight = (maxPixels / cappedWidth).coerceAtLeast(1)
+            return Size(cappedWidth, maxHeight)
+        }
+
+        // Scale down proportionally if the bitmap would exceed the safe pixel budget
+        return if (widthPx.toLong() * heightPx > maxPixels) {
+            val scale = sqrt(maxPixels.toDouble() / (widthPx.toLong() * heightPx)).toFloat()
+            Size((widthPx * scale).toInt().coerceAtLeast(1), (heightPx * scale).toInt().coerceAtLeast(1))
+        } else {
+            Size(widthPx.coerceAtLeast(1), heightPx.coerceAtLeast(1))
+        }
     }
 }