feat: v61 compact widgets support

app/src/androidTest/java/to/bitkit/ui/screens/widgets/calculator/CalculatorCardIntegrationTest.kt → app/src/androidTest/java/to/bitkit/ui/screens/widgets/calculator/CalculatorWidgetInputTest.kt

@@ -1,16 +1,16 @@
 package to.bitkit.ui.screens.widgets.calculator
 
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.test.assertTextContains
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.hasSetTextAction
-import androidx.compose.ui.test.hasText
 import androidx.compose.ui.test.junit4.createComposeRule
-import androidx.compose.ui.test.onRoot
-import androidx.compose.ui.test.performTextClearance
-import androidx.compose.ui.test.performTextInput
-import androidx.compose.ui.test.printToString
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.ViewModelStore
@@ -50,6 +50,7 @@ import to.bitkit.test.annotations.CalculatorWidget
 import to.bitkit.test.annotations.DeviceIntegration
 import to.bitkit.test.annotations.DeviceUiIntegration
 import to.bitkit.ui.screens.widgets.calculator.components.CalculatorCard
+import to.bitkit.ui.screens.widgets.calculator.components.CalculatorNumberPadBar
 import to.bitkit.ui.theme.AppThemeSurface
 import java.util.Locale
 import javax.inject.Inject
@@ -62,7 +63,7 @@ import kotlin.test.assertEquals
 @CalculatorWidget
 @DeviceIntegration
 @DeviceUiIntegration
-class CalculatorCardIntegrationTest {
+class CalculatorWidgetInputTest {
 
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
@@ -154,41 +155,27 @@ class CalculatorCardIntegrationTest {
     }
 
     @Test
-    fun btcInputUpdatesFiatValueAndPersistsWidgetState() {
-        setCalculatorCard()
+    fun btcInputViaNumberPadUpdatesFiatAndPersistsWidgetState() {
+        setCalculatorWidget()
 
-        replaceInput(BTC_INPUT_INDEX, "12340")
+        composeTestRule.onNodeWithTag(BTC_INPUT_TAG).performClick()
+        awaitNumberPad()
+        tapKeys("N1", "N2", "N3", "N4", "N0")
 
-        waitForValues(
-            btcValue = "12340",
-            fiatValue = "12.34",
-        )
-
-        assertInputText(BTC_INPUT_INDEX, "12 340")
-        assertInputText(FIAT_INPUT_INDEX, "12.34")
-        assertPersistedValues(
-            btcValue = "12340",
-            fiatValue = "12.34",
-        )
+        waitForValues(btcValue = "12340", fiatValue = "12.34")
+        assertPersistedValues(btcValue = "12340", fiatValue = "12.34")
     }
 
     @Test
-    fun fiatInputUpdatesBtcValueAndPersistsWidgetState() {
-        setCalculatorCard()
+    fun fiatInputViaNumberPadUpdatesBtcAndPersistsWidgetState() {
+        setCalculatorWidget()
 
-        replaceInput(FIAT_INPUT_INDEX, "10.00")
+        composeTestRule.onNodeWithTag(FIAT_INPUT_TAG).performClick()
+        awaitNumberPad()
+        tapKeys("N1", "N0", "NDecimal", "N0", "N0")
 
-        waitForValues(
-            btcValue = "10000",
-            fiatValue = "10.00",
-        )
-
-        assertInputText(BTC_INPUT_INDEX, "10 000")
-        assertInputText(FIAT_INPUT_INDEX, "10.00")
-        assertPersistedValues(
-            btcValue = "10000",
-            fiatValue = "10.00",
-        )
+        waitForValues(btcValue = "10000", fiatValue = "10.00")
+        assertPersistedValues(btcValue = "10000", fiatValue = "10.00")
     }
 
     private fun createCalculatorViewModel(): CalculatorViewModel {
@@ -206,80 +193,70 @@ class CalculatorCardIntegrationTest {
         )[CalculatorViewModel::class.java]
     }
 
-    private fun setCalculatorCard() {
+    private fun setCalculatorWidget() {
         composeTestRule.setContent {
             AppThemeSurface {
-                CalculatorCard(
-                    calculatorViewModel = calculatorViewModel,
-                    modifier = Modifier.fillMaxWidth()
-                )
+                val state by calculatorViewModel.uiState.collectAsState()
+                Box(modifier = Modifier.fillMaxSize()) {
+                    CalculatorCard(
+                        btcPrimaryDisplayUnit = state.displayUnit,
+                        btcValue = state.btcValue,
+                        fiatSymbol = state.currencySymbol,
+                        fiatName = state.selectedCurrency,
+                        fiatValue = state.fiatValue,
+                        activeInput = state.activeInput,
+                        onSelectInput = calculatorViewModel::onInputSelected,
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                    state.activeInput?.let { active ->
+                        CalculatorNumberPadBar(
+                            activeInput = active,
+                            btcValue = state.btcValue,
+                            fiatValue = state.fiatValue,
+                            btcPrimaryDisplayUnit = state.displayUnit,
+                            onBtcChange = calculatorViewModel::onBtcInputChanged,
+                            onFiatChange = calculatorViewModel::onFiatInputChanged,
+                            modifier = Modifier.align(Alignment.BottomCenter)
+                        )
+                    }
+                }
             }
         }
         composeTestRule.waitForIdle()
+    }
+
+    private fun awaitNumberPad() {
         composeTestRule.waitUntil(timeoutMillis = TIMEOUT_MS) {
-            composeTestRule.onAllNodes(hasSetTextAction()).fetchSemanticsNodes().size == INPUT_COUNT
+            composeTestRule.onAllNodesWithTag(NUMBER_PAD_TAG).fetchSemanticsNodes().isNotEmpty()
         }
     }
 
-    private fun inputAt(index: Int) = composeTestRule.onAllNodes(hasSetTextAction())[index]
-
-    private fun replaceInput(
-        index: Int,
-        text: String,
-    ) {
-        inputAt(index).performTextClearance()
-        inputAt(index).performTextInput(text)
+    private fun tapKeys(vararg keys: String) {
+        keys.forEach { key ->
+            composeTestRule.onNodeWithTag(key).performClick()
+            composeTestRule.waitForIdle()
+        }
     }
 
     private fun waitForValues(
         btcValue: String,
         fiatValue: String,
     ) {
-        runCatching {
-            composeTestRule.waitUntil(timeoutMillis = TIMEOUT_MS) {
-                calculatorViewModel.uiState.value.btcValue == btcValue &&
-                    calculatorViewModel.uiState.value.fiatValue == fiatValue
-            }
-        }.onFailure {
-            throw AssertionError(
-                buildString {
-                    append("Expected calculatorValues btcValue='$btcValue', fiatValue='$fiatValue', ")
-                    append("but was '${calculatorViewModel.uiState.value}'. Persisted values were ")
-                    append("'${widgetsRepo.widgetsDataFlow.value.calculatorValues}'. Semantics tree:\n")
-                    append(composeTestRule.onRoot(useUnmergedTree = true).printToString())
-                },
-                it,
-            )
+        composeTestRule.waitUntil(timeoutMillis = TIMEOUT_MS) {
+            calculatorViewModel.uiState.value.btcValue == btcValue &&
+                calculatorViewModel.uiState.value.fiatValue == fiatValue
         }
-
         val expectedValues = CalculatorValues(
             btcValue = btcValue,
             fiatValue = fiatValue,
             satsValue = btcValue.toLong(),
             displayUnit = BitcoinDisplayUnit.MODERN,
         )
-        runCatching {
-            composeTestRule.waitUntil(timeoutMillis = TIMEOUT_MS) {
-                widgetsRepo.widgetsDataFlow.value.calculatorValues == expectedValues
-            }
-        }.onFailure {
-            throw AssertionError(
-                "Expected persisted values '$expectedValues', but was " +
-                    "'${widgetsRepo.widgetsDataFlow.value.calculatorValues}'",
-                it,
-            )
+        composeTestRule.waitUntil(timeoutMillis = TIMEOUT_MS) {
+            widgetsRepo.widgetsDataFlow.value.calculatorValues == expectedValues
         }
     }
 
-    private fun assertInputText(
-        inputIndex: Int,
-        text: String,
-    ) {
-        inputAt(inputIndex).assertTextContains(text, substring = true)
-        composeTestRule.onNode(hasText(text, substring = true), useUnmergedTree = true)
-            .assertIsDisplayed()
-    }
-
     private fun assertPersistedValues(
         btcValue: String,
         fiatValue: String,
@@ -296,9 +273,9 @@ class CalculatorCardIntegrationTest {
     }
 
     companion object {
-        private const val BTC_INPUT_INDEX = 0
-        private const val FIAT_INPUT_INDEX = 1
-        private const val INPUT_COUNT = 2
+        private const val BTC_INPUT_TAG = "CalculatorBtcInput"
+        private const val FIAT_INPUT_TAG = "CalculatorFiatInput"
+        private const val NUMBER_PAD_TAG = "CalculatorNumberPad"
         private const val TIMEOUT_MS = 5_000L
         private const val TEST_CREATED_AT = 0L
         private const val TEST_USD_RATE = "100000"
@@ -330,6 +307,7 @@ class CalculatorCardIntegrationTest {
 
         @Provides
         @Named("enablePolling")
+        @Suppress("FunctionOnlyReturningConstant")
         fun provideEnablePolling(): Boolean = false
     }
 }

app/src/main/java/to/bitkit/data/WidgetsStore.kt

@@ -13,6 +13,7 @@ import to.bitkit.data.dto.BlockDTO
 import to.bitkit.data.dto.WeatherDTO
 import to.bitkit.data.dto.price.PriceDTO
 import to.bitkit.data.serializers.WidgetsSerializer
+import to.bitkit.models.WidgetSize
 import to.bitkit.models.WidgetType
 import to.bitkit.models.WidgetWithPosition
 import to.bitkit.models.WidgetsBackupV1
@@ -123,15 +124,28 @@ class WidgetsStore @Inject constructor(
         Logger.info("Deleted all widgets data.")
     }
 
-    suspend fun addWidget(type: WidgetType) {
-        if (store.data.first().widgets.map { it.type }.contains(type)) return
+    suspend fun addWidget(type: WidgetType, size: WidgetSize = WidgetSize.default(type)) {
+        store.updateData { data ->
+            val existing = data.widgets.firstOrNull { it.type == type }
+            if (existing != null) {
+                data.copy(
+                    widgets = data.widgets
+                        .map { if (it.type == type) it.copy(size = size) else it }
+                        .sortedBy { it.position }
+                )
+            } else {
+                val nextPosition = (data.widgets.maxOfOrNull { it.position } ?: -1) + 1
+                data.copy(
+                    widgets = (data.widgets + WidgetWithPosition(type = type, position = nextPosition, size = size))
+                        .sortedBy { it.position }
+                )
+            }
+        }
+    }
 
+    suspend fun updateWidgetSize(type: WidgetType, size: WidgetSize) {
         store.updateData { data ->
-            val nextPosition = (data.widgets.maxOfOrNull { it.position } ?: -1) + 1
-            data.copy(
-                widgets = (data.widgets + WidgetWithPosition(type = type, position = nextPosition))
-                    .sortedBy { it.position }
-            )
+            data.copy(widgets = data.widgets.map { if (it.type == type) it.copy(size = size) else it })
         }
     }
 
@@ -161,9 +175,13 @@ class WidgetsStore @Inject constructor(
 @Serializable
 data class WidgetsData(
     val widgets: List<WidgetWithPosition> = listOf(
-        WidgetWithPosition(type = WidgetType.SUGGESTIONS, position = 0),
-        WidgetWithPosition(type = WidgetType.PRICE, position = 1),
-        WidgetWithPosition(type = WidgetType.BLOCK, position = 2),
+        WidgetWithPosition(type = WidgetType.SUGGESTIONS, position = 0, size = WidgetSize.WIDE),
+        WidgetWithPosition(type = WidgetType.PRICE, position = 1, size = WidgetSize.WIDE),
+        WidgetWithPosition(type = WidgetType.BLOCK, position = 2, size = WidgetSize.SMALL),
+        WidgetWithPosition(type = WidgetType.FACTS, position = 3, size = WidgetSize.SMALL),
+        WidgetWithPosition(type = WidgetType.WEATHER, position = 4, size = WidgetSize.SMALL),
+        WidgetWithPosition(type = WidgetType.CALCULATOR, position = 5, size = WidgetSize.SMALL),
+        WidgetWithPosition(type = WidgetType.NEWS, position = 6, size = WidgetSize.WIDE),
     ),
     val headlinePreferences: HeadlinePreferences = HeadlinePreferences(),
     val blocksPreferences: BlocksPreferences = BlocksPreferences(),

app/src/main/java/to/bitkit/models/WidgetSize.kt

@@ -0,0 +1,24 @@
+package to.bitkit.models
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class WidgetSize {
+    @SerialName("small")
+    SMALL,
+
+    @SerialName("wide")
+    WIDE;
+
+    companion object {
+        fun default(type: WidgetType): WidgetSize = when (type) {
+            WidgetType.PRICE,
+            WidgetType.NEWS,
+            WidgetType.SUGGESTIONS,
+            -> WIDE
+
+            else -> SMALL
+        }
+    }
+}

app/src/main/java/to/bitkit/models/WidgetWithPosition.kt

@@ -8,4 +8,8 @@ import kotlinx.serialization.Serializable
 data class WidgetWithPosition(
     val type: WidgetType,
     val position: Int = 0,
+    val size: WidgetSize = WidgetSize.WIDE,
 )
+
+fun WidgetWithPosition.effectiveSize(): WidgetSize =
+    if (type == WidgetType.SUGGESTIONS) WidgetSize.WIDE else size

app/src/main/java/to/bitkit/repositories/WidgetsRepo.kt

@@ -33,6 +33,7 @@ import to.bitkit.data.widgets.PriceService
 import to.bitkit.data.widgets.WeatherService
 import to.bitkit.data.widgets.WidgetService
 import to.bitkit.di.BgDispatcher
+import to.bitkit.models.WidgetSize
 import to.bitkit.models.WidgetType
 import to.bitkit.models.WidgetWithPosition
 import to.bitkit.models.widget.BlocksPreferences
@@ -173,7 +174,11 @@ class WidgetsRepo @Inject constructor(
         Logger.verbose("Stopped refresh coroutine for $widgetType", context = TAG)
     }
 
-    suspend fun addWidget(type: WidgetType) = withContext(bgDispatcher) { widgetsStore.addWidget(type) }
+    suspend fun addWidget(type: WidgetType, size: WidgetSize = WidgetSize.default(type)) =
+        withContext(bgDispatcher) { widgetsStore.addWidget(type, size) }
+
+    suspend fun updateWidgetSize(type: WidgetType, size: WidgetSize) =
+        withContext(bgDispatcher) { widgetsStore.updateWidgetSize(type, size) }
 
     suspend fun deleteWidget(type: WidgetType) = withContext(bgDispatcher) { widgetsStore.deleteWidget(type) }