Release/v4.7.2 202506296

app/build.gradle.kts

@@ -21,7 +21,7 @@ android {
         applicationId = "ltd.grunt.brainwallet"
         minSdk = 29
         targetSdk = 36
-        versionCode = 202506295
+        versionCode = 202506296
         versionName = "v4.7.2"
 
         multiDexEnabled = true
@@ -71,6 +71,13 @@ android {
             firebaseCrashlytics {
                 nativeSymbolUploadEnabled = true
             }
+            buildConfigField("String[]", "SCREENGRAB_PAPERKEY",
+                "new String[] {${
+                    localProperties.getProperty("SCREENGRAB_PAPERKEY", "")
+                        .split(" ")
+                        .joinToString { "\"$it\"" }
+                }}"
+            )
         }
 
         val release by getting {
@@ -125,13 +132,6 @@ android {
             applicationId = "ltd.grunt.brainwallet.screengrab"
             versionNameSuffix = "-screengrab"
             resValue("string", "app_name", "Brainwallet (screengrab)")
-            buildConfigField("String[]", "SCREENGRAB_PAPERKEY",
-                "new String[] {${
-                    localProperties.getProperty("SCREENGRAB_PAPERKEY", "")
-                        .split(" ")
-                        .joinToString { "\"$it\"" }
-                }}"
-            )
 
             externalNativeBuild {
                 cmake {
@@ -220,6 +220,7 @@ dependencies {
     implementation(libs.bundles.google.play.feature.delivery)
     implementation(libs.bundles.google.play.review)
     implementation(libs.kotlinx.serialization.json)
+    implementation(libs.kotlinx.coroutines.android)
     implementation (libs.airbnb.lottie.compose)
     implementation(platform(libs.koin.bom))
     implementation(libs.bundles.koin)
@@ -243,11 +244,15 @@ dependencies {
 
     testImplementation(libs.junit)
     testImplementation(libs.mockk)
+    testImplementation(libs.turbine)
+    testImplementation(libs.slf4j.android)
+    testImplementation(libs.kotlinx.coroutines.tests)
 
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.bundles.androidx.compose.ui.test)
     androidTestImplementation(libs.bundles.android.test)
     androidTestImplementation(libs.fastlane.screengrab)
+    androidTestImplementation(libs.slf4j.android)
 }
 
 val ktlintCheck by tasks.registering(JavaExec::class) {
@@ -280,4 +285,8 @@ tasks.register<JavaExec>("ktlintFormat") {
         "**.kts",
         "!**/build/**",
     )
-}
+}
+
+tasks.withType<Test> {
+    jvmArgs("-XX:+EnableDynamicAgentLoading")
+}

app/src/main/java/com/brainwallet/BrainwalletApp.kt

@@ -8,6 +8,7 @@ import android.content.res.Resources
 import com.appsflyer.AppsFlyerLib
 import com.brainwallet.data.source.RemoteConfigSource
 import com.brainwallet.di.AppModule
+import com.brainwallet.domain.MessagingTopicUseCase
 import com.brainwallet.notification.NotificationHandler
 import com.brainwallet.presenter.activities.util.BRActivity
 import com.brainwallet.presenter.entities.ServiceItems
@@ -32,6 +33,7 @@ open class BrainwalletApp : Application() {
 
     private val remoteConfigSource: RemoteConfigSource by inject()
     private val notificationHandler: NotificationHandler by inject()
+    private val messagingTopicHandler: MessagingTopicUseCase by inject()
 
     override fun onCreate() {
         super.onCreate()
@@ -80,6 +82,7 @@ open class BrainwalletApp : Application() {
             modules(AppModule.dataModule, AppModule.module)
         }
         thread { remoteConfigSource.initialize() }
+        thread { messagingTopicHandler.initialize() }
     }
 
 //    override fun attachBaseContext(base: Context) {

app/src/main/java/com/brainwallet/data/repository/MessagingTopicRepository.kt

@@ -0,0 +1,20 @@
+package com.brainwallet.data.repository
+
+import com.brainwallet.data.model.Language
+import com.brainwallet.data.source.MessagingTopicDataSource
+import org.koin.core.annotation.Single
+
+@Single
+class MessagingTopicRepository(
+    private val settingRepository: SettingRepository,
+    private val topicDataSource: MessagingTopicDataSource
+) {
+    fun getCurrentTopics(): List<String> {
+        val currentLanguage = settingRepository.getCurrentLanguage()
+        return topicDataSource.getTopicsByLanguageCode(currentLanguage.code)
+    }
+
+    fun getTopicsByLanguage(language: Language): List<String> {
+        return topicDataSource.getTopicsByLanguageCode(language.code)
+    }
+}

app/src/main/java/com/brainwallet/data/repository/SyncAnalyticsRepository.kt

@@ -0,0 +1,106 @@
+package com.brainwallet.data.repository
+
+import android.content.SharedPreferences
+import androidx.core.content.edit
+import com.brainwallet.data.source.AnalyticsSource
+import com.brainwallet.data.source.PeerManagerSource
+import org.koin.core.annotation.Single
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.UUID
+
+@Single
+class SyncAnalyticsRepository(
+    private val analyticsSource: AnalyticsSource,
+    private val peerManagerSource: PeerManagerSource,
+    private val prefs: SharedPreferences,
+) {
+    fun startSync() {
+        // Record the start time of the current sync segment.
+        prefs.edit {
+            putLong(KEY_CURRENT_SYNC_START_TIMESTAMP, peerManagerSource.getLastBlockTimestamp())
+        }
+    }
+
+    fun stopSync() {
+        val start = prefs.getLong(KEY_CURRENT_SYNC_START_TIMESTAMP, 0L)
+        if (start != 0L) {
+            val duration = peerManagerSource.getLastBlockTimestamp() - start
+            val accumulated = prefs.getLong(KEY_ACCUMULATED_DURATION, 0L)
+            prefs.edit {
+                putLong(KEY_ACCUMULATED_DURATION, accumulated + duration)
+                remove(KEY_CURRENT_SYNC_START_TIMESTAMP)
+            }
+        }
+    }
+
+    fun completeSync() {
+        // Capture the duration of the final segment.
+        stopSync()
+
+        val totalDuration = prefs.getLong(KEY_ACCUMULATED_DURATION, 0L)
+        if (totalDuration == 0L) return
+
+        val endTimestamp = peerManagerSource.getLastBlockTimestamp()
+        val endBlockHeight = peerManagerSource.getCurrentBlockHeight()
+        val uuid = UUID.randomUUID().toString()
+        val totalDurationInMillis = totalDuration * 1000
+
+        prefs.edit {
+            putString(KEY_LAST_UUID, uuid)
+            putLong(KEY_LAST_DURATION, totalDurationInMillis)
+            putLong(KEY_LAST_END, endTimestamp)
+            remove(KEY_ACCUMULATED_DURATION)
+        }
+
+        val params = mapOf(
+            KEY_UUID to uuid,
+            KEY_DURATION_MILLIS to (totalDurationInMillis),
+            KEY_END_TIMESTAMP to endTimestamp,
+            KEY_END_BLOCK_HEIGHT to endBlockHeight
+        )
+        analyticsSource.logEventWithParams(KEY_EVENT, params)
+    }
+
+    fun getLastSyncMetadata(): SyncMetadata? {
+        val uuid = prefs.getString(KEY_LAST_UUID, null) ?: return null
+        val duration = prefs.getLong(KEY_LAST_DURATION, 0L)
+        val end = prefs.getLong(KEY_LAST_END, 0L)
+        return SyncMetadata(uuid, duration, end)
+    }
+
+    data class SyncMetadata(
+        val uuid: String,
+        val durationMillis: Long,
+        val endTimestamp: Long
+    ) {
+        class Formatter(
+            private val dateFormat: SimpleDateFormat = SimpleDateFormat(
+                "MMMM dd, yyyy h:mm:ss a",
+                Locale.getDefault()
+            )
+        ) {
+            fun format(syncMetadata: SyncMetadata): String {
+                val durationSeconds = syncMetadata.durationMillis / 1000.0
+                val date = Date(syncMetadata.endTimestamp * 1000)
+                val dateString = dateFormat.format(date)
+
+                return "Duration: %.1f seconds\nTimestamp: %s".format(durationSeconds, dateString)
+            }
+        }
+    }
+
+    companion object {
+        private const val KEY_CURRENT_SYNC_START_TIMESTAMP = "current_sync_start_timestamp"
+        private const val KEY_ACCUMULATED_DURATION = "accumulated_sync_duration"
+        private const val KEY_LAST_UUID = "last_sync_uuid"
+        private const val KEY_LAST_DURATION = "last_sync_duration"
+        private const val KEY_LAST_END = "last_sync_end_timestamp"
+        private const val KEY_DURATION_MILLIS = "duration_millis"
+        private const val KEY_END_TIMESTAMP = "end_timestamp"
+        private const val KEY_END_BLOCK_HEIGHT = "end_block_height"
+        private const val KEY_UUID = "uuid"
+        private const val KEY_EVENT = "user_did_complete_sync"
+    }
+}

app/src/main/java/com/brainwallet/data/source/AnalyticsSource.kt

@@ -0,0 +1,6 @@
+package com.brainwallet.data.source
+
+interface AnalyticsSource {
+    fun logEvent(event: String)
+    fun logEventWithParams(event: String, params: Map<String, Any?>)
+}

app/src/main/java/com/brainwallet/data/source/FirebaseAnalyticsSource.kt

@@ -0,0 +1,33 @@
+package com.brainwallet.data.source
+
+import android.content.Context
+import android.os.Bundle
+import com.google.firebase.analytics.FirebaseAnalytics
+import org.koin.core.annotation.Single
+
+@Single
+class FirebaseAnalyticsSource(
+    private val context: Context,
+    private val analytics: FirebaseAnalytics = FirebaseAnalytics.getInstance(context)
+) : AnalyticsSource {
+
+    override fun logEvent(event: String) {
+        analytics.logEvent(event, null)
+    }
+
+    override fun logEventWithParams(event: String, params: Map<String, Any?>) {
+        val bundle = Bundle().apply {
+            params.forEach { (key, value) ->
+                when (value) {
+                    is String -> putString(key, value)
+                    is Int -> putInt(key, value)
+                    is Long -> putLong(key, value)
+                    is Double -> putDouble(key, value)
+                    is Boolean -> putBoolean(key, value)
+                    // add more types if needed
+                }
+            }
+        }
+        analytics.logEvent(event, bundle)
+    }
+}

app/src/main/java/com/brainwallet/data/source/MessagingTopicDataSource.kt

@@ -0,0 +1,46 @@
+package com.brainwallet.data.source
+
+import com.brainwallet.data.model.Language
+import org.koin.core.annotation.Single
+
+@Single
+class MessagingTopicDataSource(
+    private val supportedLanguages: List<Language> = Language.entries,
+    private val defaultLanguage: Language = Language.ENGLISH
+) {
+    fun getTopicsByLanguageCode(languageCode: String): List<String> {
+        val baseLanguageCode = getBaseLanguageCode(languageCode)
+        return listOf(
+            "initial_$baseLanguageCode",
+            "news_$baseLanguageCode",
+            "promo_$baseLanguageCode",
+            "warn_$baseLanguageCode"
+        )
+    }
+
+    /**
+     * Note: Indonesian language code is normalized from "in" to "id" to maintain
+     * consistency with backend batch messaging server which uses ISO 639-1 standard.
+     * Supports both "in" and "id" as input for Indonesian language.
+     */
+    private fun getBaseLanguageCode(languageCode: String): String {
+        val normalizedLanguageCode = languageCode.split("_", "-").first().lowercase()
+
+        // Handle reverse mapping: if "id" is passed, treat it as Indonesian
+        val searchCode = when (normalizedLanguageCode) {
+            "id" -> "in"
+            else -> normalizedLanguageCode
+        }
+
+        val targetLanguage = supportedLanguages.find { 
+            it.code.split("-").first().lowercase() == searchCode 
+        } ?: defaultLanguage
+
+        val baseCode = targetLanguage.code.split("-").first().lowercase()
+
+        return when (baseCode) {
+            "in" -> "id"
+            else -> baseCode
+        }
+    }
+}

app/src/main/java/com/brainwallet/data/source/PeerManagerSource.kt

@@ -0,0 +1,17 @@
+package com.brainwallet.data.source
+
+import com.brainwallet.wallet.BRPeerManager
+import org.koin.core.annotation.Single
+
+interface BRPeerManagerProxy {
+    fun getCurrentBlockHeight(): Int
+    fun getLastBlockTimestamp(): Long
+}
+
+@Single
+class PeerManagerSource(
+    private val proxy: BRPeerManagerProxy = object : BRPeerManagerProxy {
+        override fun getCurrentBlockHeight(): Int = BRPeerManager.getCurrentBlockHeight()
+        override fun getLastBlockTimestamp(): Long = BRPeerManager.getInstance().lastBlockTimestamp
+    }
+) : BRPeerManagerProxy by proxy

app/src/main/java/com/brainwallet/domain/LanguageSwitcherUseCase.kt

@@ -0,0 +1,16 @@
+package com.brainwallet.domain
+
+import com.brainwallet.data.model.Language
+import com.brainwallet.data.repository.SettingRepository
+import org.koin.core.annotation.Single
+
+@Single
+class LanguageSwitcherUseCase(
+    private val settingRepository: SettingRepository,
+    private val messagingTopicUseCase: MessagingTopicUseCase
+) {
+    fun switchLanguage(newLanguage: Language) {
+        messagingTopicUseCase.subscribeByLanguage(newLanguage)
+        settingRepository.updateCurrentLanguage(newLanguage.code)
+    }
+}

app/src/main/java/com/brainwallet/domain/MessagingTopicUseCase.kt

@@ -0,0 +1,36 @@
+package com.brainwallet.domain
+
+import com.brainwallet.data.model.Language
+import com.brainwallet.data.repository.MessagingTopicRepository
+import com.google.firebase.messaging.FirebaseMessaging
+import org.koin.core.annotation.Single
+
+@Single
+class MessagingTopicUseCase(
+    private val messagingTopicRepository: MessagingTopicRepository,
+    private val firebaseMessaging: FirebaseMessaging = FirebaseMessaging.getInstance()
+) {
+    fun initialize() {
+        val topics = messagingTopicRepository.getCurrentTopics()
+        subscribeToTopics(topics)
+    }
+
+    fun subscribeByLanguage(newLanguage: Language) {
+        val currentTopics = messagingTopicRepository.getCurrentTopics()
+        unsubscribeFromTopics(currentTopics)
+        val newTopics = messagingTopicRepository.getTopicsByLanguage(newLanguage)
+        subscribeToTopics(newTopics)
+    }
+
+    private fun subscribeToTopics(topics: List<String>) {
+        topics.forEach { topic ->
+            firebaseMessaging.subscribeToTopic(topic)
+        }
+    }
+
+    private fun unsubscribeFromTopics(topics: List<String>) {
+        topics.forEach { topic ->
+            firebaseMessaging.unsubscribeFromTopic(topic)
+        }
+    }
+}