fix: respect system 24-hour time setting

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

@@ -16,6 +16,7 @@ import android.content.pm.PackageManager.PERMISSION_GRANTED
 import android.hardware.usb.UsbManager
 import android.os.PowerManager
 import android.provider.Settings
+import android.text.format.DateFormat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import androidx.core.net.toUri
@@ -55,6 +56,11 @@ val Context.powerManager: PowerManager
 val Context.usageStatsManager: UsageStatsManager
     get() = getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager
 
+// Settings
+
+val Context.is24HourTimeFormat: Boolean
+    get() = DateFormat.is24HourFormat(this)
+
 // Permissions
 
 fun Context.requiresPermission(permission: String): Boolean =

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

@@ -29,6 +29,7 @@ import kotlin.time.Clock
 import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.ExperimentalTime
+import java.time.LocalDate as JavaLocalDate
 import kotlin.time.Instant as KInstant
 
 @OptIn(ExperimentalTime::class)
@@ -39,11 +40,17 @@ fun Clock.nowMs(): Long = now().toEpochMilliseconds()
 
 fun nowTimestamp(): Instant = Instant.now().truncatedTo(ChronoUnit.SECONDS)
 
-fun Instant.formatted(pattern: String = DatePattern.DATE_TIME): String {
-    val dateTime = LocalDateTime.ofInstant(this, ZoneId.systemDefault())
-    val formatter = DateTimeFormatter.ofPattern(pattern)
-    return dateTime.format(formatter)
-}
+fun dateTimeFormatterOf(
+    pattern: String,
+    locale: Locale = Locale.getDefault(),
+    zone: ZoneId = ZoneId.systemDefault(),
+): DateTimeFormatter = DateTimeFormatter.ofPattern(pattern, locale).withZone(zone)
+
+fun Instant.formatted(
+    pattern: String = DatePattern.DATE_TIME,
+    locale: Locale = Locale.getDefault(),
+    zone: ZoneId = ZoneId.systemDefault(),
+): String = dateTimeFormatterOf(pattern, locale, zone).format(this)
 
 fun ULong?.formatToString(pattern: String = DatePattern.DATE_TIME): String? {
     return this?.let { Instant.ofEpochSecond(toLong()).formatted(pattern) }
@@ -213,13 +220,46 @@ fun utcDateFormatterOf(pattern: String) = SimpleDateFormat(pattern, Locale.US).a
     timeZone = java.util.TimeZone.getTimeZone("UTC")
 }
 
+fun uiDateStyleFor(
+    timestamp: ULong,
+    today: JavaLocalDate = JavaLocalDate.now(),
+    zone: ZoneId = ZoneId.systemDefault(),
+): UiDateStyle {
+    val date = Instant.ofEpochSecond(timestamp.toLong()).atZone(zone).toLocalDate()
+    return when {
+        date == today -> UiDateStyle.TIME
+        date.year == today.year -> UiDateStyle.DATE_TIME
+        else -> UiDateStyle.DATE_TIME_YEAR
+    }
+}
+
+enum class UiDateStyle {
+    TIME,
+    DATE,
+    DATE_TIME,
+    DATE_TIME_YEAR,
+    ;
+
+    fun pattern(is24Hour: Boolean): String {
+        val time = if (is24Hour) TIME_24H else TIME_12H
+        return when (this) {
+            TIME -> time
+            DATE -> DAY
+            DATE_TIME -> "$DAY, $time"
+            DATE_TIME_YEAR -> "$DAY_WITH_YEAR, $time"
+        }
+    }
+
+    private companion object {
+        const val TIME_12H = "h:mm a"
+        const val TIME_24H = "HH:mm"
+        const val DAY = "MMMM d"
+        const val DAY_WITH_YEAR = "MMMM d yyyy"
+    }
+}
+
 object DatePattern {
     const val DATE_TIME = "dd/MM/yyyy, HH:mm"
-    const val INVOICE_EXPIRY = "MMM dd, h:mm a"
-    const val ACTIVITY_DATE = "MMMM d"
-    const val ACTIVITY_ROW_DATE = "MMMM d, HH:mm"
-    const val ACTIVITY_ROW_DATE_YEAR = "MMMM d yyyy, HH:mm"
-    const val ACTIVITY_TIME = "h:mm"
     const val CHANNEL_DETAILS = "MMM d, yyyy, HH:mm"
     const val LOG_FILE = "yyyy-MM-dd_HH-mm-ss"
     const val LOG_LINE = "yyyy-MM-dd HH:mm:ss.SSS"

app/src/main/java/to/bitkit/ui/ContentView.kt

@@ -208,6 +208,7 @@ import to.bitkit.ui.utils.AutoReadClipboardHandler
 import to.bitkit.ui.utils.RequestNotificationPermissions
 import to.bitkit.ui.utils.composableWithDefaultTransitions
 import to.bitkit.ui.utils.navigationWithDefaultTransitions
+import to.bitkit.ui.utils.rememberIs24HourFormat
 import to.bitkit.ui.utils.rememberRequestNotificationPermission
 import to.bitkit.utils.Logger
 import to.bitkit.viewmodels.ActivityListViewModel
@@ -399,6 +400,7 @@ fun ContentView(
         LocalSettingsViewModel provides settingsViewModel,
         LocalBackupsViewModel provides backupsViewModel,
         LocalDrawerState provides drawerState,
+        LocalIs24HourFormat provides rememberIs24HourFormat(),
         LocalBalances provides balance,
         LocalCurrencies provides currencies,
     ) {

app/src/main/java/to/bitkit/ui/Locals.kt

@@ -18,6 +18,7 @@ import to.bitkit.viewmodels.WalletViewModel
 // Locals
 val LocalBalances = compositionLocalOf { BalanceState() }
 val LocalCurrencies = compositionLocalOf { CurrencyState() }
+val LocalIs24HourFormat = compositionLocalOf { false }
 
 // Statics
 val LocalDrawerState = staticCompositionLocalOf<DrawerState?> { null }

app/src/main/java/to/bitkit/ui/screens/wallets/activity/ActivityDetailScreen.kt

@@ -55,15 +55,14 @@ import kotlinx.collections.immutable.ImmutableMap
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.persistentMapOf
 import to.bitkit.R
+import to.bitkit.ext.UiDateStyle
 import to.bitkit.ext.contact
 import to.bitkit.ext.create
 import to.bitkit.ext.ellipsisMiddle
 import to.bitkit.ext.isSent
 import to.bitkit.ext.isTransfer
 import to.bitkit.ext.rawId
 import to.bitkit.ext.timestamp
-import to.bitkit.ext.toActivityItemDate
-import to.bitkit.ext.toActivityItemTime
 import to.bitkit.ext.totalValue
 import to.bitkit.models.FeeRate.Companion.getFeeShortDescription
 import to.bitkit.models.PubkyProfile
@@ -97,6 +96,7 @@ import to.bitkit.ui.theme.AppThemeSurface
 import to.bitkit.ui.theme.Colors
 import to.bitkit.ui.utils.copyToClipboard
 import to.bitkit.ui.utils.getScreenTitleRes
+import to.bitkit.ui.utils.uiDateText
 import to.bitkit.viewmodels.ActivityDetailViewModel
 import to.bitkit.viewmodels.ActivityListViewModel
 
@@ -433,7 +433,7 @@ private fun ActivityDetailContent(
                         modifier = Modifier.size(16.dp)
                     )
                     Spacer(modifier = Modifier.width(4.dp))
-                    BodySSB(text = timestamp.toActivityItemDate())
+                    BodySSB(text = uiDateText(timestamp, UiDateStyle.DATE))
                 }
                 Spacer(modifier = Modifier.height(16.dp))
                 HorizontalDivider()
@@ -454,7 +454,7 @@ private fun ActivityDetailContent(
                         modifier = Modifier.size(16.dp)
                     )
                     Spacer(modifier = Modifier.width(4.dp))
-                    BodySSB(text = timestamp.toActivityItemTime())
+                    BodySSB(text = uiDateText(timestamp, UiDateStyle.TIME))
                 }
                 Spacer(modifier = Modifier.height(16.dp))
                 HorizontalDivider()

app/src/main/java/to/bitkit/ui/screens/wallets/activity/components/ActivityRow.kt

@@ -28,14 +28,13 @@ import com.synonym.bitkitcore.Activity
 import com.synonym.bitkitcore.PaymentState
 import com.synonym.bitkitcore.PaymentType
 import to.bitkit.R
-import to.bitkit.ext.DatePattern
-import to.bitkit.ext.formatted
 import to.bitkit.ext.isSent
 import to.bitkit.ext.isTransfer
 import to.bitkit.ext.rawId
 import to.bitkit.ext.timestamp
 import to.bitkit.ext.totalValue
 import to.bitkit.ext.txType
+import to.bitkit.ext.uiDateStyleFor
 import to.bitkit.models.FeeRate.Companion.getFeeShortDescription
 import to.bitkit.models.PrimaryDisplay
 import to.bitkit.models.PubkyProfile
@@ -57,9 +56,7 @@ import to.bitkit.ui.shared.modifiers.clickableAlpha
 import to.bitkit.ui.theme.AppThemeSurface
 import to.bitkit.ui.theme.Colors
 import to.bitkit.ui.theme.Shapes
-import java.time.Instant
-import java.time.LocalDate
-import java.time.ZoneId
+import to.bitkit.ui.utils.uiDateText
 
 @Suppress("CyclomaticComplexMethod")
 @Composable
@@ -138,7 +135,7 @@ fun ActivityRow(
             )
             val context = LocalContext.current
             val subtitleText = when (item) {
-                is Activity.Lightning -> item.v1.message.ifEmpty { formattedTime(timestamp) }
+                is Activity.Lightning -> item.v1.message.ifEmpty { activityTimeText(timestamp) }
                 is Activity.Onchain -> {
                     when {
                         !item.v1.doesExist -> stringResource(R.string.wallet__activity_removed)
@@ -161,7 +158,7 @@ fun ActivityRow(
                                 .replace("{duration}", duration)
                         }
 
-                        confirmed == true -> formattedTime(timestamp)
+                        confirmed == true -> activityTimeText(timestamp)
 
                         else -> {
                             val feeDescription = context.getFeeShortDescription(item.v1.feeRate, feeRates)
@@ -363,19 +360,8 @@ private fun AmountViewContent(
     }
 }
 
-private fun formattedTime(timestamp: ULong): String {
-    val instant = Instant.ofEpochSecond(timestamp.toLong())
-    val dateTime = instant.atZone(ZoneId.systemDefault())
-    val now = LocalDate.now()
-
-    val isToday = dateTime.toLocalDate() == now
-    val isThisYear = dateTime.year == now.year
-    return when {
-        isToday -> instant.formatted(DatePattern.ACTIVITY_TIME)
-        isThisYear -> instant.formatted(DatePattern.ACTIVITY_ROW_DATE)
-        else -> instant.formatted(DatePattern.ACTIVITY_ROW_DATE_YEAR)
-    }
-}
+@Composable
+private fun activityTimeText(timestamp: ULong): String = uiDateText(timestamp, uiDateStyleFor(timestamp))
 
 private class ActivityItemsPreviewProvider : PreviewParameterProvider<Activity> {
     override val values: Sequence<Activity> get() = previewActivityItems.asSequence()

app/src/main/java/to/bitkit/ui/utils/DateText.kt

@@ -0,0 +1,60 @@
+package to.bitkit.ui.utils
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
+import to.bitkit.ext.UiDateStyle
+import to.bitkit.ext.dateTimeFormatterOf
+import to.bitkit.ext.is24HourTimeFormat
+import to.bitkit.ui.LocalIs24HourFormat
+import java.time.Instant
+import java.time.ZoneId
+import java.util.Locale
+
+@Composable
+fun uiDateText(
+    timestamp: ULong,
+    style: UiDateStyle,
+    locale: Locale = Locale.getDefault(),
+    zone: ZoneId = ZoneId.systemDefault(),
+): String {
+    val is24Hour = LocalIs24HourFormat.current
+
+    val formatter = remember(style, is24Hour, locale, zone) {
+        dateTimeFormatterOf(style.pattern(is24Hour), locale, zone)
+    }
+
+    return remember(formatter, timestamp) { formatter.format(Instant.ofEpochSecond(timestamp.toLong())) }
+}
+
+@Composable
+fun rememberIs24HourFormat(context: Context = LocalContext.current): Boolean {
+    var is24Hour by remember(context) { mutableStateOf(context.is24HourTimeFormat) }
+
+    DisposableEffect(context) {
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(receiverContext: Context?, intent: Intent?) = run {
+                is24Hour = context.is24HourTimeFormat
+            }
+        }
+        ContextCompat.registerReceiver(
+            context,
+            receiver,
+            IntentFilter(Intent.ACTION_TIME_CHANGED),
+            ContextCompat.RECEIVER_NOT_EXPORTED,
+        )
+
+        onDispose { context.unregisterReceiver(receiver) }
+    }
+
+    return is24Hour
+}