diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 8e9533233..b228fd345 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -19,6 +19,13 @@
+
+
+
+
+
+
+
@@ -77,5 +84,34 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/src/main/java/com/bitchat/android/BitchatApplication.kt b/app/src/main/java/com/bitchat/android/BitchatApplication.kt
index 06fb33c77..b120b2162 100644
--- a/app/src/main/java/com/bitchat/android/BitchatApplication.kt
+++ b/app/src/main/java/com/bitchat/android/BitchatApplication.kt
@@ -41,6 +41,12 @@ class BitchatApplication : Application() {
// Initialize debug preference manager (persists debug toggles)
try { com.bitchat.android.ui.debug.DebugPreferenceManager.init(this) } catch (_: Exception) { }
+ // Initialize mesh service preferences
+ try { com.bitchat.android.service.MeshServicePreferences.init(this) } catch (_: Exception) { }
+
+ // Proactively start the foreground service to keep mesh alive
+ try { com.bitchat.android.service.MeshForegroundService.start(this) } catch (_: Exception) { }
+
// TorManager already initialized above
}
}
diff --git a/app/src/main/java/com/bitchat/android/MainActivity.kt b/app/src/main/java/com/bitchat/android/MainActivity.kt
index 28d672802..6e9fbd396 100644
--- a/app/src/main/java/com/bitchat/android/MainActivity.kt
+++ b/app/src/main/java/com/bitchat/android/MainActivity.kt
@@ -51,7 +51,7 @@ class MainActivity : OrientationAwareActivity() {
private lateinit var locationStatusManager: LocationStatusManager
private lateinit var batteryOptimizationManager: BatteryOptimizationManager
- // Core mesh service - managed at app level
+ // Core mesh service - provided by the foreground service holder
private lateinit var meshService: BluetoothMeshService
private val mainViewModel: MainViewModel by viewModels()
private val chatViewModel: ChatViewModel by viewModels {
@@ -66,13 +66,21 @@ class MainActivity : OrientationAwareActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
+ // Check if this is a quit request from the notification
+ if (intent.getBooleanExtra("ACTION_QUIT_APP", false)) {
+ android.util.Log.d("MainActivity", "Quit request received in onCreate, finishing activity")
+ finish()
+ return
+ }
+
// Enable edge-to-edge display for modern Android look
enableEdgeToEdge()
// Initialize permission management
permissionManager = PermissionManager(this)
- // Initialize core mesh service first
- meshService = BluetoothMeshService(this)
+ // Ensure foreground service is running and get mesh instance from holder
+ try { com.bitchat.android.service.MeshForegroundService.start(applicationContext) } catch (_: Exception) { }
+ meshService = com.bitchat.android.service.MeshServiceHolder.getOrCreate(applicationContext)
bluetoothStatusManager = BluetoothStatusManager(
activity = this,
context = this,
@@ -630,6 +638,15 @@ class MainActivity : OrientationAwareActivity() {
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
+ setIntent(intent)
+
+ // Check if this is a quit request from the notification
+ if (intent.getBooleanExtra("ACTION_QUIT_APP", false)) {
+ android.util.Log.d("MainActivity", "Quit request received, finishing activity")
+ finish()
+ return
+ }
+
// Handle notification intents when app is already running
if (mainViewModel.onboardingState.value == OnboardingState.COMPLETE) {
handleNotificationIntent(intent)
@@ -640,6 +657,8 @@ class MainActivity : OrientationAwareActivity() {
super.onResume()
// Check Bluetooth and Location status on resume and handle accordingly
if (mainViewModel.onboardingState.value == OnboardingState.COMPLETE) {
+ // Reattach mesh delegate to new ChatViewModel instance after Activity recreation
+ try { meshService.delegate = chatViewModel } catch (_: Exception) { }
// Set app foreground state
meshService.connectionManager.setAppBackgroundState(false)
chatViewModel.setAppBackgroundState(false)
@@ -665,13 +684,15 @@ class MainActivity : OrientationAwareActivity() {
}
}
- override fun onPause() {
+ override fun onPause() {
super.onPause()
// Only set background state if app is fully initialized
if (mainViewModel.onboardingState.value == OnboardingState.COMPLETE) {
// Set app background state
meshService.connectionManager.setAppBackgroundState(true)
chatViewModel.setAppBackgroundState(true)
+ // Detach UI delegate so the foreground service can own DM notifications while UI is closed
+ try { meshService.delegate = null } catch (_: Exception) { }
}
}
@@ -746,14 +767,6 @@ class MainActivity : OrientationAwareActivity() {
Log.w("MainActivity", "Error cleaning up location status manager: ${e.message}")
}
- // Stop mesh services if app was fully initialized
- if (mainViewModel.onboardingState.value == OnboardingState.COMPLETE) {
- try {
- meshService.stopServices()
- Log.d("MainActivity", "Mesh services stopped successfully")
- } catch (e: Exception) {
- Log.w("MainActivity", "Error stopping mesh services in onDestroy: ${e.message}")
- }
- }
+ // Do not stop mesh here; ForegroundService owns lifecycle for background reliability
}
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
index 3ac87764e..8e0fa15b4 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
@@ -149,6 +149,7 @@ class BluetoothConnectionManager(
try {
isActive = true
+ Log.d(TAG, "ConnectionManager activated (permissions and adapter OK)")
// set the adapter's name to our 8-character peerID for iOS privacy, TODO: Make this configurable
// try {
@@ -179,6 +180,7 @@ class BluetoothConnectionManager(
this@BluetoothConnectionManager.isActive = false
return@launch
}
+ Log.d(TAG, "GATT Server started")
} else {
Log.i(TAG, "GATT Server disabled by debug settings; not starting")
}
@@ -189,6 +191,7 @@ class BluetoothConnectionManager(
this@BluetoothConnectionManager.isActive = false
return@launch
}
+ Log.d(TAG, "GATT Client started")
} else {
Log.i(TAG, "GATT Client disabled by debug settings; not starting")
}
@@ -214,6 +217,7 @@ class BluetoothConnectionManager(
isActive = false
connectionScope.launch {
+ Log.d(TAG, "Stopping client/server and power components...")
// Stop component managers
clientManager.stop()
serverManager.stop()
@@ -230,6 +234,18 @@ class BluetoothConnectionManager(
Log.i(TAG, "All Bluetooth services stopped")
}
}
+
+ /**
+ * Indicates whether this instance can be safely reused for a future start.
+ * Returns false if its coroutine scope has been cancelled.
+ */
+ fun isReusable(): Boolean {
+ val active = connectionScope.isActive
+ if (!active) {
+ Log.d(TAG, "BluetoothConnectionManager isReusable=false (scope cancelled)")
+ }
+ return active
+ }
/**
* Set app background state for power optimization
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
index dd12138d0..3de484072 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
@@ -52,6 +52,12 @@ class BluetoothMeshService(private val context: Context) {
internal val connectionManager = BluetoothConnectionManager(context, myPeerID, fragmentManager) // Made internal for access
private val packetProcessor = PacketProcessor(myPeerID)
private lateinit var gossipSyncManager: GossipSyncManager
+ // Service-level notification manager for background (no-UI) DMs
+ private val serviceNotificationManager = com.bitchat.android.ui.NotificationManager(
+ context.applicationContext,
+ androidx.core.app.NotificationManagerCompat.from(context.applicationContext),
+ com.bitchat.android.util.NotificationIntervalManager()
+ )
// Service state management
private var isActive = false
@@ -61,8 +67,11 @@ class BluetoothMeshService(private val context: Context) {
// Coroutines
private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+ // Tracks whether this instance has been terminated via stopServices()
+ private var terminated = false
init {
+ Log.i(TAG, "Initializing BluetoothMeshService for peer=$myPeerID")
setupDelegates()
messageHandler.packetProcessor = packetProcessor
//startPeriodicDebugLogging()
@@ -98,6 +107,7 @@ class BluetoothMeshService(private val context: Context) {
return signPacketBeforeBroadcast(packet)
}
}
+ Log.d(TAG, "Delegates set up; GossipSyncManager initialized")
}
/**
@@ -105,6 +115,7 @@ class BluetoothMeshService(private val context: Context) {
*/
private fun startPeriodicDebugLogging() {
serviceScope.launch {
+ Log.d(TAG, "Starting periodic debug logging loop")
while (isActive) {
try {
delay(10000) // 10 seconds
@@ -116,6 +127,7 @@ class BluetoothMeshService(private val context: Context) {
Log.e(TAG, "Error in periodic debug logging: ${e.message}")
}
}
+ Log.d(TAG, "Periodic debug logging loop ended (isActive=$isActive)")
}
}
@@ -124,6 +136,7 @@ class BluetoothMeshService(private val context: Context) {
*/
private fun sendPeriodicBroadcastAnnounce() {
serviceScope.launch {
+ Log.d(TAG, "Starting periodic announce loop")
while (isActive) {
try {
delay(30000) // 30 seconds
@@ -132,6 +145,7 @@ class BluetoothMeshService(private val context: Context) {
Log.e(TAG, "Error in periodic broadcast announce: ${e.message}")
}
}
+ Log.d(TAG, "Periodic announce loop ended (isActive=$isActive)")
}
}
@@ -139,6 +153,7 @@ class BluetoothMeshService(private val context: Context) {
* Setup delegate connections between components
*/
private fun setupDelegates() {
+ Log.d(TAG, "Setting up component delegates")
// Provide nickname resolver to BLE broadcaster for detailed logs
try {
connectionManager.setNicknameResolver { pid -> peerManager.getPeerNickname(pid) }
@@ -146,6 +161,9 @@ class BluetoothMeshService(private val context: Context) {
// PeerManager delegates to main mesh service delegate
peerManager.delegate = object : PeerManagerDelegate {
override fun onPeerListUpdated(peerIDs: List) {
+ // Update process-wide state first
+ try { com.bitchat.android.services.AppStateStore.setPeers(peerIDs) } catch (_: Exception) { }
+ // Then notify UI delegate if attached
delegate?.didUpdatePeerList(peerIDs)
}
override fun onPeerRemoved(peerID: String) {
@@ -165,6 +183,7 @@ class BluetoothMeshService(private val context: Context) {
override fun onKeyExchangeCompleted(peerID: String, peerPublicKeyData: ByteArray) {
// Send announcement and cached messages after key exchange
serviceScope.launch {
+ Log.d(TAG, "Key exchange completed with $peerID; sending follow-ups")
delay(100)
sendAnnouncementToPeer(peerID)
@@ -352,7 +371,36 @@ class BluetoothMeshService(private val context: Context) {
// Callbacks
override fun onMessageReceived(message: BitchatMessage) {
+ // Always reflect into process-wide store so UI can hydrate after recreation
+ try {
+ when {
+ message.isPrivate -> {
+ val peer = message.senderPeerID ?: ""
+ if (peer.isNotEmpty()) com.bitchat.android.services.AppStateStore.addPrivateMessage(peer, message)
+ }
+ message.channel != null -> {
+ com.bitchat.android.services.AppStateStore.addChannelMessage(message.channel!!, message)
+ }
+ else -> {
+ com.bitchat.android.services.AppStateStore.addPublicMessage(message)
+ }
+ }
+ } catch (_: Exception) { }
+ // And forward to UI delegate if attached
delegate?.didReceiveMessage(message)
+
+ // If no UI delegate attached (app closed), show DM notification via service manager
+ if (delegate == null && message.isPrivate) {
+ try {
+ val senderPeerID = message.senderPeerID
+ if (senderPeerID != null) {
+ val nick = try { peerManager.getPeerNickname(senderPeerID) } catch (_: Exception) { null } ?: senderPeerID
+ val preview = com.bitchat.android.ui.NotificationTextUtils.buildPrivateMessagePreview(message)
+ serviceNotificationManager.setAppBackgroundState(true)
+ serviceNotificationManager.showPrivateMessageNotification(senderPeerID, nick, preview)
+ }
+ } catch (_: Exception) { }
+ }
}
override fun onChannelLeave(channel: String, fromPeer: String) {
@@ -477,12 +525,23 @@ class BluetoothMeshService(private val context: Context) {
// BluetoothConnectionManager delegates
connectionManager.delegate = object : BluetoothConnectionManagerDelegate {
override fun onPacketReceived(packet: BitchatPacket, peerID: String, device: android.bluetooth.BluetoothDevice?) {
+ // Log incoming for debug graphs (do not double-count anywhere else)
+ try {
+ val nick = getPeerNicknames()[peerID]
+ com.bitchat.android.ui.debug.DebugSettingsManager.getInstance().logIncoming(
+ packetType = packet.type.toString(),
+ fromPeerID = peerID,
+ fromNickname = nick,
+ fromDeviceAddress = device?.address
+ )
+ } catch (_: Exception) { }
packetProcessor.processPacket(RoutedPacket(packet, peerID, device?.address))
}
override fun onDeviceConnected(device: android.bluetooth.BluetoothDevice) {
// Send initial announcements after services are ready
serviceScope.launch {
+ Log.d(TAG, "Device connected: ${device.address}; scheduling announce")
delay(200)
sendBroadcastAnnounce()
}
@@ -497,6 +556,7 @@ class BluetoothMeshService(private val context: Context) {
}
override fun onDeviceDisconnected(device: android.bluetooth.BluetoothDevice) {
+ Log.d(TAG, "Device disconnected: ${device.address}")
val addr = device.address
// Remove mapping and, if that was the last direct path for the peer, clear direct flag
val peer = connectionManager.addressPeerMap[addr]
@@ -535,6 +595,11 @@ class BluetoothMeshService(private val context: Context) {
Log.w(TAG, "Mesh service already active, ignoring duplicate start request")
return
}
+ if (terminated) {
+ // This instance's scope was cancelled previously; refuse to start to avoid using dead scopes.
+ Log.e(TAG, "Mesh service instance was terminated; create a new instance instead of restarting")
+ return
+ }
Log.i(TAG, "Starting Bluetooth mesh service with peer ID: $myPeerID")
@@ -546,6 +611,7 @@ class BluetoothMeshService(private val context: Context) {
Log.d(TAG, "Started periodic broadcast announcements (every 30 seconds)")
// Start periodic syncs
gossipSyncManager.start()
+ Log.d(TAG, "GossipSyncManager started")
} else {
Log.e(TAG, "Failed to start Bluetooth services")
}
@@ -567,11 +633,14 @@ class BluetoothMeshService(private val context: Context) {
sendLeaveAnnouncement()
serviceScope.launch {
+ Log.d(TAG, "Stopping subcomponents and cancelling scope...")
delay(200) // Give leave message time to send
// Stop all components
gossipSyncManager.stop()
+ Log.d(TAG, "GossipSyncManager stopped")
connectionManager.stopServices()
+ Log.d(TAG, "BluetoothConnectionManager stop requested")
peerManager.shutdown()
fragmentManager.shutdown()
securityManager.shutdown()
@@ -579,8 +648,23 @@ class BluetoothMeshService(private val context: Context) {
messageHandler.shutdown()
packetProcessor.shutdown()
+ // Mark this instance as terminated and cancel its scope so it won't be reused
+ terminated = true
serviceScope.cancel()
+ Log.i(TAG, "BluetoothMeshService terminated and scope cancelled")
+ }
+ }
+
+ /**
+ * Whether this instance can be safely reused. Returns false after stopServices() or if
+ * any critical internal scope has been cancelled.
+ */
+ fun isReusable(): Boolean {
+ val reusable = !terminated && serviceScope.isActive && connectionManager.isReusable()
+ if (!reusable) {
+ Log.d(TAG, "isReusable=false (terminated=$terminated, scopeActive=${serviceScope.isActive}, connReusable=${connectionManager.isReusable()})")
}
+ return reusable
}
/**
@@ -801,7 +885,7 @@ class BluetoothMeshService(private val context: Context) {
fun sendReadReceipt(messageID: String, recipientPeerID: String, readerNickname: String) {
serviceScope.launch {
Log.d(TAG, "📖 Sending read receipt for message $messageID to $recipientPeerID")
-
+
// Route geohash read receipts via MessageRouter instead of here
val geo = runCatching { com.bitchat.android.services.MessageRouter.tryGetInstance() }.getOrNull()
val isGeoAlias = try {
@@ -812,8 +896,15 @@ class BluetoothMeshService(private val context: Context) {
geo.sendReadReceipt(com.bitchat.android.model.ReadReceipt(messageID), recipientPeerID)
return@launch
}
-
+
try {
+ // Avoid duplicate read receipts: check persistent store first
+ val seenStore = try { com.bitchat.android.services.SeenMessageStore.getInstance(context.applicationContext) } catch (_: Exception) { null }
+ if (seenStore?.hasRead(messageID) == true) {
+ Log.d(TAG, "Skipping read receipt for $messageID - already marked read")
+ return@launch
+ }
+
// Create read receipt payload using NoisePayloadType exactly like iOS
val readReceiptPayload = com.bitchat.android.model.NoisePayload(
type = com.bitchat.android.model.NoisePayloadType.READ_RECEIPT,
@@ -839,7 +930,10 @@ class BluetoothMeshService(private val context: Context) {
val signedPacket = signPacketBeforeBroadcast(packet)
connectionManager.broadcastPacket(RoutedPacket(signedPacket))
Log.d(TAG, "📤 Sent read receipt to $recipientPeerID for message $messageID")
-
+
+ // Persist as read after successful send
+ try { seenStore?.markRead(messageID) } catch (_: Exception) { }
+
} catch (e: Exception) {
Log.e(TAG, "Failed to send read receipt to $recipientPeerID: ${e.message}")
}
@@ -852,7 +946,7 @@ class BluetoothMeshService(private val context: Context) {
fun sendBroadcastAnnounce() {
Log.d(TAG, "Sending broadcast announce")
serviceScope.launch {
- val nickname = delegate?.getNickname() ?: myPeerID
+ val nickname = try { com.bitchat.android.services.NicknameProvider.getNickname(context, myPeerID) } catch (_: Exception) { myPeerID }
// Get the static public key for the announcement
val staticKey = encryptionService.getStaticPublicKey()
@@ -901,7 +995,7 @@ class BluetoothMeshService(private val context: Context) {
fun sendAnnouncementToPeer(peerID: String) {
if (peerManager.hasAnnouncedToPeer(peerID)) return
- val nickname = delegate?.getNickname() ?: myPeerID
+ val nickname = try { com.bitchat.android.services.NicknameProvider.getNickname(context, myPeerID) } catch (_: Exception) { myPeerID }
// Get the static public key for the announcement
val staticKey = encryptionService.getStaticPublicKey()
@@ -1000,6 +1094,13 @@ class BluetoothMeshService(private val context: Context) {
return peerManager.getFingerprintForPeer(peerID)
}
+ /**
+ * Get current active peer count (for status/notifications)
+ */
+ fun getActivePeerCount(): Int {
+ return try { peerManager.getActivePeerCount() } catch (_: Exception) { 0 }
+ }
+
/**
* Get peer info for verification purposes
*/
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
index b34742177..04e5d7564 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
@@ -73,9 +73,17 @@ class BluetoothPacketBroadcaster(
try {
val fromNick = incomingPeer?.let { nicknameResolver?.invoke(it) }
val toNick = toPeer?.let { nicknameResolver?.invoke(it) }
- val isRelay = (incomingAddr != null || incomingPeer != null)
-
- com.bitchat.android.ui.debug.DebugSettingsManager.getInstance().logPacketRelayDetailed(
+ val manager = com.bitchat.android.ui.debug.DebugSettingsManager.getInstance()
+ // Always log outgoing for the actual transmission target
+ manager.logOutgoing(
+ packetType = typeName,
+ toPeerID = toPeer,
+ toNickname = toNick,
+ toDeviceAddress = toDeviceAddress,
+ previousHopPeerID = incomingPeer
+ )
+ // Keep the verbose relay message for human readability
+ manager.logPacketRelayDetailed(
packetType = typeName,
senderPeerID = senderPeerID,
senderNickname = senderNick,
@@ -86,7 +94,7 @@ class BluetoothPacketBroadcaster(
toNickname = toNick,
toDeviceAddress = toDeviceAddress,
ttl = ttl,
- isRelay = isRelay
+ isRelay = true
)
} catch (_: Exception) {
// Silently ignore debug logging failures
diff --git a/app/src/main/java/com/bitchat/android/mesh/PowerManager.kt b/app/src/main/java/com/bitchat/android/mesh/PowerManager.kt
index 9db444e6f..46bc394fb 100644
--- a/app/src/main/java/com/bitchat/android/mesh/PowerManager.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/PowerManager.kt
@@ -224,26 +224,29 @@ class PowerManager(private val context: Context) {
}
private fun updatePowerMode() {
- val newMode = when {
- // Always use performance mode when charging (unless in background too long)
+ // Determine the base mode from battery/charging state only
+ val baseMode = when {
+ // Charging in foreground may use performance
isCharging && !isAppInBackground -> PowerMode.PERFORMANCE
-
- // Critical battery - use ultra low power
+
+ // Critical battery - force ultra low power regardless of foreground/background
batteryLevel <= CRITICAL_BATTERY -> PowerMode.ULTRA_LOW_POWER
-
- // Low battery - use power saver
+
+ // Low battery - prefer power saver
batteryLevel <= LOW_BATTERY -> PowerMode.POWER_SAVER
-
- // Background app with medium battery - use power saver
- isAppInBackground && batteryLevel <= MEDIUM_BATTERY -> PowerMode.POWER_SAVER
-
- // Background app with good battery - use balanced
- isAppInBackground -> PowerMode.BALANCED
-
- // Foreground with good battery - use balanced
+
+ // Otherwise balanced
else -> PowerMode.BALANCED
}
-
+
+ // If app is in background (including when running as a foreground service),
+ // cap the power mode to at least POWER_SAVER. Preserve ULTRA_LOW_POWER.
+ val newMode = if (isAppInBackground) {
+ if (baseMode == PowerMode.ULTRA_LOW_POWER) PowerMode.ULTRA_LOW_POWER else PowerMode.POWER_SAVER
+ } else {
+ baseMode
+ }
+
if (newMode != currentMode) {
val oldMode = currentMode
currentMode = newMode
diff --git a/app/src/main/java/com/bitchat/android/service/AppShutdownCoordinator.kt b/app/src/main/java/com/bitchat/android/service/AppShutdownCoordinator.kt
new file mode 100644
index 000000000..d4e001048
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/service/AppShutdownCoordinator.kt
@@ -0,0 +1,67 @@
+package com.bitchat.android.service
+
+import android.app.Application
+import android.os.Process
+import androidx.core.app.NotificationManagerCompat
+import com.bitchat.android.mesh.BluetoothMeshService
+import com.bitchat.android.net.ArtiTorManager
+import com.bitchat.android.net.TorMode
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+
+/**
+ * Coordinates a full application shutdown:
+ * - Stop mesh cleanly
+ * - Stop Tor without changing persistent setting
+ * - Clear in-memory AppState
+ * - Stop foreground service/notification
+ * - Kill the process after completion or after a 5s timeout
+ */
+object AppShutdownCoordinator {
+ private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
+
+ fun requestFullShutdownAndKill(
+ app: Application,
+ mesh: BluetoothMeshService?,
+ notificationManager: NotificationManagerCompat,
+ stopForeground: () -> Unit,
+ stopService: () -> Unit
+ ) {
+ scope.launch {
+ // Stop mesh (best-effort)
+ try { mesh?.stopServices() } catch (_: Exception) { }
+
+ // Stop Tor temporarily (do not change user setting)
+ val torProvider = ArtiTorManager.getInstance()
+ val torStop = async {
+ try { torProvider.applyMode(app, TorMode.OFF) } catch (_: Exception) { }
+ }
+
+ // Clear AppState in-memory store
+ try { com.bitchat.android.services.AppStateStore.clear() } catch (_: Exception) { }
+
+ // Stop foreground and clear notification
+ try { stopForeground() } catch (_: Exception) { }
+ try { notificationManager.cancel(10001) } catch (_: Exception) { }
+
+ // Wait up to 5 seconds for shutdown tasks
+ withTimeoutOrNull(5000) {
+ try { torStop.await() } catch (_: Exception) { }
+ delay(100)
+ }
+
+ // Stop the service itself
+ try { stopService() } catch (_: Exception) { }
+
+ // Hard kill the app process
+ try { Process.killProcess(Process.myPid()) } catch (_: Exception) { }
+ try { System.exit(0) } catch (_: Exception) { }
+ }
+ }
+}
+
diff --git a/app/src/main/java/com/bitchat/android/service/BootCompletedReceiver.kt b/app/src/main/java/com/bitchat/android/service/BootCompletedReceiver.kt
new file mode 100644
index 000000000..03a9dcd81
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/service/BootCompletedReceiver.kt
@@ -0,0 +1,16 @@
+package com.bitchat.android.service
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class BootCompletedReceiver : BroadcastReceiver() {
+ override fun onReceive(context: Context, intent: Intent) {
+ // Ensure preferences are initialized on cold boot before reading values
+ try { MeshServicePreferences.init(context.applicationContext) } catch (_: Exception) { }
+
+ if (MeshServicePreferences.isAutoStartEnabled(true)) {
+ MeshForegroundService.start(context.applicationContext)
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/service/MeshForegroundService.kt b/app/src/main/java/com/bitchat/android/service/MeshForegroundService.kt
new file mode 100644
index 000000000..7510fa06a
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/service/MeshForegroundService.kt
@@ -0,0 +1,324 @@
+package com.bitchat.android.service
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.bitchat.android.MainActivity
+import com.bitchat.android.R
+import com.bitchat.android.mesh.BluetoothMeshService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+class MeshForegroundService : Service() {
+
+ companion object {
+ private const val CHANNEL_ID = "bitchat_mesh_service"
+ private const val NOTIFICATION_ID = 10001
+
+ const val ACTION_START = "com.bitchat.android.service.START"
+ const val ACTION_STOP = "com.bitchat.android.service.STOP"
+ const val ACTION_QUIT = "com.bitchat.android.service.QUIT"
+ const val ACTION_UPDATE_NOTIFICATION = "com.bitchat.android.service.UPDATE_NOTIFICATION"
+ const val ACTION_NOTIFICATION_PERMISSION_GRANTED = "com.bitchat.android.action.NOTIFICATION_PERMISSION_GRANTED"
+
+ fun start(context: Context) {
+ val intent = Intent(context, MeshForegroundService::class.java).apply { action = ACTION_START }
+
+ // On API >= 26, avoid background-service start restrictions by using startForegroundService
+ // only when we can actually post a notification (Android 13+ requires runtime notif permission)
+ val bgEnabled = MeshServicePreferences.isBackgroundEnabled(true)
+ val hasNotifPerm = hasNotificationPermissionStatic(context)
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ if (bgEnabled && hasNotifPerm) {
+ context.startForegroundService(intent)
+ } else {
+ // Do not attempt to start a background service from headless context without notif permission
+ // or when background is disabled, to avoid BackgroundServiceStartNotAllowedException.
+ android.util.Log.i(
+ "MeshForegroundService",
+ "Not starting service on API>=26 (bgEnabled=$bgEnabled, hasNotifPerm=$hasNotifPerm)"
+ )
+ }
+ } else {
+ if (bgEnabled) {
+ context.startService(intent)
+ } else {
+ android.util.Log.i("MeshForegroundService", "Background disabled; not starting service (pre-O)")
+ }
+ }
+ }
+
+ /**
+ * Helper to be invoked right after POST_NOTIFICATIONS is granted to try
+ * promoting/starting the foreground service immediately without polling.
+ */
+ fun onNotificationPermissionGranted(context: Context) {
+ // If background is enabled and permission now granted, start/promo service
+ val hasNotifPerm = hasNotificationPermissionStatic(context)
+ if (!MeshServicePreferences.isBackgroundEnabled(true) || !hasNotifPerm) return
+
+ val intent = Intent(context, MeshForegroundService::class.java).apply { action = ACTION_UPDATE_NOTIFICATION }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ // Safe now that we can show a notification
+ context.startForegroundService(intent)
+ } else {
+ context.startService(intent)
+ }
+ }
+
+ fun stop(context: Context) {
+ val intent = Intent(context, MeshForegroundService::class.java).apply { action = ACTION_STOP }
+ context.startService(intent)
+ }
+
+ private fun shouldStartAsForeground(context: Context): Boolean {
+ return MeshServicePreferences.isBackgroundEnabled(true) &&
+ hasBluetoothPermissionsStatic(context) &&
+ hasNotificationPermissionStatic(context)
+ }
+
+ private fun hasBluetoothPermissionsStatic(ctx: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.BLUETOOTH_ADVERTISE) == android.content.pm.PackageManager.PERMISSION_GRANTED &&
+ androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.BLUETOOTH_CONNECT) == android.content.pm.PackageManager.PERMISSION_GRANTED &&
+ androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.BLUETOOTH_SCAN) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ } else {
+ val fine = androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.ACCESS_FINE_LOCATION) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ val coarse = androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.ACCESS_COARSE_LOCATION) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ fine || coarse
+ }
+ }
+
+ private fun hasNotificationPermissionStatic(ctx: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= 33) {
+ androidx.core.content.ContextCompat.checkSelfPermission(ctx, android.Manifest.permission.POST_NOTIFICATIONS) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ } else true
+ }
+ }
+
+ private lateinit var notificationManager: NotificationManagerCompat
+ private var updateJob: Job? = null
+ private var meshService: BluetoothMeshService? = null
+ private val serviceJob = Job()
+ private val scope = CoroutineScope(Dispatchers.Default + serviceJob)
+ private var isInForeground: Boolean = false
+
+ override fun onCreate() {
+ super.onCreate()
+ notificationManager = NotificationManagerCompat.from(this)
+ createChannel()
+
+ // Adopt or create the mesh service
+ val existing = MeshServiceHolder.meshService
+ meshService = existing ?: MeshServiceHolder.getOrCreate(applicationContext)
+ if (existing != null) {
+ android.util.Log.d("MeshForegroundService", "Adopted existing BluetoothMeshService from holder")
+ } else {
+ android.util.Log.i("MeshForegroundService", "Created/adopted new BluetoothMeshService via holder")
+ }
+ MeshServiceHolder.attach(meshService!!)
+ }
+
+ override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+ when (intent?.action) {
+ ACTION_STOP -> {
+ // Stop FGS and mesh cleanly
+ try { meshService?.stopServices() } catch (_: Exception) { }
+ try { MeshServiceHolder.clear() } catch (_: Exception) { }
+ try { stopForeground(true) } catch (_: Exception) { }
+ notificationManager.cancel(NOTIFICATION_ID)
+ isInForeground = false
+ stopSelf()
+ return START_NOT_STICKY
+ }
+ ACTION_QUIT -> {
+ // Fully stop all background activity, stop Tor (without changing setting), then kill the app
+ AppShutdownCoordinator.requestFullShutdownAndKill(
+ app = application,
+ mesh = meshService,
+ notificationManager = notificationManager,
+ stopForeground = {
+ try { stopForeground(true) } catch (_: Exception) { }
+ isInForeground = false
+ },
+ stopService = { stopSelf() }
+ )
+ return START_NOT_STICKY
+ }
+ ACTION_UPDATE_NOTIFICATION -> {
+ // If we became eligible and are not in foreground yet, promote once
+ if (MeshServicePreferences.isBackgroundEnabled(true) && hasAllRequiredPermissions() && !isInForeground) {
+ val n = buildNotification(meshService?.getActivePeerCount() ?: 0)
+ startForeground(NOTIFICATION_ID, n)
+ isInForeground = true
+ } else {
+ updateNotification(force = true)
+ }
+ }
+ else -> { /* ACTION_START or null */ }
+ }
+
+ // Ensure mesh is running (only after permissions are granted)
+ ensureMeshStarted()
+
+ // Promote exactly once when eligible, otherwise stay background (or stop)
+ if (MeshServicePreferences.isBackgroundEnabled(true) && hasAllRequiredPermissions() && !isInForeground) {
+ val notification = buildNotification(meshService?.getActivePeerCount() ?: 0)
+ startForeground(NOTIFICATION_ID, notification)
+ isInForeground = true
+ }
+
+ // Periodically refresh the notification with live network size
+ if (updateJob == null) {
+ updateJob = scope.launch {
+ while (isActive) {
+ // Retry enabling mesh/foreground once permissions become available
+ ensureMeshStarted()
+ val eligible = MeshServicePreferences.isBackgroundEnabled(true) && hasAllRequiredPermissions()
+ if (eligible) {
+ // Only update the notification; do not re-call startForeground()
+ updateNotification(force = false)
+ } else {
+ // If disabled or perms missing, ensure we are not in foreground and clear notif
+ if (isInForeground) {
+ try { stopForeground(false) } catch (_: Exception) { }
+ isInForeground = false
+ }
+ notificationManager.cancel(NOTIFICATION_ID)
+ }
+ delay(5000)
+ }
+ }
+ }
+
+ return START_STICKY
+ }
+
+ private fun ensureMeshStarted() {
+ if (!hasBluetoothPermissions()) return
+ try {
+ android.util.Log.d("MeshForegroundService", "Ensuring mesh service is started")
+ meshService?.startServices()
+ } catch (e: Exception) {
+ android.util.Log.e("MeshForegroundService", "Failed to start mesh service: ${e.message}")
+ }
+ }
+
+ private fun updateNotification(force: Boolean) {
+ val count = meshService?.getActivePeerCount() ?: 0
+ val notification = buildNotification(count)
+ if (MeshServicePreferences.isBackgroundEnabled(true) && hasAllRequiredPermissions()) {
+ notificationManager.notify(NOTIFICATION_ID, notification)
+ } else if (force) {
+ // If disabled and forced, make sure to remove any prior foreground state
+ try { stopForeground(false) } catch (_: Exception) { }
+ notificationManager.cancel(NOTIFICATION_ID)
+ isInForeground = false
+ }
+ }
+
+ private fun hasAllRequiredPermissions(): Boolean {
+ // For starting FGS with connectedDevice|dataSync, we need:
+ // - Foreground service permissions (declared in manifest)
+ // - One of the device-related permissions (we request BL perms at runtime)
+ // - On Android 13+, POST_NOTIFICATIONS to actually show notification
+ return hasBluetoothPermissions() && hasNotificationPermission()
+ }
+
+ private fun hasBluetoothPermissions(): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_ADVERTISE) == android.content.pm.PackageManager.PERMISSION_GRANTED &&
+ androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_CONNECT) == android.content.pm.PackageManager.PERMISSION_GRANTED &&
+ androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ } else {
+ // Prior to S, scanning requires location permissions
+ val fine = androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ val coarse = androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_COARSE_LOCATION) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ fine || coarse
+ }
+ }
+
+ private fun hasNotificationPermission(): Boolean {
+ return if (Build.VERSION.SDK_INT >= 33) {
+ androidx.core.content.ContextCompat.checkSelfPermission(this, android.Manifest.permission.POST_NOTIFICATIONS) == android.content.pm.PackageManager.PERMISSION_GRANTED
+ } else true
+ }
+
+ private fun buildNotification(activeUsers: Int): Notification {
+ val openIntent = Intent(this, MainActivity::class.java)
+ val pendingIntent = PendingIntent.getActivity(
+ this, 0, openIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= 23) PendingIntent.FLAG_IMMUTABLE else 0)
+ )
+
+ // Action: Quit Bitchat
+ val quitIntent = Intent(this, MeshForegroundService::class.java).apply { action = ACTION_QUIT }
+ val quitPendingIntent = PendingIntent.getService(
+ this, 1, quitIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= 23) PendingIntent.FLAG_IMMUTABLE else 0)
+ )
+
+ val title = getString(R.string.app_name)
+ val content = getString(R.string.mesh_service_notification_content, activeUsers)
+
+ return NotificationCompat.Builder(this, CHANNEL_ID)
+ .setContentTitle(title)
+ .setContentText(content)
+ .setSmallIcon(R.mipmap.ic_launcher)
+ .setOngoing(true)
+ .setOnlyAlertOnce(true)
+ .setPriority(NotificationCompat.PRIORITY_LOW)
+ .setCategory(NotificationCompat.CATEGORY_SERVICE)
+ .setContentIntent(pendingIntent)
+ // Add an action button that appears when notification is expanded
+ .addAction(
+ android.R.drawable.ic_menu_close_clear_cancel,
+ getString(R.string.notification_action_quit_bitchat),
+ quitPendingIntent
+ )
+ .build()
+ }
+
+ private fun createChannel() {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ val channel = NotificationChannel(
+ CHANNEL_ID,
+ getString(R.string.mesh_service_channel_name),
+ NotificationManager.IMPORTANCE_LOW
+ ).apply {
+ description = getString(R.string.mesh_service_channel_desc)
+ setShowBadge(false)
+ }
+ (getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+ .createNotificationChannel(channel)
+ }
+ }
+
+ override fun onDestroy() {
+ updateJob?.cancel()
+ updateJob = null
+ // Cancel the service coroutine scope to prevent leaks
+ try { serviceJob.cancel() } catch (_: Exception) { }
+ // Best-effort ensure we are not marked foreground
+ if (isInForeground) {
+ try { stopForeground(true) } catch (_: Exception) { }
+ isInForeground = false
+ }
+ super.onDestroy()
+ }
+
+ override fun onBind(intent: Intent?): IBinder? = null
+}
diff --git a/app/src/main/java/com/bitchat/android/service/MeshServiceHolder.kt b/app/src/main/java/com/bitchat/android/service/MeshServiceHolder.kt
new file mode 100644
index 000000000..d271ab295
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/service/MeshServiceHolder.kt
@@ -0,0 +1,60 @@
+package com.bitchat.android.service
+
+import android.content.Context
+import com.bitchat.android.mesh.BluetoothMeshService
+
+/**
+ * Process-wide holder to share a single BluetoothMeshService instance
+ * between the foreground service and UI (MainActivity/ViewModels).
+ */
+object MeshServiceHolder {
+ private const val TAG = "MeshServiceHolder"
+ @Volatile
+ var meshService: BluetoothMeshService? = null
+ private set
+
+ @Synchronized
+ fun getOrCreate(context: Context): BluetoothMeshService {
+ val existing = meshService
+ if (existing != null) {
+ // If the existing instance is healthy, reuse it; otherwise, replace it.
+ return try {
+ if (existing.isReusable()) {
+ android.util.Log.d(TAG, "Reusing existing BluetoothMeshService instance")
+ existing
+ } else {
+ android.util.Log.w(TAG, "Existing BluetoothMeshService not reusable; replacing with a fresh instance")
+ // Best-effort stop before replacing
+ try { existing.stopServices() } catch (e: Exception) {
+ android.util.Log.w(TAG, "Error while stopping non-reusable instance: ${e.message}")
+ }
+ val created = BluetoothMeshService(context.applicationContext)
+ android.util.Log.i(TAG, "Created new BluetoothMeshService (replacement)")
+ meshService = created
+ created
+ }
+ } catch (e: Exception) {
+ android.util.Log.e(TAG, "Error checking service reusability; creating new instance: ${e.message}")
+ val created = BluetoothMeshService(context.applicationContext)
+ meshService = created
+ created
+ }
+ }
+ val created = BluetoothMeshService(context.applicationContext)
+ android.util.Log.i(TAG, "Created new BluetoothMeshService (no existing instance)")
+ meshService = created
+ return created
+ }
+
+ @Synchronized
+ fun attach(service: BluetoothMeshService) {
+ android.util.Log.d(TAG, "Attaching BluetoothMeshService to holder")
+ meshService = service
+ }
+
+ @Synchronized
+ fun clear() {
+ android.util.Log.d(TAG, "Clearing BluetoothMeshService from holder")
+ meshService = null
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/service/MeshServicePreferences.kt b/app/src/main/java/com/bitchat/android/service/MeshServicePreferences.kt
new file mode 100644
index 000000000..47335ee3d
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/service/MeshServicePreferences.kt
@@ -0,0 +1,32 @@
+package com.bitchat.android.service
+
+import android.content.Context
+import android.content.SharedPreferences
+
+object MeshServicePreferences {
+ private const val PREFS_NAME = "bitchat_mesh_service_prefs"
+ private const val KEY_AUTO_START = "auto_start_on_boot"
+ private const val KEY_BACKGROUND_ENABLED = "background_enabled"
+
+ private lateinit var prefs: SharedPreferences
+
+ fun init(context: Context) {
+ prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+ }
+
+ fun isAutoStartEnabled(default: Boolean = true): Boolean {
+ return prefs.getBoolean(KEY_AUTO_START, default)
+ }
+
+ fun setAutoStartEnabled(enabled: Boolean) {
+ prefs.edit().putBoolean(KEY_AUTO_START, enabled).apply()
+ }
+
+ fun isBackgroundEnabled(default: Boolean = true): Boolean {
+ return prefs.getBoolean(KEY_BACKGROUND_ENABLED, default)
+ }
+
+ fun setBackgroundEnabled(enabled: Boolean) {
+ prefs.edit().putBoolean(KEY_BACKGROUND_ENABLED, enabled).apply()
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/AppStateStore.kt b/app/src/main/java/com/bitchat/android/services/AppStateStore.kt
new file mode 100644
index 000000000..07f146bd2
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/AppStateStore.kt
@@ -0,0 +1,109 @@
+package com.bitchat.android.services
+
+import com.bitchat.android.model.BitchatMessage
+import com.bitchat.android.model.DeliveryStatus
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Process-wide in-memory state store that survives Activity recreation.
+ * The foreground Mesh service updates this store; UI subscribes/hydrates from it.
+ */
+object AppStateStore {
+ // Global de-dup set by message id to avoid duplicate keys in Compose lists
+ private val seenMessageIds = mutableSetOf()
+ // Connected peer IDs (mesh ephemeral IDs)
+ private val _peers = MutableStateFlow>(emptyList())
+ val peers: StateFlow> = _peers.asStateFlow()
+
+ // Public mesh timeline messages (non-channel)
+ private val _publicMessages = MutableStateFlow>(emptyList())
+ val publicMessages: StateFlow> = _publicMessages.asStateFlow()
+
+ // Private messages by peerID
+ private val _privateMessages = MutableStateFlow>>(emptyMap())
+ val privateMessages: StateFlow>> = _privateMessages.asStateFlow()
+
+ // Channel messages by channel name
+ private val _channelMessages = MutableStateFlow>>(emptyMap())
+ val channelMessages: StateFlow>> = _channelMessages.asStateFlow()
+
+ fun setPeers(ids: List) {
+ _peers.value = ids
+ }
+
+ fun addPublicMessage(msg: BitchatMessage) {
+ synchronized(this) {
+ if (seenMessageIds.contains(msg.id)) return
+ seenMessageIds.add(msg.id)
+ _publicMessages.value = _publicMessages.value + msg
+ }
+ }
+
+ fun addPrivateMessage(peerID: String, msg: BitchatMessage) {
+ synchronized(this) {
+ if (seenMessageIds.contains(msg.id)) return
+ seenMessageIds.add(msg.id)
+ val map = _privateMessages.value.toMutableMap()
+ val list = (map[peerID] ?: emptyList()) + msg
+ map[peerID] = list
+ _privateMessages.value = map
+ }
+ }
+
+ private fun statusPriority(status: DeliveryStatus?): Int = when (status) {
+ null -> 0
+ is DeliveryStatus.Sending -> 1
+ is DeliveryStatus.Sent -> 2
+ is DeliveryStatus.PartiallyDelivered -> 3
+ is DeliveryStatus.Delivered -> 4
+ is DeliveryStatus.Read -> 5
+ is DeliveryStatus.Failed -> 0
+ }
+
+ fun updatePrivateMessageStatus(messageID: String, status: DeliveryStatus) {
+ synchronized(this) {
+ val map = _privateMessages.value.toMutableMap()
+ var changed = false
+ map.keys.toList().forEach { peer ->
+ val list = map[peer]?.toMutableList() ?: mutableListOf()
+ val idx = list.indexOfFirst { it.id == messageID }
+ if (idx >= 0) {
+ val current = list[idx].deliveryStatus
+ // Do not downgrade (e.g., Read -> Delivered)
+ if (statusPriority(status) >= statusPriority(current)) {
+ list[idx] = list[idx].copy(deliveryStatus = status)
+ map[peer] = list
+ changed = true
+ }
+ }
+ }
+ if (changed) {
+ _privateMessages.value = map
+ }
+ }
+ }
+
+ fun addChannelMessage(channel: String, msg: BitchatMessage) {
+ synchronized(this) {
+ if (seenMessageIds.contains(msg.id)) return
+ seenMessageIds.add(msg.id)
+ val map = _channelMessages.value.toMutableMap()
+ val list = (map[channel] ?: emptyList()) + msg
+ map[channel] = list
+ _channelMessages.value = map
+ }
+ }
+
+ // Clear all in-memory state (used for full app shutdown)
+ fun clear() {
+ synchronized(this) {
+ seenMessageIds.clear()
+ _peers.value = emptyList()
+ _publicMessages.value = emptyList()
+ _privateMessages.value = emptyMap()
+ _channelMessages.value = emptyMap()
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/NicknameProvider.kt b/app/src/main/java/com/bitchat/android/services/NicknameProvider.kt
new file mode 100644
index 000000000..c7cc601f9
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/NicknameProvider.kt
@@ -0,0 +1,21 @@
+package com.bitchat.android.services
+
+import android.content.Context
+import com.bitchat.android.ui.DataManager
+
+/**
+ * Provides current user's nickname for announcements and leave messages.
+ * If no nickname saved, falls back to the provided peerID.
+ */
+object NicknameProvider {
+ fun getNickname(context: Context, myPeerID: String): String {
+ return try {
+ val dm = DataManager(context.applicationContext)
+ val nick = dm.loadNickname()
+ if (nick.isNullOrBlank()) myPeerID else nick
+ } catch (_: Exception) {
+ myPeerID
+ }
+ }
+}
+
diff --git a/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt b/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
index 49c664d39..7c5fa7a00 100644
--- a/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
+++ b/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
@@ -12,6 +12,9 @@ import androidx.compose.material.icons.filled.Bluetooth
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Public
import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material.icons.filled.NetworkCheck
+import androidx.compose.material.icons.filled.Speed
import androidx.compose.material.icons.outlined.Info
import androidx.compose.material3.*
import androidx.compose.runtime.*
@@ -19,6 +22,7 @@ import androidx.compose.ui.Alignment
import kotlinx.coroutines.launch
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
@@ -37,8 +41,162 @@ import com.bitchat.android.net.TorPreferenceManager
import com.bitchat.android.net.ArtiTorManager
/**
- * About Sheet for bitchat app information
- * Matches the design language of LocationChannelsSheet
+ * Feature row for displaying app capabilities
+ */
+@Composable
+private fun FeatureRow(
+ icon: ImageVector,
+ title: String,
+ subtitle: String
+) {
+ val colorScheme = MaterialTheme.colorScheme
+
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 16.dp, vertical = 14.dp),
+ verticalAlignment = Alignment.Top
+ ) {
+ Icon(
+ imageVector = icon,
+ contentDescription = null,
+ tint = colorScheme.primary,
+ modifier = Modifier
+ .padding(top = 2.dp)
+ .size(22.dp)
+ )
+ Spacer(modifier = Modifier.width(14.dp))
+ Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+ Text(
+ text = title,
+ style = MaterialTheme.typography.bodyMedium,
+ fontWeight = FontWeight.Medium,
+ color = colorScheme.onSurface
+ )
+ Text(
+ text = subtitle,
+ style = MaterialTheme.typography.bodySmall,
+ color = colorScheme.onSurface.copy(alpha = 0.6f),
+ lineHeight = 18.sp
+ )
+ }
+ }
+}
+
+/**
+ * Theme selection chip with Apple-like styling
+ */
+@Composable
+private fun ThemeChip(
+ label: String,
+ selected: Boolean,
+ onClick: () -> Unit,
+ modifier: Modifier = Modifier
+) {
+ val colorScheme = MaterialTheme.colorScheme
+ val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f
+
+ Surface(
+ modifier = modifier,
+ onClick = onClick,
+ shape = RoundedCornerShape(10.dp),
+ color = if (selected) {
+ if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
+ } else {
+ colorScheme.surfaceVariant.copy(alpha = 0.5f)
+ }
+ ) {
+ Box(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(vertical = 10.dp),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = label,
+ style = MaterialTheme.typography.bodySmall,
+ fontWeight = if (selected) FontWeight.SemiBold else FontWeight.Normal,
+ color = if (selected) Color.White else colorScheme.onSurface.copy(alpha = 0.8f)
+ )
+ }
+ }
+}
+
+/**
+ * Unified settings toggle row with icon, title, subtitle, and switch
+ * Apple-like design with proper spacing
+ */
+@Composable
+private fun SettingsToggleRow(
+ icon: ImageVector,
+ title: String,
+ subtitle: String,
+ checked: Boolean,
+ onCheckedChange: (Boolean) -> Unit,
+ enabled: Boolean = true,
+ statusIndicator: (@Composable () -> Unit)? = null
+) {
+ val colorScheme = MaterialTheme.colorScheme
+ val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f
+
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 16.dp, vertical = 14.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Icon(
+ imageVector = icon,
+ contentDescription = null,
+ tint = if (enabled) colorScheme.primary else colorScheme.onSurface.copy(alpha = 0.3f),
+ modifier = Modifier.size(22.dp)
+ )
+
+ Spacer(modifier = Modifier.width(14.dp))
+
+ Column(
+ modifier = Modifier.weight(1f),
+ verticalArrangement = Arrangement.spacedBy(2.dp)
+ ) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(8.dp)
+ ) {
+ Text(
+ text = title,
+ style = MaterialTheme.typography.bodyMedium,
+ fontWeight = FontWeight.Medium,
+ color = if (enabled) colorScheme.onSurface else colorScheme.onSurface.copy(alpha = 0.4f)
+ )
+ statusIndicator?.invoke()
+ }
+ Text(
+ text = subtitle,
+ style = MaterialTheme.typography.bodySmall,
+ color = colorScheme.onSurface.copy(alpha = if (enabled) 0.6f else 0.3f),
+ lineHeight = 16.sp
+ )
+ }
+
+ Spacer(modifier = Modifier.width(16.dp))
+
+ Switch(
+ checked = checked,
+ onCheckedChange = { if (enabled) onCheckedChange(it) },
+ enabled = enabled,
+ colors = SwitchDefaults.colors(
+ checkedThumbColor = Color.White,
+ checkedTrackColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
+ uncheckedThumbColor = Color.White,
+ uncheckedTrackColor = colorScheme.surfaceVariant
+ )
+ )
+ }
+}
+
+/**
+ * Apple-like About/Settings Sheet with high-quality design
+ * Professional UX optimized for checkout scenarios
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -58,8 +216,6 @@ fun AboutSheet(
"1.0.0" // fallback version
}
}
-
- // Bottom sheet state
val sheetState = rememberModalBottomSheetState(
skipPartiallyExpanded = true
@@ -72,11 +228,10 @@ fun AboutSheet(
}
}
val topBarAlpha by animateFloatAsState(
- targetValue = if (isScrolled) 0.95f else 0f,
+ targetValue = if (isScrolled) 0.98f else 0f,
label = "topBarAlpha"
)
- // Color scheme matching LocationChannelsSheet
val colorScheme = MaterialTheme.colorScheme
val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f
@@ -85,424 +240,352 @@ fun AboutSheet(
modifier = modifier.statusBarsPadding(),
onDismissRequest = onDismiss,
sheetState = sheetState,
- containerColor = MaterialTheme.colorScheme.background,
+ containerColor = colorScheme.background,
dragHandle = null
) {
Box(modifier = Modifier.fillMaxWidth()) {
LazyColumn(
state = lazyListState,
modifier = Modifier.fillMaxSize(),
- contentPadding = PaddingValues(top = 80.dp, bottom = 20.dp)
+ contentPadding = PaddingValues(top = 80.dp, bottom = 32.dp),
+ verticalArrangement = Arrangement.spacedBy(20.dp)
) {
- // Header Section
+ // Header Section - App Identity
item(key = "header") {
Column(
modifier = Modifier
.fillMaxWidth()
- .padding(horizontal = 24.dp)
- .padding(bottom = 16.dp),
- verticalArrangement = Arrangement.spacedBy(8.dp)
+ .padding(horizontal = 20.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(4.dp)
) {
- Row(
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- verticalAlignment = Alignment.Bottom
- ) {
- Text(
- text = stringResource(R.string.app_name),
- style = TextStyle(
- fontFamily = FontFamily.Monospace,
- fontWeight = FontWeight.Bold,
- fontSize = 32.sp
- ),
- color = MaterialTheme.colorScheme.onBackground
- )
-
- Text(
- text = stringResource(R.string.version_prefix, versionName?:""),
- fontSize = 11.sp,
+ Text(
+ text = stringResource(R.string.app_name),
+ style = TextStyle(
fontFamily = FontFamily.Monospace,
- color = colorScheme.onBackground.copy(alpha = 0.5f),
- style = MaterialTheme.typography.bodySmall.copy(
- baselineShift = BaselineShift(0.1f)
- )
- )
- }
-
+ fontWeight = FontWeight.Bold,
+ fontSize = 28.sp,
+ letterSpacing = 1.sp
+ ),
+ color = colorScheme.onBackground
+ )
+ Text(
+ text = stringResource(R.string.version_prefix, versionName ?: ""),
+ fontSize = 13.sp,
+ fontFamily = FontFamily.Monospace,
+ color = colorScheme.onBackground.copy(alpha = 0.5f)
+ )
Text(
text = stringResource(R.string.about_tagline),
- fontSize = 12.sp,
+ fontSize = 13.sp,
fontFamily = FontFamily.Monospace,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f)
+ color = colorScheme.onBackground.copy(alpha = 0.6f),
+ modifier = Modifier.padding(top = 4.dp)
)
}
}
- // Features section
- item(key = "feature_offline") {
- Row(
- verticalAlignment = Alignment.Top,
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(vertical = 8.dp)
- ) {
- Icon(
- imageVector = Icons.Filled.Bluetooth,
- contentDescription = stringResource(R.string.cd_offline_mesh_chat),
- tint = MaterialTheme.colorScheme.primary,
- modifier = Modifier
- .padding(top = 2.dp)
- .size(20.dp)
- )
- Spacer(modifier = Modifier.width(16.dp))
- Column {
- Text(
- text = stringResource(R.string.about_offline_mesh_title),
- style = MaterialTheme.typography.titleMedium,
- fontWeight = FontWeight.Medium,
- color = MaterialTheme.colorScheme.onBackground
- )
- Spacer(modifier = Modifier.height(4.dp))
- Text(
- text = stringResource(R.string.about_offline_mesh_desc),
- style = MaterialTheme.typography.bodySmall,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f)
- )
- }
- }
- }
- item(key = "feature_geohash") {
- Row(
- verticalAlignment = Alignment.Top,
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(vertical = 8.dp)
- ) {
- Icon(
- imageVector = Icons.Default.Public,
- contentDescription = stringResource(R.string.cd_online_geohash_channels),
- tint = MaterialTheme.colorScheme.primary,
- modifier = Modifier
- .padding(top = 2.dp)
- .size(20.dp)
- )
- Spacer(modifier = Modifier.width(16.dp))
- Column {
- Text(
- text = stringResource(R.string.about_online_geohash_title),
- style = MaterialTheme.typography.titleMedium,
- fontWeight = FontWeight.Medium,
- color = MaterialTheme.colorScheme.onBackground
- )
- Spacer(modifier = Modifier.height(4.dp))
- Text(
- text = stringResource(R.string.about_online_geohash_desc),
- style = MaterialTheme.typography.bodySmall,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f)
- )
- }
- }
- }
- item(key = "feature_encryption") {
- Row(
- verticalAlignment = Alignment.Top,
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(vertical = 8.dp)
- ) {
- Icon(
- imageVector = Icons.Default.Lock,
- contentDescription = stringResource(R.string.cd_end_to_end_encryption),
- tint = MaterialTheme.colorScheme.primary,
- modifier = Modifier
- .padding(top = 2.dp)
- .size(20.dp)
+ // Features Section - Grouped Card
+ item(key = "features") {
+ Column(modifier = Modifier.padding(horizontal = 20.dp)) {
+ Text(
+ text = stringResource(R.string.about_appearance).uppercase(),
+ style = MaterialTheme.typography.labelSmall,
+ color = colorScheme.onBackground.copy(alpha = 0.5f),
+ letterSpacing = 0.5.sp,
+ modifier = Modifier.padding(start = 16.dp, bottom = 8.dp)
)
- Spacer(modifier = Modifier.width(16.dp))
- Column {
- Text(
- text = stringResource(R.string.about_e2e_title),
- style = MaterialTheme.typography.titleMedium,
- fontWeight = FontWeight.Medium,
- color = MaterialTheme.colorScheme.onBackground
- )
- Spacer(modifier = Modifier.height(4.dp))
- Text(
- text = stringResource(R.string.about_e2e_desc),
- style = MaterialTheme.typography.bodySmall,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f)
- )
+ Surface(
+ modifier = Modifier.fillMaxWidth(),
+ color = colorScheme.surface,
+ shape = RoundedCornerShape(16.dp)
+ ) {
+ Column {
+ FeatureRow(
+ icon = Icons.Filled.Bluetooth,
+ title = stringResource(R.string.about_offline_mesh_title),
+ subtitle = stringResource(R.string.about_offline_mesh_desc)
+ )
+ HorizontalDivider(
+ modifier = Modifier.padding(start = 56.dp),
+ color = colorScheme.outline.copy(alpha = 0.12f)
+ )
+ FeatureRow(
+ icon = Icons.Default.Public,
+ title = stringResource(R.string.about_online_geohash_title),
+ subtitle = stringResource(R.string.about_online_geohash_desc)
+ )
+ HorizontalDivider(
+ modifier = Modifier.padding(start = 56.dp),
+ color = colorScheme.outline.copy(alpha = 0.12f)
+ )
+ FeatureRow(
+ icon = Icons.Default.Lock,
+ title = stringResource(R.string.about_e2e_title),
+ subtitle = stringResource(R.string.about_e2e_desc)
+ )
+ }
}
}
}
// Appearance Section
- item(key = "appearance_section") {
- Text(
- text = stringResource(R.string.about_appearance),
- style = MaterialTheme.typography.labelLarge,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f),
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(top = 24.dp, bottom = 8.dp)
- )
- val themePref by com.bitchat.android.ui.theme.ThemePreferenceManager.themeFlow.collectAsStateWithLifecycle()
- Row(
- modifier = Modifier.padding(horizontal = 24.dp),
- horizontalArrangement = Arrangement.spacedBy(8.dp)
- ) {
- FilterChip(
- selected = themePref.isSystem,
- onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.System) },
- label = { Text(stringResource(R.string.about_system), fontFamily = FontFamily.Monospace) }
- )
- FilterChip(
- selected = themePref.isLight,
- onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.Light) },
- label = { Text(stringResource(R.string.about_light), fontFamily = FontFamily.Monospace) }
- )
- FilterChip(
- selected = themePref.isDark,
- onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.Dark) },
- label = { Text(stringResource(R.string.about_dark), fontFamily = FontFamily.Monospace) }
+ item(key = "appearance") {
+ Column(modifier = Modifier.padding(horizontal = 20.dp)) {
+ Text(
+ text = "THEME",
+ style = MaterialTheme.typography.labelSmall,
+ color = colorScheme.onBackground.copy(alpha = 0.5f),
+ letterSpacing = 0.5.sp,
+ modifier = Modifier.padding(start = 16.dp, bottom = 8.dp)
)
+ val themePref by com.bitchat.android.ui.theme.ThemePreferenceManager.themeFlow.collectAsState()
+ Surface(
+ modifier = Modifier.fillMaxWidth(),
+ color = colorScheme.surface,
+ shape = RoundedCornerShape(16.dp)
+ ) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(12.dp),
+ horizontalArrangement = Arrangement.spacedBy(8.dp)
+ ) {
+ ThemeChip(
+ label = stringResource(R.string.about_system),
+ selected = themePref.isSystem,
+ onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.System) },
+ modifier = Modifier.weight(1f)
+ )
+ ThemeChip(
+ label = stringResource(R.string.about_light),
+ selected = themePref.isLight,
+ onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.Light) },
+ modifier = Modifier.weight(1f)
+ )
+ ThemeChip(
+ label = stringResource(R.string.about_dark),
+ selected = themePref.isDark,
+ onClick = { com.bitchat.android.ui.theme.ThemePreferenceManager.set(context, com.bitchat.android.ui.theme.ThemePreference.Dark) },
+ modifier = Modifier.weight(1f)
+ )
+ }
+ }
}
}
- // Proof of Work Section
- item(key = "pow_section") {
- Text(
- text = stringResource(R.string.about_pow),
- style = MaterialTheme.typography.labelLarge,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f),
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(top = 24.dp, bottom = 8.dp)
- )
- LaunchedEffect(Unit) {
- PoWPreferenceManager.init(context)
- }
- val powEnabled by PoWPreferenceManager.powEnabled.collectAsStateWithLifecycle()
- val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsStateWithLifecycle()
+ // Settings Section - Unified Card with Toggles
+ item(key = "settings") {
+ LaunchedEffect(Unit) { PoWPreferenceManager.init(context) }
+ val powEnabled by PoWPreferenceManager.powEnabled.collectAsState()
+ val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState()
+ var backgroundEnabled by remember { mutableStateOf(com.bitchat.android.service.MeshServicePreferences.isBackgroundEnabled(true)) }
+ val torMode = remember { mutableStateOf(TorPreferenceManager.get(context)) }
+ val torProvider = remember { ArtiTorManager.getInstance() }
+ val torStatus by torProvider.statusFlow.collectAsState()
+ val torAvailable = remember { torProvider.isTorAvailable() }
- Column(
- modifier = Modifier.padding(horizontal = 24.dp),
- verticalArrangement = Arrangement.spacedBy(8.dp)
- ) {
- Row(
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- verticalAlignment = Alignment.CenterVertically
+ Column(modifier = Modifier.padding(horizontal = 20.dp)) {
+ Text(
+ text = "SETTINGS",
+ style = MaterialTheme.typography.labelSmall,
+ color = colorScheme.onBackground.copy(alpha = 0.5f),
+ letterSpacing = 0.5.sp,
+ modifier = Modifier.padding(start = 16.dp, bottom = 8.dp)
+ )
+ Surface(
+ modifier = Modifier.fillMaxWidth(),
+ color = colorScheme.surface,
+ shape = RoundedCornerShape(16.dp)
) {
- FilterChip(
- selected = !powEnabled,
- onClick = { PoWPreferenceManager.setPowEnabled(false) },
- label = { Text(stringResource(R.string.about_pow_off), fontFamily = FontFamily.Monospace) }
- )
- FilterChip(
- selected = powEnabled,
- onClick = { PoWPreferenceManager.setPowEnabled(true) },
- label = {
- Row(
- horizontalArrangement = Arrangement.spacedBy(6.dp),
- verticalAlignment = Alignment.CenterVertically
- ) {
- Text(stringResource(R.string.about_pow_on), fontFamily = FontFamily.Monospace)
- // Show current difficulty
- if (powEnabled) {
- Surface(
- color = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
- shape = RoundedCornerShape(50)
- ) { Box(Modifier.size(8.dp)) }
+ Column {
+ // Background Mode Toggle
+ SettingsToggleRow(
+ icon = Icons.Filled.Bluetooth,
+ title = stringResource(R.string.about_background_title),
+ subtitle = stringResource(R.string.about_background_desc),
+ checked = backgroundEnabled,
+ onCheckedChange = { enabled ->
+ backgroundEnabled = enabled
+ com.bitchat.android.service.MeshServicePreferences.setBackgroundEnabled(enabled)
+ if (!enabled) {
+ com.bitchat.android.service.MeshForegroundService.stop(context)
+ } else {
+ com.bitchat.android.service.MeshForegroundService.start(context)
}
}
- }
+ )
+
+ HorizontalDivider(
+ modifier = Modifier.padding(start = 56.dp),
+ color = colorScheme.outline.copy(alpha = 0.12f)
+ )
+
+ // Proof of Work Toggle
+ SettingsToggleRow(
+ icon = Icons.Filled.Speed,
+ title = stringResource(R.string.about_pow),
+ subtitle = stringResource(R.string.about_pow_tip),
+ checked = powEnabled,
+ onCheckedChange = { PoWPreferenceManager.setPowEnabled(it) }
+ )
+
+ HorizontalDivider(
+ modifier = Modifier.padding(start = 56.dp),
+ color = colorScheme.outline.copy(alpha = 0.12f)
+ )
+
+ // Tor Toggle
+ SettingsToggleRow(
+ icon = Icons.Filled.Security,
+ title = "Tor Network",
+ subtitle = stringResource(R.string.about_tor_route),
+ checked = torMode.value == TorMode.ON,
+ onCheckedChange = { enabled ->
+ if (torAvailable) {
+ torMode.value = if (enabled) TorMode.ON else TorMode.OFF
+ TorPreferenceManager.set(context, torMode.value)
+ }
+ },
+ enabled = torAvailable,
+ statusIndicator = if (torMode.value == TorMode.ON) {
+ {
+ val statusColor = when {
+ torStatus.running && torStatus.bootstrapPercent >= 100 -> if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
+ torStatus.running -> Color(0xFFFF9500)
+ else -> Color(0xFFFF3B30)
+ }
+ Surface(
+ color = statusColor,
+ shape = CircleShape,
+ modifier = Modifier.size(8.dp)
+ ) {}
+ }
+ } else null
+ )
+ }
+ }
+
+ // Tor unavailable hint
+ if (!torAvailable) {
+ Text(
+ text = stringResource(R.string.tor_not_available_in_this_build),
+ fontSize = 12.sp,
+ fontFamily = FontFamily.Monospace,
+ color = colorScheme.onBackground.copy(alpha = 0.5f),
+ modifier = Modifier.padding(start = 16.dp, top = 8.dp)
)
}
+ }
+ }
- Text(
- text = stringResource(R.string.about_pow_tip),
- fontSize = 10.sp,
- fontFamily = FontFamily.Monospace,
- color = colorScheme.onSurface.copy(alpha = 0.6f)
- )
-
- // Show difficulty slider when enabled
- if (powEnabled) {
- Column(
+ // PoW Difficulty Slider (when enabled)
+ item(key = "pow_slider") {
+ val powEnabled by PoWPreferenceManager.powEnabled.collectAsState()
+ val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState()
+
+ if (powEnabled) {
+ Column(modifier = Modifier.padding(horizontal = 20.dp)) {
+ Surface(
modifier = Modifier.fillMaxWidth(),
- verticalArrangement = Arrangement.spacedBy(8.dp)
+ color = colorScheme.surface,
+ shape = RoundedCornerShape(16.dp)
) {
- Text(
- text = stringResource(R.string.about_pow_difficulty, powDifficulty, NostrProofOfWork.estimateMiningTime(powDifficulty)),
- fontSize = 11.sp,
- fontFamily = FontFamily.Monospace,
- )
-
- Slider(
- value = powDifficulty.toFloat(),
- onValueChange = { PoWPreferenceManager.setPowDifficulty(it.toInt()) },
- valueRange = 0f..32f,
- steps = 33,
- colors = SliderDefaults.colors(
- thumbColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
- activeTrackColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
- )
- )
-
- // Show difficulty description
- Surface(
- modifier = Modifier.fillMaxWidth(),
- color = colorScheme.surfaceVariant.copy(alpha = 0.25f),
- shape = RoundedCornerShape(8.dp)
+ Column(
+ modifier = Modifier.padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(12.dp)
) {
- Column(
- modifier = Modifier.padding(12.dp),
- verticalArrangement = Arrangement.spacedBy(4.dp)
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
) {
Text(
- text = stringResource(R.string.about_pow_difficulty_attempts, powDifficulty, NostrProofOfWork.estimateWork(powDifficulty)),
- fontSize = 10.sp,
- fontFamily = FontFamily.Monospace,
- color = colorScheme.onSurface.copy(alpha = 0.7f)
+ text = "Difficulty",
+ style = MaterialTheme.typography.bodyMedium,
+ fontWeight = FontWeight.Medium,
+ color = colorScheme.onSurface
)
Text(
- text = when {
- powDifficulty == 0 -> stringResource(R.string.about_pow_desc_none)
- powDifficulty <= 8 -> stringResource(R.string.about_pow_desc_very_low)
- powDifficulty <= 12 -> stringResource(R.string.about_pow_desc_low)
- powDifficulty <= 16 -> stringResource(R.string.about_pow_desc_medium)
- powDifficulty <= 20 -> stringResource(R.string.about_pow_desc_high)
- powDifficulty <= 24 -> stringResource(R.string.about_pow_desc_very_high)
- else -> stringResource(R.string.about_pow_desc_extreme)
- },
- fontSize = 10.sp,
+ text = "$powDifficulty bits • ${NostrProofOfWork.estimateMiningTime(powDifficulty)}",
+ style = MaterialTheme.typography.bodySmall,
fontFamily = FontFamily.Monospace,
color = colorScheme.onSurface.copy(alpha = 0.6f)
)
}
+
+ Slider(
+ value = powDifficulty.toFloat(),
+ onValueChange = { PoWPreferenceManager.setPowDifficulty(it.toInt()) },
+ valueRange = 0f..32f,
+ steps = 31,
+ colors = SliderDefaults.colors(
+ thumbColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
+ activeTrackColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
+ )
+ )
+
+ Text(
+ text = when {
+ powDifficulty == 0 -> stringResource(R.string.about_pow_desc_none)
+ powDifficulty <= 8 -> stringResource(R.string.about_pow_desc_very_low)
+ powDifficulty <= 12 -> stringResource(R.string.about_pow_desc_low)
+ powDifficulty <= 16 -> stringResource(R.string.about_pow_desc_medium)
+ powDifficulty <= 20 -> stringResource(R.string.about_pow_desc_high)
+ powDifficulty <= 24 -> stringResource(R.string.about_pow_desc_very_high)
+ else -> stringResource(R.string.about_pow_desc_extreme)
+ },
+ fontSize = 12.sp,
+ fontFamily = FontFamily.Monospace,
+ color = colorScheme.onSurface.copy(alpha = 0.5f)
+ )
}
}
}
}
}
- // Network (Tor) section
- item(key = "network_section") {
- val torMode = remember { mutableStateOf(com.bitchat.android.net.TorPreferenceManager.get(context)) }
+ // Tor Status (when enabled)
+ item(key = "tor_status") {
+ val torMode = remember { mutableStateOf(TorPreferenceManager.get(context)) }
val torProvider = remember { ArtiTorManager.getInstance() }
val torStatus by torProvider.statusFlow.collectAsState()
- val torAvailable = remember { torProvider.isTorAvailable() }
- Text(
- text = stringResource(R.string.about_network),
- style = MaterialTheme.typography.labelLarge,
- color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f),
- modifier = Modifier
- .padding(horizontal = 24.dp)
- .padding(top = 24.dp, bottom = 8.dp)
- )
- Column(modifier = Modifier.padding(horizontal = 24.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
- Row(
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- verticalAlignment = Alignment.CenterVertically
- ) {
- FilterChip(
- selected = torMode.value == TorMode.OFF,
- onClick = {
- torMode.value = TorMode.OFF
- TorPreferenceManager.set(context, torMode.value)
- },
- label = { Text("tor off", fontFamily = FontFamily.Monospace) }
- )
- FilterChip(
- selected = torMode.value == TorMode.ON,
- onClick = {
- if (torAvailable) {
- torMode.value = TorMode.ON
- TorPreferenceManager.set(context, torMode.value)
- }
- },
- enabled = torAvailable,
- label = {
+
+ if (torMode.value == TorMode.ON) {
+ Column(modifier = Modifier.padding(horizontal = 20.dp)) {
+ Surface(
+ modifier = Modifier.fillMaxWidth(),
+ color = colorScheme.surface,
+ shape = RoundedCornerShape(16.dp)
+ ) {
+ Column(
+ modifier = Modifier.padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(8.dp)
+ ) {
Row(
- horizontalArrangement = Arrangement.spacedBy(6.dp),
- verticalAlignment = Alignment.CenterVertically
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
- Text("tor on", fontFamily = FontFamily.Monospace)
val statusColor = when {
- torStatus.running && torStatus.bootstrapPercent < 100 -> Color(0xFFFF9500)
torStatus.running && torStatus.bootstrapPercent >= 100 -> if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
- else -> Color.Red
+ torStatus.running -> Color(0xFFFF9500)
+ else -> Color(0xFFFF3B30)
}
- Surface(color = statusColor, shape = CircleShape) {
- Box(Modifier.size(8.dp))
- }
- }
- }
- )
-
- if (!torAvailable) {
- val tooltipState = rememberTooltipState()
- val scope = rememberCoroutineScope()
- TooltipBox(
- positionProvider = TooltipDefaults.rememberPlainTooltipPositionProvider(),
- tooltip = {
- PlainTooltip {
- Text(
- text = stringResource(R.string.tor_not_available_in_this_build),
- fontSize = 11.sp,
- fontFamily = FontFamily.Monospace
- )
- }
- },
- state = tooltipState
- ) {
- IconButton(
- onClick = {
- scope.launch {
- tooltipState.show()
- }
- },
- modifier = Modifier.size(32.dp)
- ) {
- Icon(
- imageVector = Icons.Outlined.Info,
- contentDescription = null,
- tint = MaterialTheme.colorScheme.onSurface.copy(
- alpha = 0.6f
- ),
- modifier = Modifier.size(18.dp)
+ Surface(color = statusColor, shape = CircleShape, modifier = Modifier.size(10.dp)) {}
+ Text(
+ text = if (torStatus.running) "Connected (${torStatus.bootstrapPercent}%)" else "Disconnected",
+ style = MaterialTheme.typography.bodyMedium,
+ fontWeight = FontWeight.Medium,
+ color = colorScheme.onSurface
)
}
- }
- }
- }
- Text(
- text = stringResource(R.string.about_tor_route),
- style = MaterialTheme.typography.bodySmall,
- color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
- )
- if (torMode.value == TorMode.ON) {
- val statusText = if (torStatus.running) "Running" else "Stopped"
- // Debug status (temporary)
- Surface(
- modifier = Modifier.fillMaxWidth(),
- color = colorScheme.surfaceVariant.copy(alpha = 0.25f),
- shape = RoundedCornerShape(8.dp)
- ) {
- Column(
- modifier = Modifier.padding(12.dp),
- verticalArrangement = Arrangement.spacedBy(6.dp)
- ) {
- Text(
- text = stringResource(R.string.about_tor_status, statusText, torStatus.bootstrapPercent),
- style = MaterialTheme.typography.bodySmall,
- color = colorScheme.onSurface.copy(alpha = 0.75f)
- )
- val lastLog = torStatus.lastLogLine
- if (lastLog.isNotEmpty()) {
+ if (torStatus.lastLogLine.isNotEmpty()) {
Text(
- text = stringResource(R.string.about_last, lastLog.take(160)),
- style = MaterialTheme.typography.labelSmall,
- color = colorScheme.onSurface.copy(alpha = 0.6f)
+ text = torStatus.lastLogLine.take(120),
+ fontSize = 11.sp,
+ fontFamily = FontFamily.Monospace,
+ color = colorScheme.onSurface.copy(alpha = 0.5f),
+ maxLines = 2
)
}
}
@@ -511,17 +594,14 @@ fun AboutSheet(
}
}
- // Emergency Warning Section
- item(key = "warning_section") {
- val colorScheme = MaterialTheme.colorScheme
- val errorColor = colorScheme.error
-
+ // Emergency Warning
+ item(key = "warning") {
Surface(
modifier = Modifier
- .padding(horizontal = 24.dp, vertical = 24.dp)
+ .padding(horizontal = 20.dp)
.fillMaxWidth(),
- color = errorColor.copy(alpha = 0.1f),
- shape = RoundedCornerShape(12.dp)
+ color = colorScheme.error.copy(alpha = 0.1f),
+ shape = RoundedCornerShape(16.dp)
) {
Row(
modifier = Modifier.padding(16.dp),
@@ -530,61 +610,53 @@ fun AboutSheet(
) {
Icon(
imageVector = Icons.Filled.Warning,
- contentDescription = stringResource(R.string.cd_warning),
- tint = errorColor,
- modifier = Modifier.size(16.dp)
+ contentDescription = null,
+ tint = colorScheme.error,
+ modifier = Modifier.size(20.dp)
)
Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
Text(
text = stringResource(R.string.about_emergency_title),
- fontSize = 12.sp,
- fontFamily = FontFamily.Monospace,
- fontWeight = FontWeight.Bold,
- color = errorColor
+ style = MaterialTheme.typography.bodyMedium,
+ fontWeight = FontWeight.SemiBold,
+ color = colorScheme.error
)
Text(
text = stringResource(R.string.about_emergency_tip),
- fontSize = 11.sp,
- fontFamily = FontFamily.Monospace,
- color = colorScheme.onSurface.copy(alpha = 0.8f)
+ fontSize = 13.sp,
+ color = colorScheme.onSurface.copy(alpha = 0.7f)
)
}
}
}
}
- // Footer Section
+ // Footer
item(key = "footer") {
Column(
modifier = Modifier
- .padding(horizontal = 24.dp)
- .fillMaxWidth(),
+ .fillMaxWidth()
+ .padding(horizontal = 20.dp),
horizontalAlignment = Alignment.CenterHorizontally,
- verticalArrangement = Arrangement.spacedBy(8.dp)
+ verticalArrangement = Arrangement.spacedBy(12.dp)
) {
if (onShowDebug != null) {
- TextButton(
- onClick = onShowDebug,
- colors = ButtonDefaults.textButtonColors(
- contentColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
- )
- ) {
+ TextButton(onClick = onShowDebug) {
Text(
text = stringResource(R.string.about_debug_settings),
- fontSize = 11.sp,
- fontFamily = FontFamily.Monospace
+ fontSize = 13.sp,
+ fontFamily = FontFamily.Monospace,
+ color = colorScheme.primary
)
}
}
Text(
text = stringResource(R.string.about_footer),
- fontSize = 11.sp,
+ fontSize = 12.sp,
fontFamily = FontFamily.Monospace,
- color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f),
+ color = colorScheme.onSurface.copy(alpha = 0.4f)
)
-
- // Add extra space at bottom for gesture area
- Spacer(modifier = Modifier.height(16.dp))
+ Spacer(modifier = Modifier.height(20.dp))
}
}
}
diff --git a/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt b/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
index 7cf31d433..1196396d5 100644
--- a/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
+++ b/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
@@ -143,6 +143,41 @@ class ChatViewModel(
init {
// Note: Mesh service delegate is now set by MainActivity
loadAndInitialize()
+ // Hydrate UI state from process-wide AppStateStore to survive Activity recreation
+ viewModelScope.launch {
+ try { com.bitchat.android.services.AppStateStore.peers.collect { peers ->
+ state.setConnectedPeers(peers)
+ state.setIsConnected(peers.isNotEmpty())
+ } } catch (_: Exception) { }
+ }
+ viewModelScope.launch {
+ try { com.bitchat.android.services.AppStateStore.publicMessages.collect { msgs ->
+ // Source of truth is AppStateStore; replace to avoid duplicate keys in LazyColumn
+ state.setMessages(msgs)
+ } } catch (_: Exception) { }
+ }
+ viewModelScope.launch {
+ try { com.bitchat.android.services.AppStateStore.privateMessages.collect { byPeer ->
+ // Replace with store snapshot
+ state.setPrivateChats(byPeer)
+ // Recompute unread set using SeenMessageStore for robustness across Activity recreation
+ try {
+ val seen = com.bitchat.android.services.SeenMessageStore.getInstance(getApplication())
+ val myNick = state.getNicknameValue() ?: meshService.myPeerID
+ val unread = mutableSetOf()
+ byPeer.forEach { (peer, list) ->
+ if (list.any { msg -> msg.sender != myNick && !seen.hasRead(msg.id) }) unread.add(peer)
+ }
+ state.setUnreadPrivateMessages(unread)
+ } catch (_: Exception) { }
+ } } catch (_: Exception) { }
+ }
+ viewModelScope.launch {
+ try { com.bitchat.android.services.AppStateStore.channelMessages.collect { byChannel ->
+ // Replace with store snapshot
+ state.setChannelMessages(byChannel)
+ } } catch (_: Exception) { }
+ }
// Subscribe to BLE transfer progress and reflect in message deliveryStatus
viewModelScope.launch {
com.bitchat.android.mesh.TransferProgressManager.events.collect { evt ->
diff --git a/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt b/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt
index d6a9e7467..a452616ec 100644
--- a/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt
+++ b/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt
@@ -46,10 +46,10 @@ class MeshDelegateHandler(
if (message.isPrivate) {
// Private message
privateChatManager.handleIncomingPrivateMessage(message)
-
- // Reactive read receipts: Send immediately if user is currently viewing this chat
+
+ // Reactive read receipts: if chat is focused, send immediately for this message
message.senderPeerID?.let { senderPeerID ->
- sendReadReceiptIfFocused(senderPeerID)
+ sendReadReceiptIfFocused(message)
}
// Show notification with enhanced information - now includes senderPeerID
@@ -64,15 +64,26 @@ class MeshDelegateHandler(
)
}
} else if (message.channel != null) {
- // Channel message
+ // Channel message: AppStateStore is the source of truth for list; only manage unread
if (state.getJoinedChannelsValue().contains(message.channel)) {
- channelManager.addChannelMessage(message.channel, message, message.senderPeerID)
+ val channel = message.channel
+ val viewingClassic = state.getCurrentChannelValue() == channel
+ val viewingGeohash = try {
+ if (channel.startsWith("geo:")) {
+ val geo = channel.removePrefix("geo:")
+ val selected = state.selectedLocationChannel.value
+ selected is com.bitchat.android.geohash.ChannelID.Location && selected.channel.geohash.equals(geo, ignoreCase = true)
+ } else false
+ } catch (_: Exception) { false }
+ if (!viewingClassic && !viewingGeohash) {
+ val currentUnread = state.getUnreadChannelMessagesValue().toMutableMap()
+ currentUnread[channel] = (currentUnread[channel] ?: 0) + 1
+ state.setUnreadChannelMessages(currentUnread)
+ }
}
} else {
- // Public mesh message - always store to preserve message history
- messageManager.addMessage(message)
-
- // Check for mentions in mesh chat
+ // Public mesh message: AppStateStore is the source of truth; avoid double-adding to UI state
+ // Still run mention detection/notifications
checkAndTriggerMeshMentionNotification(message)
}
@@ -263,21 +274,31 @@ class MeshDelegateHandler(
* Uses same logic as notification system - send read receipt if user is currently
* viewing the private chat with this sender AND app is in foreground.
*/
- private fun sendReadReceiptIfFocused(senderPeerID: String) {
+ private fun sendReadReceiptIfFocused(message: BitchatMessage) {
// Get notification manager's focus state (mirror the notification logic)
val isAppInBackground = notificationManager.getAppBackgroundState()
val currentPrivateChatPeer = notificationManager.getCurrentPrivateChatPeer()
// Send read receipt if user is currently focused on this specific chat
- val shouldSendReadReceipt = !isAppInBackground && currentPrivateChatPeer == senderPeerID
+ val senderPeerID = message.senderPeerID
+ val shouldSendReadReceipt = !isAppInBackground && senderPeerID != null && currentPrivateChatPeer == senderPeerID
- if (shouldSendReadReceipt) {
- android.util.Log.d("MeshDelegateHandler", "Sending reactive read receipt for focused chat with $senderPeerID")
- privateChatManager.sendReadReceiptsForPeer(senderPeerID, getMeshService())
- } else {
- android.util.Log.d("MeshDelegateHandler", "Skipping read receipt - chat not focused (background: $isAppInBackground, current peer: $currentPrivateChatPeer, sender: $senderPeerID)")
+ if (shouldSendReadReceipt) {
+ android.util.Log.d("MeshDelegateHandler", "Sending reactive read receipt for focused chat with $senderPeerID (message=${message.id})")
+ val nickname = state.getNicknameValue() ?: "unknown"
+ // Send directly for this message to avoid relying on unread queues
+ getMeshService().sendReadReceipt(message.id, senderPeerID!!, nickname)
+ // Ensure unread badge is cleared for this peer immediately
+ try {
+ val current = state.getUnreadPrivateMessagesValue().toMutableSet()
+ if (current.remove(senderPeerID)) {
+ state.setUnreadPrivateMessages(current)
+ }
+ } catch (_: Exception) { }
+ } else {
+ android.util.Log.d("MeshDelegateHandler", "Skipping read receipt - chat not focused (background: $isAppInBackground, current peer: $currentPrivateChatPeer, sender: $senderPeerID)")
+ }
}
- }
// registerPeerPublicKey REMOVED - fingerprints now handled centrally in PeerManager
diff --git a/app/src/main/java/com/bitchat/android/ui/MessageManager.kt b/app/src/main/java/com/bitchat/android/ui/MessageManager.kt
index f35689e7d..40b7eb988 100644
--- a/app/src/main/java/com/bitchat/android/ui/MessageManager.kt
+++ b/app/src/main/java/com/bitchat/android/ui/MessageManager.kt
@@ -22,6 +22,8 @@ class MessageManager(private val state: ChatState) {
val currentMessages = state.getMessagesValue().toMutableList()
currentMessages.add(message)
state.setMessages(currentMessages)
+ // Reflect into process-wide store so snapshot replacements don't drop local outgoing messages
+ try { com.bitchat.android.services.AppStateStore.addPublicMessage(message) } catch (_: Exception) { }
}
// Log a system message into the main chat (visible to user)
@@ -52,6 +54,8 @@ class MessageManager(private val state: ChatState) {
channelMessageList.add(message)
currentChannelMessages[channel] = channelMessageList
state.setChannelMessages(currentChannelMessages)
+ // Reflect into process-wide store
+ try { com.bitchat.android.services.AppStateStore.addChannelMessage(channel, message) } catch (_: Exception) { }
// Update unread count if not currently viewing this channel
// Consider both classic channels (state.currentChannel) and geohash location channel selection
@@ -105,6 +109,8 @@ class MessageManager(private val state: ChatState) {
chatMessages.add(message)
currentPrivateChats[peerID] = chatMessages
state.setPrivateChats(currentPrivateChats)
+ // Reflect into process-wide store
+ try { com.bitchat.android.services.AppStateStore.addPrivateMessage(peerID, message) } catch (_: Exception) { }
// Mark as unread if not currently viewing this chat
if (state.getSelectedPrivateChatPeerValue() != peerID && message.sender != state.getNicknameValue()) {
@@ -124,6 +130,8 @@ class MessageManager(private val state: ChatState) {
chatMessages.add(message)
currentPrivateChats[peerID] = chatMessages
state.setPrivateChats(currentPrivateChats)
+ // Reflect into process-wide store
+ try { com.bitchat.android.services.AppStateStore.addPrivateMessage(peerID, message) } catch (_: Exception) { }
}
fun clearPrivateMessages(peerID: String) {
@@ -206,6 +214,21 @@ class MessageManager(private val state: ChatState) {
// MARK: - Delivery Status Updates
+ private fun statusPriority(status: DeliveryStatus?): Int = when (status) {
+ null -> 0
+ is DeliveryStatus.Sending -> 1
+ is DeliveryStatus.Sent -> 2
+ is DeliveryStatus.PartiallyDelivered -> 3
+ is DeliveryStatus.Delivered -> 4
+ is DeliveryStatus.Read -> 5
+ is DeliveryStatus.Failed -> 0 // treat as lowest for UI check marks ordering
+ }
+
+ private fun chooseStatus(old: DeliveryStatus?, new: DeliveryStatus): DeliveryStatus? {
+ // Never downgrade (e.g., Read -> Delivered). Keep the higher priority.
+ return if (statusPriority(new) >= statusPriority(old)) new else old
+ }
+
fun updateMessageDeliveryStatus(messageID: String, status: DeliveryStatus) {
// Update in private chats
val updatedPrivateChats = state.getPrivateChatsValue().toMutableMap()
@@ -215,22 +238,32 @@ class MessageManager(private val state: ChatState) {
val updatedMessages = messages.toMutableList()
val messageIndex = updatedMessages.indexOfFirst { it.id == messageID }
if (messageIndex >= 0) {
- updatedMessages[messageIndex] = updatedMessages[messageIndex].copy(deliveryStatus = status)
- updatedPrivateChats[peerID] = updatedMessages
- updated = true
+ val current = updatedMessages[messageIndex].deliveryStatus
+ val finalStatus = chooseStatus(current, status)
+ if (finalStatus !== current) {
+ updatedMessages[messageIndex] = updatedMessages[messageIndex].copy(deliveryStatus = finalStatus)
+ updatedPrivateChats[peerID] = updatedMessages
+ updated = true
+ }
}
}
if (updated) {
state.setPrivateChats(updatedPrivateChats)
+ // Keep process-wide store in sync to prevent snapshot overwrites resetting status
+ try { com.bitchat.android.services.AppStateStore.updatePrivateMessageStatus(messageID, status) } catch (_: Exception) { }
}
// Update in main messages
val updatedMessages = state.getMessagesValue().toMutableList()
val messageIndex = updatedMessages.indexOfFirst { it.id == messageID }
if (messageIndex >= 0) {
- updatedMessages[messageIndex] = updatedMessages[messageIndex].copy(deliveryStatus = status)
- state.setMessages(updatedMessages)
+ val current = updatedMessages[messageIndex].deliveryStatus
+ val finalStatus = chooseStatus(current, status)
+ if (finalStatus !== current) {
+ updatedMessages[messageIndex] = updatedMessages[messageIndex].copy(deliveryStatus = finalStatus)
+ state.setMessages(updatedMessages)
+ }
}
// Update in channel messages
@@ -239,8 +272,12 @@ class MessageManager(private val state: ChatState) {
val channelMessagesList = messages.toMutableList()
val channelMessageIndex = channelMessagesList.indexOfFirst { it.id == messageID }
if (channelMessageIndex >= 0) {
- channelMessagesList[channelMessageIndex] = channelMessagesList[channelMessageIndex].copy(deliveryStatus = status)
- updatedChannelMessages[channel] = channelMessagesList
+ val current = channelMessagesList[channelMessageIndex].deliveryStatus
+ val finalStatus = chooseStatus(current, status)
+ if (finalStatus !== current) {
+ channelMessagesList[channelMessageIndex] = channelMessagesList[channelMessageIndex].copy(deliveryStatus = finalStatus)
+ updatedChannelMessages[channel] = channelMessagesList
+ }
}
}
state.setChannelMessages(updatedChannelMessages)
diff --git a/app/src/main/java/com/bitchat/android/ui/PrivateChatManager.kt b/app/src/main/java/com/bitchat/android/ui/PrivateChatManager.kt
index e8a3a4612..098a83d70 100644
--- a/app/src/main/java/com/bitchat/android/ui/PrivateChatManager.kt
+++ b/app/src/main/java/com/bitchat/android/ui/PrivateChatManager.kt
@@ -292,28 +292,30 @@ class PrivateChatManager(
}
fun handleIncomingPrivateMessage(message: BitchatMessage, suppressUnread: Boolean) {
- message.senderPeerID?.let { senderPeerID ->
+ val senderPeerID = message.senderPeerID
+ if (senderPeerID != null) {
+ // Mesh-origin private message: AppStateStore updates the list; avoid double-add here.
if (!isPeerBlocked(senderPeerID)) {
- // Add to private messages
- if (suppressUnread) {
- messageManager.addPrivateMessageNoUnread(senderPeerID, message)
- } else {
- messageManager.addPrivateMessage(senderPeerID, message)
- }
-
- // Track as unread for read receipt purposes
- var unreadCount = 0
- if (!suppressUnread) {
+ // Ensure chat exists
+ messageManager.initializePrivateChat(senderPeerID)
+ // Track as unread for read receipt purposes if not focused
+ if (!suppressUnread && state.getSelectedPrivateChatPeerValue() != senderPeerID) {
val unreadList = unreadReceivedMessages.getOrPut(senderPeerID) { mutableListOf() }
unreadList.add(message)
- unreadCount = unreadList.size
+ Log.d(TAG, "Queued unread from $senderPeerID (count=${unreadList.size})")
+ val currentUnread = state.getUnreadPrivateMessagesValue().toMutableSet()
+ currentUnread.add(senderPeerID)
+ state.setUnreadPrivateMessages(currentUnread)
}
-
- Log.d(
- TAG,
- "Added received message ${message.id} from $senderPeerID to unread list (${unreadCount} unread)"
- )
}
+ return
+ }
+ // Non-mesh path (e.g., Nostr): add to UI state using existing logic
+ val inferredPeer = state.getSelectedPrivateChatPeerValue() ?: return
+ if (suppressUnread) {
+ messageManager.addPrivateMessageNoUnread(inferredPeer, message)
+ } else {
+ messageManager.addPrivateMessage(inferredPeer, message)
}
}
@@ -322,27 +324,33 @@ class PrivateChatManager(
* Called when the user focuses on a private chat
*/
fun sendReadReceiptsForPeer(peerID: String, meshService: BluetoothMeshService) {
- val unreadList = unreadReceivedMessages[peerID]
- if (unreadList.isNullOrEmpty()) {
- Log.d(TAG, "No unread messages to send read receipts for peer $peerID")
- return
- }
+ // Collect candidate messages: all incoming messages from this peer in the conversation
+ val chats = try { state.getPrivateChatsValue() } catch (_: Exception) { emptyMap>() }
+ val messages = chats[peerID].orEmpty()
- Log.d(TAG, "Sending read receipts for ${unreadList.size} unread messages from $peerID")
+ if (messages.isEmpty()) {
+ Log.d(TAG, "No messages found for peer $peerID to send read receipts")
+ }
- // Send read receipt for each unread message - now using direct method call
- unreadList.forEach { message ->
- try {
- val myNickname = state.getNicknameValue() ?: "unknown"
- meshService.sendReadReceipt(message.id, peerID, myNickname)
- Log.d(TAG, "Sent read receipt for message ${message.id} to $peerID")
- } catch (e: Exception) {
- Log.w(TAG, "Failed to send read receipt for message ${message.id}: ${e.message}")
+ val myNickname = state.getNicknameValue() ?: "unknown"
+ var sentCount = 0
+ messages.forEach { msg ->
+ // Only for incoming messages from this peer
+ if (msg.senderPeerID == peerID) {
+ try {
+ meshService.sendReadReceipt(msg.id, peerID, myNickname)
+ sentCount += 1
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to send read receipt for message ${msg.id}: ${e.message}")
+ }
}
}
- // Clear the unread list since we've sent read receipts
+ // Clear any locally tracked unread queue for this peer
unreadReceivedMessages.remove(peerID)
+ // Also clear UI unread marker for this peer now that chat is focused/read
+ try { messageManager.clearPrivateUnreadMessages(peerID) } catch (_: Exception) { }
+ Log.d(TAG, "Sent $sentCount read receipts for peer $peerID (from conversation messages)")
}
fun cleanupDisconnectedPeer(peerID: String) {
diff --git a/app/src/main/java/com/bitchat/android/ui/debug/DebugPreferenceManager.kt b/app/src/main/java/com/bitchat/android/ui/debug/DebugPreferenceManager.kt
index e2f9d966e..04ad48a2e 100644
--- a/app/src/main/java/com/bitchat/android/ui/debug/DebugPreferenceManager.kt
+++ b/app/src/main/java/com/bitchat/android/ui/debug/DebugPreferenceManager.kt
@@ -20,6 +20,7 @@ object DebugPreferenceManager {
// GCS keys (no migration/back-compat)
private const val KEY_GCS_MAX_BYTES = "gcs_max_filter_bytes"
private const val KEY_GCS_FPR = "gcs_filter_fpr_percent"
+ // Removed: persistent notification toggle is now governed by MeshServicePreferences.isBackgroundEnabled
private lateinit var prefs: SharedPreferences
@@ -100,4 +101,6 @@ object DebugPreferenceManager {
fun setGcsFprPercent(value: Double) {
if (ready()) prefs.edit().putLong(KEY_GCS_FPR, java.lang.Double.doubleToRawLongBits(value)).apply()
}
+
+ // No longer storing persistent notification in debug prefs.
}
diff --git a/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsManager.kt b/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsManager.kt
index 6e37286fb..77f6ce12a 100644
--- a/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsManager.kt
+++ b/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsManager.kt
@@ -36,6 +36,11 @@ class DebugSettingsManager private constructor() {
private val _packetRelayEnabled = MutableStateFlow(true)
val packetRelayEnabled: StateFlow = _packetRelayEnabled.asStateFlow()
+ // Visibility of the debug sheet; gates heavy work
+ private val _debugSheetVisible = MutableStateFlow(false)
+ val debugSheetVisible: StateFlow = _debugSheetVisible.asStateFlow()
+ fun setDebugSheetVisible(visible: Boolean) { _debugSheetVisible.value = visible }
+
// Connection limit overrides (debug)
private val _maxConnectionsOverall = MutableStateFlow(8)
val maxConnectionsOverall: StateFlow = _maxConnectionsOverall.asStateFlow()
@@ -75,12 +80,63 @@ class DebugSettingsManager private constructor() {
// Timestamps to compute rolling window stats
private val relayTimestamps = ConcurrentLinkedQueue()
+ // Per-device and per-peer rolling timestamps for stacked graphs
+ private val perDeviceRelayTimestamps = mutableMapOf>()
+ private val perPeerRelayTimestamps = mutableMapOf>()
+
+ // Additional buckets to split incoming vs outgoing
+ private val incomingTimestamps = ConcurrentLinkedQueue()
+ private val outgoingTimestamps = ConcurrentLinkedQueue()
+ private val perDeviceIncoming = mutableMapOf>()
+ private val perDeviceOutgoing = mutableMapOf>()
+ private val perPeerIncoming = mutableMapOf>()
+ private val perPeerOutgoing = mutableMapOf>()
+
+ // Expose current per-second rates (updated when logging/pruning occurs)
+ private val _perDeviceLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceLastSecond: StateFlow> = _perDeviceLastSecond.asStateFlow()
+ private val _perPeerLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerLastSecond: StateFlow> = _perPeerLastSecond.asStateFlow()
+ // New flows used by UI for incoming/outgoing stacked plots
+ private val _perDeviceIncomingLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceIncomingLastSecond: StateFlow> = _perDeviceIncomingLastSecond.asStateFlow()
+ private val _perDeviceOutgoingLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceOutgoingLastSecond: StateFlow> = _perDeviceOutgoingLastSecond.asStateFlow()
+ private val _perPeerIncomingLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerIncomingLastSecond: StateFlow> = _perPeerIncomingLastSecond.asStateFlow()
+ private val _perPeerOutgoingLastSecond: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerOutgoingLastSecond: StateFlow> = _perPeerOutgoingLastSecond.asStateFlow()
+
+ // Per-minute counts per key
+ private val _perDeviceIncomingLastMinute: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceIncomingLastMinute: StateFlow> = _perDeviceIncomingLastMinute.asStateFlow()
+ private val _perDeviceOutgoingLastMinute: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceOutgoingLastMinute: StateFlow> = _perDeviceOutgoingLastMinute.asStateFlow()
+ private val _perPeerIncomingLastMinute: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerIncomingLastMinute: StateFlow> = _perPeerIncomingLastMinute.asStateFlow()
+ private val _perPeerOutgoingLastMinute: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerOutgoingLastMinute: StateFlow> = _perPeerOutgoingLastMinute.asStateFlow()
+
+ // Totals per key (since app start)
+ private val deviceIncomingTotalsMap = mutableMapOf()
+ private val deviceOutgoingTotalsMap = mutableMapOf()
+ private val peerIncomingTotalsMap = mutableMapOf()
+ private val peerOutgoingTotalsMap = mutableMapOf()
+ private val _perDeviceIncomingTotalsFlow: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceIncomingTotal: StateFlow> = _perDeviceIncomingTotalsFlow.asStateFlow()
+ private val _perDeviceOutgoingTotalsFlow: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perDeviceOutgoingTotal: StateFlow> = _perDeviceOutgoingTotalsFlow.asStateFlow()
+ private val _perPeerIncomingTotalsFlow: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerIncomingTotal: StateFlow> = _perPeerIncomingTotalsFlow.asStateFlow()
+ private val _perPeerOutgoingTotalsFlow: MutableStateFlow> = MutableStateFlow(emptyMap())
+ val perPeerOutgoingTotal: StateFlow> = _perPeerOutgoingTotalsFlow.asStateFlow()
// Internal data storage for managing debug data
private val debugMessageQueue = ConcurrentLinkedQueue()
private val scanResultsQueue = ConcurrentLinkedQueue()
private fun updateRelayStatsFromTimestamps() {
+ if (!_debugSheetVisible.value) return
val now = System.currentTimeMillis()
// prune older than 15m
while (true) {
@@ -89,18 +145,84 @@ class DebugSettingsManager private constructor() {
relayTimestamps.poll()
} else break
}
+ // prune per-device and per-peer and compute 1s/60s rates
+ fun pruneAndCount1s(map: MutableMap>): Map {
+ val result = mutableMapOf()
+ val iterator = map.entries.iterator()
+ while (iterator.hasNext()) {
+ val (key, q) = iterator.next()
+ // prune this queue
+ while (true) {
+ val ts = q.peek() ?: break
+ if (now - ts > 15 * 60 * 1000L) {
+ q.poll()
+ } else break
+ }
+ // count last 1s only
+ val count1s = q.count { now - it <= 1_000L }
+ if (q.isEmpty()) {
+ // cleanup empty queues to prevent unbounded growth
+ iterator.remove()
+ }
+ if (count1s > 0) result[key] = count1s
+ }
+ return result
+ }
+ fun pruneAndCount60s(map: MutableMap>): Map {
+ val result = mutableMapOf()
+ map.forEach { (key, q) ->
+ val count60 = q.count { now - it <= 60_000L }
+ if (count60 > 0) result[key] = count60
+ }
+ return result
+ }
+
+ val perDevice1s = pruneAndCount1s(perDeviceRelayTimestamps)
+ val perPeer1s = pruneAndCount1s(perPeerRelayTimestamps)
+
+ _perDeviceLastSecond.value = perDevice1s
+ _perPeerLastSecond.value = perPeer1s
+ // Also compute incoming/outgoing per-key rates
+ _perDeviceIncomingLastSecond.value = pruneAndCount1s(perDeviceIncoming)
+ _perDeviceOutgoingLastSecond.value = pruneAndCount1s(perDeviceOutgoing)
+ _perPeerIncomingLastSecond.value = pruneAndCount1s(perPeerIncoming)
+ _perPeerOutgoingLastSecond.value = pruneAndCount1s(perPeerOutgoing)
+ _perDeviceIncomingLastMinute.value = pruneAndCount60s(perDeviceIncoming)
+ _perDeviceOutgoingLastMinute.value = pruneAndCount60s(perDeviceOutgoing)
+ _perPeerIncomingLastMinute.value = pruneAndCount60s(perPeerIncoming)
+ _perPeerOutgoingLastMinute.value = pruneAndCount60s(perPeerOutgoing)
val last1s = relayTimestamps.count { now - it <= 1_000L }
val last10s = relayTimestamps.count { now - it <= 10_000L }
val last1m = relayTimestamps.count { now - it <= 60_000L }
val last15m = relayTimestamps.size
- val total = _relayStats.value.totalRelaysCount + 1
+ // And incoming/outgoing per-second counters
+ val last1sIncoming = incomingTimestamps.count { now - it <= 1_000L }
+ val last1sOutgoing = outgoingTimestamps.count { now - it <= 1_000L }
+ val last10sIncoming = incomingTimestamps.count { now - it <= 10_000L }
+ val last10sOutgoing = outgoingTimestamps.count { now - it <= 10_000L }
+ val last1mIncoming = incomingTimestamps.count { now - it <= 60_000L }
+ val last1mOutgoing = outgoingTimestamps.count { now - it <= 60_000L }
+ val last15mIncoming = incomingTimestamps.size
+ val last15mOutgoing = outgoingTimestamps.size
+ val totalIncoming = _relayStats.value.totalIncomingCount
+ val totalOutgoing = _relayStats.value.totalOutgoingCount
_relayStats.value = PacketRelayStats(
- totalRelaysCount = total,
+ totalRelaysCount = totalIncoming + totalOutgoing,
lastSecondRelays = last1s,
last10SecondRelays = last10s,
lastMinuteRelays = last1m,
last15MinuteRelays = last15m,
- lastResetTime = _relayStats.value.lastResetTime
+ lastResetTime = _relayStats.value.lastResetTime,
+ lastSecondIncoming = last1sIncoming,
+ lastSecondOutgoing = last1sOutgoing,
+ last10SecondIncoming = last10sIncoming,
+ last10SecondOutgoing = last10sOutgoing,
+ lastMinuteIncoming = last1mIncoming,
+ lastMinuteOutgoing = last1mOutgoing,
+ last15MinuteIncoming = last15mIncoming,
+ last15MinuteOutgoing = last15mOutgoing,
+ totalIncomingCount = totalIncoming,
+ totalOutgoingCount = totalOutgoing
)
}
@@ -336,11 +458,61 @@ class DebugSettingsManager private constructor() {
}
}
- // Update rolling statistics only for relays
- if (isRelay) {
- relayTimestamps.offer(System.currentTimeMillis())
- updateRelayStatsFromTimestamps()
+ // Do not update counters here; this path is for readable logs only.
+ }
+
+ // Explicit incoming/outgoing logging to avoid double counting
+ fun logIncoming(packetType: String, fromPeerID: String?, fromNickname: String?, fromDeviceAddress: String?) {
+ if (verboseLoggingEnabled.value) {
+ val who = fromNickname ?: fromPeerID ?: "unknown"
+ addDebugMessage(DebugMessage.PacketEvent("📥 Incoming $packetType from $who (${fromPeerID ?: "?"}, ${fromDeviceAddress ?: "?"})"))
+ }
+ val now = System.currentTimeMillis()
+ val visible = _debugSheetVisible.value
+ if (visible) incomingTimestamps.offer(now)
+ fromDeviceAddress?.let {
+ perDeviceIncoming.getOrPut(it) { ConcurrentLinkedQueue() }.offer(now)
+ deviceIncomingTotalsMap[it] = (deviceIncomingTotalsMap[it] ?: 0L) + 1L
+ _perDeviceIncomingTotalsFlow.value = deviceIncomingTotalsMap.toMap()
+ }
+ fromPeerID?.let {
+ perPeerIncoming.getOrPut(it) { ConcurrentLinkedQueue() }.offer(now)
+ peerIncomingTotalsMap[it] = (peerIncomingTotalsMap[it] ?: 0L) + 1L
+ _perPeerIncomingTotalsFlow.value = peerIncomingTotalsMap.toMap()
+ }
+ // bump totals
+ val cur = _relayStats.value
+ _relayStats.value = cur.copy(
+ totalIncomingCount = cur.totalIncomingCount + 1,
+ totalRelaysCount = cur.totalRelaysCount + 1
+ )
+ if (visible) updateRelayStatsFromTimestamps()
+ }
+
+ fun logOutgoing(packetType: String, toPeerID: String?, toNickname: String?, toDeviceAddress: String?, previousHopPeerID: String? = null) {
+ if (verboseLoggingEnabled.value) {
+ val who = toNickname ?: toPeerID ?: "unknown"
+ addDebugMessage(DebugMessage.PacketEvent("📤 Outgoing $packetType to $who (${toPeerID ?: "?"}, ${toDeviceAddress ?: "?"})"))
+ }
+ val now = System.currentTimeMillis()
+ val visible = _debugSheetVisible.value
+ if (visible) outgoingTimestamps.offer(now)
+ toDeviceAddress?.let {
+ perDeviceOutgoing.getOrPut(it) { ConcurrentLinkedQueue() }.offer(now)
+ deviceOutgoingTotalsMap[it] = (deviceOutgoingTotalsMap[it] ?: 0L) + 1L
+ _perDeviceOutgoingTotalsFlow.value = deviceOutgoingTotalsMap.toMap()
+ }
+ (toPeerID ?: previousHopPeerID)?.let {
+ perPeerOutgoing.getOrPut(it) { ConcurrentLinkedQueue() }.offer(now)
+ peerOutgoingTotalsMap[it] = (peerOutgoingTotalsMap[it] ?: 0L) + 1L
+ _perPeerOutgoingTotalsFlow.value = peerOutgoingTotalsMap.toMap()
}
+ val cur = _relayStats.value
+ _relayStats.value = cur.copy(
+ totalOutgoingCount = cur.totalOutgoingCount + 1,
+ totalRelaysCount = cur.totalRelaysCount + 1
+ )
+ if (visible) updateRelayStatsFromTimestamps()
}
// MARK: - Clear Data
@@ -407,5 +579,15 @@ data class PacketRelayStats(
val last10SecondRelays: Int = 0,
val lastMinuteRelays: Int = 0,
val last15MinuteRelays: Int = 0,
- val lastResetTime: Date = Date()
+ val lastResetTime: Date = Date(),
+ val lastSecondIncoming: Int = 0,
+ val lastSecondOutgoing: Int = 0,
+ val last10SecondIncoming: Int = 0,
+ val last10SecondOutgoing: Int = 0,
+ val lastMinuteIncoming: Int = 0,
+ val lastMinuteOutgoing: Int = 0,
+ val last15MinuteIncoming: Int = 0,
+ val last15MinuteOutgoing: Int = 0,
+ val totalIncomingCount: Long = 0,
+ val totalOutgoingCount: Long = 0
)
diff --git a/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsSheet.kt b/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsSheet.kt
index 6cd255475..4b9f983a8 100644
--- a/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsSheet.kt
+++ b/app/src/main/java/com/bitchat/android/ui/debug/DebugSettingsSheet.kt
@@ -3,9 +3,11 @@ package com.bitchat.android.ui.debug
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Bluetooth
import androidx.compose.material.icons.filled.BugReport
@@ -15,6 +17,7 @@ import androidx.compose.material.icons.filled.PowerSettingsNew
import androidx.compose.material.icons.filled.SettingsEthernet
import androidx.compose.material3.*
import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
@@ -27,8 +30,13 @@ import com.bitchat.android.mesh.BluetoothMeshService
import kotlinx.coroutines.launch
import androidx.compose.ui.res.stringResource
import com.bitchat.android.R
+import androidx.compose.ui.platform.LocalContext
+import com.bitchat.android.service.MeshServicePreferences
+import com.bitchat.android.service.MeshForegroundService
-@OptIn(ExperimentalMaterial3Api::class)
+private enum class GraphMode { OVERALL, PER_DEVICE, PER_PEER }
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
@Composable
fun DebugSettingsSheet(
isPresented: Boolean,
@@ -53,6 +61,8 @@ fun DebugSettingsSheet(
val seenCapacity by manager.seenPacketCapacity.collectAsState()
val gcsMaxBytes by manager.gcsMaxBytes.collectAsState()
val gcsFpr by manager.gcsFprPercent.collectAsState()
+ val context = LocalContext.current
+ // Persistent notification is now controlled solely by MeshServicePreferences.isBackgroundEnabled
// Push live connected devices from mesh service whenever sheet is visible
LaunchedEffect(isPresented) {
@@ -89,6 +99,11 @@ fun DebugSettingsSheet(
onDismissRequest = onDismiss,
sheetState = sheetState
) {
+ // Mark debug sheet visible/invisible to gate heavy work
+ LaunchedEffect(Unit) { DebugSettingsManager.getInstance().setDebugSheetVisible(true) }
+ DisposableEffect(Unit) {
+ onDispose { DebugSettingsManager.getInstance().setDebugSheetVisible(false) }
+ }
LazyColumn(
modifier = Modifier
.fillMaxWidth()
@@ -202,88 +217,256 @@ fun DebugSettingsSheet(
item {
Surface(shape = RoundedCornerShape(12.dp), color = colorScheme.surfaceVariant.copy(alpha = 0.2f)) {
Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+ // Persistent notification is controlled by About sheet (MeshServicePreferences.isBackgroundEnabled)
+
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Icon(Icons.Filled.PowerSettingsNew, contentDescription = null, tint = Color(0xFFFF9500))
Text(stringResource(R.string.debug_packet_relay), fontFamily = FontFamily.Monospace, fontSize = 14.sp, fontWeight = FontWeight.Medium)
Spacer(Modifier.weight(1f))
Switch(checked = packetRelayEnabled, onCheckedChange = { manager.setPacketRelayEnabled(it) })
}
- Text(stringResource(R.string.debug_since_start_fmt, relayStats.totalRelaysCount), fontFamily = FontFamily.Monospace, fontSize = 11.sp)
- Text(stringResource(R.string.debug_relays_window_fmt, relayStats.last10SecondRelays, relayStats.lastMinuteRelays, relayStats.last15MinuteRelays), fontFamily = FontFamily.Monospace, fontSize = 11.sp)
- // Realtime graph: per-second relays, full-width canvas, bottom-up bars, fast decay
- var series by remember { mutableStateOf(List(60) { 0f }) }
- LaunchedEffect(isPresented) {
+ // Removed aggregate labels; we will show per-direction compact labels below titles
+ // Toggle: overall vs per-connection vs per-peer
+ var graphMode by rememberSaveable { mutableStateOf(GraphMode.OVERALL) }
+ val perDeviceIncoming by manager.perDeviceIncomingLastSecond.collectAsState()
+ val perPeerIncoming by manager.perPeerIncomingLastSecond.collectAsState()
+ val perDeviceOutgoing by manager.perDeviceOutgoingLastSecond.collectAsState()
+ val perPeerOutgoing by manager.perPeerOutgoingLastSecond.collectAsState()
+ val perDeviceIncoming1m by manager.perDeviceIncomingLastMinute.collectAsState()
+ val perDeviceOutgoing1m by manager.perDeviceOutgoingLastMinute.collectAsState()
+ val perPeerIncoming1m by manager.perPeerIncomingLastMinute.collectAsState()
+ val perPeerOutgoing1m by manager.perPeerOutgoingLastMinute.collectAsState()
+ val perDeviceIncomingTotal by manager.perDeviceIncomingTotal.collectAsState()
+ val perDeviceOutgoingTotal by manager.perDeviceOutgoingTotal.collectAsState()
+ val perPeerIncomingTotal by manager.perPeerIncomingTotal.collectAsState()
+ val perPeerOutgoingTotal by manager.perPeerOutgoingTotal.collectAsState()
+ val nicknameMap = remember { mutableStateOf>(emptyMap()) }
+ val devicePeerMap = remember { mutableStateOf>(emptyMap()) }
+ LaunchedEffect(Unit) {
+ try { nicknameMap.value = meshService.getPeerNicknames() } catch (_: Exception) { }
+ // Try to fetch device->peer map periodically for legend resolution
while (isPresented) {
- val s = relayStats.lastSecondRelays.toFloat()
- val last = series.lastOrNull() ?: 0f
- // Faster decay and smoothing
- val v = last * 0.5f + s * 0.5f
- series = (series + v).takeLast(60)
- kotlinx.coroutines.delay(400)
+ try { devicePeerMap.value = meshService.getDeviceAddressToPeerMapping() } catch (_: Exception) { }
+ kotlinx.coroutines.delay(1000)
}
}
- val maxValRaw = series.maxOrNull() ?: 0f
- val maxVal = if (maxValRaw > 0f) maxValRaw else 0f
- val leftGutter = 40.dp
- Box(Modifier.fillMaxWidth().height(56.dp)) {
- // Graph canvas
- androidx.compose.foundation.Canvas(Modifier.fillMaxSize()) {
- val axisPx = leftGutter.toPx() // reserved left gutter for labels
- val barCount = series.size
- val availW = (size.width - axisPx).coerceAtLeast(1f)
- val w = availW / barCount
- val h = size.height
- // Baseline at bottom (y = 0)
- drawLine(
- color = Color(0x33888888),
- start = androidx.compose.ui.geometry.Offset(axisPx, h - 1f),
- end = androidx.compose.ui.geometry.Offset(size.width, h - 1f),
- strokeWidth = 1f
+
+ Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ // Mode selector
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilterChip(
+ selected = graphMode == GraphMode.OVERALL,
+ onClick = { graphMode = GraphMode.OVERALL },
+ label = { Text("Overall") }
+ )
+ FilterChip(
+ selected = graphMode == GraphMode.PER_DEVICE,
+ onClick = { graphMode = GraphMode.PER_DEVICE },
+ label = { Text("Per Device") },
+ leadingIcon = { Icon(Icons.Filled.Devices, contentDescription = null) }
+ )
+ FilterChip(
+ selected = graphMode == GraphMode.PER_PEER,
+ onClick = { graphMode = GraphMode.PER_PEER },
+ label = { Text("Per Peer") },
+ leadingIcon = { Icon(Icons.Filled.SettingsEthernet, contentDescription = null) }
+ )
+ }
+
+ // Time series state
+ var overallSeriesIncoming by rememberSaveable { mutableStateOf(List(60) { 0f }) }
+ var overallSeriesOutgoing by rememberSaveable { mutableStateOf(List(60) { 0f }) }
+ var stackedKeysIncoming by rememberSaveable { mutableStateOf(listOf()) }
+ var stackedKeysOutgoing by rememberSaveable { mutableStateOf(listOf()) }
+ var stackedSeriesIncoming by rememberSaveable { mutableStateOf>>(emptyMap()) }
+ var stackedSeriesOutgoing by rememberSaveable { mutableStateOf>>(emptyMap()) }
+ var highlightedKey by rememberSaveable { mutableStateOf(null) }
+
+ // Color palette for stacked legend
+ val palette = remember {
+ listOf(
+ Color(0xFF00C851), Color(0xFF007AFF), Color(0xFFFF9500), Color(0xFFFF3B30),
+ Color(0xFF5AC8FA), Color(0xFFAF52DE), Color(0xFFFF2D55), Color(0xFF34C759),
+ Color(0xFFFFCC00), Color(0xFF5856D6)
)
- // Bars from bottom-up; skip zeros entirely
- series.forEachIndexed { i, value ->
- if (value > 0f && maxVal > 0f) {
- val ratio = (value / maxVal).coerceIn(0f, 1f)
- val barHeight = (h * ratio).coerceAtLeast(0f)
- if (barHeight > 0.5f) {
- drawRect(
- color = Color(0xFF00C851),
- topLeft = androidx.compose.ui.geometry.Offset(x = axisPx + i * w, y = h - barHeight),
- size = androidx.compose.ui.geometry.Size(w, barHeight)
- )
+ }
+ val colorForKey = remember { mutableStateMapOf() }
+ fun stableColorFor(key: String): Color {
+ // Deterministic fallback color based on key hash using HSV palette
+ val h = (key.hashCode().toUInt().toInt() and 0x7FFFFFFF) % 360
+ return Color.hsv(h.toFloat(), 0.65f, 0.95f)
+ }
+ // Ensure colors are assigned for current keys before drawing
+ fun ensureColors(keys: List) {
+ keys.forEachIndexed { idx, k ->
+ colorForKey.putIfAbsent(k, palette.getOrNull(idx) ?: stableColorFor(k))
+ }
+ }
+
+ LaunchedEffect(isPresented, graphMode) {
+ while (isPresented) {
+ when (graphMode) {
+ GraphMode.OVERALL -> {
+ val sIn = relayStats.lastSecondIncoming.toFloat()
+ val sOut = relayStats.lastSecondOutgoing.toFloat()
+ overallSeriesIncoming = (overallSeriesIncoming + sIn).takeLast(60)
+ overallSeriesOutgoing = (overallSeriesOutgoing + sOut).takeLast(60)
+ }
+ GraphMode.PER_DEVICE -> {
+ val snapshotIn = perDeviceIncoming
+ val snapshotOut = perDeviceOutgoing
+ fun advance(base: Map>, snap: Map): Map> {
+ val next = mutableMapOf>()
+ val union = (base.keys + snap.keys).toSet()
+ union.forEach { k ->
+ val prev = base[k] ?: List(60) { 0f }
+ val s = (snap[k] ?: 0).toFloat()
+ next[k] = (prev + s).takeLast(60)
+ }
+ return next
+ }
+ // Advance and prune fully-stale series (all-zero in visible window)
+ stackedSeriesIncoming = advance(stackedSeriesIncoming, snapshotIn).filterValues { series -> series.any { it != 0f } }
+ stackedSeriesOutgoing = advance(stackedSeriesOutgoing, snapshotOut).filterValues { series -> series.any { it != 0f } }
+ stackedKeysIncoming = stackedSeriesIncoming.keys.sorted()
+ stackedKeysOutgoing = stackedSeriesOutgoing.keys.sorted()
+ }
+ GraphMode.PER_PEER -> {
+ val snapshotIn = perPeerIncoming
+ val snapshotOut = perPeerOutgoing
+ fun advance(base: Map>, snap: Map): Map> {
+ val next = mutableMapOf>()
+ val union = (base.keys + snap.keys).toSet()
+ union.forEach { k ->
+ val prev = base[k] ?: List(60) { 0f }
+ val s = (snap[k] ?: 0).toFloat()
+ next[k] = (prev + s).takeLast(60)
+ }
+ return next
+ }
+ stackedSeriesIncoming = advance(stackedSeriesIncoming, snapshotIn).filterValues { series -> series.any { it != 0f } }
+ stackedSeriesOutgoing = advance(stackedSeriesOutgoing, snapshotOut).filterValues { series -> series.any { it != 0f } }
+ stackedKeysIncoming = stackedSeriesIncoming.keys.sorted()
+ stackedKeysOutgoing = stackedSeriesOutgoing.keys.sorted()
}
}
+ kotlinx.coroutines.delay(1000)
}
}
- // Left gutter layout: unit + ticks neatly aligned
- Row(Modifier.fillMaxSize()) {
- Box(Modifier.width(leftGutter).fillMaxHeight()) {
- // Unit label on the far left, centered vertically
- Text(
- "p/s",
- fontFamily = FontFamily.Monospace,
- fontSize = 10.sp,
- color = colorScheme.onSurface.copy(alpha = 0.7f),
- modifier = Modifier.align(Alignment.CenterStart).padding(start = 2.dp).rotate(-90f)
- )
- // Tick labels right-aligned in gutter, top and bottom aligned
- Text(
- "${maxVal.toInt()}",
- fontFamily = FontFamily.Monospace,
- fontSize = 10.sp,
- color = colorScheme.onSurface.copy(alpha = 0.7f),
- modifier = Modifier.align(Alignment.TopEnd).padding(end = 4.dp, top = 0.dp)
- )
- Text(
- "0",
- fontFamily = FontFamily.Monospace,
- fontSize = 10.sp,
- color = colorScheme.onSurface.copy(alpha = 0.7f),
- modifier = Modifier.align(Alignment.BottomEnd).padding(end = 4.dp, bottom = 0.dp)
- )
+
+ // Helper functions moved to top-level composable below to avoid scope issues
+
+ // Render two blocks: Incoming and Outgoing
+ Text("Incoming", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f))
+ Text(
+ "${relayStats.lastSecondIncoming}/s • ${relayStats.lastMinuteIncoming}/m • ${relayStats.last15MinuteIncoming}/15m • total ${relayStats.totalIncomingCount}",
+ fontFamily = FontFamily.Monospace, fontSize = 10.sp, color = colorScheme.onSurface.copy(alpha = 0.6f)
+ )
+ DrawGraphBlock(
+ title = "Incoming",
+ stackedKeys = stackedKeysIncoming,
+ stackedSeries = stackedSeriesIncoming,
+ overallSeries = if (graphMode == GraphMode.OVERALL) overallSeriesIncoming else null,
+ graphMode = graphMode,
+ highlightedKey = highlightedKey,
+ onToggleHighlight = { key -> highlightedKey = if (highlightedKey == key) null else key },
+ ensureColors = { keys -> ensureColors(keys) },
+ colorForKey = { k -> colorForKey[k] ?: stableColorFor(k) },
+ legendTitleFor = { key ->
+ when (graphMode) {
+ GraphMode.PER_PEER -> {
+ val nick = nicknameMap.value[key]
+ val prefix = key.take(6)
+ if (!nick.isNullOrBlank()) "$nick ($prefix)" else prefix
+ }
+ GraphMode.PER_DEVICE -> {
+ val device = key
+ val pid = connectedDevices.firstOrNull { it.deviceAddress == device }?.peerID
+ ?: devicePeerMap.value[device]
+ if (pid != null) {
+ val nick = nicknameMap.value[pid]
+ val prefix = pid.take(6)
+ "$device (${if (!nick.isNullOrBlank()) "$nick ($prefix)" else prefix})"
+ } else device
+ }
+ else -> key
+ }
+ },
+ legendMetricsFor = { key ->
+ when (graphMode) {
+ GraphMode.PER_PEER -> {
+ val s = perPeerIncoming[key] ?: 0
+ val m = perPeerIncoming1m[key] ?: 0
+ val t = (perPeerIncomingTotal[key] ?: 0L)
+ "${s}/s • ${m}/m • total ${t}"
+ }
+ GraphMode.PER_DEVICE -> {
+ val s = perDeviceIncoming[key] ?: 0
+ val m = perDeviceIncoming1m[key] ?: 0
+ val t = (perDeviceIncomingTotal[key] ?: 0L)
+ "${s}/s • ${m}/m • total ${t}"
+ }
+ else -> ""
+ }
}
- Spacer(Modifier.weight(1f))
- }
+ )
+ if (graphMode != GraphMode.OVERALL && stackedKeysIncoming.isNotEmpty()) { /* legend printed inside DrawGraphBlock */ }
+
+ Spacer(Modifier.height(8.dp))
+ Text("Outgoing", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f))
+ Text(
+ "${relayStats.lastSecondOutgoing}/s • ${relayStats.lastMinuteOutgoing}/m • ${relayStats.last15MinuteOutgoing}/15m • total ${relayStats.totalOutgoingCount}",
+ fontFamily = FontFamily.Monospace, fontSize = 10.sp, color = colorScheme.onSurface.copy(alpha = 0.6f)
+ )
+ DrawGraphBlock(
+ title = "Outgoing",
+ stackedKeys = stackedKeysOutgoing,
+ stackedSeries = stackedSeriesOutgoing,
+ overallSeries = if (graphMode == GraphMode.OVERALL) overallSeriesOutgoing else null,
+ graphMode = graphMode,
+ highlightedKey = highlightedKey,
+ onToggleHighlight = { key -> highlightedKey = if (highlightedKey == key) null else key },
+ ensureColors = { keys -> ensureColors(keys) },
+ colorForKey = { k -> colorForKey[k] ?: stableColorFor(k) },
+ legendTitleFor = { key ->
+ when (graphMode) {
+ GraphMode.PER_PEER -> {
+ val nick = nicknameMap.value[key]
+ val prefix = key.take(6)
+ if (!nick.isNullOrBlank()) "$nick ($prefix)" else prefix
+ }
+ GraphMode.PER_DEVICE -> {
+ val device = key
+ val pid = connectedDevices.firstOrNull { it.deviceAddress == device }?.peerID
+ ?: devicePeerMap.value[device]
+ if (pid != null) {
+ val nick = nicknameMap.value[pid]
+ val prefix = pid.take(6)
+ "$device (${if (!nick.isNullOrBlank()) "$nick ($prefix)" else prefix})"
+ } else device
+ }
+ else -> key
+ }
+ },
+ legendMetricsFor = { key ->
+ when (graphMode) {
+ GraphMode.PER_PEER -> {
+ val s = perPeerOutgoing[key] ?: 0
+ val m = perPeerOutgoing1m[key] ?: 0
+ val t = (perPeerOutgoingTotal[key] ?: 0L)
+ "${s}/s • ${m}/m • total ${t}"
+ }
+ GraphMode.PER_DEVICE -> {
+ val s = perDeviceOutgoing[key] ?: 0
+ val m = perDeviceOutgoing1m[key] ?: 0
+ val t = (perDeviceOutgoingTotal[key] ?: 0L)
+ "${s}/s • ${m}/m • total ${t}"
+ }
+ else -> ""
+ }
+ }
+ )
+ if (graphMode != GraphMode.OVERALL && stackedKeysOutgoing.isNotEmpty()) { /* legend printed inside DrawGraphBlock */ }
}
}
}
@@ -399,3 +582,146 @@ fun DebugSettingsSheet(
}
}
}
+
+@Composable
+private fun DrawGraphBlock(
+ title: String,
+ stackedKeys: List,
+ stackedSeries: Map>,
+ overallSeries: List?,
+ graphMode: GraphMode,
+ highlightedKey: String?,
+ onToggleHighlight: (String) -> Unit,
+ ensureColors: (List) -> Unit,
+ colorForKey: (String) -> Color,
+ legendTitleFor: (String) -> String,
+ legendMetricsFor: (String) -> String
+) {
+ val colorScheme = MaterialTheme.colorScheme
+ val leftGutter = 40.dp
+ Box(Modifier.fillMaxWidth().height(56.dp)) {
+ androidx.compose.foundation.Canvas(Modifier.fillMaxSize()) {
+ val axisPx = leftGutter.toPx()
+ val barCount = 60
+ val availW = (size.width - axisPx).coerceAtLeast(1f)
+ val w = availW / barCount
+ val h = size.height
+ drawLine(
+ color = Color(0x33888888),
+ start = androidx.compose.ui.geometry.Offset(axisPx, h - 1f),
+ end = androidx.compose.ui.geometry.Offset(size.width, h - 1f),
+ strokeWidth = 1f
+ )
+
+ when (graphMode) {
+ GraphMode.OVERALL -> {
+ val maxValRaw = (overallSeries?.maxOrNull() ?: 0f)
+ val maxVal = if (maxValRaw > 0f) maxValRaw else 0f
+ (overallSeries ?: emptyList()).forEachIndexed { i, value ->
+ if (value > 0f && maxVal > 0f) {
+ val ratio = (value / maxVal).coerceIn(0f, 1f)
+ val barHeight = (h * ratio).coerceAtLeast(0f)
+ if (barHeight > 0.5f) {
+ drawRect(
+ color = Color(0xFF00C851),
+ topLeft = androidx.compose.ui.geometry.Offset(x = axisPx + i * w, y = h - barHeight),
+ size = androidx.compose.ui.geometry.Size(w, barHeight)
+ )
+ }
+ }
+ }
+ }
+ else -> {
+ val indices = 0 until 60
+ val totals = indices.map { idx ->
+ stackedSeries.values.sumOf { it.getOrNull(idx)?.toDouble() ?: 0.0 }.toFloat()
+ }
+ val maxTotal = (totals.maxOrNull() ?: 0f)
+ val drawKeysBars = if (stackedKeys.isNotEmpty()) stackedKeys else stackedSeries.keys.sorted()
+ indices.forEach { i ->
+ var yTop = h
+ if (maxTotal > 0f) {
+ ensureColors(drawKeysBars)
+ drawKeysBars.forEach { k ->
+ val v = stackedSeries[k]?.getOrNull(i) ?: 0f
+ if (v > 0f) {
+ val ratio = (v / maxTotal).coerceIn(0f, 1f)
+ val segH = (h * ratio)
+ if (segH > 0.5f) {
+ val top = (yTop - segH)
+ val baseColor = colorForKey(k)
+ val c = if (highlightedKey == null || highlightedKey == k) baseColor else baseColor.copy(alpha = 0.35f)
+ drawRect(
+ color = c,
+ topLeft = androidx.compose.ui.geometry.Offset(x = axisPx + i * w, y = top),
+ size = androidx.compose.ui.geometry.Size(w, segH)
+ )
+ yTop = top
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ Row(Modifier.fillMaxSize()) {
+ Box(Modifier.width(leftGutter).fillMaxHeight()) {
+ Text(
+ "p/s",
+ fontFamily = FontFamily.Monospace,
+ fontSize = 10.sp,
+ color = colorScheme.onSurface.copy(alpha = 0.7f),
+ modifier = Modifier.align(Alignment.CenterStart).padding(start = 2.dp).rotate(-90f)
+ )
+ val topLabel = when (graphMode) {
+ GraphMode.OVERALL -> (overallSeries?.maxOrNull() ?: 0f).toInt().toString()
+ else -> {
+ val totals = (0 until 60).map { idx -> stackedSeries.values.sumOf { it.getOrNull(idx)?.toDouble() ?: 0.0 }.toFloat() }
+ (totals.maxOrNull() ?: 0f).toInt().toString()
+ }
+ }
+ Text(
+ topLabel,
+ fontFamily = FontFamily.Monospace,
+ fontSize = 10.sp,
+ color = colorScheme.onSurface.copy(alpha = 0.7f),
+ modifier = Modifier.align(Alignment.TopEnd).padding(end = 4.dp)
+ )
+ Text(
+ "0",
+ fontFamily = FontFamily.Monospace,
+ fontSize = 10.sp,
+ color = colorScheme.onSurface.copy(alpha = 0.7f),
+ modifier = Modifier.align(Alignment.BottomEnd).padding(end = 4.dp)
+ )
+ }
+ Spacer(Modifier.weight(1f))
+ }
+ }
+
+ val drawKeys = if (stackedKeys.isNotEmpty()) stackedKeys else stackedSeries.keys.sorted()
+ if (graphMode != GraphMode.OVERALL && drawKeys.isNotEmpty()) {
+ Column(Modifier.fillMaxWidth()) {
+ FlowRow(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ drawKeys.forEach { key ->
+ val baseColor = colorForKey(key)
+ val dimmed = highlightedKey != null && highlightedKey != key
+ val swatchColor = if (dimmed) baseColor.copy(alpha = 0.35f) else baseColor
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(6.dp),
+ modifier = Modifier.clickable { onToggleHighlight(key) }
+ ) {
+ Box(Modifier.size(10.dp).background(swatchColor, RoundedCornerShape(2.dp)))
+ Column {
+ Text(legendTitleFor(key), fontFamily = FontFamily.Monospace, fontSize = 10.sp, color = MaterialTheme.colorScheme.onSurface.copy(alpha = if (dimmed) 0.6f else 0.95f))
+ Text(legendMetricsFor(key), fontFamily = FontFamily.Monospace, fontSize = 9.sp, color = MaterialTheme.colorScheme.onSurface.copy(alpha = if (dimmed) 0.45f else 0.75f))
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/util/AppConstants.kt b/app/src/main/java/com/bitchat/android/util/AppConstants.kt
index a332fca2b..9881cc2f7 100644
--- a/app/src/main/java/com/bitchat/android/util/AppConstants.kt
+++ b/app/src/main/java/com/bitchat/android/util/AppConstants.kt
@@ -80,8 +80,8 @@ object AppConstants {
const val SCAN_ON_DURATION_ULTRA_LOW_MS: Long = 1_000L
const val SCAN_OFF_DURATION_ULTRA_LOW_MS: Long = 10_000L
const val MAX_CONNECTIONS_NORMAL: Int = 8
- const val MAX_CONNECTIONS_POWER_SAVE: Int = 4
- const val MAX_CONNECTIONS_ULTRA_LOW: Int = 2
+ const val MAX_CONNECTIONS_POWER_SAVE: Int = 8
+ const val MAX_CONNECTIONS_ULTRA_LOW: Int = 4
}
object Nostr {
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index a140f9bb5..4a985c6c3 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -61,6 +61,11 @@
and %1$d more locations
and %1$d more
+
+ Mesh Background Service
+ Keeps the Bluetooth mesh running in the background
+ Mesh running — %1$d users connected
+
Add to favorites
Remove from favorites
@@ -152,6 +157,9 @@
Remove bookmark
Teleport
Selected
+ Quit bitchat
+ run in background
+ keep mesh active when app is closed (foreground service)
Leave channel
Reachable via Nostr
Offline favorite