feat: server driven widgets

android/build.gradle

@@ -51,11 +51,20 @@ if (useManagedAndroidSdkVersions) {
   }
 }
 
+// Read version from package.json for BuildConfig
+def packageJsonFile = new File(project.projectDir.parentFile, "package.json")
+def packageJson = new groovy.json.JsonSlurper().parseText(packageJsonFile.text)
+def voltraVersion = packageJson.version
+
 android {
   namespace "voltra"
   defaultConfig {
     versionCode 1
     versionName "0.1.0"
+    buildConfigField "String", "VOLTRA_VERSION", "\"${voltraVersion}\""
+  }
+  buildFeatures {
+    buildConfig true
   }
   lintOptions {
     abortOnError false
@@ -84,6 +93,12 @@ dependencies {
   // Compose runtime (required for Glance)
   api "androidx.compose.runtime:runtime:1.6.8"
 
+  // WorkManager (for periodic server-driven widget updates)
+  api "androidx.work:work-runtime-ktx:2.9.1"
+
+  // DataStore (secure credential storage for widget server updates)
+  api "androidx.datastore:datastore-preferences:1.1.4"
+
   // JSON parsing
   implementation "com.google.code.gson:gson:2.10.1"
 

android/src/main/java/voltra/VoltraModule.kt

@@ -328,6 +328,44 @@ class VoltraModule : Module() {
                 imageManager.clearPreloadedImages(keys)
             }
 
+            // Widget Server Credentials APIs
+
+            AsyncFunction("setWidgetServerCredentials") { credentials: Map<String, Any?> ->
+                Log.d(TAG, "setWidgetServerCredentials called")
+
+                val context = appContext.reactContext!!
+                val token = credentials["token"] as? String
+                    ?: throw IllegalArgumentException("token is required in credentials")
+
+                @Suppress("UNCHECKED_CAST")
+                val headers = credentials["headers"] as? Map<String, String>
+
+                runBlocking {
+                    voltra.widget.VoltraWidgetCredentialStore.saveToken(context, token)
+                    if (headers != null && headers.isNotEmpty()) {
+                        voltra.widget.VoltraWidgetCredentialStore.saveHeaders(context, headers)
+                    }
+                }
+
+                Log.d(TAG, "Widget server credentials saved")
+            }
+
+            AsyncFunction("clearWidgetServerCredentials") {
+                Log.d(TAG, "clearWidgetServerCredentials called")
+
+                val context = appContext.reactContext!!
+                runBlocking {
+                    voltra.widget.VoltraWidgetCredentialStore.clearAll(context)
+                }
+
+                Log.d(TAG, "Widget server credentials cleared")
+
+                val widgetManager = voltra.widget.VoltraWidgetManager(context)
+                runBlocking {
+                    widgetManager.reloadAllWidgets()
+                }
+            }
+
             AsyncFunction("reloadLiveActivities") { activityNames: List<String>? ->
                 // On Android, we don't have "Live Activities" in the same sense as iOS,
                 // but we might want to refresh widgets or notifications.

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

@@ -0,0 +1,165 @@
+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 storing auth tokens and custom headers.
+ *
+ * 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.
+     * Called from the main app after user login.
+     */
+    suspend fun saveToken(context: Context, token: String): Boolean {
+        return try {
+            context.voltraCredentialsDataStore.edit { prefs ->
+                prefs[KEY_TOKEN] = token
+            }
+            Log.d(TAG, "Token saved")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to save token: ${e.message}", e)
+            false
+        }
+    }
+
+    /**
+     * Read the auth token.
+     * Called from the WorkManager Worker during background fetch.
+     */
+    suspend fun readToken(context: Context): String? {
+        return try {
+            context.voltraCredentialsDataStore.data
+                .map { prefs -> prefs[KEY_TOKEN] }
+                .firstOrNull()
+        } 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? {
+        return runBlocking { readToken(context) }
+    }
+
+    /**
+     * Save custom headers.
+     */
+    suspend fun saveHeaders(context: Context, headers: Map<String, String>): Boolean {
+        return 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
+                val headerKeys = mutableSetOf<String>()
+                headers.forEach { (key, value) ->
+                    prefs[stringPreferencesKey("$KEY_HEADERS_PREFIX$key")] = value
+                    headerKeys.add(key)
+                }
+                prefs[KEY_HEADER_KEYS] = headerKeys
+            }
+            Log.d(TAG, "Headers saved (${headers.size} headers)")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to save headers: ${e.message}", e)
+            false
+        }
+    }
+
+    /**
+     * Read custom headers.
+     * Called from the WorkManager Worker during background fetch.
+     */
+    suspend fun readHeaders(context: Context): Map<String, String> {
+        return try {
+            context.voltraCredentialsDataStore.data
+                .map { prefs ->
+                    val headerKeys = prefs[KEY_HEADER_KEYS] ?: emptySet()
+                    val headers = mutableMapOf<String, String>()
+                    headerKeys.forEach { key ->
+                        val value = prefs[stringPreferencesKey("$KEY_HEADERS_PREFIX$key")]
+                        if (value != null) {
+                            headers[key] = value
+                        }
+                    }
+                    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> {
+        return runBlocking { readHeaders(context) }
+    }
+
+    /**
+     * Delete the auth token.
+     */
+    suspend fun deleteToken(context: Context): Boolean {
+        return 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 {
+        return 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
+        }
+    }
+}

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

@@ -267,15 +267,20 @@ class VoltraWidgetManager(
     }
 
     /**
-     * Reload specific widgets or all widgets
+     * 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 {
-                        updateWidget(widgetId)
+                        reloadSingleWidget(widgetId)
                     } catch (e: Exception) {
                         Log.e(TAG, "Failed to reload widget $widgetId: ${e.message}")
                     }
@@ -286,6 +291,21 @@ class VoltraWidgetManager(
             }
         }
 
+    /**
+     * 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
      */
@@ -301,11 +321,15 @@ class VoltraWidgetManager(
                     .map { it.removePrefix(KEY_JSON_PREFIX) }
                     .toSet()
 
-            Log.d(TAG, "Found ${widgetIds.size} widgets with saved data: $widgetIds")
+            // 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 widgetIds) {
+            for (widgetId in allWidgetIds) {
                 try {
-                    updateWidget(widgetId)
+                    reloadSingleWidget(widgetId)
                 } catch (e: Exception) {
                     Log.e(TAG, "Failed to update widget $widgetId: ${e.message}")
                 }