voltra 1.4.1 → 2.0.0-rc.4

package/android/src/main/java/voltra/widget/VoltraRefreshActionCallback.kt

@@ -1,157 +0,0 @@
-package voltra.widget
-
-import android.appwidget.AppWidgetManager
-import android.content.ComponentName
-import android.content.Context
-import android.util.Log
-import android.widget.RemoteViews
-import androidx.glance.GlanceId
-import androidx.glance.action.ActionParameters
-import androidx.glance.appwidget.action.ActionCallback
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import voltra.BuildConfig
-import voltra.glance.RemoteViewsGenerator
-import voltra.parsing.VoltraPayloadParser
-import java.io.BufferedReader
-import java.io.InputStreamReader
-import java.net.HttpURLConnection
-import java.net.URL
-
-/**
- * Glance ActionCallback that fetches fresh widget content from the server,
- * then pushes updated RemoteViews (with refresh button) directly via AppWidgetManager.
- *
- * We bypass Glance's update()/session mechanism entirely because it doesn't reliably
- * trigger provideGlance() from ActionCallbacks. Instead we use GlanceRemoteViews.compose()
- * to generate RemoteViews that include both the widget content and the refresh button overlay,
- * then push them directly.
- */
-class VoltraRefreshActionCallback : ActionCallback {
-    companion object {
-        private const val TAG = "VoltraRefreshCallback"
-        val KEY_WIDGET_ID = ActionParameters.Key<String>("voltra_widget_id")
-    }
-
-    override suspend fun onAction(
-        context: Context,
-        glanceId: GlanceId,
-        parameters: ActionParameters,
-    ) {
-        val widgetId = parameters[KEY_WIDGET_ID]
-        if (widgetId == null) {
-            Log.e(TAG, "No widget ID in action parameters")
-            return
-        }
-
-        Log.d(TAG, "Refresh requested for widget '$widgetId'")
-
-        val serverUrl = VoltraWidgetUpdateScheduler.readServerUrl(context, widgetId)
-        if (serverUrl == null) {
-            Log.w(TAG, "No server URL registered for widget '$widgetId', skipping refresh")
-            return
-        }
-
-        val jsonString =
-            withContext(Dispatchers.IO) {
-                try {
-                    val url = VoltraWidgetUpdateRequest.buildUrl(serverUrl, widgetId, context)
-                    val connection = url.openConnection() as HttpURLConnection
-
-                    try {
-                        connection.requestMethod = "GET"
-                        connection.connectTimeout = 10000
-                        connection.readTimeout = 10000
-                        connection.setRequestProperty("Accept", "application/json")
-                        val androidVersion = android.os.Build.VERSION.RELEASE
-                        connection.setRequestProperty(
-                            "User-Agent",
-                            "VoltraWidget/${BuildConfig.VOLTRA_VERSION} (Android/$androidVersion)",
-                        )
-
-                        val token = VoltraWidgetCredentialStore.readToken(context)
-                        if (token != null) {
-                            connection.setRequestProperty("Authorization", "Bearer $token")
-                        }
-                        VoltraWidgetCredentialStore.readHeaders(context).forEach { (key, value) ->
-                            connection.setRequestProperty(key, value)
-                        }
-
-                        val responseCode = connection.responseCode
-                        if (responseCode !in 200..299) {
-                            Log.e(TAG, "Server returned HTTP $responseCode for widget '$widgetId'")
-                            return@withContext null
-                        }
-
-                        val reader = BufferedReader(InputStreamReader(connection.inputStream))
-                        val json = reader.readText()
-                        reader.close()
-
-                        if (json.isEmpty()) {
-                            Log.e(TAG, "Empty response from server for widget '$widgetId'")
-                            return@withContext null
-                        }
-
-                        Log.d(TAG, "Received ${json.length} bytes for widget '$widgetId'")
-                        json
-                    } finally {
-                        connection.disconnect()
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Refresh failed for widget '$widgetId': ${e.message}", e)
-                    null
-                }
-            } ?: return
-
-        val widgetManager = VoltraWidgetManager(context)
-        widgetManager.writeWidgetData(widgetId, jsonString, null)
-        Log.d(TAG, "Data stored for widget '$widgetId'")
-
-        val payload =
-            try {
-                VoltraPayloadParser.parse(jsonString)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to parse widget payload: ${e.message}", e)
-                return
-            }
-
-        if (payload.variants.isNullOrEmpty()) {
-            Log.w(TAG, "No variants in payload for widget '$widgetId'")
-            return
-        }
-
-        try {
-            val sizeMapping =
-                RemoteViewsGenerator.generateWidgetRemoteViewsWithRefresh(
-                    context,
-                    payload,
-                    widgetId,
-                )
-
-            if (sizeMapping.isEmpty()) {
-                Log.w(TAG, "No RemoteViews generated for widget '$widgetId'")
-                return
-            }
-
-            val receiverClassName =
-                "${context.packageName}.widget.VoltraWidget_${widgetId}Receiver"
-            val componentName = ComponentName(context.packageName, receiverClassName)
-            val appWidgetManager = AppWidgetManager.getInstance(context)
-            val appWidgetIds = appWidgetManager.getAppWidgetIds(componentName)
-
-            for (appWidgetId in appWidgetIds) {
-                try {
-                    val responsiveRemoteViews = RemoteViews(sizeMapping)
-                    appWidgetManager.updateAppWidget(appWidgetId, responsiveRemoteViews)
-                    Log.d(TAG, "Pushed RemoteViews to widget instance $appWidgetId")
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to update widget instance $appWidgetId: ${e.message}", e)
-                }
-            }
-
-            Log.d(TAG, "Refresh completed for widget '$widgetId' (${appWidgetIds.size} instances)")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to generate/push RemoteViews for widget '$widgetId': ${e.message}", e)
-        }
-    }
-}

package/android/src/main/java/voltra/widget/VoltraWidgetCredentialStore.kt

@@ -1,174 +0,0 @@
-package voltra.widget
-
-import android.content.Context
-import android.util.Log
-import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.core.Preferences
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.core.stringSetPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
-import kotlinx.coroutines.flow.firstOrNull
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.runBlocking
-
-/**
- * Secure credential storage for widget server-driven updates.
- * Uses Jetpack DataStore with Preferences for persistence, and Google Tink AEAD
- * for encrypting sensitive values (tokens and headers) at rest.
- *
- * Since Android widgets are part of the main app binary, they inherently share
- * this storage; no special grouping or sharing configuration is required.
- */
-
-private val Context.voltraCredentialsDataStore: DataStore<Preferences> by preferencesDataStore(
-    name = "voltra_widget_credentials",
-)
-
-object VoltraWidgetCredentialStore {
-    private const val TAG = "VoltraWidgetCredStore"
-
-    private val KEY_TOKEN = stringPreferencesKey("auth_token")
-    private val KEY_HEADER_KEYS = stringSetPreferencesKey("header_keys")
-    private const val KEY_HEADERS_PREFIX = "header_"
-
-    /**
-     * Save an auth token (encrypted via Tink AEAD).
-     * Called from the main app after user login.
-     */
-    suspend fun saveToken(
-        context: Context,
-        token: String,
-    ): Boolean =
-        try {
-            val encrypted =
-                VoltraCryptoManager.encrypt(context, token)
-                    ?: throw IllegalStateException("Failed to encrypt token")
-            context.voltraCredentialsDataStore.edit { prefs ->
-                prefs[KEY_TOKEN] = encrypted
-            }
-            Log.d(TAG, "Token saved (encrypted)")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to save token: ${e.message}", e)
-            false
-        }
-
-    /**
-     * Read the auth token (decrypted via Tink AEAD).
-     * Called from the WorkManager Worker during background fetch.
-     */
-    suspend fun readToken(context: Context): String? =
-        try {
-            val encrypted =
-                context.voltraCredentialsDataStore.data
-                    .map { prefs -> prefs[KEY_TOKEN] }
-                    .firstOrNull()
-            encrypted?.let { VoltraCryptoManager.decrypt(context, it) }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to read token: ${e.message}", e)
-            null
-        }
-
-    /**
-     * Read the auth token synchronously (blocking).
-     * Use only from contexts where a suspend function is not available.
-     */
-    fun readTokenBlocking(context: Context): String? = runBlocking { readToken(context) }
-
-    /**
-     * Save custom headers (values encrypted via Tink AEAD).
-     */
-    suspend fun saveHeaders(
-        context: Context,
-        headers: Map<String, String>,
-    ): Boolean =
-        try {
-            context.voltraCredentialsDataStore.edit { prefs ->
-                // Clear existing headers
-                val existingKeys = prefs[KEY_HEADER_KEYS] ?: emptySet()
-                existingKeys.forEach { key ->
-                    prefs.remove(stringPreferencesKey("$KEY_HEADERS_PREFIX$key"))
-                }
-
-                // Save new headers with encrypted values
-                val headerKeys = mutableSetOf<String>()
-                headers.forEach { (key, value) ->
-                    val encrypted =
-                        VoltraCryptoManager.encrypt(context, value)
-                            ?: throw IllegalStateException("Failed to encrypt header value for key: $key")
-                    prefs[stringPreferencesKey("$KEY_HEADERS_PREFIX$key")] = encrypted
-                    headerKeys.add(key)
-                }
-                prefs[KEY_HEADER_KEYS] = headerKeys
-            }
-            Log.d(TAG, "Headers saved (${headers.size} headers, encrypted)")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to save headers: ${e.message}", e)
-            false
-        }
-
-    /**
-     * Read custom headers (values decrypted via Tink AEAD).
-     * Called from the WorkManager Worker during background fetch.
-     */
-    suspend fun readHeaders(context: Context): Map<String, String> =
-        try {
-            context.voltraCredentialsDataStore.data
-                .map { prefs ->
-                    val headerKeys = prefs[KEY_HEADER_KEYS] ?: emptySet()
-                    val headers = mutableMapOf<String, String>()
-                    headerKeys.forEach { key ->
-                        val encrypted = prefs[stringPreferencesKey("$KEY_HEADERS_PREFIX$key")]
-                        if (encrypted != null) {
-                            val decrypted = VoltraCryptoManager.decrypt(context, encrypted)
-                            if (decrypted != null) {
-                                headers[key] = decrypted
-                            } else {
-                                Log.w(TAG, "Failed to decrypt header value for key: $key")
-                            }
-                        }
-                    }
-                    headers as Map<String, String>
-                }.firstOrNull() ?: emptyMap()
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to read headers: ${e.message}", e)
-            emptyMap()
-        }
-
-    /**
-     * Read custom headers synchronously (blocking).
-     * Use only from contexts where a suspend function is not available.
-     */
-    fun readHeadersBlocking(context: Context): Map<String, String> = runBlocking { readHeaders(context) }
-
-    /**
-     * Delete the auth token.
-     */
-    suspend fun deleteToken(context: Context): Boolean =
-        try {
-            context.voltraCredentialsDataStore.edit { prefs ->
-                prefs.remove(KEY_TOKEN)
-            }
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to delete token: ${e.message}", e)
-            false
-        }
-
-    /**
-     * Clear all stored credentials.
-     */
-    suspend fun clearAll(context: Context): Boolean =
-        try {
-            context.voltraCredentialsDataStore.edit { prefs ->
-                prefs.clear()
-            }
-            Log.d(TAG, "All credentials cleared")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to clear credentials: ${e.message}", e)
-            false
-        }
-}

package/android/src/main/java/voltra/widget/VoltraWidgetManager.kt

@@ -1,347 +0,0 @@
-package voltra.widget
-
-import android.appwidget.AppWidgetManager
-import android.content.ComponentName
-import android.content.Context
-import android.content.SharedPreferences
-import android.util.Log
-import android.widget.RemoteViews
-import androidx.glance.appwidget.ExperimentalGlanceRemoteViewsApi
-import androidx.glance.appwidget.GlanceAppWidgetManager
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import org.json.JSONObject
-import voltra.glance.RemoteViewsGenerator
-import voltra.parsing.VoltraPayloadParser
-import java.io.InputStream
-import java.nio.charset.Charset
-
-class VoltraWidgetManager(
-    private val context: Context,
-) {
-    companion object {
-        private const val TAG = "VoltraWidgetManager"
-        private const val PREFS_NAME = "voltra_widgets"
-        private const val KEY_JSON_PREFIX = "Voltra_Widget_JSON_"
-        private const val KEY_DEEP_LINK_PREFIX = "Voltra_Widget_DeepLinkURL_"
-        private const val ASSET_INITIAL_STATES = "voltra_initial_states.json"
-    }
-
-    private val prefs: SharedPreferences =
-        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-
-    /**
-     * Write widget data to SharedPreferences
-     * Uses commit() instead of apply() to ensure data is written before widget update
-     */
-    fun writeWidgetData(
-        widgetId: String,
-        jsonString: String,
-        deepLinkUrl: String?,
-    ) {
-        Log.d(TAG, "writeWidgetData: widgetId=$widgetId, deepLinkUrl=$deepLinkUrl")
-        Log.d(TAG, "JSON length: ${jsonString.length}, preview: ${jsonString.take(200)}")
-
-        val editor = prefs.edit()
-        editor.putString("$KEY_JSON_PREFIX$widgetId", jsonString)
-
-        if (deepLinkUrl != null && deepLinkUrl.isNotEmpty()) {
-            editor.putString("$KEY_DEEP_LINK_PREFIX$widgetId", deepLinkUrl)
-        } else {
-            editor.remove("$KEY_DEEP_LINK_PREFIX$widgetId")
-        }
-
-        // Use commit() for synchronous write - ensures data is available before widget update
-        val success = editor.commit()
-        Log.d(TAG, "Widget data written. Success: $success, length: ${jsonString.length}")
-    }
-
-    /**
-     * Read widget JSON from SharedPreferences.
-     * Falls back to pre-rendered initial state from assets if no dynamic data is found.
-     */
-    fun readWidgetJson(widgetId: String): String? {
-        val json = prefs.getString("$KEY_JSON_PREFIX$widgetId", null)
-        if (json != null) {
-            Log.d(TAG, "readWidgetJson: widgetId=$widgetId, found in SharedPreferences, length=${json.length}")
-            return json
-        }
-
-        // Fallback to pre-rendered state from assets
-        val preloadedJson = readPreloadedWidgetJson(widgetId)
-        if (preloadedJson != null) {
-            Log.d(TAG, "readWidgetJson: widgetId=$widgetId, found in assets, length=${preloadedJson.length}")
-            return preloadedJson
-        }
-
-        Log.d(TAG, "readWidgetJson: widgetId=$widgetId, not found anywhere")
-        return null
-    }
-
-    /**
-     * Read pre-rendered widget JSON from assets
-     */
-    private fun readPreloadedWidgetJson(widgetId: String): String? =
-        try {
-            val inputStream: InputStream = context.assets.open(ASSET_INITIAL_STATES)
-            val size: Int = inputStream.available()
-            val buffer = ByteArray(size)
-            inputStream.read(buffer)
-            inputStream.close()
-
-            val jsonString = String(buffer, Charset.forName("UTF-8"))
-            val jsonObject = JSONObject(jsonString)
-
-            if (jsonObject.has(widgetId)) {
-                jsonObject.get(widgetId).toString()
-            } else {
-                null
-            }
-        } catch (e: Exception) {
-            // Asset might not exist or be invalid, which is fine if no pre-rendering was configured
-            null
-        }
-
-    /**
-     * Read widget deep link URL from SharedPreferences
-     */
-    fun readDeepLinkUrl(widgetId: String): String? = prefs.getString("$KEY_DEEP_LINK_PREFIX$widgetId", null)
-
-    /**
-     * Clear widget data from SharedPreferences
-     */
-    fun clearWidgetData(widgetId: String) {
-        Log.d(TAG, "clearWidgetData: widgetId=$widgetId")
-
-        val editor = prefs.edit()
-        editor.remove("$KEY_JSON_PREFIX$widgetId")
-        editor.remove("$KEY_DEEP_LINK_PREFIX$widgetId")
-        editor.commit()
-    }
-
-    /**
-     * Clear all widget data from SharedPreferences
-     */
-    fun clearAllWidgetData() {
-        Log.d(TAG, "clearAllWidgetData")
-
-        val allKeys = prefs.all.keys
-        val widgetKeys =
-            allKeys.filter { key: String ->
-                key.startsWith(KEY_JSON_PREFIX) || key.startsWith(KEY_DEEP_LINK_PREFIX)
-            }
-
-        val editor = prefs.edit()
-        widgetKeys.forEach { key: String -> editor.remove(key) }
-        editor.commit()
-
-        Log.d(TAG, "Cleared ${widgetKeys.size} widget keys")
-    }
-
-    /**
-     * Update a widget directly using GlanceRemoteViews, bypassing Glance's session lock.
-     * This allows rapid widget updates without the 45-50 second cooldown.
-     * Uses RemoteViews with size mapping for responsive layouts (Android 12+ required).
-     */
-    @OptIn(ExperimentalGlanceRemoteViewsApi::class)
-    suspend fun updateWidgetDirect(widgetId: String) =
-        withContext(Dispatchers.IO) {
-            Log.d(TAG, "updateWidgetDirect: widgetId=$widgetId")
-
-            // 1. Read and parse the JSON payload
-            val jsonString = readWidgetJson(widgetId)
-            if (jsonString == null) {
-                Log.w(TAG, "No JSON data found for widgetId=$widgetId")
-                return@withContext
-            }
-
-            val payload =
-                try {
-                    VoltraPayloadParser.parse(jsonString)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to parse widget payload: ${e.message}", e)
-                    return@withContext
-                }
-
-            if (payload.variants.isNullOrEmpty()) {
-                Log.w(TAG, "No variants in payload for widgetId=$widgetId")
-                return@withContext
-            }
-
-            // 2. Get widget instances from AppWidgetManager
-            val receiverClassName = "${context.packageName}.widget.VoltraWidget_${widgetId}Receiver"
-            val componentName = ComponentName(context.packageName, receiverClassName)
-            val appWidgetManager = AppWidgetManager.getInstance(context)
-            val appWidgetIds = appWidgetManager.getAppWidgetIds(componentName)
-
-            Log.d(TAG, "Found ${appWidgetIds.size} app widget instances for $widgetId")
-
-            if (appWidgetIds.isEmpty()) {
-                Log.w(TAG, "No widget instances found on home screen for $widgetId")
-                return@withContext
-            }
-
-            // 3. Generate RemoteViews for all variants (with refresh button if enabled)
-            val refreshEnabled = VoltraWidgetUpdateScheduler.isRefreshEnabled(context, widgetId)
-            val sizeMapping =
-                if (refreshEnabled) {
-                    RemoteViewsGenerator.generateWidgetRemoteViewsWithRefresh(context, payload, widgetId)
-                } else {
-                    RemoteViewsGenerator.generateWidgetRemoteViews(context, payload)
-                }
-
-            if (sizeMapping.isEmpty()) {
-                Log.e(TAG, "Failed to generate any RemoteViews for widgetId=$widgetId")
-                return@withContext
-            }
-
-            // 4. Update each widget instance with responsive RemoteViews
-            for (appWidgetId in appWidgetIds) {
-                try {
-                    // Android 12+ (API 31): Use RemoteViews with size mapping for responsive layout
-                    // The system will automatically select the appropriate RemoteViews based on current size
-                    val responsiveRemoteViews = RemoteViews(sizeMapping)
-                    appWidgetManager.updateAppWidget(appWidgetId, responsiveRemoteViews)
-                    Log.d(TAG, "Updated widget $appWidgetId with responsive RemoteViews (${sizeMapping.size} sizes)")
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to update widget instance $appWidgetId: ${e.message}", e)
-                }
-            }
-
-            Log.d(TAG, "Direct widget update completed for $widgetId")
-        }
-
-    /**
-     * Update a specific widget using direct RemoteViews generation.
-     * This bypasses Glance's session management to avoid the 45-50 second lock.
-     *
-     * Falls back to Glance's native update if direct update fails.
-     */
-    suspend fun updateWidget(widgetId: String) =
-        withContext(Dispatchers.IO) {
-            Log.d(TAG, "updateWidget: widgetId=$widgetId")
-
-            try {
-                // Try direct update first (bypasses session lock)
-                updateWidgetDirect(widgetId)
-            } catch (e: Exception) {
-                Log.w(TAG, "Direct widget update failed, falling back to Glance update: ${e.message}")
-                // Fallback to Glance's native update mechanism
-                updateWidgetViaGlance(widgetId)
-            }
-        }
-
-    /**
-     * Update widget using Glance's native mechanism (has session lock).
-     * Kept as fallback for edge cases.
-     */
-    private suspend fun updateWidgetViaGlance(widgetId: String) {
-        Log.d(TAG, "updateWidgetViaGlance: widgetId=$widgetId")
-
-        // Build the receiver component name by convention (no reflection needed)
-        val receiverClassName = "${context.packageName}.widget.VoltraWidget_${widgetId}Receiver"
-        val componentName = ComponentName(context.packageName, receiverClassName)
-        Log.d(TAG, "Looking for receiver: $receiverClassName")
-
-        // Get widget IDs using standard Android AppWidgetManager
-        val appWidgetManager = AppWidgetManager.getInstance(context)
-        val appWidgetIds = appWidgetManager.getAppWidgetIds(componentName)
-
-        Log.d(TAG, "Found ${appWidgetIds.size} app widget instances for $widgetId: ${appWidgetIds.toList()}")
-
-        if (appWidgetIds.isNotEmpty()) {
-            // Create the widget instance with the specific widgetId
-            val widget = VoltraGlanceWidget(widgetId)
-
-            // Get the GlanceAppWidgetManager to convert IDs
-            val glanceManager = GlanceAppWidgetManager(context)
-
-            // Update each widget instance using Glance's update mechanism
-            for (appWidgetId in appWidgetIds) {
-                try {
-                    val glanceId = glanceManager.getGlanceIdBy(appWidgetId)
-                    Log.d(TAG, "Updating Glance widget instance: appWidgetId=$appWidgetId, glanceId=$glanceId")
-                    widget.update(context, glanceId)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to update widget instance $appWidgetId: ${e.message}", e)
-                }
-            }
-            Log.d(TAG, "Glance widget update completed for $widgetId")
-        } else {
-            Log.w(TAG, "No widget instances found on home screen for $widgetId")
-        }
-    }
-
-    /**
-     * Reload specific widgets or all widgets.
-     *
-     * For server-driven widgets (those with a registered server URL),
-     * this enqueues an immediate WorkManager fetch so the widget gets
-     * fresh content from the server. For local-only widgets it
-     * re-renders from the cached SharedPreferences data.
-     */
-    suspend fun reloadWidgets(widgetIds: List<String>?) =
-        withContext(Dispatchers.Main) {
-            if (widgetIds != null && widgetIds.isNotEmpty()) {
-                Log.d(TAG, "reloadWidgets: specific widgets ${widgetIds.joinToString()}")
-                for (widgetId in widgetIds) {
-                    try {
-                        reloadSingleWidget(widgetId)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Failed to reload widget $widgetId: ${e.message}")
-                    }
-                }
-            } else {
-                Log.d(TAG, "reloadWidgets: all widgets")
-                reloadAllWidgets()
-            }
-        }
-
-    /**
-     * Reload a single widget.
-     * If the widget is server-driven, enqueues an immediate server fetch.
-     * Otherwise, re-renders from cached data.
-     */
-    private suspend fun reloadSingleWidget(widgetId: String) {
-        val didEnqueue = VoltraWidgetUpdateScheduler.requestImmediateUpdate(context, widgetId)
-        if (didEnqueue) {
-            Log.d(TAG, "reloadSingleWidget: enqueued immediate server fetch for $widgetId")
-        } else {
-            Log.d(TAG, "reloadSingleWidget: no server URL for $widgetId, updating from cache")
-            updateWidget(widgetId)
-        }
-    }
-
-    /**
-     * Reload all widgets by finding all saved widget data
-     */
-    suspend fun reloadAllWidgets() =
-        withContext(Dispatchers.Main) {
-            Log.d(TAG, "reloadAllWidgets")
-
-            // Get all widget IDs from saved data
-            val allKeys = prefs.all.keys
-            val widgetIds =
-                allKeys
-                    .filter { it.startsWith(KEY_JSON_PREFIX) }
-                    .map { it.removePrefix(KEY_JSON_PREFIX) }
-                    .toSet()
-
-            // Also include server-driven widgets that may not have cached data yet
-            val serverDrivenIds = VoltraWidgetUpdateScheduler.getAllServerDrivenWidgetIds(context)
-            val allWidgetIds = widgetIds + serverDrivenIds
-
-            Log.d(
-                TAG,
-                "Found ${allWidgetIds.size} widgets to reload (${widgetIds.size} cached, ${serverDrivenIds.size} server-driven)",
-            )
-
-            for (widgetId in allWidgetIds) {
-                try {
-                    reloadSingleWidget(widgetId)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to update widget $widgetId: ${e.message}")
-                }
-            }
-        }
-}