feat: polish backup & restore

app/build.gradle.kts

@@ -34,6 +34,8 @@ val keystoreProperties by lazy {
     keystoreProperties
 }
 
+val locales = listOf("en", "ar", "ca", "cs", "de", "el", "es", "fr", "it", "nl", "pl", "pt", "ru")
+
 android {
     namespace = "to.bitkit"
     compileSdk = 35
@@ -49,6 +51,7 @@ android {
         }
         buildConfigField("boolean", "E2E", System.getenv("E2E")?.toBoolean()?.toString() ?: "false")
         buildConfigField("boolean", "GEO", System.getenv("GEO")?.toBoolean()?.toString() ?: "true")
+        buildConfigField("String", "LOCALES", "\"${locales.joinToString(",")}\"")
     }
 
     flavorDimensions += "network"
@@ -131,7 +134,7 @@ android {
     }
     androidResources {
         @Suppress("UnstableApiUsage")
-        localeFilters.addAll(listOf("en", "ar", "ca", "cs", "de", "el", "es", "fr", "it", "nl", "pl", "pt", "ru"))
+        localeFilters.addAll(locales)
         @Suppress("UnstableApiUsage")
         generateLocaleConfig = true
     }

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

@@ -12,6 +12,7 @@ import to.bitkit.env.Env
 import to.bitkit.models.BitcoinDisplayUnit
 import to.bitkit.models.CoinSelectionPreference
 import to.bitkit.models.PrimaryDisplay
+import to.bitkit.models.SettingsBackupV1
 import to.bitkit.models.Suggestion
 import to.bitkit.models.TransactionSpeed
 import to.bitkit.utils.Logger
@@ -31,6 +32,14 @@ class SettingsStore @Inject constructor(
 
     val data: Flow<SettingsData> = store.data
 
+    suspend fun restoreFromBackup(payload: SettingsBackupV1) =
+        runCatching {
+            val data = payload.settings.resetPin()
+            store.updateData { data }
+        }.onSuccess {
+            Logger.debug("Restored settings", TAG)
+        }
+
     suspend fun update(transform: (SettingsData) -> SettingsData) {
         store.updateData(transform)
     }
@@ -62,6 +71,7 @@ class SettingsStore @Inject constructor(
     }
 
     companion object {
+        private const val TAG = "SettingsStore"
         private const val MAX_LAST_USED_TAGS = 10
     }
 }

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

@@ -15,6 +15,7 @@ import to.bitkit.data.dto.price.PriceDTO
 import to.bitkit.data.serializers.WidgetsSerializer
 import to.bitkit.models.WidgetType
 import to.bitkit.models.WidgetWithPosition
+import to.bitkit.models.WidgetsBackupV1
 import to.bitkit.models.widget.BlocksPreferences
 import to.bitkit.models.widget.CalculatorValues
 import to.bitkit.models.widget.FactsPreferences
@@ -43,9 +44,13 @@ class WidgetsStore @Inject constructor(
     val weatherFlow: Flow<WeatherDTO?> = data.map { it.weather }
     val priceFlow: Flow<PriceDTO?> = data.map { it.price }
 
-    suspend fun update(transform: (WidgetsData) -> WidgetsData) {
-        store.updateData(transform)
-    }
+    suspend fun restoreFromBackup(payload: WidgetsBackupV1) =
+        runCatching {
+            val data = payload.widgets
+            store.updateData { data }
+        }.onSuccess {
+            Logger.debug("Restored widgets", TAG)
+        }
 
     suspend fun updateCalculatorValues(calculatorValues: CalculatorValues) {
         store.updateData {
@@ -127,16 +132,16 @@ class WidgetsStore @Inject constructor(
     suspend fun addWidget(type: WidgetType) {
         if (store.data.first().widgets.map { it.type }.contains(type)) return
 
-        store.updateData {
-            it.copy(widgets = (it.widgets + WidgetWithPosition(type = type)).sortedBy { it.position })
+        store.updateData { data ->
+            data.copy(widgets = (data.widgets + WidgetWithPosition(type = type)).sortedBy { it.position })
         }
     }
 
     suspend fun deleteWidget(type: WidgetType) {
         if (!store.data.first().widgets.map { it.type }.contains(type)) return
 
-        store.updateData {
-            it.copy(widgets = it.widgets.filterNot { it.type == type })
+        store.updateData { data ->
+            data.copy(widgets = data.widgets.filterNot { it.type == type })
         }
     }
 
@@ -145,6 +150,10 @@ class WidgetsStore @Inject constructor(
             it.copy(widgets = widgets)
         }
     }
+
+    companion object {
+        private const val TAG = "WidgetsStore"
+    }
 }
 
 @Serializable

app/src/main/java/to/bitkit/env/Env.kt

@@ -18,6 +18,7 @@ internal object Env {
     const val isE2eTest = BuildConfig.E2E
     const val isGeoblockingEnabled = BuildConfig.GEO
     val network = Network.valueOf(BuildConfig.NETWORK)
+    val locales = BuildConfig.LOCALES.split(",")
     val walletSyncIntervalSecs = 10_uL // TODO review
     val platform = "Android ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})"
     const val version = "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})"
@@ -116,10 +117,10 @@ internal object Env {
         Logger.info("App storage path: $path")
     }
 
-    val logDir: String
+    val logDir: File
         get() {
             require(::appStoragePath.isInitialized)
-            return File(appStoragePath).resolve("logs").ensureDir().path
+            return File(appStoragePath).resolve("logs").ensureDir()
         }
 
     fun ldkStoragePath(walletIndex: Int) = storagePathOf(walletIndex, network.name.lowercase(), "ldk")

app/src/main/java/to/bitkit/ext/Activities.kt

@@ -9,6 +9,11 @@ fun Activity.rawId(): String = when (this) {
     is Activity.Onchain -> v1.id
 }
 
+fun Activity.txType(): PaymentType = when (this) {
+    is Activity.Lightning -> v1.txType
+    is Activity.Onchain -> v1.txType
+}
+
 /**
  * Calculates the total value of an activity based on its type.
  *

app/src/main/java/to/bitkit/ext/DateTime.kt

@@ -3,6 +3,12 @@
 package to.bitkit.ext
 
 import android.icu.text.DateFormat
+import android.icu.text.DisplayContext
+import android.icu.text.NumberFormat
+import android.icu.text.RelativeDateTimeFormatter
+import android.icu.text.RelativeDateTimeFormatter.AbsoluteUnit
+import android.icu.text.RelativeDateTimeFormatter.Direction
+import android.icu.text.RelativeDateTimeFormatter.RelativeUnit
 import android.icu.util.ULocale
 import kotlinx.datetime.Clock
 import kotlinx.datetime.LocalDate
@@ -48,11 +54,50 @@ fun Long.toDateUTC(): String {
 fun Long.toLocalizedTimestamp(): String {
     val uLocale = ULocale.forLocale(Locale.US)
     val formatter = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT, uLocale)
+        ?: return SimpleDateFormat("MMMM d, yyyy 'at' h:mm a", Locale.US).format(Date(this))
     return formatter.format(Date(this))
 }
 
+@Suppress("LongMethod")
+fun Long.toRelativeTimeString(
+    locale: Locale = Locale.getDefault(),
+    clock: Clock = Clock.System,
+): String {
+    val now = nowMillis(clock)
+    val diffMillis = now - this
+
+    val uLocale = ULocale.forLocale(locale)
+    val numberFormat = NumberFormat.getNumberInstance(uLocale)?.apply { maximumFractionDigits = 0 }
+
+    val formatter = RelativeDateTimeFormatter.getInstance(
+        uLocale,
+        numberFormat,
+        RelativeDateTimeFormatter.Style.LONG,
+        DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE,
+    ) ?: return toLocalizedTimestamp()
+
+    val seconds = diffMillis / Factor.MILLIS_TO_SECONDS
+    val minutes = seconds / Factor.SECONDS_TO_MINUTES
+    val hours = minutes / Factor.MINUTES_TO_HOURS
+    val days = hours / Factor.HOURS_TO_DAYS
+    val weeks = days / Factor.DAYS_TO_WEEKS
+    val months = days / Factor.DAYS_TO_MONTHS
+    val years = days / Factor.DAYS_TO_YEARS
+
+    return when {
+        seconds < Threshold.SECONDS -> formatter.format(Direction.PLAIN, AbsoluteUnit.NOW)
+        minutes < Threshold.MINUTES -> formatter.format(minutes, Direction.LAST, RelativeUnit.MINUTES)
+        hours < Threshold.HOURS -> formatter.format(hours, Direction.LAST, RelativeUnit.HOURS)
+        days < Threshold.YESTERDAY -> formatter.format(Direction.LAST, AbsoluteUnit.DAY)
+        days < Threshold.DAYS -> formatter.format(days, Direction.LAST, RelativeUnit.DAYS)
+        weeks < Threshold.WEEKS -> formatter.format(weeks, Direction.LAST, RelativeUnit.WEEKS)
+        months < Threshold.MONTHS -> formatter.format(months, Direction.LAST, RelativeUnit.MONTHS)
+        else -> formatter.format(years, Direction.LAST, RelativeUnit.YEARS)
+    }
+}
+
 fun getDaysInMonth(month: LocalDate): List<LocalDate?> {
-    val firstDayOfMonth = LocalDate(month.year, month.month, CalendarConstants.FIRST_DAY_OF_MONTH)
+    val firstDayOfMonth = LocalDate(month.year, month.month, Constants.FIRST_DAY_OF_MONTH)
     val daysInMonth = month.month.length(isLeapYear(month.year))
 
     // Get the day of week for the first day (1 = Monday, 7 = Sunday)
@@ -70,7 +115,7 @@ fun getDaysInMonth(month: LocalDate): List<LocalDate?> {
     }
 
     // Add all days of the month
-    for (day in CalendarConstants.FIRST_DAY_OF_MONTH..daysInMonth) {
+    for (day in Constants.FIRST_DAY_OF_MONTH..daysInMonth) {
         days.add(LocalDate(month.year, month.month, day))
     }
 
@@ -83,49 +128,43 @@ fun getDaysInMonth(month: LocalDate): List<LocalDate?> {
 }
 
 fun isLeapYear(year: Int): Boolean {
-    return (year % CalendarConstants.LEAP_YEAR_DIVISOR_4 == 0 && year % CalendarConstants.LEAP_YEAR_DIVISOR_100 != 0) ||
-        (year % CalendarConstants.LEAP_YEAR_DIVISOR_400 == 0)
+    return (year % Constants.LEAP_YEAR_DIVISOR_4 == 0 && year % Constants.LEAP_YEAR_DIVISOR_100 != 0) ||
+        (year % Constants.LEAP_YEAR_DIVISOR_400 == 0)
 }
 
-fun isDateInRange(dateMillis: Long, startMillis: Long?, endMillis: Long?): Boolean {
+fun isDateInRange(
+    dateMillis: Long,
+    startMillis: Long?,
+    endMillis: Long?,
+    zone: TimeZone = TimeZone.currentSystemDefault(),
+): Boolean {
     if (startMillis == null) return false
     val end = endMillis ?: startMillis
 
-    val normalizedDate = kotlinx.datetime.Instant.fromEpochMilliseconds(dateMillis)
-        .toLocalDateTime(TimeZone.currentSystemDefault()).date
-    val normalizedStart = kotlinx.datetime.Instant.fromEpochMilliseconds(startMillis)
-        .toLocalDateTime(TimeZone.currentSystemDefault()).date
-    val normalizedEnd = kotlinx.datetime.Instant.fromEpochMilliseconds(end)
-        .toLocalDateTime(TimeZone.currentSystemDefault()).date
+    val normalizedDate = kotlinx.datetime.Instant.fromEpochMilliseconds(dateMillis).toLocalDateTime(zone).date
+    val normalizedStart = kotlinx.datetime.Instant.fromEpochMilliseconds(startMillis).toLocalDateTime(zone).date
+    val normalizedEnd = kotlinx.datetime.Instant.fromEpochMilliseconds(end).toLocalDateTime(zone).date
 
-    return normalizedDate >= normalizedStart && normalizedDate <= normalizedEnd
+    return normalizedDate in normalizedStart..normalizedEnd
 }
 
-fun LocalDate.toMonthYearString(): String {
-    val formatter = SimpleDateFormat(DatePattern.MONTH_YEAR_FORMAT, Locale.getDefault())
+fun LocalDate.toMonthYearString(locale: Locale = Locale.getDefault()): String {
+    val formatter = SimpleDateFormat(DatePattern.MONTH_YEAR_FORMAT, locale)
     val calendar = Calendar.getInstance()
-    calendar.set(year, monthNumber - CalendarConstants.MONTH_INDEX_OFFSET, CalendarConstants.FIRST_DAY_OF_MONTH)
+    calendar.set(year, monthNumber - CalendarConstants.MONTH_INDEX_OFFSET, Constants.FIRST_DAY_OF_MONTH)
     return formatter.format(calendar.time)
 }
 
 fun LocalDate.minusMonths(months: Int): LocalDate =
-    this.toJavaLocalDate()
-        .minusMonths(months.toLong())
-        .withDayOfMonth(1) // Always use first day of month for display
+    toJavaLocalDate().minusMonths(months.toLong()).withDayOfMonth(1) // Always use first day of month for display
         .toKotlinLocalDate()
 
 fun LocalDate.plusMonths(months: Int): LocalDate =
-    this.toJavaLocalDate()
-        .plusMonths(months.toLong())
-        .withDayOfMonth(1) // Always use first day of month for display
+    toJavaLocalDate().plusMonths(months.toLong()).withDayOfMonth(1) // Always use first day of month for display
         .toKotlinLocalDate()
 
-fun LocalDate.endOfDay(): Long {
-    return this.atStartOfDayIn(TimeZone.currentSystemDefault())
-        .plus(1.days)
-        .minus(1.milliseconds)
-        .toEpochMilliseconds()
-}
+fun LocalDate.endOfDay(zone: TimeZone = TimeZone.currentSystemDefault()): Long =
+    atStartOfDayIn(zone).plus(1.days).minus(1.milliseconds).toEpochMilliseconds()
 
 fun utcDateFormatterOf(pattern: String) = SimpleDateFormat(pattern, Locale.US).apply {
     timeZone = java.util.TimeZone.getTimeZone("UTC")
@@ -147,11 +186,39 @@ object DatePattern {
     const val WEEKDAY_FORMAT = "EEE"
 }
 
-object CalendarConstants {
+private object Constants {
+    // Calendar
+    const val FIRST_DAY_OF_MONTH = 1
+
+    // Leap year calculation
+    const val LEAP_YEAR_DIVISOR_4 = 4
+    const val LEAP_YEAR_DIVISOR_100 = 100
+    const val LEAP_YEAR_DIVISOR_400 = 400
+}
 
+private object Factor {
+    const val MILLIS_TO_SECONDS = 1000.0
+    const val SECONDS_TO_MINUTES = 60.0
+    const val MINUTES_TO_HOURS = 60.0
+    const val HOURS_TO_DAYS = 24.0
+    const val DAYS_TO_WEEKS = 7.0
+    const val DAYS_TO_MONTHS = 30.0
+    const val DAYS_TO_YEARS = 365.0
+}
+
+private object Threshold {
+    const val SECONDS = 60
+    const val MINUTES = 60
+    const val HOURS = 24
+    const val YESTERDAY = 2
+    const val DAYS = 7
+    const val WEEKS = 4
+    const val MONTHS = 12
+}
+
+object CalendarConstants {
     // Calendar grid
     const val DAYS_IN_WEEK = 7
-    const val FIRST_DAY_OF_MONTH = 1
 
     // Date formatting
     const val WEEKDAY_ABBREVIATION_LENGTH = 3
@@ -160,12 +227,4 @@ object CalendarConstants {
     const val DAYS_IN_WEEK_MOD = 7
     const val CALENDAR_WEEK_OFFSET = 1
     const val MONTH_INDEX_OFFSET = 1
-
-    // Leap year calculation
-    const val LEAP_YEAR_DIVISOR_4 = 4
-    const val LEAP_YEAR_DIVISOR_100 = 100
-    const val LEAP_YEAR_DIVISOR_400 = 400
-
-    // Preview
-    const val PREVIEW_DAYS_AGO = 7
 }

app/src/main/java/to/bitkit/ext/TagMetadataEntity.kt

@@ -0,0 +1,31 @@
+package to.bitkit.ext
+
+import com.synonym.bitkitcore.PreActivityMetadata
+import to.bitkit.data.entities.TagMetadataEntity
+
+// TODO use PreActivityMetadata
+fun TagMetadataEntity.toActivityTagsMetadata() = PreActivityMetadata(
+    paymentId = id,
+    createdAt = createdAt.toULong(),
+    tags = tags,
+    paymentHash = paymentHash,
+    txId = txId,
+    address = address,
+    isReceive = isReceive,
+    feeRate = 0u, // TODO: update room db entity or drop it in favour of bitkit-core
+    isTransfer = false, // TODO: update room db entity or drop it in favour of bitkit-core
+    channelId = "", // TODO: update room db entity or drop it in favour of bitkit-core
+)
+
+fun PreActivityMetadata.toTagMetadataEntity() = TagMetadataEntity(
+    id = paymentId,
+    createdAt = createdAt.toLong(),
+    tags = tags,
+    paymentHash = paymentHash,
+    txId = txId,
+    address = address.orEmpty(),
+    isReceive = isReceive,
+    // feeRate = 0u,
+    // isTransfer = false,
+    // channelId = "",
+)

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

@@ -50,9 +50,9 @@ enum class BackupCategory(
 }
 
 /**
- * @property running In progress
- * @property synced Timestamp in ms of last time this backup was synced
- * @property required Timestamp in ms of last time this backup was required
+ * @property running Backup is currently in progress
+ * @property synced Timestamp in millis of last time this backup succeeded
+ * @property required Timestamp in millis of last time the data changed
  */
 @Serializable
 data class BackupItemStatus(