fix: apply formatting to WakeNodeWorker.onCjitChannelReady

Author: jvsena42

app/src/main/java/to/bitkit/fcm/WakeNodeWorker.kt

@@ -10,7 +10,6 @@ import dagger.assisted.AssistedInject
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withTimeout
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
@@ -21,12 +20,10 @@ import to.bitkit.App
 import to.bitkit.R
 import to.bitkit.androidServices.LightningNodeService
 import to.bitkit.data.CacheStore
-import to.bitkit.data.SettingsStore
 import to.bitkit.di.json
 import to.bitkit.domain.commands.ReceivedNotificationContent
 import to.bitkit.ext.amountOnClose
 import to.bitkit.ext.toUserMessage
-import to.bitkit.models.BITCOIN_SYMBOL
 import to.bitkit.models.BlocktankNotificationType
 import to.bitkit.models.BlocktankNotificationType.cjitPaymentArrived
 import to.bitkit.models.BlocktankNotificationType.incomingHtlc
@@ -37,7 +34,6 @@ import to.bitkit.models.NewTransactionSheetDetails
 import to.bitkit.models.NewTransactionSheetDirection
 import to.bitkit.models.NewTransactionSheetType
 import to.bitkit.models.NotificationDetails
-import to.bitkit.models.formatToModernDisplay
 import to.bitkit.models.msatCeilOf
 import to.bitkit.repositories.ActivityRepo
 import to.bitkit.repositories.BlocktankRepo
@@ -56,7 +52,6 @@ class WakeNodeWorker @AssistedInject constructor(
     private val lightningRepo: LightningRepo,
     private val blocktankRepo: BlocktankRepo,
     private val activityRepo: ActivityRepo,
-    private val settingsStore: SettingsStore,
     private val cacheStore: CacheStore,
     private val receivedNotificationContent: ReceivedNotificationContent,
 ) : CoroutineWorker(appContext, workerParams) {
@@ -141,8 +136,6 @@ class WakeNodeWorker @AssistedInject constructor(
      * @param event The LDK event to check.
      */
     private suspend fun handleLdkEvent(event: Event) {
-        val showDetails = settingsStore.data.first().showNotificationDetails
-        val hiddenBody = appContext.getString(R.string.notification__received__body_hidden)
         when (event) {
             is Event.PaymentReceived -> onPaymentReceived(event)
 
@@ -154,7 +147,7 @@ class WakeNodeWorker @AssistedInject constructor(
                 // Don't deliver, give a chance for channelReady event to update the content if it's a turbo channel
             }
 
-            is Event.ChannelReady -> onChannelReady(event, showDetails, hiddenBody)
+            is Event.ChannelReady -> onChannelReady(event)
             is Event.ChannelClosed -> onChannelClosed(event)
 
             is Event.PaymentFailed -> {
@@ -218,13 +211,9 @@ class WakeNodeWorker @AssistedInject constructor(
         }
     }
 
-    private suspend fun onChannelReady(
-        event: Event.ChannelReady,
-        showDetails: Boolean,
-        hiddenBody: String,
-    ) {
+    private suspend fun onChannelReady(event: Event.ChannelReady) {
         when (notificationType) {
-            cjitPaymentArrived -> onCjitChannelReady(event, showDetails, hiddenBody)
+            cjitPaymentArrived -> onCjitChannelReady(event)
 
             orderPaymentConfirmed -> bestAttemptContent = NotificationDetails(
                 title = appContext.getString(R.string.notification__channel_opened_title),
@@ -236,11 +225,7 @@ class WakeNodeWorker @AssistedInject constructor(
         deliver()
     }
 
-    private suspend fun onCjitChannelReady(
-        event: Event.ChannelReady,
-        showDetails: Boolean,
-        hiddenBody: String,
-    ) {
+    private suspend fun onCjitChannelReady(event: Event.ChannelReady) {
         val channel = lightningRepo.getChannels()?.find { it.channelId == event.channelId }
         val cjitEntry = channel?.let { blocktankRepo.getCjitEntry(it) }
 
@@ -277,11 +262,7 @@ class WakeNodeWorker @AssistedInject constructor(
             return
         }
 
-        val content = if (showDetails) "$BITCOIN_SYMBOL ${sats.formatToModernDisplay()}" else hiddenBody
-        bestAttemptContent = NotificationDetails(
-            title = content,
-            body = appContext.getString(R.string.notification__received__body_channel),
-        )
+        bestAttemptContent = receivedNotificationContent.build(sats.toLong())
     }
 
     private fun isHandledInProcess(): Boolean =

app/src/test/java/to/bitkit/fcm/WakeNodeWorkerTest.kt

@@ -10,7 +10,6 @@ import androidx.work.ListenableWorker
 import androidx.work.WorkerParameters
 import androidx.work.workDataOf
 import com.synonym.bitkitcore.IcJitEntry
-import kotlinx.coroutines.flow.flowOf
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -33,16 +32,12 @@ import to.bitkit.CurrentActivity
 import to.bitkit.R
 import to.bitkit.androidServices.LightningNodeService
 import to.bitkit.data.CacheStore
-import to.bitkit.data.SettingsData
-import to.bitkit.data.SettingsStore
 import to.bitkit.domain.commands.ReceivedNotificationContent
 import to.bitkit.ext.createChannelDetails
 import to.bitkit.ext.mock
 import to.bitkit.ext.notificationManager
-import to.bitkit.models.BITCOIN_SYMBOL
 import to.bitkit.models.BlocktankNotificationType
 import to.bitkit.models.NotificationDetails
-import to.bitkit.models.formatToModernDisplay
 import to.bitkit.repositories.ActivityRepo
 import to.bitkit.repositories.BlocktankRepo
 import to.bitkit.repositories.LightningRepo
@@ -51,7 +46,6 @@ import to.bitkit.test.BaseUnitTest
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
-import kotlin.test.assertTrue
 
 @Config(sdk = [34])
 @RunWith(RobolectricTestRunner::class)
@@ -61,19 +55,17 @@ class WakeNodeWorkerTest : BaseUnitTest() {
     private val lightningRepo = mock<LightningRepo>()
     private val blocktankRepo = mock<BlocktankRepo>()
     private val activityRepo = mock<ActivityRepo>()
-    private val settingsStore = mock<SettingsStore>()
     private val cacheStore = mock<CacheStore>()
     private val receivedNotificationContent = mock<ReceivedNotificationContent>()
 
     private val channelId = "channel-1"
-    private val viaNewChannel by lazy { context.getString(R.string.notification__received__body_channel) }
+    private val receivedTitle by lazy { context.getString(R.string.notification__received__title) }
 
     @Before
     fun setUp() {
         whenever(workerParams.inputData).thenReturn(
             workDataOf("type" to BlocktankNotificationType.cjitPaymentArrived.name),
         )
-        whenever(settingsStore.data).thenReturn(flowOf(SettingsData(showNotificationDetails = true)))
 
         val app = context as Application
         Shadows.shadowOf(app).grantPermissions(Manifest.permission.POST_NOTIFICATIONS)
@@ -90,22 +82,19 @@ class WakeNodeWorkerTest : BaseUnitTest() {
     }
 
     @Test
-    fun `cjit channel ready formats amount with thousands separators`() = test {
+    fun `cjit channel ready delivers rich notification content with fiat`() = test {
+        val body = $$"Received ₿ 48 064 ($30.79)"
+        whenever(receivedNotificationContent.build(48_064L)).thenReturn(NotificationDetails(receivedTitle, body))
         val channel = cjitChannel(sats = 48_064)
         stubChannel(channel, cjitEntry = IcJitEntry.mock())
         stubStartFiring(channelReadyEvent())
 
         val result = worker().doWork()
 
         assertEquals(ListenableWorker.Result.success(), result)
-        val notification = findNotification(viaNewChannel)
+        val notification = findNotificationByTitle(receivedTitle)
         assertNotNull(notification, "CJIT notification should be delivered when app is killed")
-        assertEquals(
-            "$BITCOIN_SYMBOL ${48_064L.formatToModernDisplay()}",
-            notification?.extras?.getString(Notification.EXTRA_TITLE),
-        )
-        // sanity: a thousands separator is actually present
-        assertTrue(48_064L.formatToModernDisplay().contains(' '), "amount should be grouped")
+        assertEquals(body, notification?.extras?.getString(Notification.EXTRA_TEXT))
         verify(activityRepo).insertActivityFromCjit(any(), any())
     }
 
@@ -118,7 +107,7 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         val result = worker().doWork()
 
         assertEquals(ListenableWorker.Result.success(), result)
-        assertNull(findNotification(viaNewChannel), "A non-CJIT channel must not show a 'via new channel' notification")
+        assertNull(findNotificationByTitle(receivedTitle), "A non-CJIT channel must not show a payment notification")
         verify(activityRepo, never()).insertActivityFromCjit(any(), any())
         verify(cacheStore, never()).setBackgroundReceive(any())
     }
@@ -133,7 +122,7 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         val result = worker().doWork()
 
         assertEquals(ListenableWorker.Result.success(), result)
-        assertNull(findNotification(viaNewChannel), "Notification is deduped when the foreground service handles it")
+        assertNull(findNotificationByTitle(receivedTitle), "Deduped when the foreground service handles it")
         // Activity is still recorded so the receive is not lost
         verify(activityRepo).insertActivityFromCjit(any(), any())
     }
@@ -148,7 +137,7 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         val result = worker().doWork()
 
         assertEquals(ListenableWorker.Result.success(), result)
-        assertNull(findNotification(viaNewChannel), "A duplicate CJIT channel ready must not notify again")
+        assertNull(findNotificationByTitle(receivedTitle), "A duplicate CJIT channel ready must not notify again")
         verify(cacheStore, never()).setBackgroundReceive(any())
     }
 
@@ -162,7 +151,7 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         val result = worker().doWork()
 
         assertEquals(ListenableWorker.Result.success(), result)
-        assertNull(findNotification(viaNewChannel), "Notification is deduped when the in-app UI handles it")
+        assertNull(findNotificationByTitle(receivedTitle), "Notification is deduped when the in-app UI handles it")
         verify(activityRepo).insertActivityFromCjit(any(), any())
     }
 
@@ -211,7 +200,6 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         lightningRepo = lightningRepo,
         blocktankRepo = blocktankRepo,
         activityRepo = activityRepo,
-        settingsStore = settingsStore,
         cacheStore = cacheStore,
         receivedNotificationContent = receivedNotificationContent,
     )
@@ -250,11 +238,6 @@ class WakeNodeWorkerTest : BaseUnitTest() {
         }
     }
 
-    private fun findNotification(body: String): Notification? {
-        val shadows = Shadows.shadowOf(context.notificationManager)
-        return shadows.allNotifications.find { it.extras.getString(Notification.EXTRA_TEXT) == body }
-    }
-
     private fun findNotificationByTitle(title: String): Notification? {
         val shadows = Shadows.shadowOf(context.notificationManager)
         return shadows.allNotifications.find { it.extras.getString(Notification.EXTRA_TITLE) == title }