feat: system widgets foundation + price widget

CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Polish Terms of Use screen padding to match iOS #903
 
+### Added
+- Home screen widgets foundation with Glance, including price widget as the first implementation #895
+
 ## [2.2.0] - 2026-04-07
 
 ### Fixed

app/build.gradle.kts

@@ -286,6 +286,9 @@ dependencies {
     // WorkManager
     implementation(libs.hilt.work)
     implementation(libs.work.runtime.ktx)
+    // Glance - AppWidgets
+    implementation(libs.glance.appwidget)
+    implementation(libs.glance.material3)
     // Ktor - Networking
     implementation(libs.ktor.client.core)
     implementation(libs.ktor.client.okhttp)

app/src/main/AndroidManifest.xml

@@ -177,6 +177,33 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/provider_paths" />
         </provider>
+
+        <!-- AppWidget Config Activity -->
+        <activity
+            android:name=".appwidget.config.AppWidgetConfigActivity"
+            android:exported="true"
+            android:excludeFromRecents="true"
+            android:screenOrientation="portrait"
+            android:taskAffinity=""
+            android:theme="@style/Theme.App">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
+            </intent-filter>
+        </activity>
+
+        <!-- Price Widget -->
+        <receiver
+            android:name=".appwidget.ui.price.PriceGlanceReceiver"
+            android:exported="true"
+            android:label="@string/widgets__price__name">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/appwidget_info_price" />
+        </receiver>
+
     </application>
 
 </manifest>

app/src/main/java/to/bitkit/appwidget/AppWidgetDataRepository.kt

@@ -0,0 +1,21 @@
+package to.bitkit.appwidget
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import to.bitkit.data.dto.price.GraphPeriod
+import to.bitkit.data.dto.price.PriceDTO
+import to.bitkit.data.widgets.PriceService
+import to.bitkit.di.IoDispatcher
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AppWidgetDataRepository @Inject constructor(
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val priceService: PriceService,
+) {
+    suspend fun fetchPriceData(period: GraphPeriod = GraphPeriod.ONE_DAY): Result<PriceDTO> =
+        withContext(ioDispatcher) {
+            priceService.fetchData(period)
+        }
+}

app/src/main/java/to/bitkit/appwidget/AppWidgetPreferencesStore.kt

@@ -0,0 +1,82 @@
+package to.bitkit.appwidget
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.dataStore
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import to.bitkit.appwidget.model.AppWidgetData
+import to.bitkit.appwidget.model.AppWidgetEntry
+import to.bitkit.appwidget.model.AppWidgetType
+import to.bitkit.data.dto.price.GraphPeriod
+import to.bitkit.data.dto.price.PriceDTO
+import to.bitkit.data.serializers.AppWidgetDataSerializer
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private val Context.appWidgetDataStore: DataStore<AppWidgetData> by dataStore(
+    fileName = "appwidget_data.json",
+    serializer = AppWidgetDataSerializer,
+)
+
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface AppWidgetEntryPoint {
+    fun appWidgetPreferencesStore(): AppWidgetPreferencesStore
+}
+
+@Singleton
+class AppWidgetPreferencesStore @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    private val store = context.appWidgetDataStore
+
+    val data: Flow<AppWidgetData> = store.data
+
+    suspend fun registerWidget(appWidgetId: Int, type: AppWidgetType) {
+        store.updateData { data ->
+            if (data.entries.any { it.appWidgetId == appWidgetId }) return@updateData data
+            data.copy(entries = data.entries + AppWidgetEntry(appWidgetId = appWidgetId, type = type))
+        }
+    }
+
+    suspend fun unregisterWidget(appWidgetId: Int) {
+        store.updateData { data ->
+            data.copy(entries = data.entries.filter { it.appWidgetId != appWidgetId })
+        }
+    }
+
+    suspend fun getEntry(appWidgetId: Int): AppWidgetEntry? =
+        store.data.first().entries.find { it.appWidgetId == appWidgetId }
+
+    suspend fun updateEntry(appWidgetId: Int, transform: (AppWidgetEntry) -> AppWidgetEntry) {
+        store.updateData { data ->
+            data.copy(
+                entries = data.entries.map {
+                    if (it.appWidgetId == appWidgetId) transform(it) else it
+                },
+            )
+        }
+    }
+
+    suspend fun getActiveWidgetTypes(): Set<AppWidgetType> =
+        store.data.first().entries.map { it.type }.toSet()
+
+    suspend fun getActivePricePeriods(): Set<GraphPeriod> =
+        store.data.first().entries
+            .filter { it.type == AppWidgetType.PRICE }
+            .map { it.pricePreferences.period }
+            .toSet()
+
+    fun hasWidgetsOfType(type: AppWidgetType): Flow<Boolean> =
+        data.map { it.entries.any { entry -> entry.type == type } }
+
+    suspend fun cachePriceData(period: GraphPeriod, price: PriceDTO) {
+        store.updateData { it.copy(cachedPrices = it.cachedPrices + (period to price)) }
+    }
+}

app/src/main/java/to/bitkit/appwidget/AppWidgetRefreshWorker.kt

@@ -0,0 +1,92 @@
+package to.bitkit.appwidget
+
+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import androidx.glance.appwidget.GlanceAppWidgetReceiver
+import androidx.glance.appwidget.updateAll
+import androidx.hilt.work.HiltWorker
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import to.bitkit.appwidget.model.AppWidgetType
+import to.bitkit.appwidget.ui.price.PriceGlanceReceiver
+import to.bitkit.appwidget.ui.price.PriceGlanceWidget
+import to.bitkit.utils.Logger
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.toJavaDuration
+
+@HiltWorker
+class AppWidgetRefreshWorker @AssistedInject constructor(
+    @Assisted private val appContext: Context,
+    @Assisted workerParams: WorkerParameters,
+    private val dataRepository: AppWidgetDataRepository,
+    private val preferencesStore: AppWidgetPreferencesStore,
+) : CoroutineWorker(appContext, workerParams) {
+
+    companion object {
+        private const val TAG = "AppWidgetRefreshWorker"
+        private const val WORK_NAME = "appwidget_refresh"
+
+        fun enqueue(context: Context) {
+            val constraints = Constraints.Builder()
+                .setRequiredNetworkType(NetworkType.CONNECTED)
+                .build()
+
+            val request = PeriodicWorkRequestBuilder<AppWidgetRefreshWorker>(15.minutes.toJavaDuration())
+                .setConstraints(constraints)
+                .build()
+
+            WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+                WORK_NAME,
+                ExistingPeriodicWorkPolicy.KEEP,
+                request,
+            )
+        }
+
+        fun cancelIfNoWidgets(context: Context) {
+            val manager = AppWidgetManager.getInstance(context)
+            val hasAny = AppWidgetType.entries.any { type ->
+                manager.getAppWidgetIds(ComponentName(context, receiverClassFor(type))).isNotEmpty()
+            }
+            if (!hasAny) {
+                WorkManager.getInstance(context).cancelUniqueWork(WORK_NAME)
+            }
+        }
+
+        private fun receiverClassFor(type: AppWidgetType): Class<out GlanceAppWidgetReceiver> = when (type) {
+            AppWidgetType.PRICE -> PriceGlanceReceiver::class.java
+        }
+    }
+
+    override suspend fun doWork(): Result {
+        val activeTypes = preferencesStore.getActiveWidgetTypes()
+        if (activeTypes.isEmpty()) return Result.success()
+
+        Logger.debug("Refreshing data for widget types: '$activeTypes'", context = TAG)
+
+        for (type in activeTypes) {
+            when (type) {
+                AppWidgetType.PRICE -> {
+                    val periods = preferencesStore.getActivePricePeriods()
+                    periods.forEach { period ->
+                        dataRepository.fetchPriceData(period)
+                            .onSuccess { preferencesStore.cachePriceData(period, it) }
+                            .onFailure {
+                                Logger.warn("Failed to refresh price for '$period'", it, context = TAG)
+                            }
+                    }
+                    PriceGlanceWidget().updateAll(appContext)
+                }
+            }
+        }
+
+        return Result.success()
+    }
+}

app/src/main/java/to/bitkit/appwidget/config/AppWidgetConfigActivity.kt

@@ -0,0 +1,66 @@
+package to.bitkit.appwidget.config
+
+import android.app.Activity
+import android.appwidget.AppWidgetManager
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.viewModels
+import androidx.glance.appwidget.updateAll
+import dagger.hilt.android.AndroidEntryPoint
+import to.bitkit.appwidget.AppWidgetRefreshWorker
+import to.bitkit.appwidget.model.AppWidgetType
+import to.bitkit.appwidget.ui.price.PriceGlanceWidget
+import to.bitkit.ui.theme.AppThemeSurface
+
+@AndroidEntryPoint
+class AppWidgetConfigActivity : ComponentActivity() {
+
+    companion object {
+        const val EXTRA_WIDGET_TYPE = "extra_widget_type"
+    }
+
+    private val viewModel: AppWidgetConfigViewModel by viewModels()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val appWidgetId = intent?.extras?.getInt(
+            AppWidgetManager.EXTRA_APPWIDGET_ID,
+            AppWidgetManager.INVALID_APPWIDGET_ID,
+        ) ?: AppWidgetManager.INVALID_APPWIDGET_ID
+
+        setResult(RESULT_CANCELED)
+
+        if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
+            finish()
+            return
+        }
+
+        val typeName = intent?.getStringExtra(EXTRA_WIDGET_TYPE)
+        val type = typeName?.let { runCatching { AppWidgetType.valueOf(it) }.getOrNull() }
+            ?: AppWidgetType.PRICE
+
+        viewModel.init(appWidgetId, type)
+
+        setContent {
+            AppThemeSurface {
+                AppWidgetConfigScreen(
+                    viewModel = viewModel,
+                    onConfirm = {
+                        PriceGlanceWidget().updateAll(this@AppWidgetConfigActivity)
+                        AppWidgetRefreshWorker.enqueue(this@AppWidgetConfigActivity)
+                        val result = Intent().putExtra(
+                            AppWidgetManager.EXTRA_APPWIDGET_ID,
+                            appWidgetId,
+                        )
+                        setResult(Activity.RESULT_OK, result)
+                        finish()
+                    },
+                    onCancel = { finish() },
+                )
+            }
+        }
+    }
+}