refactor: enhance widget update handling and improve error resilience

kelsos · kelsos · commit ecb3917861b9 · 2025-06-21T14:04:02.000+02:00
diff --git a/app/src/main/java/com/kelsos/mbrc/common/state/AppStateManager.kt b/app/src/main/java/com/kelsos/mbrc/common/state/AppStateManager.kt
@@ -27,6 +27,7 @@ class AppStateManager(
   init {
     launch {
       val track = trackCache.restoreInfo()
+      Timber.v("Restoring playing last played track: $track")
       appState.updatePlayingTrack(track)
     }
   }
diff --git a/app/src/main/java/com/kelsos/mbrc/common/state/PlayingTrackCache.kt b/app/src/main/java/com/kelsos/mbrc/common/state/PlayingTrackCache.kt
@@ -28,10 +28,6 @@ interface PlayingTrackCache {
   suspend fun persistInfo(playingTrack: PlayingTrack)
 
   suspend fun restoreInfo(): PlayingTrack
-
-  suspend fun persistCover(cover: String)
-
-  suspend fun restoreCover(): String
 }
 
 class PlayingTrackCacheImpl(
@@ -67,6 +63,11 @@ class PlayingTrackCacheImpl(
           .toBuilder()
           .setTrack(track)
           .build()
+
+        store
+          .toBuilder()
+          .setCover(playingTrack.coverUrl)
+          .build()
       }
       return@withContext
     }
@@ -75,23 +76,17 @@ class PlayingTrackCacheImpl(
   override suspend fun restoreInfo(): PlayingTrack =
     withContext(dispatchers.io) {
       val track = storeFlow.first().track
+      val cover = storeFlow.first().cover
 
       return@withContext PlayingTrack(
-        track.artist,
-        track.title,
-        track.album,
-        track.year,
-        track.path,
+        artist = track.artist,
+        title = track.title,
+        album = track.album,
+        year = track.year,
+        path = track.path,
+        coverUrl = cover,
       )
     }
-
-  override suspend fun persistCover(cover: String) {
-    context.cacheDataStore.updateData { store ->
-      store.toBuilder().setCover(cover).build()
-    }
-  }
-
-  override suspend fun restoreCover(): String = storeFlow.first().cover
 }
 
 object PlayerStateSerializer : Serializer<Store> {
diff --git a/app/src/main/java/com/kelsos/mbrc/features/widgets/BundleData.kt b/app/src/main/java/com/kelsos/mbrc/features/widgets/BundleData.kt
@@ -12,10 +12,6 @@ class BundleData(
 
   fun isInfo() = bundle.getBoolean(WidgetUpdater.INFO, false)
 
-  fun isCover() = bundle.getBoolean(WidgetUpdater.COVER, false)
-
-  fun cover(): String = bundle.getString(WidgetUpdater.COVER_PATH, "")
-
   fun state(): String = bundle.getString(WidgetUpdater.PLAYER_STATE, PlayerState.UNDEFINED)
 
   fun playingTrack(): PlayingTrack =
@@ -29,7 +25,6 @@ class BundleData(
     when {
       this.isState() -> "State: ${this.state()}"
       this.isInfo() -> "Info: ${this.playingTrack()}"
-      this.isCover() -> "Cover: ${this.cover()}"
       else -> "Unknown"
     }
 }
diff --git a/app/src/main/java/com/kelsos/mbrc/features/widgets/RemoteViewsTarget.kt b/app/src/main/java/com/kelsos/mbrc/features/widgets/RemoteViewsTarget.kt
@@ -14,9 +14,10 @@ class RemoteViewsTarget(
   private val widget: RemoteViews,
   private val widgetIds: IntArray,
   @IdRes private val imageViewResId: Int,
+  private val onImageUpdated: (() -> Unit)? = null,
 ) : Target {
   override fun onStart(placeholder: Image?) {
-    setDrawable(placeholder, "start")
+    Timber.v("Image loading started for widgets ${widgetIds.joinToString(", ")}")
   }
 
   override fun onError(error: Image?) {
@@ -35,9 +36,11 @@ class RemoteViewsTarget(
       Timber.v("No image found for widget setting placeholder, reason: $reason")
       widget.setImageViewResource(imageViewResId, R.drawable.ic_image_no_cover)
     } else {
-      Timber.v("Updating image for widget, reason: $reason")
+      Timber.v("Updating image for widgets ${widgetIds.joinToString(", ")}, reason: $reason")
       widget.setImageViewBitmap(imageViewResId, image.toBitmap())
     }
+
+    onImageUpdated?.invoke()
     manager.updateAppWidget(widgetIds, widget)
   }
 }
diff --git a/app/src/main/java/com/kelsos/mbrc/features/widgets/WidgetBase.kt b/app/src/main/java/com/kelsos/mbrc/features/widgets/WidgetBase.kt
@@ -9,6 +9,7 @@ import android.content.Intent
 import android.os.Bundle
 import android.widget.RemoteViews
 import coil3.imageLoader
+import coil3.request.CachePolicy
 import coil3.request.ImageRequest
 import coil3.request.error
 import coil3.size.Precision
@@ -29,45 +30,63 @@ abstract class WidgetBase : AppWidgetProvider() {
     intent: Intent?,
   ) {
     super.onReceive(context, intent)
-    if (intent?.action == AppWidgetManager.ACTION_APPWIDGET_UPDATE) {
-      whenNotNull(context, intent.extras, this::updateWidget)
+    when (intent?.action) {
+      AppWidgetManager.ACTION_APPWIDGET_UPDATE -> {
+        whenNotNull(context, intent.extras, this::updateWidget)
+      }
+      else -> {
+        val extras = intent?.extras
+        if (context == null || extras == null) {
+          return
+        }
+
+        val data = BundleData(extras)
+        if (data.isInfo() || data.isState()) {
+          updateWidget(context, extras)
+        }
+      }
     }
   }
 
   private fun updateWidget(
     context: Context,
     extras: Bundle,
   ) {
-    val widgetManager = AppWidgetManager.getInstance(context)
-    val widgets = ComponentName(context.packageName, config.widgetClass.java.name)
-    val widgetsIds = widgetManager.getAppWidgetIds(widgets)
-    val data = BundleData(extras)
-
-    if (widgetsIds.isEmpty()) {
-      Timber.v("No $type widgets found for update")
-      return
-    }
-
-    Timber.v("Updating $type widgets ${widgetsIds.joinToString(", ")} with extras: $data")
+    try {
+      val widgetManager = AppWidgetManager.getInstance(context)
+      val widgets = ComponentName(context.packageName, config.widgetClass.java.name)
+      val widgetsIds = widgetManager.getAppWidgetIds(widgets)
+      val data = BundleData(extras)
+
+      if (widgetsIds.isEmpty()) {
+        Timber.v("No $type widgets found for update")
+        return
+      }
 
-    when {
-      data.isCover() -> {
-        updateCover(context, widgetManager, widgetsIds, data.cover())
+      Timber.v("Updating $type widgets ${widgetsIds.joinToString(", ")} with extras: $data")
+
+      when {
+        data.isInfo() -> {
+          val playingTrack = data.playingTrack()
+          updateInfoWithCover(
+            context,
+            widgetManager,
+            widgetsIds,
+            playingTrack,
+          )
+        }
+        data.isState() ->
+          updatePlayState(
+            context,
+            widgetManager,
+            widgetsIds,
+            data.state(),
+          )
       }
-      data.isInfo() ->
-        updateInfo(
-          context,
-          widgetManager,
-          widgetsIds,
-          data.playingTrack(),
-        )
-      data.isState() ->
-        updatePlayState(
-          context,
-          widgetManager,
-          widgetsIds,
-          data.state(),
-        )
+    } catch (e: SecurityException) {
+      Timber.e(e, "Security error updating $type widget - check permissions")
+    } catch (e: IllegalArgumentException) {
+      Timber.e(e, "Invalid arguments for $type widget update")
     }
   }
 
@@ -109,36 +128,66 @@ abstract class WidgetBase : AppWidgetProvider() {
     info: PlayingTrack,
   )
 
-  private fun updateInfo(
+  private fun updateInfoWithCover(
     context: Context,
     widgetManager: AppWidgetManager,
     widgetsIds: IntArray,
     info: PlayingTrack,
   ) {
-    val views = RemoteViews(context.packageName, config.layout)
-    setupTrackInfo(views, info)
-    widgetManager.updateAppWidget(widgetsIds, views)
+    Timber.d("updateInfoWithCover called for $type widget, coverUrl: '${info.coverUrl}'")
+
+    val widget = RemoteViews(context.packageName, config.layout)
+    setupTrackInfo(widget, info)
+    preserveActions(context, widget)
+
+    if (info.coverUrl.isNotBlank()) {
+      // Load image asynchronously, but the widget is already set up with track info
+      val target =
+        RemoteViewsTarget(
+          widgetManager,
+          widget,
+          widgetsIds,
+          config.imageId,
+          onImageUpdated = {
+            // Callback to preserve actions after the image loads
+            preserveActions(context, widget)
+          },
+        )
+
+      val request =
+        ImageRequest
+          .Builder(context)
+          .data(info.coverUrl)
+          .size(R.dimen.widget_small_height)
+          .scale(Scale.FILL)
+          .error(R.drawable.ic_image_no_cover)
+          .precision(Precision.INEXACT)
+          .memoryCachePolicy(CachePolicy.DISABLED)
+          .diskCachePolicy(CachePolicy.ENABLED)
+          .target(target)
+          .build()
+
+      context.imageLoader.enqueue(request)
+    } else {
+      // No cover URL, use placeholder and update immediately
+      widget.setImageViewResource(config.imageId, R.drawable.ic_image_no_cover)
+      widgetManager.updateAppWidget(widgetsIds, widget)
+    }
   }
 
-  private fun updateCover(
+  private fun preserveActions(
     context: Context,
-    widgetManager: AppWidgetManager,
-    widgetsIds: IntArray,
-    path: String,
+    views: RemoteViews,
   ) {
-    val widget = RemoteViews(context.packageName, config.layout)
-    val request =
-      ImageRequest
-        .Builder(context)
-        .data(path)
-        .size(R.dimen.widget_small_height)
-        .scale(Scale.FILL)
-        .error(R.drawable.ic_image_no_cover)
-        .precision(Precision.INEXACT)
-        .target(RemoteViewsTarget(widgetManager, widget, widgetsIds, config.imageId))
-        .build()
-
-    context.imageLoader.enqueue(request)
+    val intent = Intent(context, PlayerActivity::class.java)
+    val pendingIntent =
+      PendingIntent.getActivity(
+        context,
+        0,
+        intent,
+        PendingIntent.FLAG_IMMUTABLE,
+      )
+    setupActionIntents(views, pendingIntent, context)
   }
 
   private fun updatePlayState(
@@ -157,6 +206,9 @@ abstract class WidgetBase : AppWidgetProvider() {
         R.drawable.ic_baseline_play_arrow_24
       },
     )
+
+    preserveActions(context, widget)
+
     manager.updateAppWidget(widgetsIds, widget)
   }
 }
diff --git a/app/src/main/java/com/kelsos/mbrc/features/widgets/WidgetUpdater.kt b/app/src/main/java/com/kelsos/mbrc/features/widgets/WidgetUpdater.kt
@@ -5,17 +5,14 @@ import android.content.Context
 import android.content.Intent
 import com.kelsos.mbrc.common.state.PlayerState
 import com.kelsos.mbrc.common.state.PlayingTrack
+import timber.log.Timber
 
 interface WidgetUpdater {
   fun updatePlayingTrack(track: PlayingTrack)
 
   fun updatePlayState(state: PlayerState)
 
-  fun updateCover(path: String = "")
-
   companion object {
-    const val COVER = "com.kelsos.mbrc.features.widgets.COVER"
-    const val COVER_PATH = "com.kelsos.mbrc.features.widgets.COVER_PATH"
     const val STATE = "com.kelsos.mbrc.features.widgets.STATE"
     const val INFO = "com.kelsos.mbrc.features.widgets.INFO"
     const val TRACK_INFO = "com.kelsos.mbrc.features.widgets.TRACKINFO"
@@ -36,10 +33,6 @@ class WidgetUpdaterImpl(
     putExtra(WidgetUpdater.INFO, true)
       .putExtra(WidgetUpdater.TRACK_INFO, track)
 
-  private fun Intent.payload(path: String): Intent =
-    putExtra(WidgetUpdater.COVER, true)
-      .putExtra(WidgetUpdater.COVER_PATH, path)
-
   private fun Intent.statePayload(state: PlayerState): Intent =
     putExtra(WidgetUpdater.STATE, true)
       .putExtra(WidgetUpdater.PLAYER_STATE, state.state)
@@ -56,19 +49,19 @@ class WidgetUpdaterImpl(
     broadcast(smallIntent, normalIntent)
   }
 
-  override fun updateCover(path: String) {
-    val normalIntent = createIntent(WidgetNormal::class.java).payload(path)
-    val smallIntent = createIntent(WidgetSmall::class.java).payload(path)
-    broadcast(smallIntent, normalIntent)
-  }
-
   private fun broadcast(
     smallIntent: Intent,
     normalIntent: Intent,
   ) {
-    with(context) {
-      sendBroadcast(smallIntent)
-      sendBroadcast(normalIntent)
+    try {
+      with(context) {
+        sendBroadcast(smallIntent)
+        sendBroadcast(normalIntent)
+      }
+      Timber.v("Widget broadcasts sent successfully")
+    } catch (e: SecurityException) {
+      Timber.e(e, "Failed to send widget broadcasts")
+      throw e
     }
   }
 }
diff --git a/app/src/main/java/com/kelsos/mbrc/networking/protocol/ProtocolActions.kt b/app/src/main/java/com/kelsos/mbrc/networking/protocol/ProtocolActions.kt
@@ -213,7 +213,6 @@ class UpdateVolume(
 
 class UpdateCover(
   private val app: Application,
-  private val updater: WidgetUpdater,
   private val moshi: Moshi,
   private val api: ApiBase,
   private val dispatchers: AppCoroutineDispatchers,
@@ -259,7 +258,6 @@ class UpdateCover(
   ) {
     val newState = previousState.copy(coverUrl = coverUri)
     appState.updatePlayingTrack(newState)
-    updater.updateCover(coverUri)
   }
 
   private fun getBitmap(base64: String): Bitmap {

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ class AppStateManager(`
`27`	`27`	`init {`
`28`	`28`	`launch {`
`29`	`29`	`val track = trackCache.restoreInfo()`
	`30`	`+ Timber.v("Restoring playing last played track: $track")`
`30`	`31`	`appState.updatePlayingTrack(track)`
`31`	`32`	`}`
`32`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,10 @@ class RemoteViewsTarget(`
`14`	`14`	`private val widget: RemoteViews,`
`15`	`15`	`private val widgetIds: IntArray,`
`16`	`16`	`@IdRes private val imageViewResId: Int,`
	`17`	`+ private val onImageUpdated: (() -> Unit)? = null,`
`17`	`18`	`) : Target {`
`18`	`19`	`override fun onStart(placeholder: Image?) {`
`19`		`- setDrawable(placeholder, "start")`
	`20`	`+ Timber.v("Image loading started for widgets ${widgetIds.joinToString(", ")}")`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`override fun onError(error: Image?) {`
`@@ -35,9 +36,11 @@ class RemoteViewsTarget(`
`35`	`36`	`Timber.v("No image found for widget setting placeholder, reason: $reason")`
`36`	`37`	`widget.setImageViewResource(imageViewResId, R.drawable.ic_image_no_cover)`
`37`	`38`	`} else {`
`38`		`- Timber.v("Updating image for widget, reason: $reason")`
	`39`	`+ Timber.v("Updating image for widgets ${widgetIds.joinToString(", ")}, reason: $reason")`
`39`	`40`	`widget.setImageViewBitmap(imageViewResId, image.toBitmap())`
`40`	`41`	`}`
	`42`	`+`
	`43`	`+ onImageUpdated?.invoke()`
`41`	`44`	`manager.updateAppWidget(widgetIds, widget)`
`42`	`45`	`}`
`43`	`46`	`}`