Merge branch 'main' into gossip-routing-2

2026-07-25 17:25:21 +00:00 · 2025-10-28 09:00:01 +01:00
parent 7a93bb073b 80d897a022
commit 0fd1def8df
111 changed files with 12637 additions and 799 deletions
@@ -20,10 +20,10 @@ class BluetoothConnectionTracker(
    
    companion object {
        private const val TAG = "BluetoothConnectionTracker"
-        private const val CONNECTION_RETRY_DELAY = 5000L
-        private const val MAX_CONNECTION_ATTEMPTS = 3
-        private const val CLEANUP_DELAY = 500L
-        private const val CLEANUP_INTERVAL = 30000L // 30 seconds
+        private const val CONNECTION_RETRY_DELAY = com.bitchat.android.util.AppConstants.Mesh.CONNECTION_RETRY_DELAY_MS
+        private const val MAX_CONNECTION_ATTEMPTS = com.bitchat.android.util.AppConstants.Mesh.MAX_CONNECTION_ATTEMPTS
+        private const val CLEANUP_DELAY = com.bitchat.android.util.AppConstants.Mesh.CONNECTION_CLEANUP_DELAY_MS
+        private const val CLEANUP_INTERVAL = com.bitchat.android.util.AppConstants.Mesh.CONNECTION_CLEANUP_INTERVAL_MS // 30 seconds
    }
    
    // Connection tracking - reduced memory footprint
@@ -9,6 +9,7 @@ import android.content.Context
 import android.os.ParcelUuid
 import android.util.Log
 import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.util.AppConstants
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -31,13 +32,6 @@ class BluetoothGattClientManager(
    
    companion object {
        private const val TAG = "BluetoothGattClientManager"
-        // Use exact same UUIDs as iOS version
-        private val SERVICE_UUID = UUID.fromString("F47B5E2D-4A9E-4C5A-9B3F-8E1D2C3A4B5C")
-        private val CHARACTERISTIC_UUID = UUID.fromString("A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D")
-        private val DESCRIPTOR_UUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
-        
-        // RSSI monitoring constants
-        private const val RSSI_UPDATE_INTERVAL = 5000L // 5 seconds
    }
    
    // Core Bluetooth components
@@ -182,10 +176,10 @@ class BluetoothGattClientManager(
                            Log.w(TAG, "Failed to request RSSI from ${deviceConn.device.address}: ${e.message}")
                        }
                    }
-                    delay(RSSI_UPDATE_INTERVAL)
+                    delay(AppConstants.Mesh.RSSI_UPDATE_INTERVAL_MS)
                } catch (e: Exception) {
                    Log.w(TAG, "Error in RSSI monitoring: ${e.message}")
-                    delay(RSSI_UPDATE_INTERVAL)
+                    delay(AppConstants.Mesh.RSSI_UPDATE_INTERVAL_MS)
                }
            }
        }
@@ -231,12 +225,12 @@ class BluetoothGattClientManager(
        }
        
        val scanFilter = ScanFilter.Builder()
-            .setServiceUuid(ParcelUuid(SERVICE_UUID))
+            .setServiceUuid(ParcelUuid(AppConstants.Mesh.Gatt.SERVICE_UUID))
            .build()
        
        val scanFilters = listOf(scanFilter) 
        
-        Log.d(TAG, "Starting BLE scan with target service UUID: $SERVICE_UUID")
+        Log.d(TAG, "Starting BLE scan with target service UUID: ${AppConstants.Mesh.Gatt.SERVICE_UUID}")
        
        scanCallback = object : ScanCallback() {
            override fun onScanResult(callbackType: Int, result: ScanResult) {
@@ -321,7 +315,7 @@ class BluetoothGattClientManager(
        val scanRecord = result.scanRecord
        
        // CRITICAL: Only process devices that have our service UUID
-        val hasOurService = scanRecord?.serviceUuids?.any { it.uuid == SERVICE_UUID } == true
+        val hasOurService = scanRecord?.serviceUuids?.any { it.uuid == AppConstants.Mesh.Gatt.SERVICE_UUID } == true
        if (!hasOurService) {
            return
        }
@@ -456,9 +450,9 @@ class BluetoothGattClientManager(

            override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {                
                if (status == BluetoothGatt.GATT_SUCCESS) {
-                    val service = gatt.getService(SERVICE_UUID)
+                    val service = gatt.getService(AppConstants.Mesh.Gatt.SERVICE_UUID)
                    if (service != null) {
-                        val characteristic = service.getCharacteristic(CHARACTERISTIC_UUID)
+                        val characteristic = service.getCharacteristic(AppConstants.Mesh.Gatt.CHARACTERISTIC_UUID)
                        if (characteristic != null) {
                            connectionTracker.getDeviceConnection(deviceAddress)?.let { deviceConn ->
                                val updatedConn = deviceConn.copy(characteristic = characteristic)
@@ -467,7 +461,7 @@ class BluetoothGattClientManager(
                            }
                            
                            gatt.setCharacteristicNotification(characteristic, true)
-                            val descriptor = characteristic.getDescriptor(DESCRIPTOR_UUID)
+                            val descriptor = characteristic.getDescriptor(AppConstants.Mesh.Gatt.DESCRIPTOR_UUID)
                            if (descriptor != null) {
                                descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
                                gatt.writeDescriptor(descriptor)
@@ -9,6 +9,7 @@ import android.content.Context
 import android.os.ParcelUuid
 import android.util.Log
 import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.util.AppConstants
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -28,10 +29,6 @@ class BluetoothGattServerManager(
    
    companion object {
        private const val TAG = "BluetoothGattServerManager"
-        // Use exact same UUIDs as iOS version
-        private val SERVICE_UUID = UUID.fromString("F47B5E2D-4A9E-4C5A-9B3F-8E1D2C3A4B5C")
-        private val CHARACTERISTIC_UUID = UUID.fromString("A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D")
-        private val DESCRIPTOR_UUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
    }
    
    // Core Bluetooth components
@@ -223,7 +220,7 @@ class BluetoothGattServerManager(
                    return
                }
                
-                if (characteristic.uuid == CHARACTERISTIC_UUID) {
+                if (characteristic.uuid == AppConstants.Mesh.Gatt.CHARACTERISTIC_UUID) {
                    Log.i(TAG, "Server: Received packet from ${device.address}, size: ${value.size} bytes")
                    val packet = BitchatPacket.fromBinaryData(value)
                    if (packet != null) {
@@ -297,7 +294,7 @@ class BluetoothGattServerManager(
        
        // Create characteristic with notification support
        characteristic = BluetoothGattCharacteristic(
-            CHARACTERISTIC_UUID,
+            AppConstants.Mesh.Gatt.CHARACTERISTIC_UUID,
            BluetoothGattCharacteristic.PROPERTY_READ or 
            BluetoothGattCharacteristic.PROPERTY_WRITE or 
            BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE or
@@ -307,12 +304,12 @@ class BluetoothGattServerManager(
        )
        
        val descriptor = BluetoothGattDescriptor(
-            DESCRIPTOR_UUID,
+            AppConstants.Mesh.Gatt.DESCRIPTOR_UUID,
            BluetoothGattDescriptor.PERMISSION_READ or BluetoothGattDescriptor.PERMISSION_WRITE
        )
        characteristic?.addDescriptor(descriptor)
        
-        val service = BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY)
+        val service = BluetoothGattService(AppConstants.Mesh.Gatt.SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY)
        service.addCharacteristic(characteristic)
        
        gattServer?.addService(service)
@@ -357,7 +354,7 @@ class BluetoothGattServerManager(
        val settings = powerManager.getAdvertiseSettings()
        
        val data = AdvertiseData.Builder()
-            .addServiceUuid(ParcelUuid(SERVICE_UUID))
+            .addServiceUuid(ParcelUuid(AppConstants.Mesh.Gatt.SERVICE_UUID))
            .setIncludeTxPowerLevel(false)
            .setIncludeDeviceName(false)
            .build()
@@ -36,7 +36,7 @@ class BluetoothMeshService(private val context: Context) {
    
    companion object {
        private const val TAG = "BluetoothMeshService"
-        private const val MAX_TTL: UByte = 7u
+        private val MAX_TTL: UByte = com.bitchat.android.util.AppConstants.MESSAGE_TTL_HOPS
    }
    
    // Core components - each handling specific responsibilities
@@ -698,7 +698,7 @@ class BluetoothMeshService(private val context: Context) {
                            timestamp = System.currentTimeMillis().toULong(),
                            payload = encrypted,
                            signature = null,
-                            ttl = 7u
+                            ttl = com.bitchat.android.util.AppConstants.MESSAGE_TTL_HOPS
                        )
                        
                        // Sign and send the encrypted packet
@@ -844,7 +844,7 @@ class BluetoothMeshService(private val context: Context) {
                    timestamp = System.currentTimeMillis().toULong(),
                    payload = encrypted,
                    signature = null,
-                    ttl = 7u // Same TTL as iOS messageTTL
+                    ttl = com.bitchat.android.util.AppConstants.MESSAGE_TTL_HOPS // Same TTL as iOS messageTTL
                )
                
                // Sign the packet before broadcasting
@@ -47,7 +47,7 @@ class BluetoothPacketBroadcaster(
    
    companion object {
        private const val TAG = "BluetoothPacketBroadcaster"
-        private const val CLEANUP_DELAY = 500L
+        private const val CLEANUP_DELAY = com.bitchat.android.util.AppConstants.Mesh.BROADCAST_CLEANUP_DELAY_MS
    }

    // Optional nickname resolver injected by higher layer (peerID -> nickname?)
@@ -22,10 +22,10 @@ class FragmentManager {
    companion object {
        private const val TAG = "FragmentManager"
        // iOS values: 512 MTU threshold, 469 max fragment size (512 MTU - headers)
-        private const val FRAGMENT_SIZE_THRESHOLD = 512 // Matches iOS: if data.count > 512
-        private const val MAX_FRAGMENT_SIZE = 469        // Matches iOS: maxFragmentSize = 469 
-        private const val FRAGMENT_TIMEOUT = 30000L     // Matches iOS: 30 seconds cleanup
-        private const val CLEANUP_INTERVAL = 10000L     // 10 seconds cleanup check
+        private const val FRAGMENT_SIZE_THRESHOLD = com.bitchat.android.util.AppConstants.Fragmentation.FRAGMENT_SIZE_THRESHOLD // Matches iOS: if data.count > 512
+        private const val MAX_FRAGMENT_SIZE = com.bitchat.android.util.AppConstants.Fragmentation.MAX_FRAGMENT_SIZE        // Matches iOS: maxFragmentSize = 469 
+        private const val FRAGMENT_TIMEOUT = com.bitchat.android.util.AppConstants.Fragmentation.FRAGMENT_TIMEOUT_MS     // Matches iOS: 30 seconds cleanup
+        private const val CLEANUP_INTERVAL = com.bitchat.android.util.AppConstants.Fragmentation.CLEANUP_INTERVAL_MS     // 10 seconds cleanup check
    }
    
    // Fragment storage - iOS equivalent: incomingFragments: [String: [Int: Data]]
@@ -180,8 +180,12 @@ class FragmentManager {
                    incomingFragments.remove(fragmentIDString)
                    fragmentMetadata.remove(fragmentIDString)
                    
-                    Log.d(TAG, "Successfully reassembled and decoded original packet of ${reassembledData.size} bytes")
-                    return originalPacket
+                    // Suppress re-broadcast of the reassembled packet by zeroing TTL.
+                    // We already relayed the incoming fragments; setting TTL=0 ensures
+                    // PacketRelayManager will skip relaying this reconstructed packet.
+                    val suppressedTtlPacket = originalPacket.copy(ttl = 0u.toUByte())
+                    Log.d(TAG, "Successfully reassembled original (${reassembledData.size} bytes); set TTL=0 to suppress relay")
+                    return suppressedTtlPacket
                } else {
                    val metadata = fragmentMetadata[fragmentIDString]
                    Log.e(TAG, "Failed to decode reassembled packet (type=${metadata?.first}, total=${metadata?.second})")
@@ -183,16 +183,16 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
            }
            
            // Create NOISE_ENCRYPTED packet exactly like iOS
-            val packet = BitchatPacket(
-                version = 1u,
-                type = MessageType.NOISE_ENCRYPTED.value,
-                senderID = hexStringToByteArray(myPeerID),
-                recipientID = hexStringToByteArray(senderPeerID),
-                timestamp = System.currentTimeMillis().toULong(),
-                payload = encryptedPayload,
-                signature = null,
-                ttl = 7u // Same TTL as iOS messageTTL
-            )
+                val packet = BitchatPacket(
+                    version = 1u,
+                    type = MessageType.NOISE_ENCRYPTED.value,
+                    senderID = hexStringToByteArray(myPeerID),
+                    recipientID = hexStringToByteArray(senderPeerID),
+                    timestamp = System.currentTimeMillis().toULong(),
+                    payload = encryptedPayload,
+                    signature = null,
+                    ttl = com.bitchat.android.util.AppConstants.MESSAGE_TTL_HOPS // Same TTL as iOS messageTTL
+                )
            
            delegate?.sendPacket(packet)
            Log.d(TAG, "📤 Sent delivery ACK to $senderPeerID for message $messageID")
@@ -210,6 +210,14 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
        val peerID = routed.peerID ?: "unknown"

        if (peerID == myPeerID) return false
+
+        // Ignore stale announcements older than STALE_PEER_TIMEOUT
+        val now = System.currentTimeMillis()
+        val age = now - packet.timestamp.toLong()
+        if (age > com.bitchat.android.util.AppConstants.Mesh.STALE_PEER_TIMEOUT_MS) {
+            Log.w(TAG, "Ignoring stale ANNOUNCE from ${peerID.take(8)} (age=${age}ms > ${com.bitchat.android.util.AppConstants.Mesh.STALE_PEER_TIMEOUT_MS}ms)")
+            return false
+        }
        
        // Try to decode as iOS-compatible IdentityAnnouncement with TLV format
        val announcement = IdentityAnnouncement.decode(packet.payload)
@@ -317,7 +325,7 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
                    timestamp = System.currentTimeMillis().toULong(),
                    payload = response,
                    signature = null,
-                    ttl = 7u // Same TTL as iOS
+                    ttl = com.bitchat.android.util.AppConstants.MESSAGE_TTL_HOPS // Same TTL as iOS
                )
                
                delegate?.sendPacket(responsePacket)
@@ -67,9 +67,10 @@ class PeerManager {
    
    companion object {
        private const val TAG = "PeerManager"
-        private const val STALE_PEER_TIMEOUT = 180000L // 3 minutes (same as iOS)
-        private const val CLEANUP_INTERVAL = 60000L // 1 minute
    }
+
+    // Centralized timeout from AppConstants
+    private val stalePeerTimeoutMs: Long = com.bitchat.android.util.AppConstants.Mesh.STALE_PEER_TIMEOUT_MS
    
    // Peer tracking data - enhanced with verification status
    private val peers = ConcurrentHashMap<String, PeerInfo>() // peerID -> PeerInfo
@@ -299,7 +300,7 @@ class PeerManager {
    fun isPeerActive(peerID: String): Boolean {
        val info = peers[peerID] ?: return false
        val now = System.currentTimeMillis()
-        return (now - info.lastSeen) <= STALE_PEER_TIMEOUT && info.isConnected
+        return (now - info.lastSeen) <= stalePeerTimeoutMs && info.isConnected
    }
    
    /**
@@ -328,7 +329,7 @@ class PeerManager {
     */
    fun getActivePeerIDs(): List<String> {
        val now = System.currentTimeMillis()
-        return peers.filterValues { (now - it.lastSeen) <= STALE_PEER_TIMEOUT && it.isConnected }
+        return peers.filterValues { (now - it.lastSeen) <= stalePeerTimeoutMs && it.isConnected }
            .keys
            .toList()
            .sorted()
@@ -414,7 +415,7 @@ class PeerManager {
    private fun startPeriodicCleanup() {
        managerScope.launch {
            while (isActive) {
-                delay(CLEANUP_INTERVAL)
+                delay(com.bitchat.android.util.AppConstants.Mesh.PEER_CLEANUP_INTERVAL_MS)
                cleanupStalePeers()
            }
        }
@@ -426,7 +427,7 @@ class PeerManager {
    private fun cleanupStalePeers() {
        val now = System.currentTimeMillis()
        
-        val peersToRemove = peers.filterValues { (now - it.lastSeen) > STALE_PEER_TIMEOUT }
+        val peersToRemove = peers.filterValues { (now - it.lastSeen) > stalePeerTimeoutMs }
            .keys
            .toList()
        
@@ -21,22 +21,22 @@ class PowerManager(private val context: Context) {
        private const val TAG = "PowerManager"
        
        // Battery thresholds
-        private const val CRITICAL_BATTERY = 10
-        private const val LOW_BATTERY = 20
-        private const val MEDIUM_BATTERY = 50
+        private const val CRITICAL_BATTERY = com.bitchat.android.util.AppConstants.Power.CRITICAL_BATTERY_PERCENT
+        private const val LOW_BATTERY = com.bitchat.android.util.AppConstants.Power.LOW_BATTERY_PERCENT
+        private const val MEDIUM_BATTERY = com.bitchat.android.util.AppConstants.Power.MEDIUM_BATTERY_PERCENT
        
        // Scan duty cycle periods (ms)
-        private const val SCAN_ON_DURATION_NORMAL = 8000L    // 8 seconds on
-        private const val SCAN_OFF_DURATION_NORMAL = 2000L   // 2 seconds off
-        private const val SCAN_ON_DURATION_POWER_SAVE = 2000L    // 2 seconds on
-        private const val SCAN_OFF_DURATION_POWER_SAVE = 8000L  // 8 seconds off
-        private const val SCAN_ON_DURATION_ULTRA_LOW = 1000L      // 1 second on
-        private const val SCAN_OFF_DURATION_ULTRA_LOW = 10000L   // 10 seconds off
+        private const val SCAN_ON_DURATION_NORMAL = com.bitchat.android.util.AppConstants.Power.SCAN_ON_DURATION_NORMAL_MS    // 8 seconds on
+        private const val SCAN_OFF_DURATION_NORMAL = com.bitchat.android.util.AppConstants.Power.SCAN_OFF_DURATION_NORMAL_MS   // 2 seconds off
+        private const val SCAN_ON_DURATION_POWER_SAVE = com.bitchat.android.util.AppConstants.Power.SCAN_ON_DURATION_POWER_SAVE_MS    // 2 seconds on
+        private const val SCAN_OFF_DURATION_POWER_SAVE = com.bitchat.android.util.AppConstants.Power.SCAN_OFF_DURATION_POWER_SAVE_MS  // 8 seconds off
+        private const val SCAN_ON_DURATION_ULTRA_LOW = com.bitchat.android.util.AppConstants.Power.SCAN_ON_DURATION_ULTRA_LOW_MS      // 1 second on
+        private const val SCAN_OFF_DURATION_ULTRA_LOW = com.bitchat.android.util.AppConstants.Power.SCAN_OFF_DURATION_ULTRA_LOW_MS   // 10 seconds off
        
        // Connection limits
-        private const val MAX_CONNECTIONS_NORMAL = 8
-        private const val MAX_CONNECTIONS_POWER_SAVE = 4
-        private const val MAX_CONNECTIONS_ULTRA_LOW = 2
+        private const val MAX_CONNECTIONS_NORMAL = com.bitchat.android.util.AppConstants.Power.MAX_CONNECTIONS_NORMAL
+        private const val MAX_CONNECTIONS_POWER_SAVE = com.bitchat.android.util.AppConstants.Power.MAX_CONNECTIONS_POWER_SAVE
+        private const val MAX_CONNECTIONS_ULTRA_LOW = com.bitchat.android.util.AppConstants.Power.MAX_CONNECTIONS_ULTRA_LOW
    }
    
    enum class PowerMode {
@@ -19,10 +19,10 @@ class SecurityManager(private val encryptionService: EncryptionService, private
    
    companion object {
        private const val TAG = "SecurityManager"
-        private const val MESSAGE_TIMEOUT = 300000L // 5 minutes (same as iOS)
-        private const val CLEANUP_INTERVAL = 300000L // 5 minutes
-        private const val MAX_PROCESSED_MESSAGES = 10000
-        private const val MAX_PROCESSED_KEY_EXCHANGES = 1000
+        private const val MESSAGE_TIMEOUT = com.bitchat.android.util.AppConstants.Security.MESSAGE_TIMEOUT_MS // 5 minutes (same as iOS)
+        private const val CLEANUP_INTERVAL = com.bitchat.android.util.AppConstants.Security.CLEANUP_INTERVAL_MS // 5 minutes
+        private const val MAX_PROCESSED_MESSAGES = com.bitchat.android.util.AppConstants.Security.MAX_PROCESSED_MESSAGES
+        private const val MAX_PROCESSED_KEY_EXCHANGES = com.bitchat.android.util.AppConstants.Security.MAX_PROCESSED_KEY_EXCHANGES
    }
    
    // Security tracking
@@ -16,10 +16,10 @@ class StoreForwardManager {
    
    companion object {
        private const val TAG = "StoreForwardManager"
-        private const val MESSAGE_CACHE_TIMEOUT = 43200000L  // 12 hours for regular peers
-        private const val MAX_CACHED_MESSAGES = 100  // For regular peers
-        private const val MAX_CACHED_MESSAGES_FAVORITES = 1000  // For favorites
-        private const val CLEANUP_INTERVAL = 600000L // 10 minutes
+        private const val MESSAGE_CACHE_TIMEOUT = com.bitchat.android.util.AppConstants.StoreForward.MESSAGE_CACHE_TIMEOUT_MS  // 12 hours for regular peers
+        private const val MAX_CACHED_MESSAGES = com.bitchat.android.util.AppConstants.StoreForward.MAX_CACHED_MESSAGES  // For regular peers
+        private const val MAX_CACHED_MESSAGES_FAVORITES = com.bitchat.android.util.AppConstants.StoreForward.MAX_CACHED_MESSAGES_FAVORITES  // For favorites
+        private const val CLEANUP_INTERVAL = com.bitchat.android.util.AppConstants.StoreForward.CLEANUP_INTERVAL_MS // 10 minutes
    }
    
    /**