diff --git a/.github/workflows/android-build.yml b/.github/workflows/android-build.yml index a5a31ce68..b174f6f5e 100644 --- a/.github/workflows/android-build.yml +++ b/.github/workflows/android-build.yml @@ -1,145 +1,29 @@ -name: Android CI +name: Android Build on: push: - branches: [ "main", "develop" ] + branches: + - '**' pull_request: - branches: [ "main", "develop" ] + branches: + - '**' jobs: - test: - runs-on: ubuntu-latest - - steps: - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Setup Gradle - uses: gradle/gradle-build-action@v3 - - - name: Grant execute permission for gradlew - run: chmod +x gradlew - - - name: Cache Gradle packages - uses: actions/cache@v3 - with: - path: | - ~/.gradle/caches - ~/.gradle/wrapper - key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }} - restore-keys: | - ${{ runner.os }}-gradle- - - - name: Run unit tests - run: ./gradlew testDebugUnitTest - - - name: Upload Test Reports (xml+html) - if: always() - uses: actions/upload-artifact@v4 - with: - name: test-reports - path: | - **/build/test-results/ - **/build/reports/tests/ - - - name: Upload test results - uses: actions/upload-artifact@v4 - if: always() - with: - name: test-results - path: | - **/build/test-results/ - **/build/reports/tests/ - - lint: - runs-on: ubuntu-latest - - steps: - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Setup Gradle - uses: gradle/gradle-build-action@v3 - - - name: Grant execute permission for gradlew - run: chmod +x gradlew - - - name: Cache Gradle packages - uses: actions/cache@v3 - with: - path: | - ~/.gradle/caches - ~/.gradle/wrapper - key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }} - restore-keys: | - ${{ runner.os }}-gradle- - - - name: Run lint - run: ./gradlew lintDebug - - - name: Upload lint results - uses: actions/upload-artifact@v4 - if: always() - with: - name: lint-results - path: '**/build/reports/lint-results-*.html' - build: runs-on: ubuntu-latest - needs: [test, lint] - - steps: - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Setup Gradle - uses: gradle/gradle-build-action@v3 - - name: Grant execute permission for gradlew - run: chmod +x gradlew - - - name: Cache Gradle packages - uses: actions/cache@v3 - with: - path: | - ~/.gradle/caches - ~/.gradle/wrapper - key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }} - restore-keys: | - ${{ runner.os }}-gradle- - - - name: Build debug APK - run: ./gradlew assembleDebug + steps: + - name: Checkout code + uses: actions/checkout@v3 - - name: Build release APK - run: ./gradlew assembleRelease + - name: Set up JDK 17 + uses: actions/setup-java@v3 + with: + java-version: '17' + distribution: 'temurin' - - name: Upload debug APK - uses: actions/upload-artifact@v4 - with: - name: debug-apk - path: app/build/outputs/apk/debug/*.apk + - name: Setup Gradle + uses: gradle/gradle-build-action@v2 - - name: Upload release APK - uses: actions/upload-artifact@v4 - with: - name: release-apk - path: app/build/outputs/apk/release/*.apk + - name: Build with Gradle + run: ./gradlew build diff --git a/.gitignore b/.gitignore index 151e1b4f5..9365010c0 100644 --- a/.gitignore +++ b/.gitignore @@ -12,7 +12,6 @@ captures/ debug_keystore/ *.keystore debug.keystore -app/release # Gradle /build/ diff --git a/README.md b/README.md index 50f0cf54f..b061b525a 100644 --- a/README.md +++ b/README.md @@ -15,10 +15,6 @@ This is the **Android port** of the original [bitchat iOS app](https://github.co You can download the latest version of bitchat for Android from the [GitHub Releases page](https://github.com/permissionlesstech/bitchat-android/releases). -Or you can: - -[Get it on Google Play](https://play.google.com/store/apps/details?id=com.bitchat.droid) - **Instructions:** 1. **Download the APK:** On your Android device, navigate to the link above and download the latest `.apk` file. Open it. diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 30ecc6cc1..a1a06b79b 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -13,8 +13,8 @@ android { applicationId = "com.bitchat.droid" minSdk = libs.versions.minSdk.get().toInt() targetSdk = libs.versions.targetSdk.get().toInt() - versionCode = 22 - versionName = "1.3.1" + versionCode = 19 + versionName = "1.2.3" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" vectorDrawables { diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 134dcdfa0..9516695d6 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -20,15 +20,6 @@ - - - - - - - - - @@ -50,16 +41,6 @@ android:supportsRtl="true" android:theme="@style/Theme.BitchatAndroid" tools:targetApi="31"> - - - - { + OnboardingState.CHECKING -> { InitializingScreen(modifier) } @@ -227,8 +226,16 @@ class MainActivity : ComponentActivity() { } ) } - - OnboardingState.CHECKING, OnboardingState.INITIALIZING, OnboardingState.COMPLETE -> { + + OnboardingState.PERMISSION_REQUESTING -> { + InitializingScreen(modifier) + } + + OnboardingState.INITIALIZING -> { + InitializingScreen(modifier) + } + + OnboardingState.COMPLETE -> { // Set up back navigation handling for the chat screen val backCallback = object : OnBackPressedCallback(true) { override fun handleOnBackPressed() { @@ -526,13 +533,6 @@ class MainActivity : ComponentActivity() { return } - // Check if user has previously skipped battery optimization - if (BatteryOptimizationPreferenceManager.isSkipped(this)) { - android.util.Log.d("MainActivity", "User previously skipped battery optimization, proceeding to permissions") - proceedWithPermissionCheck() - return - } - // For existing users, check battery optimization status batteryOptimizationManager.logBatteryOptimizationStatus() val currentBatteryOptimizationStatus = when { diff --git a/app/src/main/java/com/bitchat/android/favorites/FavoritesPersistenceService.kt b/app/src/main/java/com/bitchat/android/favorites/FavoritesPersistenceService.kt index 12cd3e9f4..fe04c7b27 100644 --- a/app/src/main/java/com/bitchat/android/favorites/FavoritesPersistenceService.kt +++ b/app/src/main/java/com/bitchat/android/favorites/FavoritesPersistenceService.kt @@ -138,7 +138,6 @@ class FavoritesPersistenceService private constructor(private val context: Conte Log.d(TAG, "Updated Nostr pubkey association for ${keyHex.take(16)}...") } - /** NEW: Update Nostr pubkey for specific mesh peerID (16-hex). */ fun updateNostrPublicKeyForPeerID(peerID: String, nostrPubkey: String) { val pid = peerID.lowercase() @@ -151,7 +150,6 @@ class FavoritesPersistenceService private constructor(private val context: Conte } } - /** NEW: Resolve Nostr pubkey via current peerID mapping (fast path). */ fun findNostrPubkeyForPeerID(peerID: String): String? { return peerIdIndex[peerID.lowercase()] diff --git a/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt b/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt deleted file mode 100644 index e1016b115..000000000 --- a/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt +++ /dev/null @@ -1,274 +0,0 @@ -package com.bitchat.android.features.file - -import android.content.Context -import android.net.Uri -import android.os.Environment -import android.util.Log -import androidx.core.content.FileProvider -import java.io.File -import java.io.FileOutputStream -import java.io.InputStream -import java.text.SimpleDateFormat -import java.util.* - -object FileUtils { - - private const val TAG = "FileUtils" - - /** - * Save a file from URI to app's file directory with unique filename - */ - fun saveFileFromUri( - context: Context, - uri: Uri, - originalName: String? = null - ): String? { - return try { - val inputStream = context.contentResolver.openInputStream(uri) - if (inputStream == null) { - Log.e(TAG, "❌ Failed to open input stream for URI: $uri") - return null - } - Log.d(TAG, "📂 Opened input stream successfully") - - // Determine file extension - val extension = originalName?.substringAfterLast(".") ?: "bin" - val fileName = "file_${System.currentTimeMillis()}.$extension" - - // Create incoming dir if needed - val incomingDir = File(context.filesDir, "files/incoming").apply { - if (!exists()) mkdirs() - } - - val file = File(incomingDir, fileName) - - inputStream.use { input -> - FileOutputStream(file).use { output -> - input.copyTo(output) - } - } - - Log.d(TAG, "Saved file to: ${file.absolutePath}") - file.absolutePath - - } catch (e: Exception) { - Log.e(TAG, "Failed to save file from URI", e) - null - } - } - - /** - * Copy file to app's outgoing directory for sending - */ - fun copyFileForSending(context: Context, uri: Uri, originalName: String? = null): String? { - Log.d(TAG, "🔄 Starting file copy from URI: $uri") - return try { - val inputStream = context.contentResolver.openInputStream(uri) - if (inputStream == null) { - Log.e(TAG, "❌ Failed to open input stream for URI: $uri") - return null - } - Log.d(TAG, "📂 Opened input stream successfully") - - // Determine original filename and extension if available - val displayName = originalName ?: run { - try { - context.contentResolver.query(uri, null, null, null, null)?.use { cursor -> - val nameIndex = cursor.getColumnIndex(android.provider.MediaStore.MediaColumns.DISPLAY_NAME) - if (nameIndex >= 0 && cursor.moveToFirst()) cursor.getString(nameIndex) else null - } - } catch (_: Exception) { null } - } - val extension = displayName?.substringAfterLast('.', missingDelimiterValue = "")?.takeIf { it.isNotBlank() } - ?: run { - // Try mime type to extension - val mime = try { context.contentResolver.getType(uri) } catch (_: Exception) { null } - android.webkit.MimeTypeMap.getSingleton().getExtensionFromMimeType(mime) ?: "bin" - } - // Preserve original filename (without artificial prefixes), ensure uniqueness - val baseName = displayName?.substringBeforeLast('.')?.take(64)?.replace(Regex("[^A-Za-z0-9._-]"), "_") - ?: "file" - var fileName = if (extension.isNotBlank()) "$baseName.$extension" else baseName - - // Create outgoing dir if needed - val outgoingDir = File(context.filesDir, "files/outgoing").apply { - if (!exists()) mkdirs() - } - - var target = File(outgoingDir, fileName) - if (target.exists()) { - var idx = 1 - val pureBase = baseName - val dotExt = if (extension.isNotBlank()) ".${extension}" else "" - while (target.exists() && idx < 1000) { - fileName = "$pureBase ($idx)$dotExt" - target = File(outgoingDir, fileName) - idx++ - } - } - - inputStream.use { input -> - FileOutputStream(target).use { output -> - input.copyTo(output) - } - } - - Log.d(TAG, "✅ Successfully copied file for sending: ${target.absolutePath}") - Log.d(TAG, "📊 Final file size: ${target.length()} bytes") - target.absolutePath - - } catch (e: Exception) { - Log.e(TAG, "❌ CRITICAL: Failed to copy file for sending", e) - Log.e(TAG, "❌ Source URI: $uri") - Log.e(TAG, "❌ Original name: $originalName") - Log.e(TAG, "❌ Error type: ${e.javaClass.simpleName}") - null - } - } - - /** - * Get MIME type for a file based on extension - */ - fun getMimeTypeFromExtension(fileName: String): String { - return when (fileName.substringAfterLast(".", "").lowercase()) { - "pdf" -> "application/pdf" - "doc" -> "application/msword" - "docx" -> "application/vnd.openxmlformats-officedocument.wordprocessingml.document" - "xls" -> "application/vnd.ms-excel" - "xlsx" -> "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" - "ppt" -> "application/vnd.ms-powerpoint" - "pptx" -> "application/vnd.openxmlformats-officedocument.presentationml.presentation" - "txt" -> "text/plain" - "json" -> "application/json" - "xml" -> "application/xml" - "csv" -> "text/csv" - "html", "htm" -> "text/html" - "jpg", "jpeg" -> "image/jpeg" - "png" -> "image/png" - "gif" -> "image/gif" - "bmp" -> "image/bmp" - "webp" -> "image/webp" - "svg" -> "image/svg+xml" - "mp3" -> "audio/mpeg" - "wav" -> "audio/wav" - "m4a" -> "audio/mp4" - "mp4" -> "video/mp4" - "avi" -> "video/x-msvideo" - "mov" -> "video/quicktime" - "zip" -> "application/zip" - "rar" -> "application/vnd.rar" - "7z" -> "application/x-7z-compressed" - else -> "application/octet-stream" - } - } - - /** - * Format file size for display - */ - fun formatFileSize(bytes: Long): String { - val units = arrayOf("B", "KB", "MB", "GB") - var size = bytes.toDouble() - var unitIndex = 0 - while (size >= 1024 && unitIndex < units.size - 1) { - size /= 1024.0 - unitIndex++ - } - return "%.1f %s".format(size, units[unitIndex]) - } - - /** - * Check if file is viewable in system viewer - */ - fun isFileViewable(fileName: String): Boolean { - val extension = fileName.substringAfterLast(".", "").lowercase() - return extension in listOf( - "pdf", "txt", "json", "xml", "html", "htm", "csv", - "jpg", "jpeg", "png", "gif", "bmp", "webp", "svg" - ) - } - - /** - * Save an incoming file packet to app storage and return absolute path. - * Mirrors existing behavior used in MessageHandler (preserves names and folders). - */ - fun saveIncomingFile( - context: Context, - file: com.bitchat.android.model.BitchatFilePacket - ): String { - val lowerMime = file.mimeType.lowercase() - val isImage = lowerMime.startsWith("image/") - val baseDir = context.filesDir - val subdir = if (isImage) "images/incoming" else "files/incoming" - val dir = java.io.File(baseDir, subdir).apply { mkdirs() } - - fun extFromMime(m: String): String = when (m.lowercase()) { - "image/jpeg", "image/jpg" -> ".jpg" - "image/png" -> ".png" - "image/webp" -> ".webp" - "application/pdf" -> ".pdf" - "text/plain" -> ".txt" - else -> if (isImage) ".jpg" else ".bin" - } - - // Prefer transmitted original name; ensure uniqueness to avoid overwrites - val baseName = (file.fileName.takeIf { it.isNotBlank() } - ?: (if (isImage) "img" else "file")) - .replace(Regex("[^A-Za-z0-9._-]"), "_") - val ext = extFromMime(lowerMime) - var safeName = if (baseName.contains('.')) baseName else baseName + ext - var idx = 1 - while (java.io.File(dir, safeName).exists() && idx < 1000) { - val dot = safeName.lastIndexOf('.') - safeName = if (dot > 0) { - val b = safeName.substring(0, dot) - val e = safeName.substring(dot) - "$b ($idx)$e" - } else { - "$safeName ($idx)" - } - idx++ - } - - return try { - val out = java.io.File(dir, safeName) - out.outputStream().use { it.write(file.content) } - out.absolutePath - } catch (_: Exception) { - // Fallback to cache dir with uniqueness - try { - var fallback = safeName - var idx2 = 1 - while (java.io.File(context.cacheDir, fallback).exists() && idx2 < 1000) { - val dot = fallback.lastIndexOf('.') - fallback = if (dot > 0) { - val b = fallback.substring(0, dot) - val e = fallback.substring(dot) - "$b ($idx2)$e" - } else { - "$fallback ($idx2)" - } - idx2++ - } - val out = java.io.File(context.cacheDir, fallback) - out.outputStream().use { it.write(file.content) } - out.absolutePath - } catch (_: Exception) { - val tmp = java.io.File.createTempFile(if (isImage) "img_" else "file_", if (isImage) ".jpg" else ".bin") - tmp.writeBytes(file.content) - tmp.absolutePath - } - } - } - - /** - * Classify BitchatMessageType from MIME string used in file messages. - */ - fun messageTypeForMime(mime: String): com.bitchat.android.model.BitchatMessageType { - val lower = mime.lowercase() - return when { - lower.startsWith("image/") -> com.bitchat.android.model.BitchatMessageType.Image - lower.startsWith("audio/") -> com.bitchat.android.model.BitchatMessageType.Audio - else -> com.bitchat.android.model.BitchatMessageType.File - } - } -} diff --git a/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt b/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt deleted file mode 100644 index 75d1ab9d4..000000000 --- a/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt +++ /dev/null @@ -1,36 +0,0 @@ -package com.bitchat.android.features.media - -import android.content.Context -import android.graphics.Bitmap -import android.graphics.BitmapFactory -import java.io.File -import java.io.FileOutputStream - -object ImageUtils { - fun downscaleAndSaveToAppFiles(context: Context, uri: android.net.Uri, maxDim: Int = 512, quality: Int = 85): String? { - return try { - val resolver = context.contentResolver - val input = resolver.openInputStream(uri) ?: return null - val original = BitmapFactory.decodeStream(input) - input.close() - original ?: return null - val w = original.width - val h = original.height - val scale = (maxOf(w, h).toFloat() / maxDim.toFloat()).coerceAtLeast(1f) - val newW = (w / scale).toInt().coerceAtLeast(1) - val newH = (h / scale).toInt().coerceAtLeast(1) - val scaled = if (scale > 1f) Bitmap.createScaledBitmap(original, newW, newH, true) else original - val dir = File(context.filesDir, "images/outgoing").apply { mkdirs() } - val outFile = File(dir, "img_${System.currentTimeMillis()}.jpg") - FileOutputStream(outFile).use { fos -> - scaled.compress(Bitmap.CompressFormat.JPEG, quality, fos) - } - if (scaled !== original) try { original.recycle() } catch (_: Exception) {} - try { if (scaled != original) scaled.recycle() } catch (_: Exception) {} - outFile.absolutePath - } catch (e: Exception) { - null - } - } -} - diff --git a/app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt b/app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt deleted file mode 100644 index eaa338aa0..000000000 --- a/app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt +++ /dev/null @@ -1,76 +0,0 @@ -package com.bitchat.android.features.voice - -import android.content.Context -import android.media.MediaRecorder -import android.util.Log -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow -import kotlinx.coroutines.withContext -import java.io.File -import java.text.SimpleDateFormat -import java.util.Date -import java.util.Locale - -/** - * Simple MediaRecorder wrapper that records to M4A (AAC) for wide compatibility. - * The resulting file has MIME audio/mp4. - */ -class VoiceRecorder(private val context: Context) { - companion object { private const val TAG = "VoiceRecorder" } - - private var recorder: MediaRecorder? = null - private val _amplitude = MutableStateFlow(0) - val amplitude: StateFlow = _amplitude.asStateFlow() - - private var outFile: File? = null - - fun start(): File? { - stop() // ensure previous session closed - return try { - val dir = File(context.filesDir, "voicenotes/outgoing").apply { mkdirs() } - val name = "voice_" + SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date()) + ".m4a" - val file = File(dir, name) - val rec = MediaRecorder() - rec.setAudioSource(MediaRecorder.AudioSource.MIC) - rec.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) - rec.setAudioEncoder(MediaRecorder.AudioEncoder.AAC) - rec.setAudioChannels(1) - rec.setAudioSamplingRate(44100) - // Lower bitrate to keep BLE payloads <= 32KiB for fragmentation - rec.setAudioEncodingBitRate(32_000) - rec.setOutputFile(file.absolutePath) - rec.prepare() - rec.start() - recorder = rec - outFile = file - file - } catch (e: Exception) { - Log.e(TAG, "Failed to start recording: ${e.message}") - null - } - } - - fun pollAmplitude(): Int { - return try { - val amp = recorder?.maxAmplitude ?: 0 - _amplitude.value = amp - amp - } catch (_: Exception) { 0 } - } - - fun stop(): File? { - try { - recorder?.apply { - try { stop() } catch (_: Exception) {} - try { reset() } catch (_: Exception) {} - try { release() } catch (_: Exception) {} - } - } catch (_: Exception) {} - val f = outFile - recorder = null - outFile = null - return f - } -} diff --git a/app/src/main/java/com/bitchat/android/features/voice/VoiceVisualizer.kt b/app/src/main/java/com/bitchat/android/features/voice/VoiceVisualizer.kt deleted file mode 100644 index 9e1114b7f..000000000 --- a/app/src/main/java/com/bitchat/android/features/voice/VoiceVisualizer.kt +++ /dev/null @@ -1,42 +0,0 @@ -package com.bitchat.android.features.voice - -import androidx.compose.animation.core.LinearEasing -import androidx.compose.animation.core.animateFloatAsState -import androidx.compose.animation.core.tween -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.runtime.Composable -import androidx.compose.runtime.getValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.drawscope.drawIntoCanvas -import androidx.compose.ui.unit.dp -import kotlin.math.min - -@Composable -fun CyberpunkVisualizer(amplitude: Int, color: Color, modifier: Modifier = Modifier) { - val norm = min(1f, amplitude / 20_000f) - val heightFrac by animateFloatAsState( - targetValue = 0.1f + 0.9f * norm, - animationSpec = tween(120, easing = LinearEasing), label = "amp" - ) - Canvas( - modifier = modifier - .fillMaxWidth() - .height(48.dp) - ) { - val w = size.width - val h = size.height - val barCount = 24 - val gap = 6f - val bw = (w - gap * (barCount - 1)) / barCount - for (i in 0 until barCount) { - val phase = (i.toFloat() / barCount) - val barH = (0.2f + heightFrac * (0.8f * (0.5f + 0.5f * kotlin.math.sin(phase * Math.PI * 2).toFloat()))) * h - val x = i * (bw + gap) - val y = (h - barH) / 2f - drawRect(color.copy(alpha = 0.85f), topLeft = androidx.compose.ui.geometry.Offset(x, y), size = androidx.compose.ui.geometry.Size(bw, barH)) - } - } -} diff --git a/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt b/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt deleted file mode 100644 index a65960999..000000000 --- a/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt +++ /dev/null @@ -1,174 +0,0 @@ -package com.bitchat.android.features.voice - -import android.media.MediaCodec -import android.media.MediaExtractor -import android.media.MediaFormat -import android.util.Log -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.SupervisorJob -import kotlinx.coroutines.launch -import java.nio.ByteBuffer -import java.nio.ByteOrder -import java.util.concurrent.ConcurrentHashMap -import kotlin.math.abs -import kotlin.math.ln -import kotlin.math.max -import kotlin.math.min - -object VoiceWaveformCache { - private val map = ConcurrentHashMap() - fun put(path: String, samples: FloatArray) { map[path] = samples } - fun get(path: String): FloatArray? = map[path] -} - -fun normalizeAmplitudeSample(amp: Int): Float { - val a = max(0, amp) - val norm = ln(1.0 + a.toDouble()) / ln(1.0 + 32768.0) - return norm.toFloat().coerceIn(0f, 1f) -} - -fun resampleWave(values: FloatArray, target: Int): FloatArray { - if (values.isEmpty() || target <= 0) return FloatArray(target) { 0f } - if (values.size == target) return values - val out = FloatArray(target) - val step = (values.size - 1).toFloat() / (target - 1).toFloat() - var x = 0f - for (i in 0 until target) { - val idx = x.toInt() - val frac = x - idx - val a = values[idx] - val b = values[min(values.size - 1, idx + 1)] - out[i] = (a + (b - a) * frac).coerceIn(0f, 1f) - x += step - } - return out -} - -object AudioWaveformExtractor { - private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob()) - - fun extractAsync(path: String, sampleCount: Int = 120, onComplete: (FloatArray?) -> Unit) { - scope.launch { - onComplete(runCatching { extract(path, sampleCount) }.getOrNull()) - } - } - - private fun extract(path: String, sampleCount: Int): FloatArray? { - val extractor = MediaExtractor() - extractor.setDataSource(path) - val trackIndex = (0 until extractor.trackCount).firstOrNull { idx -> - val fmt = extractor.getTrackFormat(idx) - val mime = fmt.getString(MediaFormat.KEY_MIME) ?: "" - mime.startsWith("audio/") - } ?: return null - extractor.selectTrack(trackIndex) - val format = extractor.getTrackFormat(trackIndex) - val mime = format.getString(MediaFormat.KEY_MIME) ?: return null - val codec = MediaCodec.createDecoderByType(mime) - codec.configure(format, null, null, 0) - codec.start() - - val durationUs = if (format.containsKey(MediaFormat.KEY_DURATION)) format.getLong(MediaFormat.KEY_DURATION) else 0L - val desiredBins = sampleCount.coerceAtLeast(32) - val bins = FloatArray(desiredBins) { 0f } - val counts = IntArray(desiredBins) { 0 } - - val inBuffers = codec.inputBuffers - val outInfo = MediaCodec.BufferInfo() - - var sawEOS = false - while (!sawEOS) { - // Queue input - val inIndex = codec.dequeueInputBuffer(10_000) - if (inIndex >= 0) { - val buffer = codec.getInputBuffer(inIndex) ?: inBuffers[inIndex] - val sampleSize = extractor.readSampleData(buffer, 0) - if (sampleSize < 0) { - codec.queueInputBuffer(inIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM) - } else { - val presentationTimeUs = extractor.sampleTime - codec.queueInputBuffer(inIndex, 0, sampleSize, presentationTimeUs, 0) - extractor.advance() - } - } - - // Dequeue output - var outIndex = codec.dequeueOutputBuffer(outInfo, 10_000) - while (outIndex >= 0) { - val outBuf = codec.getOutputBuffer(outIndex) - if (outBuf != null && outInfo.size > 0) { - outBuf.order(ByteOrder.LITTLE_ENDIAN) - val shortCount = outInfo.size / 2 - val shorts = ShortArray(shortCount) - outBuf.asShortBuffer().get(shorts) - - // Map this buffer to bins using timestamp range - val startUs = outInfo.presentationTimeUs - val endUs = startUs + bufferDurationUs(format, outInfo.size) - val startBin = binForTime(startUs, durationUs, desiredBins) - val endBin = binForTime(endUs, durationUs, desiredBins).coerceAtMost(desiredBins - 1) - - var idx = 0 - for (bin in startBin..endBin) { - // aggregate portion of buffer to this bin - val window = shorts.size / max(1, (endBin - startBin + 1)) - val begin = idx - val finish = min(shorts.size, idx + window) - var acc = 0.0 - var cnt = 0 - for (i in begin until finish) { - acc += abs(shorts[i].toInt()) - cnt += 1 - } - val avg = if (cnt > 0) (acc / cnt) else 0.0 - val norm = (avg / 32768.0).coerceIn(0.0, 1.0).toFloat() - bins[bin] = max(bins[bin], norm) - counts[bin] += 1 - idx += window - } - } - codec.releaseOutputBuffer(outIndex, false) - outIndex = codec.dequeueOutputBuffer(outInfo, 0) - } - - if (outInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) { - sawEOS = true - } - } - - codec.stop() - codec.release() - extractor.release() - - // Smooth + normalize - var maxVal = 0f - for (i in bins.indices) { - if (counts[i] == 0) continue - maxVal = max(maxVal, bins[i]) - } - if (maxVal <= 0f) maxVal = 1f - for (i in bins.indices) { - bins[i] = (bins[i] / maxVal).coerceIn(0f, 1f) - } - - return bins - } - - private fun bufferDurationUs(format: MediaFormat, bytes: Int): Long { - return try { - val sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE) - val channels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT) - val samples = bytes / 2 / max(1, channels) - (samples * 1_000_000L) / max(1, sampleRate) - } catch (e: Exception) { - 0L - } - } - - private fun binForTime(presentationUs: Long, durationUs: Long, bins: Int): Int { - if (durationUs <= 0L) return 0 - val frac = presentationUs.toDouble() / durationUs.toDouble() - return (frac * bins).toInt().coerceIn(0, bins - 1) - } -} diff --git a/app/src/main/java/com/bitchat/android/geohash/Geohash.kt b/app/src/main/java/com/bitchat/android/geohash/Geohash.kt index 6907a42d1..0194fe70a 100644 --- a/app/src/main/java/com/bitchat/android/geohash/Geohash.kt +++ b/app/src/main/java/com/bitchat/android/geohash/Geohash.kt @@ -11,8 +11,6 @@ object Geohash { private val base32Chars = "0123456789bcdefghjkmnpqrstuvwxyz".toCharArray() private val charToValue: Map = base32Chars.withIndex().associate { it.value to it.index } - data class Bounds(val latMin: Double, val latMax: Double, val lonMin: Double, val lonMax: Double) - /** * Encodes the provided coordinates into a geohash string. * @param latitude Latitude in degrees (-90...90) @@ -71,24 +69,14 @@ object Geohash { * @return Pair(latitude, longitude) */ fun decodeToCenter(geohash: String): Pair { - val b = decodeToBounds(geohash) - val latCenter = (b.latMin + b.latMax) / 2 - val lonCenter = (b.lonMin + b.lonMax) / 2 - return latCenter to lonCenter - } - - /** - * Decodes a geohash string to bounding box (lat/lon min/max). - */ - fun decodeToBounds(geohash: String): Bounds { - if (geohash.isEmpty()) return Bounds(0.0, 0.0, 0.0, 0.0) + if (geohash.isEmpty()) return 0.0 to 0.0 var latInterval = -90.0 to 90.0 var lonInterval = -180.0 to 180.0 var isEven = true geohash.lowercase().forEach { ch -> - val cd = charToValue[ch] ?: return Bounds(0.0, 0.0, 0.0, 0.0) + val cd = charToValue[ch] ?: return 0.0 to 0.0 for (mask in intArrayOf(16, 8, 4, 2, 1)) { if (isEven) { val mid = (lonInterval.first + lonInterval.second) / 2 @@ -108,11 +96,9 @@ object Geohash { isEven = !isEven } } - return Bounds( - latMin = minOf(latInterval.first, latInterval.second), - latMax = maxOf(latInterval.first, latInterval.second), - lonMin = minOf(lonInterval.first, lonInterval.second), - lonMax = maxOf(lonInterval.first, lonInterval.second) - ) + + val latCenter = (latInterval.first + latInterval.second) / 2 + val lonCenter = (lonInterval.first + lonInterval.second) / 2 + return latCenter to lonCenter } } diff --git a/app/src/main/java/com/bitchat/android/geohash/GeohashBookmarksStore.kt b/app/src/main/java/com/bitchat/android/geohash/GeohashBookmarksStore.kt deleted file mode 100644 index b498dd833..000000000 --- a/app/src/main/java/com/bitchat/android/geohash/GeohashBookmarksStore.kt +++ /dev/null @@ -1,249 +0,0 @@ -package com.bitchat.android.geohash - -import android.content.Context -import android.location.Geocoder -import android.location.Location -import android.location.LocationManager -import android.util.Log -import androidx.lifecycle.LiveData -import androidx.lifecycle.MutableLiveData -import com.google.gson.Gson -import com.google.gson.reflect.TypeToken -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import java.util.Locale - -/** - * Stores a user-maintained list of bookmarked geohash channels. - * - Persistence: SharedPreferences (JSON string array) - * - Semantics: geohashes are normalized to lowercase base32 and de-duplicated - */ -class GeohashBookmarksStore private constructor(private val context: Context) { - - companion object { - private const val TAG = "GeohashBookmarksStore" - private const val STORE_KEY = "locationChannel.bookmarks" - private const val NAMES_STORE_KEY = "locationChannel.bookmarkNames" - - @Volatile private var INSTANCE: GeohashBookmarksStore? = null - fun getInstance(context: Context): GeohashBookmarksStore { - return INSTANCE ?: synchronized(this) { - INSTANCE ?: GeohashBookmarksStore(context.applicationContext).also { INSTANCE = it } - } - } - - private val allowedChars = "0123456789bcdefghjkmnpqrstuvwxyz".toSet() - fun normalize(raw: String): String { - return raw.trim().lowercase(Locale.US) - .replace("#", "") - .filter { allowedChars.contains(it) } - } - } - - private val gson = Gson() - private val prefs = context.getSharedPreferences("geohash_prefs", Context.MODE_PRIVATE) - - private val membership = mutableSetOf() - - private val _bookmarks = MutableLiveData>(emptyList()) - val bookmarks: LiveData> = _bookmarks - - private val _bookmarkNames = MutableLiveData>(emptyMap()) - val bookmarkNames: LiveData> = _bookmarkNames - - // For throttling / preventing duplicate geocode lookups - private val resolving = mutableSetOf() - - init { load() } - - fun isBookmarked(geohash: String): Boolean = membership.contains(normalize(geohash)) - - fun toggle(geohash: String) { - val gh = normalize(geohash) - if (membership.contains(gh)) remove(gh) else add(gh) - } - - fun add(geohash: String) { - val gh = normalize(geohash) - if (gh.isEmpty() || membership.contains(gh)) return - membership.add(gh) - val updated = listOf(gh) + (_bookmarks.value ?: emptyList()) - _bookmarks.postValue(updated) - persist(updated) - // Resolve friendly name asynchronously - resolveNameIfNeeded(gh) - } - - fun remove(geohash: String) { - val gh = normalize(geohash) - if (!membership.contains(gh)) return - membership.remove(gh) - val updated = (_bookmarks.value ?: emptyList()).filterNot { it == gh } - _bookmarks.postValue(updated) - // Remove stored name to avoid stale cache growth - val names = _bookmarkNames.value?.toMutableMap() ?: mutableMapOf() - if (names.remove(gh) != null) { - _bookmarkNames.postValue(names) - persistNames(names) - } - persist(updated) - } - - // MARK: - Persistence - - private fun load() { - try { - val arrJson = prefs.getString(STORE_KEY, null) - if (!arrJson.isNullOrEmpty()) { - val listType = object : TypeToken>() {}.type - val arr = gson.fromJson>(arrJson, listType) - val seen = mutableSetOf() - val ordered = mutableListOf() - arr.forEach { raw -> - val gh = normalize(raw) - if (gh.isNotEmpty() && !seen.contains(gh)) { - seen.add(gh) - ordered.add(gh) - } - } - membership.clear(); membership.addAll(seen) - _bookmarks.postValue(ordered) - } - } catch (e: Exception) { - Log.e(TAG, "Failed to load bookmarks: ${e.message}") - } - try { - val namesJson = prefs.getString(NAMES_STORE_KEY, null) - if (!namesJson.isNullOrEmpty()) { - val mapType = object : TypeToken>() {}.type - val dict = gson.fromJson>(namesJson, mapType) - _bookmarkNames.postValue(dict) - } - } catch (e: Exception) { - Log.e(TAG, "Failed to load bookmark names: ${e.message}") - } - } - - private fun persist() { - try { - val json = gson.toJson(_bookmarks.value ?: emptyList()) - prefs.edit().putString(STORE_KEY, json).apply() - } catch (_: Exception) {} - } - - private fun persistNames() { - try { - val json = gson.toJson(_bookmarkNames.value ?: emptyMap()) - prefs.edit().putString(NAMES_STORE_KEY, json).apply() - } catch (_: Exception) {} - } - - // MARK: - Destructive Reset - - fun clearAll() { - try { - membership.clear() - _bookmarks.postValue(emptyList()) - _bookmarkNames.postValue(emptyMap()) - prefs.edit() - .remove(STORE_KEY) - .remove(NAMES_STORE_KEY) - .apply() - // Clear any in-flight resolutions to avoid repopulating - resolving.clear() - Log.i(TAG, "Cleared all geohash bookmarks and names") - } catch (e: Exception) { - Log.e(TAG, "Failed to clear geohash bookmarks: ${e.message}") - } - } - - - // MARK: - Friendly Name Resolution - - fun resolveNameIfNeeded(geohash: String) { - val gh = normalize(geohash) - if (gh.isEmpty()) return - if (_bookmarkNames.value?.containsKey(gh) == true) return - if (resolving.contains(gh)) return - if (!Geocoder.isPresent()) return - - resolving.add(gh) - CoroutineScope(Dispatchers.IO).launch { - try { - val geocoder = Geocoder(context, Locale.getDefault()) - val name: String? = if (gh.length <= 2) { - // Composite admin name from multiple points - val b = Geohash.decodeToBounds(gh) - val points = listOf( - Location(LocationManager.GPS_PROVIDER).apply { latitude = (b.latMin + b.latMax) / 2; longitude = (b.lonMin + b.lonMax) / 2 }, - Location(LocationManager.GPS_PROVIDER).apply { latitude = b.latMin; longitude = b.lonMin }, - Location(LocationManager.GPS_PROVIDER).apply { latitude = b.latMin; longitude = b.lonMax }, - Location(LocationManager.GPS_PROVIDER).apply { latitude = b.latMax; longitude = b.lonMin }, - Location(LocationManager.GPS_PROVIDER).apply { latitude = b.latMax; longitude = b.lonMax } - ) - val admins = linkedSetOf() - for (loc in points) { - try { - @Suppress("DEPRECATION") - val list = geocoder.getFromLocation(loc.latitude, loc.longitude, 1) - val a = list?.firstOrNull() - val admin = a?.adminArea?.takeIf { !it.isNullOrEmpty() } - val country = a?.countryName?.takeIf { !it.isNullOrEmpty() } - if (admin != null) admins.add(admin) - else if (country != null) admins.add(country) - } catch (_: Exception) {} - if (admins.size >= 2) break - } - when (admins.size) { - 0 -> null - 1 -> admins.first() - else -> admins.elementAt(0) + " and " + admins.elementAt(1) - } - } else { - val center = Geohash.decodeToCenter(gh) - @Suppress("DEPRECATION") - val list = geocoder.getFromLocation(center.first, center.second, 1) - val a = list?.firstOrNull() - pickNameForLength(gh.length, a) - } - - if (!name.isNullOrEmpty()) { - val current = _bookmarkNames.value?.toMutableMap() ?: mutableMapOf() - current[gh] = name - _bookmarkNames.postValue(current) - persistNames(current) - } - } catch (e: Exception) { - Log.w(TAG, "Name resolution failed for #$gh: ${e.message}") - } finally { - resolving.remove(gh) - } - } - } - - private fun pickNameForLength(len: Int, address: android.location.Address?): String? { - if (address == null) return null - return when (len) { - in 0..2 -> address.adminArea ?: address.countryName - in 3..4 -> address.adminArea ?: address.subAdminArea ?: address.countryName - 5 -> address.locality ?: address.subAdminArea ?: address.adminArea - in 6..7 -> address.subLocality ?: address.locality ?: address.adminArea - else -> address.subLocality ?: address.locality ?: address.adminArea ?: address.countryName - } - } - - private fun persist(list: List) { - try { - val json = gson.toJson(list) - prefs.edit().putString(STORE_KEY, json).apply() - } catch (_: Exception) {} - } - - private fun persistNames(map: Map) { - try { - val json = gson.toJson(map) - prefs.edit().putString(NAMES_STORE_KEY, json).apply() - } catch (_: Exception) {} - } -} diff --git a/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt b/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt index 2b0b2bddf..7dcad2527 100644 --- a/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt +++ b/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt @@ -5,6 +5,7 @@ import android.content.SharedPreferences import androidx.security.crypto.EncryptedSharedPreferences import androidx.security.crypto.MasterKey import java.security.MessageDigest +import java.security.SecureRandom import android.util.Log /** @@ -12,6 +13,7 @@ import android.util.Log * * Handles: * - Static identity key persistence across app sessions + * - Peer ID rotation timing (5-15 minute random intervals) * - Secure storage using Android EncryptedSharedPreferences * - Fingerprint calculation and identity validation */ @@ -24,9 +26,16 @@ class SecureIdentityStateManager(private val context: Context) { private const val KEY_STATIC_PUBLIC_KEY = "static_public_key" private const val KEY_SIGNING_PRIVATE_KEY = "signing_private_key" private const val KEY_SIGNING_PUBLIC_KEY = "signing_public_key" + private const val KEY_LAST_ROTATION = "last_rotation" + private const val KEY_NEXT_ROTATION_INTERVAL = "next_rotation_interval" + + // Rotation intervals (same as iOS) + private const val MIN_ROTATION_INTERVAL = 5 * 60 * 1000L // 5 minutes + private const val MAX_ROTATION_INTERVAL = 15 * 60 * 1000L // 15 minutes } private val prefs: SharedPreferences + private val random = SecureRandom() init { // Create master key for encryption @@ -179,9 +188,70 @@ class SecureIdentityStateManager(private val context: Context) { return fingerprint.matches(Regex("^[a-fA-F0-9]{64}$")) } - // MARK: - Peer ID Rotation Management (removed) - // Android now derives peer ID from the persisted Noise identity fingerprint. - // No timed peer ID rotation is performed here. + // MARK: - Peer ID Rotation Management + + /** + * Check if peer ID should be rotated based on random interval + */ + fun shouldRotatePeerID(): Boolean { + val lastRotation = prefs.getLong(KEY_LAST_ROTATION, 0L) + val nextInterval = prefs.getLong(KEY_NEXT_ROTATION_INTERVAL, 0L) + val now = System.currentTimeMillis() + + if (lastRotation == 0L || nextInterval == 0L) { + // First run or missing data - schedule next rotation and don't rotate now + scheduleNextRotation() + return false + } + + val shouldRotate = (now - lastRotation) >= nextInterval + if (shouldRotate) { + Log.d(TAG, "Peer ID rotation due: ${(now - lastRotation) / 1000}s since last rotation") + } + + return shouldRotate + } + + /** + * Mark rotation as completed and schedule next one + */ + fun markRotationCompleted() { + val now = System.currentTimeMillis() + prefs.edit() + .putLong(KEY_LAST_ROTATION, now) + .apply() + + scheduleNextRotation() + + Log.d(TAG, "Peer ID rotation marked as completed") + } + + /** + * Schedule the next rotation with random interval (5-15 minutes) + */ + private fun scheduleNextRotation() { + val nextInterval = MIN_ROTATION_INTERVAL + random.nextLong(MAX_ROTATION_INTERVAL - MIN_ROTATION_INTERVAL) + + prefs.edit() + .putLong(KEY_NEXT_ROTATION_INTERVAL, nextInterval) + .apply() + + Log.d(TAG, "Next peer ID rotation scheduled in ${nextInterval / 60000} minutes") + } + + /** + * Get time until next rotation (for debugging) + */ + fun getTimeUntilNextRotation(): Long { + val lastRotation = prefs.getLong(KEY_LAST_ROTATION, 0L) + val nextInterval = prefs.getLong(KEY_NEXT_ROTATION_INTERVAL, 0L) + val now = System.currentTimeMillis() + + if (lastRotation == 0L || nextInterval == 0L) return -1 + + val elapsed = now - lastRotation + return maxOf(0L, nextInterval - elapsed) + } // MARK: - Identity Validation @@ -235,6 +305,14 @@ class SecureIdentityStateManager(private val context: Context) { appendLine("Has identity: $hasIdentity") if (hasIdentity) { + val lastRotation = prefs.getLong(KEY_LAST_ROTATION, 0L) + val nextInterval = prefs.getLong(KEY_NEXT_ROTATION_INTERVAL, 0L) + val timeUntilNext = getTimeUntilNextRotation() + + appendLine("Last rotation: ${if (lastRotation > 0) "${(System.currentTimeMillis() - lastRotation) / 1000}s ago" else "never"}") + appendLine("Next rotation in: ${if (timeUntilNext >= 0) "${timeUntilNext / 1000}s" else "not scheduled"}") + appendLine("Rotation interval: ${nextInterval / 1000}s") + try { val keyPair = loadStaticKey() if (keyPair != null) { 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 f446888e6..23539dcb4 100644 --- a/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt @@ -29,7 +29,7 @@ class BluetoothConnectionManager( private val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.adapter // Power management - private val powerManager = PowerManager(context.applicationContext) + private val powerManager = PowerManager(context) // Coroutines private val connectionScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) @@ -248,18 +248,11 @@ class BluetoothConnectionManager( ) } - fun cancelTransfer(transferId: String): Boolean { - return packetBroadcaster.cancelTransfer(transferId) - } - - /** - * Send a packet directly to a specific peer, without broadcasting to others. - */ - fun sendPacketToPeer(peerID: String, packet: BitchatPacket): Boolean { + fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean { if (!isActive) return false - return packetBroadcaster.sendPacketToPeer( - RoutedPacket(packet), + return packetBroadcaster.sendToPeer( peerID, + routed, serverManager.getGattServer(), serverManager.getCharacteristic() ) diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothGattServerManager.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothGattServerManager.kt index 5be14307c..c4117b8e2 100644 --- a/app/src/main/java/com/bitchat/android/mesh/BluetoothGattServerManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothGattServerManager.kt @@ -327,31 +327,8 @@ class BluetoothGattServerManager( private fun startAdvertising() { // Respect debug setting val enabled = try { com.bitchat.android.ui.debug.DebugSettingsManager.getInstance().gattServerEnabled.value } catch (_: Exception) { true } - - // Guard conditions – never throw here to avoid crashing the app from a background coroutine - if (!permissionManager.hasBluetoothPermissions()) { - Log.w(TAG, "Not starting advertising: missing Bluetooth permissions") - return - } - if (bluetoothAdapter == null) { - Log.w(TAG, "Not starting advertising: bluetoothAdapter is null") - return - } - if (!isActive) { - Log.d(TAG, "Not starting advertising: manager not active") - return - } - if (!enabled) { - Log.i(TAG, "Not starting advertising: GATT Server disabled via debug settings") - return - } - if (bleAdvertiser == null) { - Log.w(TAG, "Not starting advertising: BLE advertiser not available on this device") - return - } - if (!bluetoothAdapter.isMultipleAdvertisementSupported) { - Log.w(TAG, "Not starting advertising: multiple advertisement not supported on this device") - return + if (!permissionManager.hasBluetoothPermissions() || bleAdvertiser == null || !isActive || bluetoothAdapter == null || !bluetoothAdapter.isMultipleAdvertisementSupported() || !enabled) { + throw Exception("Missing Bluetooth permissions or BLE advertiser not available") } val settings = powerManager.getAdvertiseSettings() @@ -364,10 +341,7 @@ class BluetoothGattServerManager( advertiseCallback = object : AdvertiseCallback() { override fun onStartSuccess(settingsInEffect: AdvertiseSettings) { - val mode = try { - powerManager.getPowerInfo().split("Current Mode: ")[1].split("\n")[0] - } catch (_: Exception) { "unknown" } - Log.i(TAG, "Advertising started (power mode: $mode)") + Log.i(TAG, "Advertising started (power mode: ${powerManager.getPowerInfo().split("Current Mode: ")[1].split("\n")[0]})") } override fun onStartFailure(errorCode: Int) { @@ -377,8 +351,6 @@ class BluetoothGattServerManager( try { bleAdvertiser.startAdvertising(settings, data, advertiseCallback) - } catch (se: SecurityException) { - Log.e(TAG, "SecurityException starting advertising (missing permission?): ${se.message}") } catch (e: Exception) { Log.e(TAG, "Exception starting advertising: ${e.message}") } @@ -391,7 +363,7 @@ class BluetoothGattServerManager( private fun stopAdvertising() { if (!permissionManager.hasBluetoothPermissions() || bleAdvertiser == null) return try { - advertiseCallback?.let { cb -> bleAdvertiser.stopAdvertising(cb) } + advertiseCallback?.let { bleAdvertiser.stopAdvertising(it) } } catch (e: Exception) { Log.w(TAG, "Error stopping advertising: ${e.message}") } @@ -414,4 +386,4 @@ class BluetoothGattServerManager( startAdvertising() } } -} +} 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 98d7a6227..6e27d6ec5 100644 --- a/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt +++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt @@ -10,8 +10,6 @@ import com.bitchat.android.model.IdentityAnnouncement import com.bitchat.android.protocol.BitchatPacket import com.bitchat.android.protocol.MessageType import com.bitchat.android.protocol.SpecialRecipients -import com.bitchat.android.model.RequestSyncPacket -import com.bitchat.android.sync.GossipSyncManager import com.bitchat.android.util.toHexString import kotlinx.coroutines.* import java.util.* @@ -39,19 +37,18 @@ class BluetoothMeshService(private val context: Context) { private const val MAX_TTL: UByte = 7u } + // My peer identification - same format as iOS + val myPeerID: String = generateCompatiblePeerID() + // Core components - each handling specific responsibilities private val encryptionService = EncryptionService(context) - - // My peer identification - derived from persisted Noise identity fingerprint (first 16 hex chars) - val myPeerID: String = encryptionService.getIdentityFingerprint().take(16) private val peerManager = PeerManager() private val fragmentManager = FragmentManager() private val securityManager = SecurityManager(encryptionService, myPeerID) private val storeForwardManager = StoreForwardManager() - private val messageHandler = MessageHandler(myPeerID, context.applicationContext) + private val messageHandler = MessageHandler(myPeerID) internal val connectionManager = BluetoothConnectionManager(context, myPeerID, fragmentManager) // Made internal for access private val packetProcessor = PacketProcessor(myPeerID) - private lateinit var gossipSyncManager: GossipSyncManager // Service state management private var isActive = false @@ -66,38 +63,6 @@ class BluetoothMeshService(private val context: Context) { setupDelegates() messageHandler.packetProcessor = packetProcessor //startPeriodicDebugLogging() - - // Initialize sync manager (needs serviceScope) - gossipSyncManager = GossipSyncManager( - myPeerID = myPeerID, - scope = serviceScope, - configProvider = object : GossipSyncManager.ConfigProvider { - override fun seenCapacity(): Int = try { - com.bitchat.android.ui.debug.DebugPreferenceManager.getSeenPacketCapacity(500) - } catch (_: Exception) { 500 } - - override fun gcsMaxBytes(): Int = try { - com.bitchat.android.ui.debug.DebugPreferenceManager.getGcsMaxFilterBytes(400) - } catch (_: Exception) { 400 } - - override fun gcsTargetFpr(): Double = try { - com.bitchat.android.ui.debug.DebugPreferenceManager.getGcsFprPercent(1.0) / 100.0 - } catch (_: Exception) { 0.01 } - } - ) - - // Wire sync manager delegate - gossipSyncManager.delegate = object : GossipSyncManager.Delegate { - override fun sendPacket(packet: BitchatPacket) { - connectionManager.broadcastPacket(RoutedPacket(packet)) - } - override fun sendPacketToPeer(peerID: String, packet: BitchatPacket) { - connectionManager.sendPacketToPeer(peerID, packet) - } - override fun signPacketForBroadcast(packet: BitchatPacket): BitchatPacket { - return signPacketBeforeBroadcast(packet) - } - } } /** @@ -148,16 +113,6 @@ class BluetoothMeshService(private val context: Context) { override fun onPeerListUpdated(peerIDs: List) { delegate?.didUpdatePeerList(peerIDs) } - override fun onPeerRemoved(peerID: String) { - try { gossipSyncManager.removeAnnouncementForPeer(peerID) } catch (_: Exception) { } - // Also drop any Noise session state for this peer when they go offline - try { - encryptionService.removePeer(peerID) - Log.d(TAG, "Removed Noise session for offline peer $peerID") - } catch (e: Exception) { - Log.w(TAG, "Failed to remove Noise session for $peerID: ${e.message}") - } - } } // SecurityManager delegate for key exchange notifications @@ -425,26 +380,13 @@ class BluetoothMeshService(private val context: Context) { } catch (_: Exception) { } } } catch (_: Exception) { } - - // Schedule initial sync for this new directly connected peer only - try { gossipSyncManager.scheduleInitialSyncToPeer(pid, 1_000) } catch (_: Exception) { } } } - // Track for sync - try { gossipSyncManager.onPublicPacketSeen(routed.packet) } catch (_: Exception) { } } } override fun handleMessage(routed: RoutedPacket) { serviceScope.launch { messageHandler.handleMessage(routed) } - // Track broadcast messages for sync - try { - val pkt = routed.packet - val isBroadcast = (pkt.recipientID == null || pkt.recipientID.contentEquals(SpecialRecipients.BROADCAST)) - if (isBroadcast && pkt.type == MessageType.MESSAGE.value) { - gossipSyncManager.onPublicPacketSeen(pkt) - } - } catch (_: Exception) { } } override fun handleLeave(routed: RoutedPacket) { @@ -452,13 +394,6 @@ class BluetoothMeshService(private val context: Context) { } override fun handleFragment(packet: BitchatPacket): BitchatPacket? { - // Track broadcast fragments for gossip sync - try { - val isBroadcast = (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST)) - if (isBroadcast && packet.type == MessageType.FRAGMENT.value) { - gossipSyncManager.onPublicPacketSeen(packet) - } - } catch (_: Exception) { } return fragmentManager.handleFragment(packet) } @@ -474,11 +409,8 @@ class BluetoothMeshService(private val context: Context) { connectionManager.broadcastPacket(routed) } - override fun handleRequestSync(routed: RoutedPacket) { - // Decode request and respond with missing packets - val fromPeer = routed.peerID ?: return - val req = RequestSyncPacket.decode(routed.packet.payload) ?: return - gossipSyncManager.handleRequestSync(fromPeer, req) + override fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean { + return connectionManager.sendToPeer(peerID, routed) } } @@ -552,8 +484,6 @@ class BluetoothMeshService(private val context: Context) { // Start periodic announcements for peer discovery and connectivity sendPeriodicBroadcastAnnounce() Log.d(TAG, "Started periodic broadcast announcements (every 30 seconds)") - // Start periodic syncs - gossipSyncManager.start() } else { Log.e(TAG, "Failed to start Bluetooth services") } @@ -578,7 +508,6 @@ class BluetoothMeshService(private val context: Context) { delay(200) // Give leave message time to send // Stop all components - gossipSyncManager.stop() connectionManager.stopServices() peerManager.shutdown() fragmentManager.shutdown() @@ -612,123 +541,8 @@ class BluetoothMeshService(private val context: Context) { // Sign the packet before broadcasting val signedPacket = signPacketBeforeBroadcast(packet) connectionManager.broadcastPacket(RoutedPacket(signedPacket)) - // Track our own broadcast message for sync - try { gossipSyncManager.onPublicPacketSeen(signedPacket) } catch (_: Exception) { } } } - - /** - * Send a file over mesh as a broadcast MESSAGE (public mesh timeline/channels). - */ - fun sendFileBroadcast(file: com.bitchat.android.model.BitchatFilePacket) { - try { - Log.d(TAG, "📤 sendFileBroadcast: name=${file.fileName}, size=${file.fileSize}") - val payload = file.encode() - if (payload == null) { - Log.e(TAG, "❌ Failed to encode file packet in sendFileBroadcast") - return - } - Log.d(TAG, "📦 Encoded payload: ${payload.size} bytes") - serviceScope.launch { - val packet = BitchatPacket( - version = 2u, // FILE_TRANSFER uses v2 for 4-byte payload length to support large files - type = MessageType.FILE_TRANSFER.value, - senderID = hexStringToByteArray(myPeerID), - recipientID = SpecialRecipients.BROADCAST, - timestamp = System.currentTimeMillis().toULong(), - payload = payload, - signature = null, - ttl = MAX_TTL - ) - val signed = signPacketBeforeBroadcast(packet) - // Use a stable transferId based on the file TLV payload for progress tracking - val transferId = sha256Hex(payload) - connectionManager.broadcastPacket(RoutedPacket(signed, transferId = transferId)) - try { gossipSyncManager.onPublicPacketSeen(signed) } catch (_: Exception) { } - } - } catch (e: Exception) { - Log.e(TAG, "❌ sendFileBroadcast failed: ${e.message}", e) - Log.e(TAG, "❌ File: name=${file.fileName}, size=${file.fileSize}") - } - } - - /** - * Send a file as an encrypted private message using Noise protocol - */ - fun sendFilePrivate(recipientPeerID: String, file: com.bitchat.android.model.BitchatFilePacket) { - try { - Log.d(TAG, "📤 sendFilePrivate (ENCRYPTED): to=$recipientPeerID, name=${file.fileName}, size=${file.fileSize}") - - serviceScope.launch { - // Check if we have an established Noise session - if (encryptionService.hasEstablishedSession(recipientPeerID)) { - try { - // Encode the file packet as TLV - val filePayload = file.encode() - if (filePayload == null) { - Log.e(TAG, "❌ Failed to encode file packet for private send") - return@launch - } - Log.d(TAG, "📦 Encoded file TLV: ${filePayload.size} bytes") - - // Create NoisePayload wrapper (type byte + file TLV data) - same as iOS - val noisePayload = com.bitchat.android.model.NoisePayload( - type = com.bitchat.android.model.NoisePayloadType.FILE_TRANSFER, - data = filePayload - ) - - // Encrypt the payload using Noise - val encrypted = encryptionService.encrypt(noisePayload.encode(), recipientPeerID) - if (encrypted == null) { - Log.e(TAG, "❌ Failed to encrypt file for $recipientPeerID") - return@launch - } - Log.d(TAG, "🔐 Encrypted file payload: ${encrypted.size} bytes") - - // Create NOISE_ENCRYPTED packet (not FILE_TRANSFER!) - val packet = BitchatPacket( - version = 1u, - type = MessageType.NOISE_ENCRYPTED.value, - senderID = hexStringToByteArray(myPeerID), - recipientID = hexStringToByteArray(recipientPeerID), - timestamp = System.currentTimeMillis().toULong(), - payload = encrypted, - signature = null, - ttl = 7u - ) - - // Sign and send the encrypted packet - val signed = signPacketBeforeBroadcast(packet) - // Use a stable transferId based on the unencrypted file TLV payload for progress tracking - val transferId = sha256Hex(filePayload) - connectionManager.broadcastPacket(RoutedPacket(signed, transferId = transferId)) - Log.d(TAG, "✅ Sent encrypted file to $recipientPeerID") - - } catch (e: Exception) { - Log.e(TAG, "❌ Failed to encrypt file for $recipientPeerID: ${e.message}", e) - } - } else { - // No session - initiate handshake but don't queue file - Log.w(TAG, "⚠️ No Noise session with $recipientPeerID for file transfer, initiating handshake") - messageHandler.delegate?.initiateNoiseHandshake(recipientPeerID) - } - } - } catch (e: Exception) { - Log.e(TAG, "❌ sendFilePrivate failed: ${e.message}", e) - Log.e(TAG, "❌ File: to=$recipientPeerID, name=${file.fileName}, size=${file.fileSize}") - } - } - - fun cancelFileTransfer(transferId: String): Boolean { - return connectionManager.cancelTransfer(transferId) - } - - // Local helper to hash payloads to a stable hex ID for progress mapping - private fun sha256Hex(bytes: ByteArray): String = try { - val md = java.security.MessageDigest.getInstance("SHA-256") - md.update(bytes) - md.digest().joinToString("") { "%02x".format(it) } - } catch (_: Exception) { bytes.size.toString(16) } /** * Send private message - SIMPLIFIED iOS-compatible version @@ -878,11 +692,25 @@ class BluetoothMeshService(private val context: Context) { // Create iOS-compatible IdentityAnnouncement with TLV encoding val announcement = IdentityAnnouncement(nickname, staticKey, signingKey) - val tlvPayload = announcement.encode() + var tlvPayload = announcement.encode() if (tlvPayload == null) { Log.e(TAG, "Failed to encode announcement as TLV") return@launch } + + // Append gossip TLV containing up to 10 direct neighbors (compact IDs) + try { + val directPeers = getDirectPeerIDsForGossip() + if (directPeers.isNotEmpty()) { + val gossip = com.bitchat.android.services.meshgraph.GossipTLV.encodeNeighbors(directPeers) + tlvPayload = tlvPayload + gossip + } + // Always update our own node in the mesh graph with the neighbor list we used + try { + com.bitchat.android.services.meshgraph.MeshGraphService.getInstance() + .updateFromAnnouncement(myPeerID, nickname, directPeers, System.currentTimeMillis().toULong()) + } catch (_: Exception) { } + } catch (_: Exception) { } val announcePacket = BitchatPacket( type = MessageType.ANNOUNCE.value, @@ -898,8 +726,6 @@ class BluetoothMeshService(private val context: Context) { connectionManager.broadcastPacket(RoutedPacket(signedPacket)) Log.d(TAG, "Sent iOS-compatible signed TLV announce (${tlvPayload.size} bytes)") - // Track announce for sync - try { gossipSyncManager.onPublicPacketSeen(signedPacket) } catch (_: Exception) { } } } @@ -927,11 +753,25 @@ class BluetoothMeshService(private val context: Context) { // Create iOS-compatible IdentityAnnouncement with TLV encoding val announcement = IdentityAnnouncement(nickname, staticKey, signingKey) - val tlvPayload = announcement.encode() + var tlvPayload = announcement.encode() if (tlvPayload == null) { Log.e(TAG, "Failed to encode peer announcement as TLV") return } + + // Append gossip TLV containing up to 10 direct neighbors (compact IDs) + try { + val directPeers = getDirectPeerIDsForGossip() + if (directPeers.isNotEmpty()) { + val gossip = com.bitchat.android.services.meshgraph.GossipTLV.encodeNeighbors(directPeers) + tlvPayload = tlvPayload + gossip + } + // Always update our own node in the mesh graph with the neighbor list we used + try { + com.bitchat.android.services.meshgraph.MeshGraphService.getInstance() + .updateFromAnnouncement(myPeerID, nickname, directPeers, System.currentTimeMillis().toULong()) + } catch (_: Exception) { } + } catch (_: Exception) { } val packet = BitchatPacket( type = MessageType.ANNOUNCE.value, @@ -948,9 +788,20 @@ class BluetoothMeshService(private val context: Context) { connectionManager.broadcastPacket(RoutedPacket(signedPacket)) peerManager.markPeerAsAnnouncedTo(peerID) Log.d(TAG, "Sent iOS-compatible signed TLV peer announce to $peerID (${tlvPayload.size} bytes)") + } - // Track announce for sync - try { gossipSyncManager.onPublicPacketSeen(signedPacket) } catch (_: Exception) { } + /** + * Collect up to 10 direct neighbors for gossip TLV. + */ + private fun getDirectPeerIDsForGossip(): List { + return try { + // Prefer verified peers that are currently marked as direct + val verified = peerManager.getVerifiedPeers() + val direct = verified.filter { it.value.isDirectConnection }.keys.toList() + direct.take(10) + } catch (_: Exception) { + emptyList() + } } /** @@ -1099,6 +950,15 @@ class BluetoothMeshService(private val context: Context) { } } + /** + * Generate peer ID compatible with iOS - exactly 8 bytes (16 hex characters) + */ + private fun generateCompatiblePeerID(): String { + val randomBytes = ByteArray(8) // 8 bytes = 16 hex characters (like iOS) + Random.nextBytes(randomBytes) + return randomBytes.joinToString("") { "%02x".format(it) } + } + /** * Convert hex string peer ID to binary data (8 bytes) - exactly same as iOS */ @@ -1125,21 +985,37 @@ class BluetoothMeshService(private val context: Context) { */ private fun signPacketBeforeBroadcast(packet: BitchatPacket): BitchatPacket { return try { + // Optionally compute and attach a source route for addressed packets + val withRoute = try { + val rec = packet.recipientID + if (rec != null && !rec.contentEquals(SpecialRecipients.BROADCAST)) { + val dest = rec.joinToString("") { b -> "%02x".format(b) } + val path = com.bitchat.android.services.meshgraph.RoutePlanner.shortestPath(myPeerID, dest) + if (path != null && path.size >= 3) { + // Exclude first (sender) and last (recipient); only intermediates + val intermediates = path.subList(1, path.size - 1) + val hopsBytes = intermediates.map { hexStringToByteArray(it) } + Log.d(TAG, "✅ Signed packet type ${packet.type} (route ${hopsBytes.size} hops: $intermediates)") + packet.copy(route = hopsBytes) + } else packet.copy(route = null) + } else packet + } catch (_: Exception) { packet } + // Get the canonical packet data for signing (without signature) - val packetDataForSigning = packet.toBinaryDataForSigning() + val packetDataForSigning = withRoute.toBinaryDataForSigning() if (packetDataForSigning == null) { Log.w(TAG, "Failed to encode packet type ${packet.type} for signing, sending unsigned") - return packet + return withRoute } // Sign the packet data using our signing key val signature = encryptionService.signData(packetDataForSigning) if (signature != null) { Log.d(TAG, "✅ Signed packet type ${packet.type} (signature ${signature.size} bytes)") - packet.copy(signature = signature) + withRoute.copy(signature = signature) } else { Log.w(TAG, "Failed to sign packet type ${packet.type}, sending unsigned") - packet + withRoute } } catch (e: Exception) { Log.w(TAG, "Error signing packet type ${packet.type}: ${e.message}, sending unsigned") 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 5110279d9..b5c5484f0 100644 --- a/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt +++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt @@ -1,4 +1,3 @@ - package com.bitchat.android.mesh import android.bluetooth.BluetoothDevice @@ -18,8 +17,6 @@ import kotlinx.coroutines.delay import kotlinx.coroutines.isActive import kotlinx.coroutines.launch import kotlinx.coroutines.channels.Channel -import kotlinx.coroutines.Job -import java.util.concurrent.ConcurrentHashMap import kotlinx.coroutines.channels.actor /** @@ -73,7 +70,6 @@ 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( packetType = typeName, @@ -85,8 +81,7 @@ class BluetoothPacketBroadcaster( toPeerID = toPeer, toNickname = toNick, toDeviceAddress = toDeviceAddress, - ttl = ttl, - isRelay = isRelay + ttl = ttl ) } catch (_: Exception) { // Silently ignore debug logging failures @@ -102,7 +97,6 @@ class BluetoothPacketBroadcaster( // Actor scope for the broadcaster private val broadcasterScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) - private val transferJobs = ConcurrentHashMap() // SERIALIZATION: Actor to serialize all broadcast operations @OptIn(kotlinx.coroutines.ObsoleteCoroutinesApi::class) @@ -125,156 +119,86 @@ class BluetoothPacketBroadcaster( characteristic: BluetoothGattCharacteristic? ) { val packet = routed.packet - val isFile = packet.type == MessageType.FILE_TRANSFER.value - if (isFile) { - Log.d(TAG, "📤 Broadcasting FILE_TRANSFER: ${packet.payload.size} bytes") - } - // Prefer caller-provided transferId (e.g., for encrypted media), else derive for FILE_TRANSFER - val transferId = routed.transferId ?: (if (isFile) sha256Hex(packet.payload) else null) // Check if we need to fragment if (fragmentManager != null) { - val fragments = try { - fragmentManager.createFragments(packet) - } catch (e: Exception) { - Log.e(TAG, "❌ Fragment creation failed: ${e.message}", e) - if (isFile) { - Log.e(TAG, "❌ File fragmentation failed for ${packet.payload.size} byte file") - } - return - } + val fragments = fragmentManager.createFragments(packet) if (fragments.size > 1) { - if (isFile) { - Log.d(TAG, "🔀 File needs ${fragments.size} fragments") - } Log.d(TAG, "Fragmenting packet into ${fragments.size} fragments") - if (transferId != null) { - TransferProgressManager.start(transferId, fragments.size) - } - val job = connectionScope.launch { - var sent = 0 + connectionScope.launch { fragments.forEach { fragment -> - if (!isActive) return@launch - // If cancelled, stop sending remaining fragments - if (transferId != null && transferJobs[transferId]?.isCancelled == true) return@launch - broadcastSinglePacket(RoutedPacket(fragment, transferId = transferId), gattServer, characteristic) - // 20ms delay between fragments - delay(20) - if (transferId != null) { - sent += 1 - TransferProgressManager.progress(transferId, sent, fragments.size) - if (sent == fragments.size) TransferProgressManager.complete(transferId, fragments.size) - } + broadcastSinglePacket(RoutedPacket(fragment), gattServer, characteristic) + // 20ms delay between fragments (matching iOS/Rust) + delay(200) } } - if (transferId != null) { - transferJobs[transferId] = job - job.invokeOnCompletion { transferJobs.remove(transferId) } - } return } } // Send single packet if no fragmentation needed - if (transferId != null) { - TransferProgressManager.start(transferId, 1) - } broadcastSinglePacket(routed, gattServer, characteristic) - if (transferId != null) { - TransferProgressManager.progress(transferId, 1, 1) - TransferProgressManager.complete(transferId, 1) - } } - fun cancelTransfer(transferId: String): Boolean { - val job = transferJobs.remove(transferId) ?: return false - job.cancel() - return true + + /** + * Public entry point for broadcasting - submits request to actor for serialization + */ + fun broadcastSinglePacket( + routed: RoutedPacket, + gattServer: BluetoothGattServer?, + characteristic: BluetoothGattCharacteristic? + ) { + // Submit broadcast request to actor for serialized processing + broadcasterScope.launch { + try { + broadcasterActor.send(BroadcastRequest(routed, gattServer, characteristic)) + } catch (e: Exception) { + Log.w(TAG, "Failed to send broadcast request to actor: ${e.message}") + // Fallback to direct processing if actor fails + broadcastSinglePacketInternal(routed, gattServer, characteristic) + } + } } /** - * Send a packet to a specific peer only, without broadcasting. - * Returns true if a direct path was found and used. + * Targeted send to a specific peer (by peerID) if directly connected. + * Returns true if sent to at least one matching connection. */ - fun sendPacketToPeer( - routed: RoutedPacket, + fun sendToPeer( targetPeerID: String, + routed: RoutedPacket, gattServer: BluetoothGattServer?, characteristic: BluetoothGattCharacteristic? ): Boolean { val packet = routed.packet val data = packet.toBinaryData() ?: return false - val isFile = packet.type == MessageType.FILE_TRANSFER.value - if (isFile) { - Log.d(TAG, "📤 Broadcasting FILE_TRANSFER: ${packet.payload.size} bytes") - } - // Prefer caller-provided transferId (e.g., for encrypted media), else derive for FILE_TRANSFER - val transferId = routed.transferId ?: (if (isFile) sha256Hex(packet.payload) else null) - if (transferId != null) { - TransferProgressManager.start(transferId, 1) - } val typeName = MessageType.fromValue(packet.type)?.name ?: packet.type.toString() + val senderPeerID = routed.peerID ?: packet.senderID.toHexString() val incomingAddr = routed.relayAddress val incomingPeer = incomingAddr?.let { connectionTracker.addressPeerMap[it] } - val senderPeerID = routed.peerID ?: packet.senderID.toHexString() val senderNick = senderPeerID.let { pid -> nicknameResolver?.invoke(pid) } - // Prefer server-side subscriptions - val serverTarget = connectionTracker.getSubscribedDevices() + // Try server-side connections first + val targetDevice = connectionTracker.getSubscribedDevices() .firstOrNull { connectionTracker.addressPeerMap[it.address] == targetPeerID } - if (serverTarget != null) { - if (notifyDevice(serverTarget, data, gattServer, characteristic)) { - logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, serverTarget.address, packet.ttl) - if (transferId != null) { - TransferProgressManager.progress(transferId, 1, 1) - TransferProgressManager.complete(transferId, 1) - } + if (targetDevice != null) { + if (notifyDevice(targetDevice, data, gattServer, characteristic)) { + logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, targetDevice.address, packet.ttl) return true } } - // Then client connections - val clientTarget = connectionTracker.getConnectedDevices().values + // Try client-side connections next + val targetConn = connectionTracker.getConnectedDevices().values .firstOrNull { connectionTracker.addressPeerMap[it.device.address] == targetPeerID } - if (clientTarget != null) { - if (writeToDeviceConn(clientTarget, data)) { - logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, clientTarget.device.address, packet.ttl) - if (transferId != null) { - TransferProgressManager.progress(transferId, 1, 1) - TransferProgressManager.complete(transferId, 1) - } + if (targetConn != null) { + if (writeToDeviceConn(targetConn, data)) { + logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, targetConn.device.address, packet.ttl) return true } } - return false } - - private fun sha256Hex(bytes: ByteArray): String = try { - val md = java.security.MessageDigest.getInstance("SHA-256") - md.update(bytes) - md.digest().joinToString("") { "%02x".format(it) } - } catch (_: Exception) { bytes.size.toString(16) } - - - /** - * Public entry point for broadcasting - submits request to actor for serialization - */ - fun broadcastSinglePacket( - routed: RoutedPacket, - gattServer: BluetoothGattServer?, - characteristic: BluetoothGattCharacteristic? - ) { - // Submit broadcast request to actor for serialized processing - broadcasterScope.launch { - try { - broadcasterActor.send(BroadcastRequest(routed, gattServer, characteristic)) - } catch (e: Exception) { - Log.w(TAG, "Failed to send broadcast request to actor: ${e.message}") - // Fallback to direct processing if actor fails - broadcastSinglePacketInternal(routed, gattServer, characteristic) - } - } - } /** * Internal broadcast implementation - runs in serialized actor context diff --git a/app/src/main/java/com/bitchat/android/mesh/FragmentManager.kt b/app/src/main/java/com/bitchat/android/mesh/FragmentManager.kt index 4ab5f45ff..6529b2c35 100644 --- a/app/src/main/java/com/bitchat/android/mesh/FragmentManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/FragmentManager.kt @@ -48,23 +48,10 @@ class FragmentManager { * Matches iOS sendFragmentedPacket() implementation exactly */ fun createFragments(packet: BitchatPacket): List { - try { - Log.d(TAG, "🔀 Creating fragments for packet type ${packet.type}, payload: ${packet.payload.size} bytes") - val encoded = packet.toBinaryData() - if (encoded == null) { - Log.e(TAG, "❌ Failed to encode packet to binary data") - return emptyList() - } - Log.d(TAG, "📦 Encoded to ${encoded.size} bytes") + val encoded = packet.toBinaryData() ?: return emptyList() // Fragment the unpadded frame; each fragment will be encoded (and padded) independently - iOS fix - val fullData = try { - MessagePadding.unpad(encoded) - } catch (e: Exception) { - Log.e(TAG, "❌ Failed to unpad data: ${e.message}", e) - return emptyList() - } - Log.d(TAG, "📏 Unpadded to ${fullData.size} bytes") + val fullData = MessagePadding.unpad(encoded) // iOS logic: if data.count > 512 && packet.type != MessageType.fragment.rawValue if (fullData.size <= FRAGMENT_SIZE_THRESHOLD) { @@ -111,13 +98,7 @@ class FragmentManager { fragments.add(fragmentPacket) } - Log.d(TAG, "✅ Created ${fragments.size} fragments successfully") - return fragments - } catch (e: Exception) { - Log.e(TAG, "❌ Fragment creation failed: ${e.message}", e) - Log.e(TAG, "❌ Packet type: ${packet.type}, payload: ${packet.payload.size} bytes") - return emptyList() - } + return fragments } /** diff --git a/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt b/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt index 2a0624f95..4a9c13dc9 100644 --- a/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt +++ b/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt @@ -2,7 +2,6 @@ package com.bitchat.android.mesh import android.util.Log import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType import com.bitchat.android.model.IdentityAnnouncement import com.bitchat.android.model.RoutedPacket import com.bitchat.android.protocol.BitchatPacket @@ -16,7 +15,7 @@ import kotlin.random.Random * Handles processing of different message types * Extracted from BluetoothMeshService for better separation of concerns */ -class MessageHandler(private val myPeerID: String, private val appContext: android.content.Context) { +class MessageHandler(private val myPeerID: String) { companion object { private const val TAG = "MessageHandler" @@ -111,35 +110,6 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro } } - com.bitchat.android.model.NoisePayloadType.FILE_TRANSFER -> { - // Handle encrypted file transfer; generate unique message ID - val file = com.bitchat.android.model.BitchatFilePacket.decode(noisePayload.data) - if (file != null) { - Log.d(TAG, "🔓 Decrypted encrypted file from $peerID: name='${file.fileName}', size=${file.fileSize}, mime='${file.mimeType}'") - val uniqueMsgId = java.util.UUID.randomUUID().toString().uppercase() - val savedPath = com.bitchat.android.features.file.FileUtils.saveIncomingFile(appContext, file) - val message = BitchatMessage( - id = uniqueMsgId, - sender = delegate?.getPeerNickname(peerID) ?: "Unknown", - content = savedPath, - type = com.bitchat.android.features.file.FileUtils.messageTypeForMime(file.mimeType), - timestamp = java.util.Date(packet.timestamp.toLong()), - isRelay = false, - isPrivate = true, - recipientNickname = delegate?.getMyNickname(), - senderPeerID = peerID - ) - - Log.d(TAG, "📄 Saved encrypted incoming file to $savedPath (msgId=$uniqueMsgId)") - delegate?.onMessageReceived(message) - - // Send delivery ACK with generated message ID - sendDeliveryAck(uniqueMsgId, peerID) - } else { - Log.w(TAG, "⚠️ Failed to decode encrypted file transfer from $peerID") - } - } - com.bitchat.android.model.NoisePayloadType.DELIVERED -> { // Handle delivery ACK exactly like iOS val messageID = String(noisePayload.data, Charsets.UTF_8) @@ -270,6 +240,13 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro previousPeerID = null ) + // Update mesh graph from gossip neighbors (only if TLV present) + try { + val neighborsOrNull = com.bitchat.android.services.meshgraph.GossipTLV.decodeNeighborsFromAnnouncementPayload(packet.payload) + com.bitchat.android.services.meshgraph.MeshGraphService.getInstance() + .updateFromAnnouncement(peerID, nickname, neighborsOrNull, packet.timestamp) + } catch (_: Exception) { } + Log.d(TAG, "✅ Processed verified TLV announce: stored identity for $peerID") return isFirstAnnounce } @@ -368,37 +345,16 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro } try { - // Try file packet first (voice, image, etc.) and log outcome for FILE_TRANSFER - val isFileTransfer = com.bitchat.android.protocol.MessageType.fromValue(packet.type) == com.bitchat.android.protocol.MessageType.FILE_TRANSFER - val file = com.bitchat.android.model.BitchatFilePacket.decode(packet.payload) - if (file != null) { - if (isFileTransfer) { - Log.d(TAG, "📥 FILE_TRANSFER decode success (broadcast): name='${file.fileName}', size=${file.fileSize}, mime='${file.mimeType}', from=${peerID.take(8)}") - } - val savedPath = com.bitchat.android.features.file.FileUtils.saveIncomingFile(appContext, file) - val message = BitchatMessage( - id = java.util.UUID.randomUUID().toString().uppercase(), - sender = delegate?.getPeerNickname(peerID) ?: "unknown", - content = savedPath, - type = com.bitchat.android.features.file.FileUtils.messageTypeForMime(file.mimeType), - senderPeerID = peerID, - timestamp = Date(packet.timestamp.toLong()) - ) - Log.d(TAG, "📄 Saved incoming file to $savedPath") - delegate?.onMessageReceived(message) - return - } else if (isFileTransfer) { - Log.w(TAG, "⚠️ FILE_TRANSFER decode failed (broadcast) from ${peerID.take(8)} payloadSize=${packet.payload.size}") - } - - // Fallback: plain text + // Parse message val message = BitchatMessage( sender = delegate?.getPeerNickname(peerID) ?: "unknown", content = String(packet.payload, Charsets.UTF_8), senderPeerID = peerID, timestamp = Date(packet.timestamp.toLong()) ) + delegate?.onMessageReceived(message) + } catch (e: Exception) { Log.e(TAG, "Failed to process broadcast message: ${e.message}") } @@ -415,32 +371,7 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro return } - // Try file packet first (voice, image, etc.) and log outcome for FILE_TRANSFER - val isFileTransfer = com.bitchat.android.protocol.MessageType.fromValue(packet.type) == com.bitchat.android.protocol.MessageType.FILE_TRANSFER - val file = com.bitchat.android.model.BitchatFilePacket.decode(packet.payload) - if (file != null) { - if (isFileTransfer) { - Log.d(TAG, "📥 FILE_TRANSFER decode success (private): name='${file.fileName}', size=${file.fileSize}, mime='${file.mimeType}', from=${peerID.take(8)}") - } - val savedPath = com.bitchat.android.features.file.FileUtils.saveIncomingFile(appContext, file) - val message = BitchatMessage( - id = java.util.UUID.randomUUID().toString().uppercase(), - sender = delegate?.getPeerNickname(peerID) ?: "unknown", - content = savedPath, - type = com.bitchat.android.features.file.FileUtils.messageTypeForMime(file.mimeType), - senderPeerID = peerID, - timestamp = Date(packet.timestamp.toLong()), - isPrivate = true, - recipientNickname = delegate?.getMyNickname() - ) - Log.d(TAG, "📄 Saved incoming file to $savedPath") - delegate?.onMessageReceived(message) - return - } else if (isFileTransfer) { - Log.w(TAG, "⚠️ FILE_TRANSFER decode failed (private) from ${peerID.take(8)} payloadSize=${packet.payload.size}") - } - - // Fallback: plain text + // Parse message val message = BitchatMessage( sender = delegate?.getPeerNickname(peerID) ?: "unknown", content = String(packet.payload, Charsets.UTF_8), @@ -453,8 +384,6 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro Log.e(TAG, "Failed to process private message from $peerID: ${e.message}") } } - - /** * Handle leave message diff --git a/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt b/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt index 2b5fac102..315308e2b 100644 --- a/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt +++ b/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt @@ -112,6 +112,9 @@ class PacketProcessor(private val myPeerID: String) { override fun broadcastPacket(routed: RoutedPacket) { delegate?.relayPacket(routed) } + override fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean { + return delegate?.sendToPeer(peerID, routed) ?: false + } } } @@ -144,17 +147,14 @@ class PacketProcessor(private val myPeerID: String) { when (messageType) { MessageType.ANNOUNCE -> handleAnnounce(routed) MessageType.MESSAGE -> handleMessage(routed) - MessageType.FILE_TRANSFER -> handleMessage(routed) // treat same routing path; parsing happens in handler MessageType.LEAVE -> handleLeave(routed) MessageType.FRAGMENT -> handleFragment(routed) - MessageType.REQUEST_SYNC -> handleRequestSync(routed) else -> { // Handle private packet types (address check required) if (packetRelayManager.isPacketAddressedToMe(packet)) { when (messageType) { MessageType.NOISE_HANDSHAKE -> handleNoiseHandshake(routed) MessageType.NOISE_ENCRYPTED -> handleNoiseEncrypted(routed) - MessageType.FILE_TRANSFER -> handleMessage(routed) else -> { validPacket = false Log.w(TAG, "Unknown message type: ${packet.type}") @@ -235,15 +235,6 @@ class PacketProcessor(private val myPeerID: String) { // Fragment relay is now handled by centralized PacketRelayManager } - - /** - * Handle REQUEST_SYNC packets (public, TTL=1) - */ - private suspend fun handleRequestSync(routed: RoutedPacket) { - val peerID = routed.peerID ?: "unknown" - Log.d(TAG, "Processing REQUEST_SYNC from ${formatPeerForLog(peerID)}") - delegate?.handleRequestSync(routed) - } /** * Handle delivery acknowledgment @@ -317,10 +308,10 @@ interface PacketProcessorDelegate { fun handleMessage(routed: RoutedPacket) fun handleLeave(routed: RoutedPacket) fun handleFragment(packet: BitchatPacket): BitchatPacket? - fun handleRequestSync(routed: RoutedPacket) // Communication fun sendAnnouncementToPeer(peerID: String) fun sendCachedMessages(peerID: String) fun relayPacket(routed: RoutedPacket) + fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean } diff --git a/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt b/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt index bc401daac..5a1abee0e 100644 --- a/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt @@ -41,7 +41,7 @@ class PacketRelayManager(private val myPeerID: String) { val packet = routed.packet val peerID = routed.peerID ?: "unknown" - Log.d(TAG, "Evaluating relay for packet type ${packet.type} from ${peerID} (TTL: ${packet.ttl})") + Log.d(TAG, "Evaluating relay for packet type ${'$'}{packet.type} from ${'$'}peerID (TTL: ${'$'}{packet.ttl})") // Double-check this packet isn't addressed to us if (isPacketAddressedToMe(packet)) { @@ -63,15 +63,46 @@ class PacketRelayManager(private val myPeerID: String) { // Decrement TTL by 1 val relayPacket = packet.copy(ttl = (packet.ttl - 1u).toUByte()) - Log.d(TAG, "Decremented TTL from ${packet.ttl} to ${relayPacket.ttl}") + Log.d(TAG, "Decremented TTL from ${'$'}{packet.ttl} to ${'$'}{relayPacket.ttl}") + // Source-based routing: if route is set and includes us, try targeted next-hop forwarding + val route = relayPacket.route + if (!route.isNullOrEmpty()) { + // Check for duplicate hops to prevent routing loops + if (route.map { it.toHexString() }.toSet().size < route.size) { + Log.w(TAG, "Packet with duplicate hops dropped") + return + } + val myIdBytes = hexStringToPeerBytes(myPeerID) + val index = route.indexOfFirst { it.contentEquals(myIdBytes) } + if (index >= 0) { + val nextHopIdHex: String? = run { + val nextIndex = index + 1 + if (nextIndex < route.size) { + route[nextIndex].toHexString() + } else { + // We are the last intermediate; try final recipient as next hop + relayPacket.recipientID?.toHexString() + } + } + if (nextHopIdHex != null) { + val success = try { delegate?.sendToPeer(nextHopIdHex, RoutedPacket(relayPacket, peerID, routed.relayAddress)) } catch (_: Exception) { false } ?: false + if (success) { + Log.i(TAG, "📦 Source-route relay: ${myPeerID.take(8)} -> ${nextHopIdHex.take(8)} (type ${'$'}{packet.type}, TTL ${'$'}{relayPacket.ttl})") + return + } else { + Log.w(TAG, "Source-route next hop ${nextHopIdHex.take(8)} not directly connected; falling back to broadcast") + } + } + } + } + // Apply relay logic based on packet type and debug switch val shouldRelay = isRelayEnabled() && shouldRelayPacket(relayPacket, peerID) - if (shouldRelay) { relayPacket(RoutedPacket(relayPacket, peerID, routed.relayAddress)) } else { - Log.d(TAG, "Relay decision: NOT relaying packet type ${packet.type}") + Log.d(TAG, "Relay decision: NOT relaying packet type ${'$'}{packet.type}") } } @@ -103,7 +134,7 @@ class PacketRelayManager(private val myPeerID: String) { private fun shouldRelayPacket(packet: BitchatPacket, fromPeerID: String): Boolean { // Always relay if TTL is high enough (indicates important message) if (packet.ttl >= 4u) { - Log.d(TAG, "High TTL (${packet.ttl}), relaying") + Log.d(TAG, "High TTL (${ '$' }{packet.ttl}), relaying") return true } @@ -112,7 +143,7 @@ class PacketRelayManager(private val myPeerID: String) { // Small networks always relay to ensure connectivity if (networkSize <= 3) { - Log.d(TAG, "Small network (${networkSize} peers), relaying") + Log.d(TAG, "Small network (${ '$' }networkSize peers), relaying") return true } @@ -126,16 +157,52 @@ class PacketRelayManager(private val myPeerID: String) { } val shouldRelay = Random.nextDouble() < relayProb - Log.d(TAG, "Network size: ${networkSize}, Relay probability: ${relayProb}, Decision: ${shouldRelay}") + Log.d(TAG, "Network size: ${'$'}networkSize, Relay probability: ${'$'}relayProb, Decision: ${'$'}shouldRelay") return shouldRelay } + /** + * Relay message with adaptive probability and timing (same as iOS) + * Moved from MessageHandler.kt + */ + suspend fun relayMessage(routed: RoutedPacket) { + val packet = routed.packet + + if (packet.ttl == 0u.toUByte()) { + Log.d(TAG, "TTL expired, not relaying message") + return + } + + val relayPacket = packet.copy(ttl = (packet.ttl - 1u).toUByte()) + + // Check network size and apply adaptive relay probability + val networkSize = delegate?.getNetworkSize() ?: 1 + val relayProb = when { + networkSize <= 10 -> 1.0 + networkSize <= 30 -> 0.85 + networkSize <= 50 -> 0.7 + networkSize <= 100 -> 0.55 + else -> 0.4 + } + + val shouldRelay = relayPacket.ttl >= 4u || networkSize <= 3 || Random.nextDouble() < relayProb + + if (shouldRelay) { + val delay = Random.nextLong(50, 500) // Random delay like iOS + Log.d(TAG, "Relaying message after ${'$'}delay ms delay") + delay(delay) + relayPacket(routed.copy(packet = relayPacket)) + } else { + Log.d(TAG, "Relay decision: NOT relaying message (network size: ${'$'}networkSize, prob: ${'$'}relayProb)") + } + } + /** * Actually broadcast the packet for relay */ private fun relayPacket(routed: RoutedPacket) { - Log.d(TAG, "🔄 Relaying packet type ${routed.packet.type} with TTL ${routed.packet.ttl}") + Log.d(TAG, "🔄 Relaying packet type ${'$'}{routed.packet.type} with TTL ${'$'}{routed.packet.ttl}") delegate?.broadcastPacket(routed) } @@ -145,9 +212,9 @@ class PacketRelayManager(private val myPeerID: String) { fun getDebugInfo(): String { return buildString { appendLine("=== Packet Relay Manager Debug Info ===") - appendLine("Relay Scope Active: ${relayScope.isActive}") - appendLine("My Peer ID: ${myPeerID}") - appendLine("Network Size: ${delegate?.getNetworkSize() ?: "unknown"}") + appendLine("Relay Scope Active: ${'$'}{relayScope.isActive}") + appendLine("My Peer ID: ${'$'}myPeerID") + appendLine("Network Size: ${'$'}{delegate?.getNetworkSize() ?: \"unknown\"}") } } @@ -170,4 +237,17 @@ interface PacketRelayManagerDelegate { // Packet operations fun broadcastPacket(routed: RoutedPacket) + fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean +} + +private fun hexStringToPeerBytes(hex: String): ByteArray { + val result = ByteArray(8) + var idx = 0 + var out = 0 + while (idx + 1 < hex.length && out < 8) { + val b = hex.substring(idx, idx + 2).toIntOrNull(16)?.toByte() ?: 0 + result[out++] = b + idx += 2 + } + return result } diff --git a/app/src/main/java/com/bitchat/android/mesh/PeerManager.kt b/app/src/main/java/com/bitchat/android/mesh/PeerManager.kt index 68a539eb8..4b8a16dcb 100644 --- a/app/src/main/java/com/bitchat/android/mesh/PeerManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/PeerManager.kt @@ -262,8 +262,6 @@ class PeerManager { fingerprintManager.removePeer(peerID) if (notifyDelegate && removed != null) { - // Notify specific removal event then list update - try { delegate?.onPeerRemoved(peerID) } catch (_: Exception) {} notifyPeerListUpdate() } } @@ -531,5 +529,4 @@ class PeerManager { */ interface PeerManagerDelegate { fun onPeerListUpdated(peerIDs: List) - fun onPeerRemoved(peerID: String) } diff --git a/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt b/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt index 42f6e356d..89f0197c3 100644 --- a/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt @@ -50,6 +50,12 @@ class SecurityManager(private val encryptionService: EncryptionService, private return false } + // TTL check + if (packet.ttl == 0u.toUByte()) { + Log.d(TAG, "Dropping packet with TTL 0") + return false + } + // Validate packet payload if (packet.payload.isEmpty()) { Log.d(TAG, "Dropping packet with empty payload") @@ -61,11 +67,11 @@ class SecurityManager(private val encryptionService: EncryptionService, private val packetTime = packet.timestamp.toLong() val timeDiff = kotlin.math.abs(currentTime - packetTime) -// if (timeDiff > MESSAGE_TIMEOUT) { -// Log.d(TAG, "Dropping old packet from $peerID, time diff: ${timeDiff/1000}s") -// return false -// } - + if (timeDiff > MESSAGE_TIMEOUT) { + Log.d(TAG, "Dropping old packet from $peerID, time diff: ${timeDiff/1000}s") + return false + } + // Duplicate detection val messageID = generateMessageID(packet, peerID) if (processedMessages.contains(messageID)) { @@ -101,17 +107,9 @@ class SecurityManager(private val encryptionService: EncryptionService, private // Skip our own handshake messages if (peerID == myPeerID) return false - // If we already have an established session but the peer is initiating a new handshake, - // drop the existing session so we can re-establish cleanly. - var forcedRehandshake = false if (encryptionService.hasEstablishedSession(peerID)) { - Log.d(TAG, "Received new Noise handshake from $peerID with an existing session. Dropping old session to re-handshake.") - try { - encryptionService.removePeer(peerID) - forcedRehandshake = true - } catch (e: Exception) { - Log.w(TAG, "Failed to remove existing Noise session for $peerID: ${e.message}") - } + Log.d(TAG, "Handshake already completed with $peerID") + return true } if (packet.payload.isEmpty()) { @@ -122,7 +120,7 @@ class SecurityManager(private val encryptionService: EncryptionService, private // Prevent duplicate handshake processing val exchangeKey = "$peerID-${packet.payload.sliceArray(0 until minOf(16, packet.payload.size)).contentHashCode()}" - if (!forcedRehandshake && processedKeyExchanges.contains(exchangeKey)) { + if (processedKeyExchanges.contains(exchangeKey)) { Log.d(TAG, "Already processed handshake: $exchangeKey") return false } diff --git a/app/src/main/java/com/bitchat/android/mesh/StoreForwardManager.kt b/app/src/main/java/com/bitchat/android/mesh/StoreForwardManager.kt index 98830bea9..f7be34069 100644 --- a/app/src/main/java/com/bitchat/android/mesh/StoreForwardManager.kt +++ b/app/src/main/java/com/bitchat/android/mesh/StoreForwardManager.kt @@ -165,7 +165,7 @@ class StoreForwardManager { // Send with delays to avoid overwhelming the connection messagesToSend.forEachIndexed { index, storedMessage -> - delay(index * 10L) // 10ms between messages + delay(index * 100L) // 100ms between messages delegate?.sendPacket(storedMessage.packet) } diff --git a/app/src/main/java/com/bitchat/android/mesh/TransferProgressManager.kt b/app/src/main/java/com/bitchat/android/mesh/TransferProgressManager.kt deleted file mode 100644 index fbffb9aaf..000000000 --- a/app/src/main/java/com/bitchat/android/mesh/TransferProgressManager.kt +++ /dev/null @@ -1,30 +0,0 @@ -package com.bitchat.android.mesh - -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.SupervisorJob -import kotlinx.coroutines.flow.MutableSharedFlow -import kotlinx.coroutines.flow.SharedFlow -import kotlinx.coroutines.launch - -data class TransferProgressEvent( - val transferId: String, - val sent: Int, - val total: Int, - val completed: Boolean -) - -object TransferProgressManager { - private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob()) - private val _events = MutableSharedFlow(replay = 0, extraBufferCapacity = 32) - val events: SharedFlow = _events - - fun start(id: String, total: Int) { emit(id, 0, total, false) } - fun progress(id: String, sent: Int, total: Int) { emit(id, sent, total, sent >= total) } - fun complete(id: String, total: Int) { emit(id, total, total, true) } - - private fun emit(id: String, sent: Int, total: Int, done: Boolean) { - scope.launch { _events.emit(TransferProgressEvent(id, sent, total, done)) } - } -} - diff --git a/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt b/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt deleted file mode 100644 index 5e47742fc..000000000 --- a/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt +++ /dev/null @@ -1,141 +0,0 @@ -package com.bitchat.android.model - -import java.nio.ByteBuffer -import java.nio.ByteOrder - -/** - * BitchatFilePacket: TLV-encoded file transfer payload for BLE mesh. - * TLVs: - * - 0x01: filename (UTF-8) - * - 0x02: file size (8 bytes, UInt64) - * - 0x03: mime type (UTF-8) - * - 0x04: content (bytes) — may appear multiple times for large files - * - * Length field for TLV is 2 bytes (UInt16, big-endian) for all TLVs. - * For large files, CONTENT is chunked into multiple TLVs of up to 65535 bytes each. - * - * Note: The outer BitchatPacket uses version 2 (4-byte payload length), so this - * TLV payload can exceed 64 KiB even though each TLV value is limited to 65535 bytes. - * Transport-level fragmentation then splits the final packet for BLE MTU. - */ -data class BitchatFilePacket( - val fileName: String, - val fileSize: Long, - val mimeType: String, - val content: ByteArray -) { - private enum class TLVType(val v: UByte) { - FILE_NAME(0x01u), FILE_SIZE(0x02u), MIME_TYPE(0x03u), CONTENT(0x04u); - companion object { fun from(value: UByte) = values().find { it.v == value } } - } - - fun encode(): ByteArray? { - try { - android.util.Log.d("BitchatFilePacket", "🔄 Encoding: name=$fileName, size=$fileSize, mime=$mimeType") - val nameBytes = fileName.toByteArray(Charsets.UTF_8) - val mimeBytes = mimeType.toByteArray(Charsets.UTF_8) - // Validate bounds for 2-byte TLV lengths (per-TLV). CONTENT may exceed 65535 and will be chunked. - if (nameBytes.size > 0xFFFF || mimeBytes.size > 0xFFFF) { - android.util.Log.e("BitchatFilePacket", "❌ TLV field too large: name=${nameBytes.size}, mime=${mimeBytes.size} (max: 65535)") - return null - } - if (content.size > 0xFFFF) { - android.util.Log.d("BitchatFilePacket", "📦 Content exceeds 65535 bytes (${content.size}); will be split into multiple CONTENT TLVs") - } else { - android.util.Log.d("BitchatFilePacket", "📏 TLV sizes OK: name=${nameBytes.size}, mime=${mimeBytes.size}, content=${content.size}") - } - val sizeFieldLen = 4 // UInt32 for FILE_SIZE (changed from 8 bytes) - val contentLenFieldLen = 4 // UInt32 for CONTENT TLV as requested - - // Compute capacity: header TLVs + single CONTENT TLV with 4-byte length - val contentTLVBytes = 1 + contentLenFieldLen + content.size - val capacity = (1 + 2 + nameBytes.size) + (1 + 2 + sizeFieldLen) + (1 + 2 + mimeBytes.size) + contentTLVBytes - val buf = ByteBuffer.allocate(capacity).order(ByteOrder.BIG_ENDIAN) - - // FILE_NAME - buf.put(TLVType.FILE_NAME.v.toByte()) - buf.putShort(nameBytes.size.toShort()) - buf.put(nameBytes) - - // FILE_SIZE (4 bytes) - buf.put(TLVType.FILE_SIZE.v.toByte()) - buf.putShort(sizeFieldLen.toShort()) - buf.putInt(fileSize.toInt()) - - // MIME_TYPE - buf.put(TLVType.MIME_TYPE.v.toByte()) - buf.putShort(mimeBytes.size.toShort()) - buf.put(mimeBytes) - - // CONTENT (single TLV with 4-byte length) - buf.put(TLVType.CONTENT.v.toByte()) - buf.putInt(content.size) - buf.put(content) - - val result = buf.array() - android.util.Log.d("BitchatFilePacket", "✅ Encoded successfully: ${result.size} bytes total") - return result - } catch (e: Exception) { - android.util.Log.e("BitchatFilePacket", "❌ Encoding failed: ${e.message}", e) - return null - } - } - - companion object { - fun decode(data: ByteArray): BitchatFilePacket? { - android.util.Log.d("BitchatFilePacket", "🔄 Decoding ${data.size} bytes") - try { - var off = 0 - var name: String? = null - var size: Long? = null - var mime: String? = null - var contentBytes: ByteArray? = null - while (off + 3 <= data.size) { // minimum TLV header size (type + 2 bytes length) - val t = TLVType.from(data[off].toUByte()) ?: return null - off += 1 - // CONTENT uses 4-byte length; others use 2-byte length - val len: Int - if (t == TLVType.CONTENT) { - if (off + 4 > data.size) return null - len = ((data[off].toInt() and 0xFF) shl 24) or ((data[off + 1].toInt() and 0xFF) shl 16) or ((data[off + 2].toInt() and 0xFF) shl 8) or (data[off + 3].toInt() and 0xFF) - off += 4 - } else { - if (off + 2 > data.size) return null - len = ((data[off].toInt() and 0xFF) shl 8) or (data[off + 1].toInt() and 0xFF) - off += 2 - } - if (len < 0 || off + len > data.size) return null - val value = data.copyOfRange(off, off + len) - off += len - when (t) { - TLVType.FILE_NAME -> name = String(value, Charsets.UTF_8) - TLVType.FILE_SIZE -> { - if (len != 4) return null - val bb = ByteBuffer.wrap(value).order(ByteOrder.BIG_ENDIAN) - size = bb.int.toLong() - } - TLVType.MIME_TYPE -> mime = String(value, Charsets.UTF_8) - TLVType.CONTENT -> { - // Expect a single CONTENT TLV - if (contentBytes == null) contentBytes = value else { - // If multiple CONTENT TLVs appear, concatenate for tolerance - contentBytes = (contentBytes!! + value) - } - } - } - } - val n = name ?: return null - val c = contentBytes ?: return null - val s = size ?: c.size.toLong() - val m = mime ?: "application/octet-stream" - val result = BitchatFilePacket(n, s, m, c) - android.util.Log.d("BitchatFilePacket", "✅ Decoded: name=$n, size=$s, mime=$m, content=${c.size} bytes") - return result - } catch (e: Exception) { - android.util.Log.e("BitchatFilePacket", "❌ Decoding failed: ${e.message}", e) - return null - } - } - } -} - diff --git a/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt b/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt index 8e1731b1a..5bce45a90 100644 --- a/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt +++ b/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt @@ -7,14 +7,6 @@ import java.nio.ByteBuffer import java.nio.ByteOrder import java.util.* -@Parcelize -enum class BitchatMessageType : Parcelable { - Message, - Audio, - Image, - File -} - /** * Delivery status for messages - exact same as iOS version */ @@ -57,7 +49,6 @@ data class BitchatMessage( val id: String = UUID.randomUUID().toString().uppercase(), val sender: String, val content: String, - val type: BitchatMessageType = BitchatMessageType.Message, val timestamp: Date, val isRelay: Boolean = false, val originalSender: String? = null, @@ -288,7 +279,6 @@ data class BitchatMessage( id = id, sender = sender, content = content, - type = BitchatMessageType.Message, timestamp = timestamp, isRelay = isRelay, originalSender = originalSender, @@ -316,7 +306,6 @@ data class BitchatMessage( if (id != other.id) return false if (sender != other.sender) return false if (content != other.content) return false - if (type != other.type) return false if (timestamp != other.timestamp) return false if (isRelay != other.isRelay) return false if (originalSender != other.originalSender) return false @@ -339,7 +328,6 @@ data class BitchatMessage( var result = id.hashCode() result = 31 * result + sender.hashCode() result = 31 * result + content.hashCode() - result = 31 * result + type.hashCode() result = 31 * result + timestamp.hashCode() result = 31 * result + isRelay.hashCode() result = 31 * result + (originalSender?.hashCode() ?: 0) diff --git a/app/src/main/java/com/bitchat/android/model/FileSharingManager.kt b/app/src/main/java/com/bitchat/android/model/FileSharingManager.kt deleted file mode 100644 index 49c489206..000000000 --- a/app/src/main/java/com/bitchat/android/model/FileSharingManager.kt +++ /dev/null @@ -1,92 +0,0 @@ -package com.bitchat.android.model - -import android.content.Context -import android.net.Uri -import android.util.Log -import com.bitchat.android.features.file.FileUtils -import java.io.File - -/** - * Business logic for file sharing operations - */ -object FileSharingManager { - - private const val TAG = "FileSharingManager" - - /** - * Create a file packet from URI for sending - */ - fun createFilePacketFromUri( - context: Context, - uri: Uri, - originalName: String? = null - ): BitchatFilePacket? { - return try { - // Get file name from URI or use original name - val fileName = originalName ?: getFileNameFromUri(context, uri) ?: "unknown_file" - - // Copy file to our temp storage for sending - val localPath = FileUtils.copyFileForSending(context, uri) ?: return null - - // Determine MIME type - val mimeType = FileUtils.getMimeTypeFromExtension(fileName) - - // Read file content - val file = File(localPath) - val content = file.readBytes() - val fileSize = file.length() - - // Clean up temp file - file.delete() - - val packet = BitchatFilePacket( - fileName = fileName, - fileSize = fileSize, - mimeType = mimeType, - content = content - ) - - Log.d(TAG, "Created file packet: name=$fileName, size=${FileUtils.formatFileSize(fileSize)}, mime=$mimeType") - packet - - } catch (e: Exception) { - Log.e(TAG, "Failed to create file packet from URI", e) - null - } - } - - /** - * Extract filename from URI - */ - private fun getFileNameFromUri(context: Context, uri: Uri): String? { - return try { - context.contentResolver.query(uri, null, null, null, null)?.use { cursor -> - val nameIndex = cursor.getColumnIndex(android.provider.MediaStore.MediaColumns.DISPLAY_NAME) - cursor.moveToFirst() - cursor.getString(nameIndex) - } ?: uri.lastPathSegment - } catch (e: Exception) { - Log.w(TAG, "Failed to get filename from URI", e) - uri.lastPathSegment - } - } - - /** - * Process a received file packet and return file info - */ - data class ReceivedFileInfo( - val fileName: String, - val fileSize: Long, - val mimeType: String, - val content: ByteArray - ) - - fun processReceivedFile(packet: BitchatFilePacket): ReceivedFileInfo { - return ReceivedFileInfo( - fileName = packet.fileName, - fileSize = packet.fileSize, - mimeType = packet.mimeType, - content = packet.content - ) - } -} diff --git a/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt b/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt index 7f691a9cc..dd297f881 100644 --- a/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt +++ b/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt @@ -20,9 +20,7 @@ import kotlinx.parcelize.Parcelize enum class NoisePayloadType(val value: UByte) { PRIVATE_MESSAGE(0x01u), // Private chat message with TLV encoding READ_RECEIPT(0x02u), // Message was read - DELIVERED(0x03u), // Message was delivered - FILE_TRANSFER(0x20u); - + DELIVERED(0x03u); // Message was delivered companion object { fun fromValue(value: UByte): NoisePayloadType? { diff --git a/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt b/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt deleted file mode 100644 index ab52f0711..000000000 --- a/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt +++ /dev/null @@ -1,82 +0,0 @@ -package com.bitchat.android.model - -import com.bitchat.android.sync.SyncDefaults - -/** - * REQUEST_SYNC payload using GCS (Golomb-Coded Set) parameters. - * TLV (type, length16, value), types: - * - 0x01: P (uint8) — Golomb-Rice parameter - * - 0x02: M (uint32, big-endian) — hash range (N * 2^P) - * - 0x03: data (opaque) — GR bitstream bytes - */ -data class RequestSyncPacket( - val p: Int, - val m: Long, - val data: ByteArray -) { - fun encode(): ByteArray { - val out = ArrayList() - fun putTLV(t: Int, v: ByteArray) { - out.add(t.toByte()) - val len = v.size - out.add(((len ushr 8) and 0xFF).toByte()) - out.add((len and 0xFF).toByte()) - out.addAll(v.toList()) - } - // P - putTLV(0x01, byteArrayOf(p.toByte())) - // M (uint32) - val m32 = m.coerceAtMost(0xffff_ffffL) - putTLV( - 0x02, - byteArrayOf( - ((m32 ushr 24) and 0xFF).toByte(), - ((m32 ushr 16) and 0xFF).toByte(), - ((m32 ushr 8) and 0xFF).toByte(), - (m32 and 0xFF).toByte() - ) - ) - // data - putTLV(0x03, data) - return out.toByteArray() - } - - companion object { - // Receiver-side safety limit (configurable constant) - const val MAX_ACCEPT_FILTER_BYTES: Int = SyncDefaults.MAX_ACCEPT_FILTER_BYTES - - fun decode(data: ByteArray): RequestSyncPacket? { - var off = 0 - var p: Int? = null - var m: Long? = null - var payload: ByteArray? = null - - while (off + 3 <= data.size) { - val t = (data[off].toInt() and 0xFF); off += 1 - val len = ((data[off].toInt() and 0xFF) shl 8) or (data[off+1].toInt() and 0xFF); off += 2 - if (off + len > data.size) return null - val v = data.copyOfRange(off, off + len); off += len - when (t) { - 0x01 -> if (len == 1) p = (v[0].toInt() and 0xFF) - 0x02 -> if (len == 4) { - val mm = ((v[0].toLong() and 0xFF) shl 24) or - ((v[1].toLong() and 0xFF) shl 16) or - ((v[2].toLong() and 0xFF) shl 8) or - (v[3].toLong() and 0xFF) - m = mm - } - 0x03 -> { - if (v.size > MAX_ACCEPT_FILTER_BYTES) return null - payload = v - } - } - } - - val pp = p ?: return null - val mm = m ?: return null - val dd = payload ?: return null - if (pp < 1 || mm <= 0L) return null - return RequestSyncPacket(pp, mm, dd) - } - } -} diff --git a/app/src/main/java/com/bitchat/android/model/RoutedPacket.kt b/app/src/main/java/com/bitchat/android/model/RoutedPacket.kt index b2c0ef454..59697360c 100644 --- a/app/src/main/java/com/bitchat/android/model/RoutedPacket.kt +++ b/app/src/main/java/com/bitchat/android/model/RoutedPacket.kt @@ -9,6 +9,5 @@ import com.bitchat.android.protocol.BitchatPacket data class RoutedPacket( val packet: BitchatPacket, val peerID: String? = null, // Who sent it (parsed from packet.senderID) - val relayAddress: String? = null, // Address it came from (for avoiding loopback) - val transferId: String? = null // Optional stable transfer ID for progress tracking -) + val relayAddress: String? = null // Address it came from (for avoiding loopback) +) \ No newline at end of file diff --git a/app/src/main/java/com/bitchat/android/net/OkHttpProvider.kt b/app/src/main/java/com/bitchat/android/net/OkHttpProvider.kt index 45cff7734..604314768 100644 --- a/app/src/main/java/com/bitchat/android/net/OkHttpProvider.kt +++ b/app/src/main/java/com/bitchat/android/net/OkHttpProvider.kt @@ -43,12 +43,11 @@ object OkHttpProvider { private fun baseBuilderForCurrentProxy(): OkHttpClient.Builder { val builder = OkHttpClient.Builder() val socks: InetSocketAddress? = TorManager.currentSocksAddress() - // If a SOCKS address is defined, always use it. TorManager sets this as soon as Tor mode is ON, - // even before bootstrap, to prevent any direct connections from occurring. - if (socks != null) { + if (socks != null && TorManager.isProxyEnabled()) { val proxy = Proxy(Proxy.Type.SOCKS, socks) builder.proxy(proxy) } return builder } } + diff --git a/app/src/main/java/com/bitchat/android/net/TorManager.kt b/app/src/main/java/com/bitchat/android/net/TorManager.kt index 4acebf737..efa2eab5b 100644 --- a/app/src/main/java/com/bitchat/android/net/TorManager.kt +++ b/app/src/main/java/com/bitchat/android/net/TorManager.kt @@ -82,18 +82,9 @@ object TorManager { currentApplication = application TorPreferenceManager.init(application) - // Apply saved mode at startup. If ON, set planned SOCKS immediately to avoid any leak. - val savedMode = TorPreferenceManager.get(application) - if (savedMode == TorMode.ON) { - if (currentSocksPort < DEFAULT_SOCKS_PORT) { - currentSocksPort = DEFAULT_SOCKS_PORT - } - desiredMode = savedMode - socksAddr = InetSocketAddress("127.0.0.1", currentSocksPort) - try { OkHttpProvider.reset() } catch (_: Throwable) { } - } + // Apply saved mode at startup appScope.launch { - applyMode(application, savedMode) + applyMode(application, TorPreferenceManager.get(application)) } // Observe changes @@ -145,11 +136,6 @@ object TorManager { bindRetryAttempts = 0 lifecycleState = LifecycleState.STARTING _status.value = _status.value.copy(mode = TorMode.ON, running = false, bootstrapPercent = 0, state = TorState.STARTING) - // Immediately set the planned SOCKS address so all traffic is forced through it, - // even before Tor is fully bootstrapped. This prevents any direct connections. - socksAddr = InetSocketAddress("127.0.0.1", currentSocksPort) - try { OkHttpProvider.reset() } catch (_: Throwable) { } - try { com.bitchat.android.nostr.NostrRelayManager.shared.resetAllConnections() } catch (_: Throwable) { } startArti(application, useDelay = false) // Defer enabling proxy until bootstrap completes appScope.launch { @@ -202,8 +188,6 @@ object TorManager { lifecycleState = LifecycleState.RUNNING startInactivityMonitoring() - // Removed onion service startup (BLE-only file transfer in this branch) - } catch (e: Exception) { Log.e(TAG, "Error starting Arti on port $currentSocksPort: ${e.message}") _status.value = _status.value.copy(state = TorState.ERROR) @@ -214,10 +198,6 @@ object TorManager { bindRetryAttempts++ currentSocksPort++ Log.w(TAG, "Port bind failed (attempt $bindRetryAttempts/$MAX_RETRY_ATTEMPTS), retrying with port $currentSocksPort") - // Update planned SOCKS address immediately so all new connections target the new port - socksAddr = InetSocketAddress("127.0.0.1", currentSocksPort) - try { OkHttpProvider.reset() } catch (_: Throwable) { } - try { com.bitchat.android.nostr.NostrRelayManager.shared.resetAllConnections() } catch (_: Throwable) { } // Immediate retry with incremented port, no exponential backoff for bind errors startArti(application, useDelay = false) } else if (isBindError) { @@ -359,7 +339,7 @@ object TorManager { completeWaitersIf(TorState.STARTING) } s.contains("Sufficiently bootstrapped; system SOCKS now functional", ignoreCase = true) -> { - _status.value = _status.value.copy(bootstrapPercent = 75, state = TorState.BOOTSTRAPPING) + _status.value = _status.value.copy(bootstrapPercent = 100, state = TorState.BOOTSTRAPPING) retryAttempts = 0 bindRetryAttempts = 0 startInactivityMonitoring() diff --git a/app/src/main/java/com/bitchat/android/net/TorPreferenceManager.kt b/app/src/main/java/com/bitchat/android/net/TorPreferenceManager.kt index 5e02a60bd..661cf7c4a 100644 --- a/app/src/main/java/com/bitchat/android/net/TorPreferenceManager.kt +++ b/app/src/main/java/com/bitchat/android/net/TorPreferenceManager.kt @@ -8,13 +8,13 @@ object TorPreferenceManager { private const val PREFS_NAME = "bitchat_settings" private const val KEY_TOR_MODE = "tor_mode" - private val _modeFlow = MutableStateFlow(TorMode.ON) + private val _modeFlow = MutableStateFlow(TorMode.OFF) val modeFlow: StateFlow = _modeFlow fun init(context: Context) { val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) - val saved = prefs.getString(KEY_TOR_MODE, TorMode.ON.name) - val mode = runCatching { TorMode.valueOf(saved ?: TorMode.ON.name) }.getOrDefault(TorMode.ON) + val saved = prefs.getString(KEY_TOR_MODE, TorMode.OFF.name) + val mode = runCatching { TorMode.valueOf(saved ?: TorMode.OFF.name) }.getOrDefault(TorMode.OFF) _modeFlow.value = mode } @@ -26,8 +26,8 @@ object TorPreferenceManager { fun get(context: Context): TorMode { val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) - val saved = prefs.getString(KEY_TOR_MODE, TorMode.ON.name) - return runCatching { TorMode.valueOf(saved ?: TorMode.ON.name) }.getOrDefault(TorMode.ON) + val saved = prefs.getString(KEY_TOR_MODE, TorMode.OFF.name) + return runCatching { TorMode.valueOf(saved ?: TorMode.OFF.name) }.getOrDefault(TorMode.OFF) } } diff --git a/app/src/main/java/com/bitchat/android/nostr/GeohashMessageHandler.kt b/app/src/main/java/com/bitchat/android/nostr/GeohashMessageHandler.kt index 0e6e66345..766169fad 100644 --- a/app/src/main/java/com/bitchat/android/nostr/GeohashMessageHandler.kt +++ b/app/src/main/java/com/bitchat/android/nostr/GeohashMessageHandler.kt @@ -22,8 +22,7 @@ class GeohashMessageHandler( private val state: ChatState, private val messageManager: MessageManager, private val repo: GeohashRepository, - private val scope: CoroutineScope, - private val dataManager: com.bitchat.android.ui.DataManager + private val scope: CoroutineScope ) { companion object { private const val TAG = "GeohashMessageHandler" } @@ -57,8 +56,8 @@ class GeohashMessageHandler( if (!NostrProofOfWork.validateDifficulty(event, pow.difficulty)) return@launch } - // Blocked users check (use injected DataManager which has loaded state) - if (dataManager.isGeohashUserBlocked(event.pubkey)) return@launch + // Blocked users check + if (com.bitchat.android.ui.DataManager(application).isGeohashUserBlocked(event.pubkey)) return@launch // Update repository (participants, nickname, teleport) // Update repository on a background-safe path; repository will post updates to LiveData @@ -79,7 +78,6 @@ class GeohashMessageHandler( if (isTeleportPresence) return@launch val senderName = repo.displayNameForNostrPubkeyUI(event.pubkey) - val hasNonce = try { NostrProofOfWork.hasNonce(event) } catch (_: Exception) { false } val msg = BitchatMessage( id = event.id, sender = senderName, @@ -90,9 +88,7 @@ class GeohashMessageHandler( senderPeerID = "nostr:${event.pubkey.take(8)}", mentions = null, channel = "#$subscribedGeohash", - powDifficulty = try { - if (hasNonce) NostrProofOfWork.calculateDifficulty(event.id).takeIf { it > 0 } else null - } catch (_: Exception) { null } + powDifficulty = try { NostrProofOfWork.calculateDifficulty(event.id).takeIf { it > 0 } } catch (_: Exception) { null } ) withContext(Dispatchers.Main) { messageManager.addChannelMessage("geo:$subscribedGeohash", msg) } } catch (e: Exception) { diff --git a/app/src/main/java/com/bitchat/android/nostr/GeohashRepository.kt b/app/src/main/java/com/bitchat/android/nostr/GeohashRepository.kt index c72c8e679..f5e607bc3 100644 --- a/app/src/main/java/com/bitchat/android/nostr/GeohashRepository.kt +++ b/app/src/main/java/com/bitchat/android/nostr/GeohashRepository.kt @@ -14,8 +14,7 @@ import java.util.Date */ class GeohashRepository( private val application: Application, - private val state: ChatState, - private val dataManager: com.bitchat.android.ui.DataManager + private val state: ChatState ) { companion object { private const val TAG = "GeohashRepository" } @@ -104,8 +103,7 @@ class GeohashRepository( val e = it.next() if (e.value.before(cutoff)) it.remove() } - // exclude blocked users - return participants.keys.count { !dataManager.isGeohashUserBlocked(it) } + return participants.size } fun refreshGeohashPeople() { @@ -124,18 +122,8 @@ class GeohashRepository( if (e.value.before(cutoff)) it.remove() } geohashParticipants[geohash] = participants - // exclude blocked users from people list - val people = participants.filterKeys { !dataManager.isGeohashUserBlocked(it) } - .map { (pubkeyHex, lastSeen) -> - // Use our actual nickname for self; otherwise use cached nickname or anon - val base = try { - val myHex = currentGeohash?.let { NostrIdentityBridge.deriveIdentity(it, application).publicKeyHex } - if (myHex != null && myHex.equals(pubkeyHex, true)) { - state.getNicknameValue() ?: "anon" - } else { - getCachedNickname(pubkeyHex) ?: "anon" - } - } catch (_: Exception) { getCachedNickname(pubkeyHex) ?: "anon" } + val people = participants.map { (pubkeyHex, lastSeen) -> + val base = getCachedNickname(pubkeyHex) ?: "anon" GeoPerson( id = pubkeyHex.lowercase(), displayName = base, // UI can add #hash if necessary @@ -150,8 +138,7 @@ class GeohashRepository( val cutoff = Date(System.currentTimeMillis() - 5 * 60 * 1000) val counts = mutableMapOf() for ((gh, participants) in geohashParticipants) { - val active = participants.filterKeys { !dataManager.isGeohashUserBlocked(it) } - .values.count { !it.before(cutoff) } + val active = participants.values.count { !it.before(cutoff) } counts[gh] = active } // Use postValue for thread safety - this can be called from background threads @@ -199,7 +186,6 @@ class GeohashRepository( val participants = geohashParticipants[current] ?: emptyMap() var count = 0 for ((k, t) in participants) { - if (dataManager.isGeohashUserBlocked(k)) continue if (t.before(cutoff)) continue val name = if (k.equals(lower, true)) base else (geoNicknames[k.lowercase()] ?: "anon") if (name.equals(base, true)) { count++; if (count > 1) break } @@ -221,7 +207,6 @@ class GeohashRepository( val participants = geohashParticipants[sourceGeohash] ?: emptyMap() var count = 0 for ((k, t) in participants) { - if (dataManager.isGeohashUserBlocked(k)) continue if (t.before(cutoff)) continue val name = if (k.equals(lower, true)) base else (geoNicknames[k.lowercase()] ?: "anon") if (name.equals(base, true)) { count++; if (count > 1) break } diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt b/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt index 3dcb60d68..394ea3d9f 100644 --- a/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt +++ b/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt @@ -21,8 +21,7 @@ class NostrDirectMessageHandler( private val privateChatManager: PrivateChatManager, private val meshDelegateHandler: MeshDelegateHandler, private val scope: CoroutineScope, - private val repo: GeohashRepository, - private val dataManager: com.bitchat.android.ui.DataManager + private val repo: GeohashRepository ) { companion object { private const val TAG = "NostrDirectMessageHandler" } @@ -59,10 +58,6 @@ class NostrDirectMessageHandler( } val (content, senderPubkey, rumorTimestamp) = decryptResult - - // If sender is blocked for geohash contexts, drop any events from this pubkey - // Applies to both geohash DMs (geohash != "") and account DMs (geohash == "") - if (dataManager.isGeohashUserBlocked(senderPubkey)) return@launch if (!content.startsWith("bitchat1:")) return@launch val base64Content = content.removePrefix("bitchat1:") @@ -72,7 +67,7 @@ class NostrDirectMessageHandler( if (packet.type != com.bitchat.android.protocol.MessageType.NOISE_ENCRYPTED.value) return@launch val noisePayload = com.bitchat.android.model.NoisePayload.decode(packet.payload) ?: return@launch - val messageTimestamp = Date(giftWrap.createdAt * 1000L) + val messageTimestamp = Date(rumorTimestamp * 1000L) val convKey = "nostr_${senderPubkey.take(16)}" repo.putNostrKeyMapping(convKey, senderPubkey) com.bitchat.android.nostr.GeohashAliasRegistry.put(convKey, senderPubkey) @@ -160,31 +155,6 @@ class NostrDirectMessageHandler( meshDelegateHandler.didReceiveReadReceipt(messageId, convKey) } } - com.bitchat.android.model.NoisePayloadType.FILE_TRANSFER -> { - // Properly handle encrypted file transfer - val file = com.bitchat.android.model.BitchatFilePacket.decode(payload.data) - if (file != null) { - val uniqueMsgId = java.util.UUID.randomUUID().toString().uppercase() - val savedPath = com.bitchat.android.features.file.FileUtils.saveIncomingFile(application, file) - val message = BitchatMessage( - id = uniqueMsgId, - sender = senderNickname, - content = savedPath, - type = com.bitchat.android.features.file.FileUtils.messageTypeForMime(file.mimeType), - timestamp = timestamp, - isRelay = false, - isPrivate = true, - recipientNickname = state.getNicknameValue(), - senderPeerID = convKey - ) - Log.d(TAG, "📄 Saved Nostr encrypted incoming file to $savedPath (msgId=$uniqueMsgId)") - withContext(Dispatchers.Main) { - privateChatManager.handleIncomingPrivateMessage(message, suppressUnread = false) - } - } else { - Log.w(TAG, "⚠️ Failed to decode Nostr file transfer from $convKey") - } - } } } @@ -203,3 +173,4 @@ class NostrDirectMessageHandler( } } } + diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrProofOfWork.kt b/app/src/main/java/com/bitchat/android/nostr/NostrProofOfWork.kt index ffbe66074..d713422a0 100644 --- a/app/src/main/java/com/bitchat/android/nostr/NostrProofOfWork.kt +++ b/app/src/main/java/com/bitchat/android/nostr/NostrProofOfWork.kt @@ -54,12 +54,6 @@ object NostrProofOfWork { fun validateDifficulty(event: NostrEvent, minimumDifficulty: Int): Boolean { if (minimumDifficulty <= 0) return true - // Require explicit nonce tag to recognize PoW per NIP-13 intent - if (!hasNonce(event)) { - Log.w(TAG, "Event ${event.id.take(16)}... missing nonce tag; treating as no PoW") - return false - } - val actualDifficulty = calculateDifficulty(event.id) val committedDifficulty = getCommittedDifficulty(event) diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt b/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt index a7c498185..18da6bc59 100644 --- a/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt +++ b/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt @@ -240,7 +240,11 @@ class NostrTransport( return@launch } - val content = if (isFavorite) "[FAVORITED]:${senderIdentity.npub}" else "[UNFAVORITED]:${senderIdentity.npub}" + val content = if (isFavorite) { + "[FAVORITED]:${senderIdentity.npub}" + } else { + "[UNFAVORITED]:${senderIdentity.npub}" + } Log.d(TAG, "NostrTransport: preparing FAVORITE($isFavorite) to ${recipientNostrPubkey.take(16)}...") diff --git a/app/src/main/java/com/bitchat/android/nostr/PoWPreferenceManager.kt b/app/src/main/java/com/bitchat/android/nostr/PoWPreferenceManager.kt index 3a3042fea..1bb3ff8a7 100644 --- a/app/src/main/java/com/bitchat/android/nostr/PoWPreferenceManager.kt +++ b/app/src/main/java/com/bitchat/android/nostr/PoWPreferenceManager.kt @@ -17,7 +17,7 @@ object PoWPreferenceManager { // Default values private const val DEFAULT_POW_ENABLED = false - private const val DEFAULT_POW_DIFFICULTY = 12 // Reasonable default for geohash spam prevention + private const val DEFAULT_POW_DIFFICULTY = 16 // Reasonable default for geohash spam prevention // State flows for reactive UI private val _powEnabled = MutableStateFlow(DEFAULT_POW_ENABLED) diff --git a/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationPreferenceManager.kt b/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationPreferenceManager.kt deleted file mode 100644 index c749dc43b..000000000 --- a/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationPreferenceManager.kt +++ /dev/null @@ -1,33 +0,0 @@ -package com.bitchat.android.onboarding - -import android.content.Context -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow - -/** - * Preference manager for battery optimization skip choice - */ -object BatteryOptimizationPreferenceManager { - private const val PREFS_NAME = "bitchat_settings" - private const val KEY_BATTERY_SKIP = "battery_optimization_skipped" - - private val _skipFlow = MutableStateFlow(false) - val skipFlow: StateFlow = _skipFlow - - fun init(context: Context) { - val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) - val skipped = prefs.getBoolean(KEY_BATTERY_SKIP, false) - _skipFlow.value = skipped - } - - fun setSkipped(context: Context, skipped: Boolean) { - val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) - prefs.edit().putBoolean(KEY_BATTERY_SKIP, skipped).apply() - _skipFlow.value = skipped - } - - fun isSkipped(context: Context): Boolean { - val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) - return prefs.getBoolean(KEY_BATTERY_SKIP, false) - } -} diff --git a/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationScreen.kt b/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationScreen.kt index 4ef455f2f..a026d47e3 100644 --- a/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationScreen.kt +++ b/app/src/main/java/com/bitchat/android/onboarding/BatteryOptimizationScreen.kt @@ -3,7 +3,6 @@ package com.bitchat.android.onboarding import androidx.compose.animation.core.* import androidx.compose.foundation.layout.* import androidx.compose.foundation.rememberScrollState -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.* @@ -13,13 +12,11 @@ import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.rotate -import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.res.stringResource import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp -import androidx.compose.ui.unit.sp import com.bitchat.android.R /** @@ -35,16 +32,10 @@ fun BatteryOptimizationScreen( onSkip: () -> Unit, isLoading: Boolean = false ) { - val context = LocalContext.current val colorScheme = MaterialTheme.colorScheme - - // Initialize preference manager - LaunchedEffect(Unit) { - BatteryOptimizationPreferenceManager.init(context) - } Box( - modifier = modifier.padding(24.dp), + modifier = modifier.padding(32.dp), contentAlignment = Alignment.Center ) { when (status) { @@ -82,8 +73,6 @@ private fun BatteryOptimizationEnabledContent( colorScheme: ColorScheme, isLoading: Boolean ) { - val context = LocalContext.current - Column( modifier = Modifier.fillMaxSize() ) { @@ -93,112 +82,78 @@ private fun BatteryOptimizationEnabledContent( .weight(1f) .verticalScroll(rememberScrollState()) .padding(bottom = 16.dp), - verticalArrangement = Arrangement.spacedBy(16.dp) + verticalArrangement = Arrangement.spacedBy(24.dp), + horizontalAlignment = Alignment.CenterHorizontally ) { - // Header Section - matching AboutSheet style - Column( - modifier = Modifier - .fillMaxWidth() - .padding(bottom = 16.dp), - verticalArrangement = Arrangement.spacedBy(8.dp) - ) { - Text( - text = "bitchat", - style = MaterialTheme.typography.headlineLarge.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - fontSize = 32.sp - ), - color = colorScheme.onBackground - ) - - Text( - text = "battery optimization detected", - fontSize = 12.sp, + Text( + text = "bitchat", + style = MaterialTheme.typography.headlineLarge.copy( fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.7f) + fontWeight = FontWeight.Bold, + color = colorScheme.primary ) - } + ) - // Battery optimization info section - Surface( - modifier = Modifier.fillMaxWidth(), - color = colorScheme.surfaceVariant.copy(alpha = 0.25f), - shape = RoundedCornerShape(12.dp) - ) { - Column( - modifier = Modifier.padding(16.dp), - verticalArrangement = Arrangement.spacedBy(8.dp) - ) { - Row( - verticalAlignment = Alignment.Top, - horizontalArrangement = Arrangement.spacedBy(12.dp) - ) { - Icon( - imageVector = Icons.Filled.Power, - contentDescription = "Battery Optimization", - tint = colorScheme.primary, - modifier = Modifier - .padding(top = 2.dp) - .size(20.dp) - ) - Column { - Text( - text = "Battery Optimization Enabled", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "bitchat needs to run in the background to maintain mesh connections. battery optimization can interrupt these connections.", - style = MaterialTheme.typography.bodySmall, - color = colorScheme.onBackground.copy(alpha = 0.8f) - ) - } - } - } - } + Spacer(modifier = Modifier.height(16.dp)) + + Icon( + imageVector = Icons.Outlined.BatteryAlert, + contentDescription = "Battery Optimization", + modifier = Modifier.size(64.dp), + tint = colorScheme.error + ) + + Text( + text = stringResource(R.string.battery_optimization_detected), + style = MaterialTheme.typography.headlineSmall.copy( + fontWeight = FontWeight.SemiBold, + color = colorScheme.onSurface + ), + textAlign = TextAlign.Center + ) - // Benefits section - Surface( + Text( + text = stringResource(R.string.battery_optimization_explanation), + style = MaterialTheme.typography.bodyLarge.copy( + color = colorScheme.onSurfaceVariant + ), + textAlign = TextAlign.Center + ) + + Card( modifier = Modifier.fillMaxWidth(), - color = colorScheme.surfaceVariant.copy(alpha = 0.25f), - shape = RoundedCornerShape(12.dp) + colors = CardDefaults.cardColors( + containerColor = colorScheme.surfaceVariant.copy(alpha = 0.5f) + ) ) { Column( modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp) ) { - Row( - verticalAlignment = Alignment.Top, - horizontalArrangement = Arrangement.spacedBy(12.dp) - ) { - Icon( - imageVector = Icons.Filled.CheckCircle, - contentDescription = "Benefits", - tint = colorScheme.primary, - modifier = Modifier - .padding(top = 2.dp) - .size(20.dp) + Text( + text = stringResource(R.string.battery_optimization_why_disable), + style = MaterialTheme.typography.titleSmall.copy( + fontWeight = FontWeight.SemiBold, + color = colorScheme.onSurface ) - Column { - Text( - text = "Benefits of Disabling", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "• reliable message delivery\n• maintains mesh connectivity\n• prevents connection drops", - style = MaterialTheme.typography.bodySmall, - color = colorScheme.onBackground.copy(alpha = 0.8f) - ) - } - } + ) + + Text( + text = stringResource(R.string.battery_optimization_benefits), + style = MaterialTheme.typography.bodyMedium.copy( + color = colorScheme.onSurfaceVariant + ) + ) } } + + Text( + text = stringResource(R.string.battery_optimization_note), + style = MaterialTheme.typography.bodySmall.copy( + color = colorScheme.onSurfaceVariant + ), + textAlign = TextAlign.Center + ) } // Fixed buttons at the bottom @@ -209,10 +164,7 @@ private fun BatteryOptimizationEnabledContent( Button( onClick = onDisableBatteryOptimization, modifier = Modifier.fillMaxWidth(), - enabled = !isLoading, - colors = ButtonDefaults.buttonColors( - containerColor = colorScheme.primary - ) + enabled = !isLoading ) { if (isLoading) { CircularProgressIndicator( @@ -222,13 +174,7 @@ private fun BatteryOptimizationEnabledContent( ) Spacer(modifier = Modifier.width(8.dp)) } - Text( - text = "Disable Battery Optimization", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold - ) - ) + Text(stringResource(R.string.battery_optimization_disable_button)) } Row( @@ -240,28 +186,15 @@ private fun BatteryOptimizationEnabledContent( modifier = Modifier.weight(1f), enabled = !isLoading ) { - Text( - text = "Check Again", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace - ) - ) + Text(stringResource(R.string.battery_optimization_check_again)) } TextButton( - onClick = { - BatteryOptimizationPreferenceManager.setSkipped(context, true) - onSkip() - }, + onClick = onSkip, modifier = Modifier.weight(1f), enabled = !isLoading ) { - Text( - text = "Skip for Now", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace - ) - ) + Text(stringResource(R.string.battery_optimization_skip)) } } } @@ -273,31 +206,17 @@ private fun BatteryOptimizationCheckingContent( colorScheme: ColorScheme ) { Column( - verticalArrangement = Arrangement.spacedBy(24.dp), + verticalArrangement = Arrangement.spacedBy(32.dp), horizontalAlignment = Alignment.CenterHorizontally ) { - // Header Section - matching AboutSheet style - Column( - verticalArrangement = Arrangement.spacedBy(8.dp), - horizontalAlignment = Alignment.CenterHorizontally - ) { - Text( - text = "bitchat", - style = MaterialTheme.typography.headlineLarge.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - fontSize = 32.sp - ), - color = colorScheme.onBackground - ) - - Text( - text = "battery optimization disabled", - fontSize = 12.sp, + Text( + text = "bitchat", + style = MaterialTheme.typography.headlineLarge.copy( fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.7f) + fontWeight = FontWeight.Bold, + color = colorScheme.primary ) - } + ) val infiniteTransition = rememberInfiniteTransition(label = "rotation") val rotation by infiniteTransition.animateFloat( @@ -320,10 +239,18 @@ private fun BatteryOptimizationCheckingContent( ) Text( - text = "bitchat can run reliably in the background", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.8f) + text = stringResource(R.string.battery_optimization_disabled), + style = MaterialTheme.typography.headlineSmall.copy( + fontWeight = FontWeight.SemiBold, + color = colorScheme.onSurface + ), + textAlign = TextAlign.Center + ) + + Text( + text = stringResource(R.string.battery_optimization_success_message), + style = MaterialTheme.typography.bodyLarge.copy( + color = colorScheme.onSurfaceVariant ), textAlign = TextAlign.Center ) @@ -339,28 +266,14 @@ private fun BatteryOptimizationNotSupportedContent( verticalArrangement = Arrangement.spacedBy(24.dp), horizontalAlignment = Alignment.CenterHorizontally ) { - // Header Section - matching AboutSheet style - Column( - verticalArrangement = Arrangement.spacedBy(8.dp), - horizontalAlignment = Alignment.CenterHorizontally - ) { - Text( - text = "bitchat", - style = MaterialTheme.typography.headlineLarge.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - fontSize = 32.sp - ), - color = colorScheme.onBackground - ) - - Text( - text = "battery optimization not required", - fontSize = 12.sp, + Text( + text = "bitchat", + style = MaterialTheme.typography.headlineLarge.copy( fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.7f) + fontWeight = FontWeight.Bold, + color = colorScheme.primary ) - } + ) Icon( imageVector = Icons.Filled.CheckCircle, @@ -370,28 +283,27 @@ private fun BatteryOptimizationNotSupportedContent( ) Text( - text = "your device doesn't require battery optimization settings. bitchat will run normally.", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.8f) + text = stringResource(R.string.battery_optimization_not_required), + style = MaterialTheme.typography.headlineSmall.copy( + fontWeight = FontWeight.SemiBold, + color = colorScheme.onSurface + ), + textAlign = TextAlign.Center + ) + + Text( + text = stringResource(R.string.battery_optimization_not_supported_message), + style = MaterialTheme.typography.bodyLarge.copy( + color = colorScheme.onSurfaceVariant ), textAlign = TextAlign.Center ) Button( onClick = onRetry, - modifier = Modifier.fillMaxWidth(), - colors = ButtonDefaults.buttonColors( - containerColor = colorScheme.primary - ) + modifier = Modifier.fillMaxWidth() ) { - Text( - text = "Continue", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold - ) - ) + Text(stringResource(R.string.battery_optimization_continue)) } } } \ No newline at end of file diff --git a/app/src/main/java/com/bitchat/android/onboarding/PermissionExplanationScreen.kt b/app/src/main/java/com/bitchat/android/onboarding/PermissionExplanationScreen.kt index 7569d345e..a925567e5 100644 --- a/app/src/main/java/com/bitchat/android/onboarding/PermissionExplanationScreen.kt +++ b/app/src/main/java/com/bitchat/android/onboarding/PermissionExplanationScreen.kt @@ -2,23 +2,12 @@ package com.bitchat.android.onboarding import androidx.compose.foundation.layout.* import androidx.compose.foundation.rememberScrollState -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Bluetooth -import androidx.compose.material.icons.filled.LocationOn -import androidx.compose.material.icons.filled.Notifications -import androidx.compose.material.icons.filled.Power -import androidx.compose.material.icons.filled.Mic -import androidx.compose.material.icons.filled.Security -import androidx.compose.material.icons.filled.Settings -import androidx.compose.material.icons.filled.Warning import androidx.compose.material3.* import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextAlign @@ -51,87 +40,86 @@ fun PermissionExplanationScreen( verticalArrangement = Arrangement.spacedBy(16.dp) ) { Spacer(modifier = Modifier.height(24.dp)) - - // Header Section - matching AboutSheet style + // Header Column( - modifier = Modifier - .fillMaxWidth() - .padding(bottom = 16.dp), - verticalArrangement = Arrangement.spacedBy(8.dp) + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally ) { - Row( - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.Bottom, - modifier = Modifier.fillMaxWidth() - ) { - Text( - text = "bitchat", - style = MaterialTheme.typography.headlineLarge.copy( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - fontSize = 32.sp - ), - color = colorScheme.onBackground - ) - } - Text( - text = "decentralized mesh messaging with end-to-end encryption", - fontSize = 12.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.7f) + text = "Welcome to bitchat", + style = MaterialTheme.typography.headlineMedium.copy( + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold, + color = colorScheme.primary + ), + textAlign = TextAlign.Center + ) + + Spacer(modifier = Modifier.height(8.dp)) + + Text( + text = "Decentralized mesh messaging over Bluetooth", + style = MaterialTheme.typography.bodyMedium.copy( + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.7f) + ), + textAlign = TextAlign.Center ) } - // Privacy assurance section - matching AboutSheet card style - Surface( + Spacer(modifier = Modifier.height(16.dp)) + + // Privacy assurance section + Card( modifier = Modifier.fillMaxWidth(), - color = colorScheme.surfaceVariant.copy(alpha = 0.25f), - shape = RoundedCornerShape(12.dp) + colors = CardDefaults.cardColors( + containerColor = colorScheme.surfaceVariant.copy(alpha = 0.3f) + ), + elevation = CardDefaults.cardElevation(defaultElevation = 2.dp) ) { Column( modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp) ) { Row( - verticalAlignment = Alignment.Top, - horizontalArrangement = Arrangement.spacedBy(12.dp) + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp) ) { - Icon( - imageVector = Icons.Filled.Security, - contentDescription = "Privacy Protected", - tint = colorScheme.primary, - modifier = Modifier - .padding(top = 2.dp) - .size(20.dp) + Text( + text = "🔒", + style = MaterialTheme.typography.titleMedium, + modifier = Modifier.size(20.dp) ) - Column { - Text( - text = "Your Privacy is Protected", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "• no tracking or data collection\n" + - "• Bluetooth mesh chats are fully offline\n" + - "• Geohash chats use the internet", - style = MaterialTheme.typography.bodySmall, - fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.8f) + Text( + text = "Your Privacy is Protected", + style = MaterialTheme.typography.titleSmall.copy( + fontWeight = FontWeight.Bold, + color = colorScheme.onSurface ) - } + ) } + + Text( + text = "• bitchat doesn't track you or collect personal data\n" + + "• Bluetooth mesh chats are fully offline and require no internet\n" + + "• Geohash chats use the internet but your location is generalized\n" + + "• Your messages stay on your device and peer devices only", + style = MaterialTheme.typography.bodySmall.copy( + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.8f) + ) + ) } } - // Section header + Spacer(modifier = Modifier.height(8.dp)) + Text( - text = "permissions", - style = MaterialTheme.typography.labelLarge, - color = colorScheme.onBackground.copy(alpha = 0.7f), - modifier = Modifier.padding(top = 8.dp, bottom = 8.dp) + text = "To work properly, bitchat needs these permissions:", + style = MaterialTheme.typography.bodyMedium.copy( + fontWeight = FontWeight.Medium, + color = colorScheme.onSurface + ) ) // Permission categories @@ -180,46 +168,55 @@ private fun PermissionCategoryCard( category: PermissionCategory, colorScheme: ColorScheme ) { - Row( - verticalAlignment = Alignment.Top, - modifier = Modifier - .fillMaxWidth() - .padding(vertical = 8.dp) + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors( + containerColor = colorScheme.surface + ), + elevation = CardDefaults.cardElevation(defaultElevation = 2.dp) ) { - Icon( - imageVector = getPermissionIcon(category.type), - contentDescription = category.type.nameValue, - tint = colorScheme.primary, - modifier = Modifier - .padding(top = 2.dp) - .size(20.dp) - ) - Spacer(modifier = Modifier.width(16.dp)) - Column { - Text( - text = category.type.nameValue, - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp) + ) { + Text( + text = getPermissionEmoji(category.type), + style = MaterialTheme.typography.titleLarge, + color = getPermissionIconColor(category.type), + modifier = Modifier.size(24.dp) + ) + + Text( + text = category.type.nameValue, + style = MaterialTheme.typography.titleSmall.copy( + fontWeight = FontWeight.Bold, + color = colorScheme.onSurface + ) + ) + } + Text( text = category.description, - style = MaterialTheme.typography.bodySmall, - color = colorScheme.onBackground.copy(alpha = 0.8f) + style = MaterialTheme.typography.bodySmall.copy( + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.8f), + lineHeight = 18.sp + ) ) if (category.type == PermissionType.PRECISE_LOCATION) { // Extra emphasis for location permission - Spacer(modifier = Modifier.height(4.dp)) Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp) ) { - Icon( - imageVector = Icons.Filled.Warning, - contentDescription = "Warning", - tint = Color(0xFFFF9800), + Text( + text = "⚠️", + style = MaterialTheme.typography.bodyMedium, modifier = Modifier.size(16.dp) ) Text( @@ -236,13 +233,22 @@ private fun PermissionCategoryCard( } } -private fun getPermissionIcon(permissionType: PermissionType): ImageVector { +private fun getPermissionEmoji(permissionType: PermissionType): String { + return when (permissionType) { + PermissionType.NEARBY_DEVICES -> "📱" + PermissionType.PRECISE_LOCATION -> "📍" + PermissionType.NOTIFICATIONS -> "🔔" + PermissionType.BATTERY_OPTIMIZATION -> "🔋" + PermissionType.OTHER -> "🔧" + } +} + +private fun getPermissionIconColor(permissionType: PermissionType): Color { return when (permissionType) { - PermissionType.NEARBY_DEVICES -> Icons.Filled.Bluetooth - PermissionType.PRECISE_LOCATION -> Icons.Filled.LocationOn - PermissionType.MICROPHONE -> Icons.Filled.Mic - PermissionType.NOTIFICATIONS -> Icons.Filled.Notifications - PermissionType.BATTERY_OPTIMIZATION -> Icons.Filled.Power - PermissionType.OTHER -> Icons.Filled.Settings + PermissionType.NEARBY_DEVICES -> Color(0xFF2196F3) // Blue + PermissionType.PRECISE_LOCATION -> Color(0xFFFF9800) // Orange + PermissionType.NOTIFICATIONS -> Color(0xFF4CAF50) // Green + PermissionType.BATTERY_OPTIMIZATION -> Color(0xFFF44336) // Red + PermissionType.OTHER -> Color(0xFF9C27B0) // Purple } } diff --git a/app/src/main/java/com/bitchat/android/onboarding/PermissionManager.kt b/app/src/main/java/com/bitchat/android/onboarding/PermissionManager.kt index ff0a160fd..ed9cc030e 100644 --- a/app/src/main/java/com/bitchat/android/onboarding/PermissionManager.kt +++ b/app/src/main/java/com/bitchat/android/onboarding/PermissionManager.kt @@ -78,7 +78,6 @@ class PermissionManager(private val context: Context) { */ fun getOptionalPermissions(): List { val optional = mutableListOf() - // Notifications on Android 13+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { optional.add(Manifest.permission.POST_NOTIFICATIONS) } @@ -190,8 +189,6 @@ class PermissionManager(private val context: Context) { ) } - // Microphone category removed from onboarding - // Battery optimization category (if applicable) if (isBatteryOptimizationSupported()) { categories.add( @@ -260,7 +257,6 @@ data class PermissionCategory( enum class PermissionType(val nameValue: String) { NEARBY_DEVICES("Nearby Devices"), PRECISE_LOCATION("Precise Location"), - MICROPHONE("Microphone"), NOTIFICATIONS("Notifications"), BATTERY_OPTIMIZATION("Battery Optimization"), OTHER("Other") diff --git a/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt b/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt index 692d95133..fee7aaad6 100644 --- a/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt +++ b/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt @@ -15,9 +15,7 @@ enum class MessageType(val value: UByte) { LEAVE(0x03u), NOISE_HANDSHAKE(0x10u), // Noise handshake NOISE_ENCRYPTED(0x11u), // Noise encrypted transport message - FRAGMENT(0x20u), // Fragmentation for large packets - REQUEST_SYNC(0x21u), // GCS-based sync request - FILE_TRANSFER(0x22u); // New: File transfer packet (BLE voice notes, etc.) + FRAGMENT(0x20u); // Fragmentation for large packets companion object { fun fromValue(value: UByte): MessageType? { @@ -34,15 +32,15 @@ object SpecialRecipients { } /** - * Binary packet format - 100% backward compatible with iOS version - * - * Header (13 bytes for v1, 15 bytes for v2): + * Binary packet format - 100% compatible with iOS version + * + * Header (Fixed 13 bytes): * - Version: 1 byte - * - Type: 1 byte + * - Type: 1 byte * - TTL: 1 byte * - Timestamp: 8 bytes (UInt64, big-endian) * - Flags: 1 byte (bit 0: hasRecipient, bit 1: hasSignature, bit 2: isCompressed) - * - PayloadLength: 2 bytes (v1) / 4 bytes (v2) (big-endian) + * - PayloadLength: 2 bytes (UInt16, big-endian) * * Variable sections: * - SenderID: 8 bytes (fixed) @@ -59,7 +57,8 @@ data class BitchatPacket( val timestamp: ULong, val payload: ByteArray, var signature: ByteArray? = null, // Changed from val to var for packet signing - var ttl: UByte + var ttl: UByte, + var route: List? = null // Optional source route: ordered list of peerIDs (8 bytes each), not including sender and final recipient ) : Parcelable { constructor( @@ -97,7 +96,8 @@ data class BitchatPacket( timestamp = timestamp, payload = payload, signature = null, // Remove signature for signing - ttl = 0u // Use fixed TTL=0 for signing to ensure relay compatibility + ttl = 0u, // Use fixed TTL=0 for signing to ensure relay compatibility + route = route ) return BinaryProtocol.encode(unsignedPacket) } @@ -149,6 +149,11 @@ data class BitchatPacket( if (!signature.contentEquals(other.signature)) return false } else if (other.signature != null) return false if (ttl != other.ttl) return false + if (route != null || other.route != null) { + val a = route?.map { it.toList() } ?: emptyList() + val b = other.route?.map { it.toList() } ?: emptyList() + if (a != b) return false + } return true } @@ -162,31 +167,25 @@ data class BitchatPacket( result = 31 * result + payload.contentHashCode() result = 31 * result + (signature?.contentHashCode() ?: 0) result = 31 * result + ttl.hashCode() + result = 31 * result + (route?.fold(1) { acc, bytes -> 31 * acc + bytes.contentHashCode() } ?: 0) return result } } /** - * Binary Protocol implementation - supports v1 and v2, backward compatible + * Binary Protocol implementation - exact same format as iOS version */ object BinaryProtocol { - private const val HEADER_SIZE_V1 = 13 - private const val HEADER_SIZE_V2 = 15 + private const val HEADER_SIZE = 13 private const val SENDER_ID_SIZE = 8 private const val RECIPIENT_ID_SIZE = 8 private const val SIGNATURE_SIZE = 64 - + object Flags { const val HAS_RECIPIENT: UByte = 0x01u const val HAS_SIGNATURE: UByte = 0x02u const val IS_COMPRESSED: UByte = 0x04u - } - - private fun getHeaderSize(version: UByte): Int { - return when (version) { - 1u.toUByte() -> HEADER_SIZE_V1 - else -> HEADER_SIZE_V2 // v2+ will use 4-byte payload length - } + const val HAS_ROUTE: UByte = 0x08u } fun encode(packet: BitchatPacket): ByteArray? { @@ -204,13 +203,7 @@ object BinaryProtocol { } } - // Compute a safe capacity for the unpadded frame - val headerSize = getHeaderSize(packet.version) - val recipientBytes = if (packet.recipientID != null) RECIPIENT_ID_SIZE else 0 - val signatureBytes = if (packet.signature != null) SIGNATURE_SIZE else 0 - val payloadBytes = payload.size + if (isCompressed) 2 else 0 - val capacity = headerSize + SENDER_ID_SIZE + recipientBytes + payloadBytes + signatureBytes + 16 // small slack - val buffer = ByteBuffer.allocate(capacity.coerceAtLeast(512)).apply { order(ByteOrder.BIG_ENDIAN) } + val buffer = ByteBuffer.allocate(4096).apply { order(ByteOrder.BIG_ENDIAN) } // Header buffer.put(packet.version.toByte()) @@ -231,15 +224,14 @@ object BinaryProtocol { if (isCompressed) { flags = flags or Flags.IS_COMPRESSED } + if (!packet.route.isNullOrEmpty()) { + flags = flags or Flags.HAS_ROUTE + } buffer.put(flags.toByte()) - // Payload length (2 or 4 bytes, big-endian) - includes original size if compressed + // Payload length (2 bytes, big-endian) - includes original size if compressed val payloadDataSize = payload.size + if (isCompressed) 2 else 0 - if (packet.version >= 2u.toUByte()) { - buffer.putInt(payloadDataSize) // 4 bytes for v2+ - } else { - buffer.putShort(payloadDataSize.toShort()) // 2 bytes for v1 - } + buffer.putShort(payloadDataSize.toShort()) // SenderID (exactly 8 bytes) val senderBytes = packet.senderID.take(SENDER_ID_SIZE).toByteArray() @@ -256,6 +248,14 @@ object BinaryProtocol { buffer.put(ByteArray(RECIPIENT_ID_SIZE - recipientBytes.size)) } } + + // Route (optional): 1 byte count + N*8 bytes + packet.route?.let { routeList -> + val cleaned = routeList.map { bytes -> bytes.take(SENDER_ID_SIZE).toByteArray().let { if (it.size < SENDER_ID_SIZE) it + ByteArray(SENDER_ID_SIZE - it.size) else it } } + val count = cleaned.size.coerceAtMost(255) + buffer.put(count.toByte()) + cleaned.take(count).forEach { hop -> buffer.put(hop) } + } // Payload (with original size prepended if compressed) if (isCompressed) { @@ -303,40 +303,44 @@ object BinaryProtocol { */ private fun decodeCore(raw: ByteArray): BitchatPacket? { try { - if (raw.size < HEADER_SIZE_V1 + SENDER_ID_SIZE) return null - + if (raw.size < HEADER_SIZE + SENDER_ID_SIZE) return null + val buffer = ByteBuffer.wrap(raw).apply { order(ByteOrder.BIG_ENDIAN) } - + // Header val version = buffer.get().toUByte() - if (version.toUInt() != 1u && version.toUInt() != 2u) return null // Support v1 and v2 - - val headerSize = getHeaderSize(version) - + if (version != 1u.toUByte()) return null + val type = buffer.get().toUByte() val ttl = buffer.get().toUByte() - + // Timestamp val timestamp = buffer.getLong().toULong() - + // Flags val flags = buffer.get().toUByte() val hasRecipient = (flags and Flags.HAS_RECIPIENT) != 0u.toUByte() val hasSignature = (flags and Flags.HAS_SIGNATURE) != 0u.toUByte() val isCompressed = (flags and Flags.IS_COMPRESSED) != 0u.toUByte() - - // Payload length - version-dependent (2 or 4 bytes) - val payloadLength = if (version >= 2u.toUByte()) { - buffer.getInt().toUInt() // 4 bytes for v2+ - } else { - buffer.getShort().toUShort().toUInt() // 2 bytes for v1, convert to UInt - } - + val hasRoute = (flags and Flags.HAS_ROUTE) != 0u.toUByte() + + // Payload length + val payloadLength = buffer.getShort().toUShort() + // Calculate expected total size - var expectedSize = headerSize + SENDER_ID_SIZE + payloadLength.toInt() + var expectedSize = HEADER_SIZE + SENDER_ID_SIZE + payloadLength.toInt() if (hasRecipient) expectedSize += RECIPIENT_ID_SIZE + var routeCount = 0 + if (hasRoute) { + // Peek count (1 byte) without consuming buffer for now + val mark = buffer.position() + if (raw.size >= mark + 1) { + routeCount = raw[mark].toUByte().toInt() + } + expectedSize += 1 + (routeCount * SENDER_ID_SIZE) + } if (hasSignature) expectedSize += SIGNATURE_SIZE - + if (raw.size < expectedSize) return null // SenderID @@ -350,6 +354,18 @@ object BinaryProtocol { recipientBytes } else null + // Route (optional) + val route: List? = if (hasRoute) { + val count = buffer.get().toUByte().toInt() + val hops = mutableListOf() + repeat(count) { + val hop = ByteArray(SENDER_ID_SIZE) + buffer.get(hop) + hops.add(hop) + } + hops + } else null + // Payload val payload = if (isCompressed) { // First 2 bytes are original size @@ -383,7 +399,8 @@ object BinaryProtocol { timestamp = timestamp, payload = payload, signature = signature, - ttl = ttl + ttl = ttl, + route = route ) } catch (e: Exception) { diff --git a/app/src/main/java/com/bitchat/android/services/MessageRouter.kt b/app/src/main/java/com/bitchat/android/services/MessageRouter.kt index 8166487e4..39119f7e1 100644 --- a/app/src/main/java/com/bitchat/android/services/MessageRouter.kt +++ b/app/src/main/java/com/bitchat/android/services/MessageRouter.kt @@ -114,7 +114,9 @@ class MessageRouter private constructor( fun sendFavoriteNotification(toPeerID: String, isFavorite: Boolean) { if (mesh.getPeerInfo(toPeerID)?.isConnected == true) { - val myNpub = try { com.bitchat.android.nostr.NostrIdentityBridge.getCurrentNostrIdentity(context)?.npub } catch (_: Exception) { null } + val myNpub = try { + com.bitchat.android.nostr.NostrIdentityBridge.getCurrentNostrIdentity(context)?.npub + } catch (_: Exception) { null } val content = if (isFavorite) "[FAVORITED]:${myNpub ?: ""}" else "[UNFAVORITED]:${myNpub ?: ""}" val nickname = mesh.getPeerNicknames()[toPeerID] ?: toPeerID mesh.sendPrivateMessage(content, toPeerID, nickname) diff --git a/app/src/main/java/com/bitchat/android/services/meshgraph/GossipTLV.kt b/app/src/main/java/com/bitchat/android/services/meshgraph/GossipTLV.kt new file mode 100644 index 000000000..85ea6c9c7 --- /dev/null +++ b/app/src/main/java/com/bitchat/android/services/meshgraph/GossipTLV.kt @@ -0,0 +1,77 @@ +package com.bitchat.android.services.meshgraph + +import android.util.Log + +/** + * Gossip TLV helpers for embedding direct neighbor peer IDs in ANNOUNCE payloads. + * Uses compact TLV: [type=0x04][len=1 byte][value=N*8 bytes of peerIDs] + */ +object GossipTLV { + // TLV type for a compact list of direct neighbor peerIDs (each 8 bytes) + const val DIRECT_NEIGHBORS_TYPE: UByte = 0x04u + + /** + * Encode up to 10 unique peerIDs (hex string up to 16 chars) as TLV value. + */ + fun encodeNeighbors(peerIDs: List): ByteArray { + val unique = peerIDs.distinct().take(10) + val valueBytes = unique.flatMap { id -> hexStringPeerIdTo8Bytes(id).toList() }.toByteArray() + if (valueBytes.size > 255) { + // Safety check, though 10*8 = 80 bytes, so well under 255 + Log.w("GossipTLV", "Neighbors value exceeds 255, truncating") + } + return byteArrayOf(DIRECT_NEIGHBORS_TYPE.toByte(), valueBytes.size.toByte()) + valueBytes + } + + /** + * Scan a TLV-encoded announce payload and extract neighbor peerIDs. + * Returns null if the TLV is not present at all; returns an empty list if present with length 0. + */ + fun decodeNeighborsFromAnnouncementPayload(payload: ByteArray): List? { + val result = mutableListOf() + var offset = 0 + while (offset + 2 <= payload.size) { + val type = payload[offset].toUByte() + val len = payload[offset + 1].toUByte().toInt() + offset += 2 + if (offset + len > payload.size) break + val value = payload.sliceArray(offset until offset + len) + offset += len + + if (type == DIRECT_NEIGHBORS_TYPE) { + // Value is N*8 bytes of peer IDs + var pos = 0 + while (pos + 8 <= value.size) { + val idBytes = value.sliceArray(pos until pos + 8) + result.add(bytesToPeerIdHex(idBytes)) + pos += 8 + } + return result // present (possibly empty) + } + } + // Not present + return null + } + + private fun hexStringPeerIdTo8Bytes(hexString: String): ByteArray { + val clean = hexString.lowercase().take(16) + val result = ByteArray(8) { 0 } + var idx = 0 + var out = 0 + while (idx + 1 < clean.length && out < 8) { + val byteStr = clean.substring(idx, idx + 2) + val b = byteStr.toIntOrNull(16)?.toByte() ?: 0 + result[out++] = b + idx += 2 + } + return result + } + + private fun bytesToPeerIdHex(bytes: ByteArray): String { + val sb = StringBuilder() + for (b in bytes.take(8)) { + sb.append(String.format("%02x", b)) + } + return sb.toString() + } +} diff --git a/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt b/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt new file mode 100644 index 000000000..ceb87a919 --- /dev/null +++ b/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt @@ -0,0 +1,102 @@ +package com.bitchat.android.services.meshgraph + +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import java.util.concurrent.ConcurrentHashMap + +/** + * Maintains an internal undirected graph of the mesh based on gossip. + * Nodes are peers (peerID), edges are direct connections. + */ +class MeshGraphService private constructor() { + data class GraphNode(val peerID: String, val nickname: String?) + data class GraphEdge(val a: String, val b: String) + data class GraphSnapshot(val nodes: List, val edges: List) + + // Map peerID -> nickname (may be null if unknown) + private val nicknames = ConcurrentHashMap() + // Adjacency (undirected): peerID -> set of neighbor peerIDs + private val adjacency = ConcurrentHashMap>() + // Latest announcement timestamp per peer (ULong from packet) + private val lastUpdate = ConcurrentHashMap() + + private val _graphState = MutableStateFlow(GraphSnapshot(emptyList(), emptyList())) + val graphState: StateFlow = _graphState.asStateFlow() + + /** + * Update graph from a verified announcement. + * Replaces previous neighbors for origin if this is newer (by timestamp). + */ + fun updateFromAnnouncement(originPeerID: String, originNickname: String?, neighborsOrNull: List?, timestamp: ULong) { + synchronized(this) { + // Always update nickname if provided + if (originNickname != null) nicknames[originPeerID] = originNickname + + // If no neighbors TLV present, do not modify edges or timestamps + if (neighborsOrNull == null) { + publishSnapshot() + return + } + + // Newer-only replacement per origin (based on TLV-bearing announcements only) + val prevTs = lastUpdate[originPeerID] + if (prevTs != null && prevTs >= timestamp) { + // Older or equal TLV-bearing update: ignore + return + } + lastUpdate[originPeerID] = timestamp + + // Remove old symmetric edges contributed by this origin + val prevNeighbors = adjacency[originPeerID]?.toSet().orEmpty() + prevNeighbors.forEach { n -> + adjacency[n]?.remove(originPeerID) + } + + // Replace origin's adjacency with new set (may be empty) + val newSet = neighborsOrNull.distinct().take(10).filter { it != originPeerID }.toMutableSet() + adjacency[originPeerID] = newSet + // Ensure undirected edges + newSet.forEach { n -> + adjacency.putIfAbsent(n, mutableSetOf()) + adjacency[n]?.add(originPeerID) + } + + publishSnapshot() + } + } + + fun updateNickname(peerID: String, nickname: String?) { + if (nickname == null) return + nicknames[peerID] = nickname + publishSnapshot() + } + + private fun publishSnapshot() { + val nodes = mutableSetOf() + adjacency.forEach { (a, neighbors) -> + nodes.add(a) + nodes.addAll(neighbors) + } + // Merge in nicknames-only nodes + nodes.addAll(nicknames.keys) + + val nodeList = nodes.map { GraphNode(it, nicknames[it]) }.sortedBy { it.peerID } + val edgeSet = mutableSetOf>() + adjacency.forEach { (a, ns) -> + ns.forEach { b -> + val (x, y) = if (a <= b) a to b else b to a + edgeSet.add(x to y) + } + } + val edges = edgeSet.map { GraphEdge(it.first, it.second) }.sortedWith(compareBy({ it.a }, { it.b })) + _graphState.value = GraphSnapshot(nodeList, edges) + } + + companion object { + @Volatile private var INSTANCE: MeshGraphService? = null + fun getInstance(): MeshGraphService = INSTANCE ?: synchronized(this) { + INSTANCE ?: MeshGraphService().also { INSTANCE = it } + } + } +} diff --git a/app/src/main/java/com/bitchat/android/services/meshgraph/RoutePlanner.kt b/app/src/main/java/com/bitchat/android/services/meshgraph/RoutePlanner.kt new file mode 100644 index 000000000..ae2794054 --- /dev/null +++ b/app/src/main/java/com/bitchat/android/services/meshgraph/RoutePlanner.kt @@ -0,0 +1,66 @@ +package com.bitchat.android.services.meshgraph + +import android.util.Log +import java.util.PriorityQueue + +/** + * Computes shortest paths on the current mesh graph snapshot using Dijkstra. + * Assumes unit edge weights. + */ +object RoutePlanner { + private const val TAG = "RoutePlanner" + + /** + * Return full path [src, ..., dst] if reachable, else null. + */ + fun shortestPath(src: String, dst: String): List? { + if (src == dst) return listOf(src) + val snapshot = MeshGraphService.getInstance().graphState.value + val neighbors = mutableMapOf>() + snapshot.edges.forEach { e -> + neighbors.getOrPut(e.a) { mutableSetOf() }.add(e.b) + neighbors.getOrPut(e.b) { mutableSetOf() }.add(e.a) + } + // Ensure nodes known even if isolated + snapshot.nodes.forEach { n -> neighbors.putIfAbsent(n.peerID, mutableSetOf()) } + + if (!neighbors.containsKey(src) || !neighbors.containsKey(dst)) return null + + val dist = mutableMapOf() + val prev = mutableMapOf() + val pq = PriorityQueue>(compareBy { it.second }) + + neighbors.keys.forEach { v -> + dist[v] = if (v == src) 0 else Int.MAX_VALUE + prev[v] = null + } + pq.add(src to 0) + + while (pq.isNotEmpty()) { + val (u, d) = pq.poll() + if (d > (dist[u] ?: Int.MAX_VALUE)) continue + if (u == dst) break + neighbors[u]?.forEach { v -> + val alt = d + 1 + if (alt < (dist[v] ?: Int.MAX_VALUE)) { + dist[v] = alt + prev[v] = u + pq.add(v to alt) + } + } + } + + if ((dist[dst] ?: Int.MAX_VALUE) == Int.MAX_VALUE) return null + + val path = mutableListOf() + var cur: String? = dst + while (cur != null) { + path.add(cur) + cur = prev[cur] + } + path.reverse() + Log.d(TAG, "Computed path $path") + return path + } +} + diff --git a/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt b/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt deleted file mode 100644 index 3cc64c583..000000000 --- a/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt +++ /dev/null @@ -1,191 +0,0 @@ -package com.bitchat.android.sync - -import java.security.MessageDigest -import kotlin.math.ceil -import kotlin.math.ln - -/** - * Golomb-Coded Set (GCS) filter implementation for sync. - * - * Hashing: - * - h64(id) = first 8 bytes of SHA-256 over the 16-byte PacketId (big-endian unsigned) - * - Map to range [0, M) via (h64 % M) - * - * Encoding (v1): - * - Sort mapped values ascending; encode deltas (first is v0, then vi - v{i-1}) as positive integers - * - For each delta x >= 1, write Golomb-Rice code with parameter P: - * q = (x - 1) >> P (unary q ones followed by a zero), then P low bits r = (x - 1) & ((1<= 1) - val m: Long, // Range M = N * 2^P - val data: ByteArray // Encoded GR bitstream - ) - - // Derive P from target FPR; FPR ~= 1 / 2^P - fun deriveP(targetFpr: Double): Int { - val f = targetFpr.coerceIn(0.000001, 0.25) - return ceil(ln(1.0 / f) / ln(2.0)).toInt().coerceAtLeast(1) - } - - // Rough capacity estimate: expected bits per element ~= P + 2 (quotient unary ~ around 2 bits) - fun estimateMaxElementsForSize(bytes: Int, p: Int): Int { - val bits = (bytes * 8).coerceAtLeast(8) - val per = (p + 2).coerceAtLeast(3) - return (bits / per).coerceAtLeast(1) - } - - fun buildFilter( - ids: List, // 16-byte PacketId bytes - maxBytes: Int, - targetFpr: Double - ): Params { - val p = deriveP(targetFpr) - var nCap = estimateMaxElementsForSize(maxBytes, p) - val n = ids.size.coerceAtMost(nCap) - val selected = ids.take(n) - // Map to [0, M) - val m = (n.toLong() shl p) - val mapped = selected.map { id -> (h64(id) % m) }.sorted() - var encoded = encode(mapped, p) - // If estimate was too optimistic, trim until it fits - var trimmedN = n - while (encoded.size > maxBytes && trimmedN > 0) { - trimmedN = (trimmedN * 9) / 10 // drop 10% - val mapped2 = mapped.take(trimmedN) - encoded = encode(mapped2, p) - } - val finalM = (trimmedN.toLong() shl p) - return Params(p = p, m = finalM, data = encoded) - } - - fun decodeToSortedSet(p: Int, m: Long, data: ByteArray): LongArray { - val values = ArrayList() - val reader = BitReader(data) - var acc = 0L - val mask = (1L shl p) - 1L - while (!reader.eof()) { - // Read unary quotient (q ones terminated by zero) - var q = 0L - while (true) { - val b = reader.readBit() ?: break - if (b == 1) q++ else break - } - if (reader.lastWasEOF) break - // Read remainder - val r = reader.readBits(p) ?: break - val x = (q shl p) + r + 1 - acc += x - if (acc >= m) break // out of range safeguard - values.add(acc) - } - return values.toLongArray() - } - - fun contains(sortedValues: LongArray, candidate: Long): Boolean { - var lo = 0 - var hi = sortedValues.size - 1 - while (lo <= hi) { - val mid = (lo + hi) ushr 1 - val v = sortedValues[mid] - if (v == candidate) return true - if (v < candidate) lo = mid + 1 else hi = mid - 1 - } - return false - } - - private fun h64(id16: ByteArray): Long { - val md = MessageDigest.getInstance("SHA-256") - md.update(id16) - val d = md.digest() - var x = 0L - for (i in 0 until 8) { - x = (x shl 8) or ((d[i].toLong() and 0xFF)) - } - return x and 0x7fff_ffff_ffff_ffffL // positive - } - - private fun encode(sorted: List, p: Int): ByteArray { - val bw = BitWriter() - var prev = 0L - val mask = (1L shl p) - 1L - for (v in sorted) { - val delta = v - prev - prev = v - val x = delta - val q = (x - 1) ushr p - val r = (x - 1) and mask - // unary q ones then a zero - repeat(q.toInt()) { bw.writeBit(1) } - bw.writeBit(0) - // then P bits of r (MSB-first) - bw.writeBits(r, p) - } - return bw.toByteArray() - } - - // Simple MSB-first bit writer - private class BitWriter { - private val buf = ArrayList() - private var cur = 0 - private var nbits = 0 - fun writeBit(bit: Int) { - cur = (cur shl 1) or (bit and 1) - nbits++ - if (nbits == 8) { - buf.add(cur.toByte()) - cur = 0; nbits = 0 - } - } - fun writeBits(value: Long, count: Int) { - if (count <= 0) return - for (i in count - 1 downTo 0) { - val bit = ((value ushr i) and 1L).toInt() - writeBit(bit) - } - } - fun toByteArray(): ByteArray { - if (nbits > 0) { - val rem = cur shl (8 - nbits) - buf.add(rem.toByte()) - cur = 0; nbits = 0 - } - return buf.toByteArray() - } - } - - // Simple MSB-first bit reader - private class BitReader(private val data: ByteArray) { - private var i = 0 - private var nleft = 8 - private var cur = if (data.isNotEmpty()) (data[0].toInt() and 0xFF) else 0 - var lastWasEOF: Boolean = false - private set - fun eof() = i >= data.size - fun readBit(): Int? { - if (i >= data.size) { lastWasEOF = true; return null } - val bit = (cur ushr 7) and 1 - cur = (cur shl 1) and 0xFF - nleft-- - if (nleft == 0) { - i++ - if (i < data.size) { - cur = data[i].toInt() and 0xFF - nleft = 8 - } - } - return bit - } - fun readBits(count: Int): Long? { - var v = 0L - for (k in 0 until count) { - val b = readBit() ?: return null - v = (v shl 1) or b.toLong() - } - return v - } - } -} - diff --git a/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt b/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt deleted file mode 100644 index 38d23a917..000000000 --- a/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt +++ /dev/null @@ -1,263 +0,0 @@ -package com.bitchat.android.sync - -import android.util.Log -import com.bitchat.android.mesh.BluetoothPacketBroadcaster -import com.bitchat.android.model.RequestSyncPacket -import com.bitchat.android.protocol.BitchatPacket -import com.bitchat.android.protocol.MessageType -import com.bitchat.android.protocol.SpecialRecipients -import kotlinx.coroutines.* -import java.util.concurrent.ConcurrentHashMap - -/** - * Gossip-based synchronization manager using on-demand GCS filters. - * Tracks seen public packets (ANNOUNCE, broadcast MESSAGE) and periodically requests sync - * from neighbors. Responds to REQUEST_SYNC by sending missing packets. - */ -class GossipSyncManager( - private val myPeerID: String, - private val scope: CoroutineScope, - private val configProvider: ConfigProvider -) { - interface Delegate { - fun sendPacket(packet: BitchatPacket) - fun sendPacketToPeer(peerID: String, packet: BitchatPacket) - fun signPacketForBroadcast(packet: BitchatPacket): BitchatPacket - } - - interface ConfigProvider { - fun seenCapacity(): Int // max packets we sync per request (cap across types) - fun gcsMaxBytes(): Int - fun gcsTargetFpr(): Double // percent -> 0.0..1.0 - } - - companion object { private const val TAG = "GossipSyncManager" } - - var delegate: Delegate? = null - - // Defaults (configurable constants) - private val defaultMaxBytes = SyncDefaults.DEFAULT_FILTER_BYTES - private val defaultFpr = SyncDefaults.DEFAULT_FPR_PERCENT - - // Stored packets for sync: - // - broadcast messages: keep up to seenCapacity() most recent, keyed by packetId - private val messages = LinkedHashMap() - // - announcements: only keep latest per sender peerID - private val latestAnnouncementByPeer = ConcurrentHashMap>() - - private var periodicJob: Job? = null - fun start() { - periodicJob?.cancel() - periodicJob = scope.launch(Dispatchers.IO) { - while (isActive) { - try { - delay(30_000) - sendRequestSync() - } catch (e: CancellationException) { throw e } - catch (e: Exception) { Log.e(TAG, "Periodic sync error: ${e.message}") } - } - } - } - - fun stop() { - periodicJob?.cancel(); periodicJob = null - } - - fun scheduleInitialSync(delayMs: Long = 5_000L) { - scope.launch(Dispatchers.IO) { - delay(delayMs) - sendRequestSync() - } - } - - fun scheduleInitialSyncToPeer(peerID: String, delayMs: Long = 5_000L) { - scope.launch(Dispatchers.IO) { - delay(delayMs) - sendRequestSyncToPeer(peerID) - } - } - - fun onPublicPacketSeen(packet: BitchatPacket) { - // Only ANNOUNCE or broadcast MESSAGE - val mt = MessageType.fromValue(packet.type) - val isBroadcastMessage = (mt == MessageType.MESSAGE && (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST))) - val isAnnouncement = (mt == MessageType.ANNOUNCE) - if (!isBroadcastMessage && !isAnnouncement) return - - val idBytes = PacketIdUtil.computeIdBytes(packet) - val id = idBytes.joinToString("") { b -> "%02x".format(b) } - - if (isBroadcastMessage) { - synchronized(messages) { - messages[id] = packet - // Enforce capacity (remove oldest when exceeded) - val cap = configProvider.seenCapacity().coerceAtLeast(1) - while (messages.size > cap) { - val it = messages.entries.iterator() - if (it.hasNext()) { it.next(); it.remove() } else break - } - } - } else if (isAnnouncement) { - // senderID is fixed-size 8 bytes; map to hex string for key - val sender = packet.senderID.joinToString("") { b -> "%02x".format(b) } - latestAnnouncementByPeer[sender] = id to packet - // Enforce capacity (remove oldest when exceeded) - val cap = configProvider.seenCapacity().coerceAtLeast(1) - while (latestAnnouncementByPeer.size > cap) { - val it = latestAnnouncementByPeer.entries.iterator() - if (it.hasNext()) { it.next(); it.remove() } else break - } - } - } - - private fun sendRequestSync() { - val payload = buildGcsPayload() - - val packet = BitchatPacket( - type = MessageType.REQUEST_SYNC.value, - senderID = hexStringToByteArray(myPeerID), - timestamp = System.currentTimeMillis().toULong(), - payload = payload, - ttl = 0u // neighbors only - ) - // Sign and broadcast - val signed = delegate?.signPacketForBroadcast(packet) ?: packet - delegate?.sendPacket(signed) - } - - private fun sendRequestSyncToPeer(peerID: String) { - val payload = buildGcsPayload() - - val packet = BitchatPacket( - type = MessageType.REQUEST_SYNC.value, - senderID = hexStringToByteArray(myPeerID), - recipientID = hexStringToByteArray(peerID), - timestamp = System.currentTimeMillis().toULong(), - payload = payload, - ttl = 0u // neighbor only - ) - Log.d(TAG, "Sending sync request to $peerID (${payload.size} bytes)") - // Sign and send directly to peer - val signed = delegate?.signPacketForBroadcast(packet) ?: packet - delegate?.sendPacketToPeer(peerID, signed) - } - - fun handleRequestSync(fromPeerID: String, request: RequestSyncPacket) { - // Decode GCS into sorted set for membership checks - val sorted = GCSFilter.decodeToSortedSet(request.p, request.m, request.data) - fun mightContain(id: ByteArray): Boolean { - val v = (GCSFilter.run { - // reuse hashing method from GCSFilter - val md = java.security.MessageDigest.getInstance("SHA-256"); - md.update(id); val d = md.digest(); - var x = 0L; for (i in 0 until 8) { x = (x shl 8) or (d[i].toLong() and 0xFF) } - (x and 0x7fff_ffff_ffff_ffffL) % request.m - }) - return GCSFilter.contains(sorted, v) - } - - // 1) Announcements: send latest per peerID if remote doesn't have them - for ((_, pair) in latestAnnouncementByPeer.entries) { - val (id, pkt) = pair - val idBytes = hexToBytes(id) - if (!mightContain(idBytes)) { - // Send original packet unchanged to requester only (keep local TTL) - val toSend = pkt.copy(ttl = 0u) - delegate?.sendPacketToPeer(fromPeerID, toSend) - Log.d(TAG, "Sent sync announce: Type ${toSend.type} from ${toSend.senderID.toHexString()} to $fromPeerID packet id ${idBytes.toHexString()}") - } - } - - // 2) Broadcast messages: send all they lack - val toSendMsgs = synchronized(messages) { messages.values.toList() } - for (pkt in toSendMsgs) { - val idBytes = PacketIdUtil.computeIdBytes(pkt) - if (!mightContain(idBytes)) { - val toSend = pkt.copy(ttl = 0u) - delegate?.sendPacketToPeer(fromPeerID, toSend) - Log.d(TAG, "Sent sync message: Type ${toSend.type} to $fromPeerID packet id ${idBytes.toHexString()}") - } - } - } - - private fun hexStringToByteArray(hexString: String): ByteArray { - val result = ByteArray(8) { 0 } - var tempID = hexString - var index = 0 - while (tempID.length >= 2 && index < 8) { - val hexByte = tempID.substring(0, 2) - val byte = hexByte.toIntOrNull(16)?.toByte() - if (byte != null) result[index] = byte - tempID = tempID.substring(2) - index++ - } - return result - } - - private fun hexToBytes(hex: String): ByteArray { - val clean = if (hex.length % 2 == 0) hex else "0$hex" - val out = ByteArray(clean.length / 2) - var i = 0 - while (i < clean.length) { - out[i/2] = clean.substring(i, i+2).toInt(16).toByte() - i += 2 - } - return out - } - - private fun buildGcsPayload(): ByteArray { - // Collect candidates: latest announcement per peer + recent broadcast messages - val list = ArrayList() - // announcements - for ((_, pair) in latestAnnouncementByPeer) { - list.add(pair.second) - } - // messages - synchronized(messages) { - list.addAll(messages.values) - } - // sort by timestamp desc, then take up to min(seenCapacity, fit capacity) - list.sortByDescending { it.timestamp.toLong() } - - val maxBytes = try { configProvider.gcsMaxBytes() } catch (_: Exception) { defaultMaxBytes } - val fpr = try { configProvider.gcsTargetFpr() } catch (_: Exception) { defaultFpr } - val p = GCSFilter.deriveP(fpr) - val nMax = GCSFilter.estimateMaxElementsForSize(maxBytes, p) - val cap = configProvider.seenCapacity().coerceAtLeast(1) - val takeN = minOf(nMax, cap, list.size) - if (takeN <= 0) { - val p0 = GCSFilter.deriveP(fpr) - return RequestSyncPacket(p = p0, m = 1, data = ByteArray(0)).encode() - } - val ids = list.take(takeN).map { pkt -> PacketIdUtil.computeIdBytes(pkt) } - val params = GCSFilter.buildFilter(ids, maxBytes, fpr) - val mVal = if (params.m <= 0L) 1 else params.m - return RequestSyncPacket(p = params.p, m = mVal, data = params.data).encode() - } - - // Explicitly remove stored announcement for a given peer (hex ID) - fun removeAnnouncementForPeer(peerID: String) { - val key = peerID.lowercase() - if (latestAnnouncementByPeer.remove(key) != null) { - Log.d(TAG, "Removed stored announcement for peer $peerID") - } - - // Collect IDs to remove first to avoid modifying collection while iterating - val idsToRemove = mutableListOf() - for ((id, message) in messages) { - val sender = message.senderID.joinToString("") { b -> "%02x".format(b) } - if (sender == key) { - idsToRemove.add(id) - } - } - - // Now remove the collected IDs - for (id in idsToRemove) { - messages.remove(id) - } - - if (idsToRemove.isNotEmpty()) { - Log.d(TAG, "Pruned ${idsToRemove.size} messages with senders without announcements") - } - } -} diff --git a/app/src/main/java/com/bitchat/android/sync/PacketIdUtil.kt b/app/src/main/java/com/bitchat/android/sync/PacketIdUtil.kt deleted file mode 100644 index 4396ff5a5..000000000 --- a/app/src/main/java/com/bitchat/android/sync/PacketIdUtil.kt +++ /dev/null @@ -1,31 +0,0 @@ -package com.bitchat.android.sync - -import com.bitchat.android.protocol.BitchatPacket -import java.security.MessageDigest - -/** - * Deterministic packet ID helper for sync purposes. - * Uses SHA-256 over a canonical subset of packet fields: - * [type | senderID | timestamp | payload] to generate a stable ID. - * Returns a 16-byte (128-bit) truncated hash for compactness. - */ -object PacketIdUtil { - fun computeIdBytes(packet: BitchatPacket): ByteArray { - val md = MessageDigest.getInstance("SHA-256") - md.update(packet.type.toByte()) - md.update(packet.senderID) - // Timestamp as 8 bytes big-endian - val ts = packet.timestamp.toLong() - for (i in 7 downTo 0) { - md.update(((ts ushr (i * 8)) and 0xFF).toByte()) - } - md.update(packet.payload) - val digest = md.digest() - return digest.copyOf(16) // 128-bit ID - } - - fun computeIdHex(packet: BitchatPacket): String { - return computeIdBytes(packet).joinToString("") { b -> "%02x".format(b) } - } -} - diff --git a/app/src/main/java/com/bitchat/android/sync/SyncDefaults.kt b/app/src/main/java/com/bitchat/android/sync/SyncDefaults.kt deleted file mode 100644 index 970c8afb8..000000000 --- a/app/src/main/java/com/bitchat/android/sync/SyncDefaults.kt +++ /dev/null @@ -1,11 +0,0 @@ -package com.bitchat.android.sync - -object SyncDefaults { - // Default values used when debug prefs are unavailable - const val DEFAULT_FILTER_BYTES: Int = 256 - const val DEFAULT_FPR_PERCENT: Double = 1.0 - - // Receiver-side hard cap to avoid DoS (also enforced in RequestSyncPacket) - const val MAX_ACCEPT_FILTER_BYTES: Int = 1024 -} - 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 bce3ef1c2..3caccf322 100644 --- a/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt +++ b/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt @@ -1,11 +1,7 @@ package com.bitchat.android.ui -import androidx.compose.animation.core.animateFloatAsState -import androidx.compose.foundation.background import androidx.compose.foundation.layout.* import androidx.compose.foundation.lazy.LazyColumn -import androidx.compose.foundation.lazy.rememberLazyListState -import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Bluetooth @@ -20,7 +16,6 @@ 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 import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.BaselineShift @@ -56,194 +51,110 @@ fun AboutSheet( // Bottom sheet state val sheetState = rememberModalBottomSheetState( - skipPartiallyExpanded = true + skipPartiallyExpanded = false ) - - val lazyListState = rememberLazyListState() - val isScrolled by remember { - derivedStateOf { - lazyListState.firstVisibleItemIndex > 0 || lazyListState.firstVisibleItemScrollOffset > 0 - } - } - val topBarAlpha by animateFloatAsState( - targetValue = if (isScrolled) 0.95f 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 + val standardBlue = Color(0xFF007AFF) // iOS blue + val standardGreen = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D) // iOS green if (isPresented) { ModalBottomSheet( - modifier = modifier.statusBarsPadding(), onDismissRequest = onDismiss, sheetState = sheetState, - containerColor = MaterialTheme.colorScheme.background, - dragHandle = null + modifier = modifier ) { - Box(modifier = Modifier.fillMaxWidth()) { - LazyColumn( - state = lazyListState, - modifier = Modifier.fillMaxSize(), - contentPadding = PaddingValues(top = 80.dp, bottom = 20.dp) - ) { - // Header Section - item(key = "header") { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - .padding(bottom = 16.dp), - verticalArrangement = Arrangement.spacedBy(8.dp) + LazyColumn( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp) + .padding(bottom = 24.dp), + verticalArrangement = Arrangement.spacedBy(16.dp) + ) { + // Header + item { + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + Row( + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.Bottom ) { - Row( - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.Bottom - ) { - Text( - text = "bitchat", - style = TextStyle( - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - fontSize = 32.sp - ), - color = MaterialTheme.colorScheme.onBackground - ) - - Text( - text = "v$versionName", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onBackground.copy(alpha = 0.5f), - style = MaterialTheme.typography.bodySmall.copy( - baselineShift = BaselineShift(0.1f) - ) - ) - } - Text( - text = "decentralized mesh messaging with end-to-end encryption", - fontSize = 12.sp, + text = "bitchat", + fontSize = 18.sp, fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f) + fontWeight = FontWeight.Medium, + color = colorScheme.onSurface ) - } - } - - // 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 = "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 = "Offline Mesh Chat", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = MaterialTheme.colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "Communicate directly via Bluetooth LE without internet or servers. Messages relay through nearby devices to extend range.", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f) + + Text( + text = "v$versionName", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.5f), + style = MaterialTheme.typography.bodySmall.copy( + baselineShift = BaselineShift(0.1f) ) - } - } - } - item(key = "feature_geohash") { - Row( - verticalAlignment = Alignment.Top, - modifier = Modifier - .padding(horizontal = 24.dp) - .padding(vertical = 8.dp) - ) { - Icon( - imageVector = Icons.Default.Public, - contentDescription = "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 = "Online Geohash Channels", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = MaterialTheme.colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "Connect with people in your area using geohash-based channels. Extend the mesh using public internet relays.", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f) - ) - } } + + Text( + text = "decentralized mesh messaging with end-to-end encryption", + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.7f) + ) } - item(key = "feature_encryption") { - Row( - verticalAlignment = Alignment.Top, - modifier = Modifier - .padding(horizontal = 24.dp) - .padding(vertical = 8.dp) - ) { - Icon( - imageVector = Icons.Default.Lock, - contentDescription = "End-to-End Encryption", - tint = MaterialTheme.colorScheme.primary, - modifier = Modifier - .padding(top = 2.dp) - .size(20.dp) - ) - Spacer(modifier = Modifier.width(16.dp)) - Column { - Text( - text = "End-to-End Encryption", - style = MaterialTheme.typography.titleMedium, - fontWeight = FontWeight.Medium, - color = MaterialTheme.colorScheme.onBackground - ) - Spacer(modifier = Modifier.height(4.dp)) - Text( - text = "Private messages are encrypted. Channel messages are public.", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.8f) - ) - } - } + } + + // Features section + item { + Column(verticalArrangement = Arrangement.spacedBy(12.dp)) { + FeatureCard( + icon = Icons.Filled.Bluetooth, + iconColor = standardBlue, + title = "offline mesh chat", + description = "communicate directly via bluetooth le without internet or servers. messages relay through nearby devices to extend range.", + modifier = Modifier.fillMaxWidth() + ) + + FeatureCard( + icon = Icons.Filled.Public, + iconColor = standardGreen, + title = "online geohash channels", + description = "connect with people in your area using geohash-based channels. extend the mesh using public internet relays.", + modifier = Modifier.fillMaxWidth() + ) + + FeatureCard( + icon = Icons.Filled.Lock, + iconColor = if (isDark) Color(0xFFFFD60A) else Color(0xFFF5A623), + title = "end-to-end encryption", + description = "private messages are encrypted. channel messages are public.", + modifier = Modifier.fillMaxWidth() + ) } + } - // Appearance Section - item(key = "appearance_section") { + // Appearance section (theme toggle) + item { + val themePref by com.bitchat.android.ui.theme.ThemePreferenceManager.themeFlow.collectAsState() + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { Text( text = "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) + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Medium, + color = colorScheme.onSurface.copy(alpha = 0.8f) ) - val themePref by com.bitchat.android.ui.theme.ThemePreferenceManager.themeFlow.collectAsState() - Row( - modifier = Modifier.padding(horizontal = 24.dp), - horizontalArrangement = Arrangement.spacedBy(8.dp) - ) { + Row(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) }, @@ -261,181 +172,94 @@ fun AboutSheet( ) } } - // Proof of Work Section - item(key = "pow_section") { + } + + // Proof of Work section + item { + val context = LocalContext.current + + // Initialize PoW preferences if not already done + LaunchedEffect(Unit) { + PoWPreferenceManager.init(context) + } + + val powEnabled by PoWPreferenceManager.powEnabled.collectAsState() + val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState() + + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { Text( text = "proof of work", - 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) + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Medium, + color = colorScheme.onSurface.copy(alpha = 0.8f) ) - LaunchedEffect(Unit) { - PoWPreferenceManager.init(context) - } - - val powEnabled by PoWPreferenceManager.powEnabled.collectAsState() - val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState() - - Column( - modifier = Modifier.padding(horizontal = 24.dp), - verticalArrangement = Arrangement.spacedBy(8.dp) + + Row( + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically ) { - Row( - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.CenterVertically - ) { - FilterChip( - selected = !powEnabled, - onClick = { PoWPreferenceManager.setPowEnabled(false) }, - label = { Text("pow off", fontFamily = FontFamily.Monospace) } - ) - FilterChip( - selected = powEnabled, - onClick = { PoWPreferenceManager.setPowEnabled(true) }, - label = { - Row( - horizontalArrangement = Arrangement.spacedBy(6.dp), - verticalAlignment = Alignment.CenterVertically - ) { - Text("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)) } - } - } - } - ) - } - - Text( - text = "add proof of work to geohash messages for spam deterrence.", - fontSize = 10.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface.copy(alpha = 0.6f) + FilterChip( + selected = !powEnabled, + onClick = { PoWPreferenceManager.setPowEnabled(false) }, + label = { Text("pow off", fontFamily = FontFamily.Monospace) } ) - - // Show difficulty slider when enabled - if (powEnabled) { - Column( - modifier = Modifier.fillMaxWidth(), - verticalArrangement = Arrangement.spacedBy(8.dp) - ) { - Text( - text = "difficulty: $powDifficulty bits (~${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) + FilterChip( + selected = powEnabled, + onClick = { PoWPreferenceManager.setPowEnabled(true) }, + label = { + Row( + horizontalArrangement = Arrangement.spacedBy(6.dp), + verticalAlignment = Alignment.CenterVertically ) { - Column( - modifier = Modifier.padding(12.dp), - verticalArrangement = Arrangement.spacedBy(4.dp) - ) { - Text( - text = "difficulty $powDifficulty requires ~${NostrProofOfWork.estimateWork(powDifficulty)} hash attempts", - fontSize = 10.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface.copy(alpha = 0.7f) - ) - Text( - text = when { - powDifficulty == 0 -> "no proof of work required" - powDifficulty <= 8 -> "very low - minimal spam protection" - powDifficulty <= 12 -> "low - basic spam protection" - powDifficulty <= 16 -> "medium - good spam protection" - powDifficulty <= 20 -> "high - strong spam protection" - powDifficulty <= 24 -> "very high - may cause delays" - else -> "extreme - significant computation required" - }, - fontSize = 10.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface.copy(alpha = 0.6f) - ) + Text("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)) } } } } - } + ) } - } - - // Network (Tor) section - item(key = "network_section") { - val torMode = remember { mutableStateOf(com.bitchat.android.net.TorPreferenceManager.get(context)) } - val torStatus by com.bitchat.android.net.TorManager.statusFlow.collectAsState() + Text( - text = "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) + text = "add proof of work to geohash messages for spam deterrence.", + fontSize = 10.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.6f) ) - Column(modifier = Modifier.padding(horizontal = 24.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - Row( - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.CenterVertically + + // Show difficulty slider when enabled + if (powEnabled) { + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp) ) { - FilterChip( - selected = torMode.value == com.bitchat.android.net.TorMode.OFF, - onClick = { - torMode.value = com.bitchat.android.net.TorMode.OFF - com.bitchat.android.net.TorPreferenceManager.set(context, torMode.value) - }, - label = { Text("tor off", fontFamily = FontFamily.Monospace) } + Text( + text = "difficulty: $powDifficulty bits (~${NostrProofOfWork.estimateMiningTime(powDifficulty)})", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.7f) ) - FilterChip( - selected = torMode.value == com.bitchat.android.net.TorMode.ON, - onClick = { - torMode.value = com.bitchat.android.net.TorMode.ON - com.bitchat.android.net.TorPreferenceManager.set(context, torMode.value) - }, - label = { - Row( - horizontalArrangement = Arrangement.spacedBy(6.dp), - verticalAlignment = Alignment.CenterVertically - ) { - 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 - } - Surface(color = statusColor, shape = CircleShape) { - Box(Modifier.size(8.dp)) - } - } - } + + Slider( + value = powDifficulty.toFloat(), + onValueChange = { PoWPreferenceManager.setPowDifficulty(it.toInt()) }, + valueRange = 0f..32f, + steps = 33, // 33 discrete values (0-32) + colors = SliderDefaults.colors( + thumbColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D), + activeTrackColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D) + ) ) - } - Text( - text = "route internet over tor for enhanced privacy.", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) - ) - if (torMode.value == com.bitchat.android.net.TorMode.ON) { - val statusText = if (torStatus.running) "Running" else "Stopped" - // Debug status (temporary) + + // Show difficulty description Surface( modifier = Modifier.fillMaxWidth(), color = colorScheme.surfaceVariant.copy(alpha = 0.25f), @@ -443,124 +267,204 @@ fun AboutSheet( ) { Column( modifier = Modifier.padding(12.dp), - verticalArrangement = Arrangement.spacedBy(6.dp) + verticalArrangement = Arrangement.spacedBy(4.dp) ) { Text( - text = "tor Status: $statusText, bootstrap ${torStatus.bootstrapPercent}%", - style = MaterialTheme.typography.bodySmall, - color = colorScheme.onSurface.copy(alpha = 0.75f) + text = "difficulty $powDifficulty requires ~${NostrProofOfWork.estimateWork(powDifficulty)} hash attempts", + fontSize = 10.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.7f) + ) + Text( + text = when { + powDifficulty == 0 -> "no proof of work required" + powDifficulty <= 8 -> "very low - minimal spam protection" + powDifficulty <= 12 -> "low - basic spam protection" + powDifficulty <= 16 -> "medium - good spam protection" + powDifficulty <= 20 -> "high - strong spam protection" + powDifficulty <= 24 -> "very high - may cause delays" + else -> "extreme - significant computation required" + }, + fontSize = 10.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.6f) ) - val lastLog = torStatus.lastLogLine - if (lastLog.isNotEmpty()) { - Text( - text = "Last: ${lastLog.take(160)}", - style = MaterialTheme.typography.labelSmall, - color = colorScheme.onSurface.copy(alpha = 0.6f) - ) - } } } } } } + } - // Emergency Warning Section - item(key = "warning_section") { - val colorScheme = MaterialTheme.colorScheme - val errorColor = colorScheme.error + // Network (Tor) section + item { + val ctx = LocalContext.current + val torMode = remember { mutableStateOf(com.bitchat.android.net.TorPreferenceManager.get(ctx)) } + val torStatus by com.bitchat.android.net.TorManager.statusFlow.collectAsState() + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + Text( + text = "network", + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Medium, + color = colorScheme.onSurface.copy(alpha = 0.8f) + ) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + FilterChip( + selected = torMode.value == com.bitchat.android.net.TorMode.OFF, + onClick = { + torMode.value = com.bitchat.android.net.TorMode.OFF + com.bitchat.android.net.TorPreferenceManager.set(ctx, torMode.value) + }, + label = { Text("tor off", fontFamily = FontFamily.Monospace) } + ) + FilterChip( + selected = torMode.value == com.bitchat.android.net.TorMode.ON, + onClick = { + torMode.value = com.bitchat.android.net.TorMode.ON + com.bitchat.android.net.TorPreferenceManager.set(ctx, torMode.value) + }, + label = { + Row( + horizontalArrangement = Arrangement.spacedBy(6.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Text("tor on", fontFamily = FontFamily.Monospace) + // Status indicator (red/orange/green) moved inside the "tor on" button + 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 + } + Surface( + color = statusColor, + shape = RoundedCornerShape(50) + ) { Box(Modifier.size(8.dp)) } + } + } + ) + } + Text( + text = "route internet over tor for enhanced privacy.", + fontSize = 10.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.6f) + ) + // Debug status (temporary) Surface( - modifier = Modifier - .padding(horizontal = 24.dp, vertical = 24.dp) - .fillMaxWidth(), - color = errorColor.copy(alpha = 0.1f), - shape = RoundedCornerShape(12.dp) + modifier = Modifier.fillMaxWidth(), + color = colorScheme.surfaceVariant.copy(alpha = 0.25f), + shape = RoundedCornerShape(8.dp) ) { - Row( - modifier = Modifier.padding(16.dp), - horizontalArrangement = Arrangement.spacedBy(12.dp), - verticalAlignment = Alignment.Top + Column( + modifier = Modifier.padding(12.dp), + verticalArrangement = Arrangement.spacedBy(6.dp) ) { - Icon( - imageVector = Icons.Filled.Warning, - contentDescription = "Warning", - tint = errorColor, - modifier = Modifier.size(16.dp) + Text( + text = "tor status: " + + (if (torStatus.running) "running" else "stopped") + + ", bootstrap=" + torStatus.bootstrapPercent + "%", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.75f) ) - Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { + val last = torStatus.lastLogLine + if (last.isNotEmpty()) { Text( - text = "Emergency Data Deletion", - fontSize = 12.sp, + text = "last: " + last.take(160), + fontSize = 10.sp, fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - color = errorColor - ) - Text( - text = "Tip: Triple-click the app title to emergency delete all stored data including messages, keys, and settings.", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface.copy(alpha = 0.8f) + color = colorScheme.onSurface.copy(alpha = 0.6f) ) } } } } - - // Footer Section - item(key = "footer") { - Column( - modifier = Modifier - .padding(horizontal = 24.dp) - .fillMaxWidth(), - horizontalAlignment = Alignment.CenterHorizontally, - verticalArrangement = Arrangement.spacedBy(8.dp) + } + + // Emergency warning + item { + Surface( + modifier = Modifier.fillMaxWidth(), + color = Color.Red.copy(alpha = 0.08f), + shape = RoundedCornerShape(12.dp) + ) { + Row( + modifier = Modifier.padding(16.dp), + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalAlignment = Alignment.Top ) { - if (onShowDebug != null) { - TextButton( - onClick = onShowDebug, - colors = ButtonDefaults.textButtonColors( - contentColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) - ) - ) { - Text( - text = "Debug Settings", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace - ) - } + Icon( + imageVector = Icons.Filled.Warning, + contentDescription = "Warning", + tint = Color(0xFFBF1A1A), + modifier = Modifier.size(16.dp) + ) + + Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { + Text( + text = "emergency data deletion", + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Medium, + color = Color(0xFFBF1A1A) + ) + + Text( + text = "tip: triple-click the app title to emergency delete all stored data including messages, keys, and settings.", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.7f) + ) } + } + } + } + + // Debug settings button + item { + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + // Debug button styled to match the app aesthetic + TextButton( + onClick = { onShowDebug?.invoke() }, + colors = ButtonDefaults.textButtonColors( + contentColor = colorScheme.onSurface.copy(alpha = 0.6f) + ) + ) { Text( - text = "Open Source • Privacy First • Decentralized", + text = "debug settings", fontSize = 11.sp, fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f), + color = colorScheme.onSurface.copy(alpha = 0.6f) ) - - // Add extra space at bottom for gesture area - Spacer(modifier = Modifier.height(16.dp)) } } } - // TopBar - Box( - modifier = Modifier - .align(Alignment.TopCenter) - .fillMaxWidth() - .height(64.dp) - .background(MaterialTheme.colorScheme.background.copy(alpha = topBarAlpha)) - ) { - TextButton( - onClick = onDismiss, - modifier = Modifier - .align(Alignment.CenterEnd) - .padding(horizontal = 16.dp) + // Version and footer space + item { + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(8.dp) ) { Text( - text = "Close", - style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Bold), - color = MaterialTheme.colorScheme.onBackground + text = "open source • privacy first • decentralized", + fontSize = 10.sp, + fontFamily = FontFamily.Monospace, + color = colorScheme.onSurface.copy(alpha = 0.5f) ) + + // Add extra space at bottom for gesture area + Spacer(modifier = Modifier.height(16.dp)) } } } @@ -568,6 +472,78 @@ fun AboutSheet( } } +@Composable +private fun FeatureCard( + icon: ImageVector, + iconColor: Color, + title: String, + description: String, + modifier: Modifier = Modifier +) { + Surface( + modifier = modifier, + color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.2f), + shape = RoundedCornerShape(12.dp) + ) { + Row( + modifier = Modifier.padding(16.dp), + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalAlignment = Alignment.Top + ) { + Icon( + imageVector = icon, + contentDescription = title, + tint = iconColor, + modifier = Modifier.size(20.dp) + ) + + Column( + modifier = Modifier.weight(1f), + verticalArrangement = Arrangement.spacedBy(4.dp) + ) { + Text( + text = title, + fontSize = 13.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Medium, + color = MaterialTheme.colorScheme.onSurface + ) + + Text( + text = description, + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f), + lineHeight = 15.sp + ) + } + } + } +} + +@Composable +private fun FeatureItem(text: String) { + Row( + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.Top + ) { + Text( + text = "•", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) + ) + + Text( + text = text, + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f), + modifier = Modifier.weight(1f) + ) + } +} + /** * Password prompt dialog for password-protected channels * Kept as dialog since it requires user input diff --git a/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt b/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt index 3b695167d..c33c3c14f 100644 --- a/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt +++ b/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt @@ -518,12 +518,7 @@ private fun MainHeader( val isConnected by viewModel.isConnected.observeAsState(false) val selectedLocationChannel by viewModel.selectedLocationChannel.observeAsState() val geohashPeople by viewModel.geohashPeople.observeAsState(emptyList()) - - // Bookmarks store for current geohash toggle (iOS parity) - val context = androidx.compose.ui.platform.LocalContext.current - val bookmarksStore = remember { com.bitchat.android.geohash.GeohashBookmarksStore.getInstance(context) } - val bookmarks by bookmarksStore.bookmarks.observeAsState(emptyList()) - + Row( modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, @@ -570,36 +565,11 @@ private fun MainHeader( ) } - // Location channels button (matching iOS implementation) and bookmark grouped tightly - Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.padding(end = 14.dp)) { - LocationChannelsButton( - viewModel = viewModel, - onClick = onLocationChannelsClick - ) - - // Bookmark toggle for current geohash (not shown for mesh) - val currentGeohash: String? = when (val sc = selectedLocationChannel) { - is com.bitchat.android.geohash.ChannelID.Location -> sc.channel.geohash - else -> null - } - if (currentGeohash != null) { - val isBookmarked = bookmarks.contains(currentGeohash) - Box( - modifier = Modifier - .padding(start = 1.dp) // minimal gap between geohash and bookmark - .size(20.dp) - .clickable { bookmarksStore.toggle(currentGeohash) }, - contentAlignment = Alignment.Center - ) { - Icon( - imageVector = if (isBookmarked) Icons.Filled.Bookmark else Icons.Outlined.BookmarkBorder, - contentDescription = "Toggle bookmark", - tint = if (isBookmarked) Color(0xFF00C851) else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.75f), - modifier = Modifier.size(16.dp) - ) - } - } - } + // Location channels button (matching iOS implementation) + LocationChannelsButton( + viewModel = viewModel, + onClick = onLocationChannelsClick + ) // Tor status cable icon when Tor is enabled TorStatusIcon(modifier = Modifier.size(14.dp)) @@ -651,7 +621,7 @@ private fun LocationChannelsButton( containerColor = Color.Transparent, contentColor = badgeColor ), - contentPadding = PaddingValues(start = 4.dp, end = 0.dp, top = 2.dp, bottom = 2.dp) + contentPadding = PaddingValues(horizontal = 4.dp, vertical = 2.dp) ) { Row(verticalAlignment = Alignment.CenterVertically) { Text( diff --git a/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt b/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt index 72a9e1e44..8e4e43b5e 100644 --- a/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt +++ b/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt @@ -1,8 +1,4 @@ package com.bitchat.android.ui -// [Goose] Bridge file share events to ViewModel via dispatcher is installed in ChatScreen composition - -// [Goose] Installing FileShareDispatcher handler in ChatScreen to forward file sends to ViewModel - import androidx.compose.animation.* import androidx.compose.animation.core.* @@ -25,7 +21,6 @@ import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.Dp import androidx.compose.ui.zIndex import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.ui.media.FullScreenImageViewer /** * Main ChatScreen - REFACTORED to use component-based architecture @@ -65,9 +60,6 @@ fun ChatScreen(viewModel: ChatViewModel) { var showUserSheet by remember { mutableStateOf(false) } var selectedUserForSheet by remember { mutableStateOf("") } var selectedMessageForSheet by remember { mutableStateOf(null) } - var showFullScreenImageViewer by remember { mutableStateOf(false) } - var viewerImagePaths by remember { mutableStateOf(emptyList()) } - var initialViewerIndex by remember { mutableStateOf(0) } var forceScrollToBottom by remember { mutableStateOf(false) } var isScrolledUp by remember { mutableStateOf(false) } @@ -162,53 +154,28 @@ fun ChatScreen(viewModel: ChatViewModel) { selectedUserForSheet = baseName selectedMessageForSheet = message showUserSheet = true - }, - onCancelTransfer = { msg -> - viewModel.cancelMediaSend(msg.id) - }, - onImageClick = { currentPath, allImagePaths, initialIndex -> - viewerImagePaths = allImagePaths - initialViewerIndex = initialIndex - showFullScreenImageViewer = true } ) // Input area - stays at bottom - // Bridge file share from lower-level input to ViewModel - androidx.compose.runtime.LaunchedEffect(Unit) { - com.bitchat.android.ui.events.FileShareDispatcher.setHandler { peer, channel, path -> - viewModel.sendFileNote(peer, channel, path) - } - } - - ChatInputSection( - messageText = messageText, - onMessageTextChange = { newText: TextFieldValue -> - messageText = newText - viewModel.updateCommandSuggestions(newText.text) - viewModel.updateMentionSuggestions(newText.text) - }, - onSend = { - if (messageText.text.trim().isNotEmpty()) { - viewModel.sendMessage(messageText.text.trim()) - messageText = TextFieldValue("") - forceScrollToBottom = !forceScrollToBottom // Toggle to trigger scroll - } - }, - onSendVoiceNote = { peer, onionOrChannel, path -> - viewModel.sendVoiceNote(peer, onionOrChannel, path) - }, - onSendImageNote = { peer, onionOrChannel, path -> - viewModel.sendImageNote(peer, onionOrChannel, path) - }, - onSendFileNote = { peer, onionOrChannel, path -> - viewModel.sendFileNote(peer, onionOrChannel, path) - }, - - showCommandSuggestions = showCommandSuggestions, - commandSuggestions = commandSuggestions, - showMentionSuggestions = showMentionSuggestions, - mentionSuggestions = mentionSuggestions, - onCommandSuggestionClick = { suggestion: CommandSuggestion -> + ChatInputSection( + messageText = messageText, + onMessageTextChange = { newText: TextFieldValue -> + messageText = newText + viewModel.updateCommandSuggestions(newText.text) + viewModel.updateMentionSuggestions(newText.text) + }, + onSend = { + if (messageText.text.trim().isNotEmpty()) { + viewModel.sendMessage(messageText.text.trim()) + messageText = TextFieldValue("") + forceScrollToBottom = !forceScrollToBottom // Toggle to trigger scroll + } + }, + showCommandSuggestions = showCommandSuggestions, + commandSuggestions = commandSuggestions, + showMentionSuggestions = showMentionSuggestions, + mentionSuggestions = mentionSuggestions, + onCommandSuggestionClick = { suggestion: CommandSuggestion -> val commandText = viewModel.selectCommandSuggestion(suggestion) messageText = TextFieldValue( text = commandText, @@ -321,15 +288,6 @@ fun ChatScreen(viewModel: ChatViewModel) { } } - // Full-screen image viewer - separate from other sheets to allow image browsing without navigation - if (showFullScreenImageViewer) { - FullScreenImageViewer( - imagePaths = viewerImagePaths, - initialIndex = initialViewerIndex, - onClose = { showFullScreenImageViewer = false } - ) - } - // Dialogs and Sheets ChatDialogs( showPasswordDialog = showPasswordDialog, @@ -369,9 +327,6 @@ private fun ChatInputSection( messageText: TextFieldValue, onMessageTextChange: (TextFieldValue) -> Unit, onSend: () -> Unit, - onSendVoiceNote: (String?, String?, String) -> Unit, - onSendImageNote: (String?, String?, String) -> Unit, - onSendFileNote: (String?, String?, String) -> Unit, showCommandSuggestions: Boolean, commandSuggestions: List, showMentionSuggestions: Boolean, @@ -396,8 +351,10 @@ private fun ChatInputSection( onSuggestionClick = onCommandSuggestionClick, modifier = Modifier.fillMaxWidth() ) + HorizontalDivider(color = colorScheme.outline.copy(alpha = 0.2f)) } + // Mention suggestions box if (showMentionSuggestions && mentionSuggestions.isNotEmpty()) { MentionSuggestionsBox( @@ -405,15 +362,14 @@ private fun ChatInputSection( onSuggestionClick = onMentionSuggestionClick, modifier = Modifier.fillMaxWidth() ) + HorizontalDivider(color = colorScheme.outline.copy(alpha = 0.2f)) } + MessageInput( value = messageText, onValueChange = onMessageTextChange, onSend = onSend, - onSendVoiceNote = onSendVoiceNote, - onSendImageNote = onSendImageNote, - onSendFileNote = onSendFileNote, selectedPrivatePeer = selectedPrivatePeer, currentChannel = currentChannel, nickname = nickname, @@ -422,6 +378,7 @@ private fun ChatInputSection( } } } + @OptIn(ExperimentalMaterial3Api::class) @Composable private fun ChatFloatingHeader( diff --git a/app/src/main/java/com/bitchat/android/ui/ChatUIUtils.kt b/app/src/main/java/com/bitchat/android/ui/ChatUIUtils.kt index 82db6b649..bc0a14f4f 100644 --- a/app/src/main/java/com/bitchat/android/ui/ChatUIUtils.kt +++ b/app/src/main/java/com/bitchat/android/ui/ChatUIUtils.kt @@ -156,105 +156,6 @@ fun formatMessageAsAnnotatedString( return builder.toAnnotatedString() } -/** - * Build only the nickname + timestamp header line for a message, matching styles of normal messages. - */ -fun formatMessageHeaderAnnotatedString( - message: BitchatMessage, - currentUserNickname: String, - meshService: BluetoothMeshService, - colorScheme: ColorScheme, - timeFormatter: SimpleDateFormat = SimpleDateFormat("HH:mm:ss", Locale.getDefault()) -): AnnotatedString { - val builder = AnnotatedString.Builder() - val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f - - val isSelf = message.senderPeerID == meshService.myPeerID || - message.sender == currentUserNickname || - message.sender.startsWith("$currentUserNickname#") - - if (message.sender != "system") { - val baseColor = if (isSelf) Color(0xFFFF9500) else getPeerColor(message, isDark) - val (baseName, suffix) = splitSuffix(message.sender) - - // "<@" - builder.pushStyle(SpanStyle( - color = baseColor, - fontSize = BASE_FONT_SIZE.sp, - fontWeight = if (isSelf) FontWeight.Bold else FontWeight.Medium - )) - builder.append("<@") - builder.pop() - - // Base name (clickable when not self) - builder.pushStyle(SpanStyle( - color = baseColor, - fontSize = BASE_FONT_SIZE.sp, - fontWeight = if (isSelf) FontWeight.Bold else FontWeight.Medium - )) - val nicknameStart = builder.length - builder.append(truncateNickname(baseName)) - val nicknameEnd = builder.length - if (!isSelf) { - builder.addStringAnnotation( - tag = "nickname_click", - annotation = (message.originalSender ?: message.sender), - start = nicknameStart, - end = nicknameEnd - ) - } - builder.pop() - - // Hashtag suffix - if (suffix.isNotEmpty()) { - builder.pushStyle(SpanStyle( - color = baseColor.copy(alpha = 0.6f), - fontSize = BASE_FONT_SIZE.sp, - fontWeight = if (isSelf) FontWeight.Bold else FontWeight.Medium - )) - builder.append(suffix) - builder.pop() - } - - // Sender suffix ">" - builder.pushStyle(SpanStyle( - color = baseColor, - fontSize = BASE_FONT_SIZE.sp, - fontWeight = if (isSelf) FontWeight.Bold else FontWeight.Medium - )) - builder.append(">") - builder.pop() - - // Timestamp and optional PoW bits, matching normal message appearance - builder.pushStyle(SpanStyle( - color = Color.Gray.copy(alpha = 0.7f), - fontSize = (BASE_FONT_SIZE - 4).sp - )) - builder.append(" [${timeFormatter.format(message.timestamp)}]") - message.powDifficulty?.let { bits -> - if (bits > 0) builder.append(" ⛨${bits}b") - } - builder.pop() - } else { - // System message header (should rarely apply to voice) - builder.pushStyle(SpanStyle( - color = Color.Gray, - fontSize = (BASE_FONT_SIZE - 2).sp, - fontStyle = androidx.compose.ui.text.font.FontStyle.Italic - )) - builder.append("* ${message.content} *") - builder.pop() - builder.pushStyle(SpanStyle( - color = Color.Gray.copy(alpha = 0.5f), - fontSize = (BASE_FONT_SIZE - 4).sp - )) - builder.append(" [${timeFormatter.format(message.timestamp)}]") - builder.pop() - } - - return builder.toAnnotatedString() -} - /** * iOS-style peer color assignment using djb2 hash algorithm * Avoids orange (~30°) reserved for self messages 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 4224d9c1f..de85c5976 100644 --- a/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt +++ b/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt @@ -9,7 +9,6 @@ import androidx.lifecycle.viewModelScope import com.bitchat.android.mesh.BluetoothMeshDelegate import com.bitchat.android.mesh.BluetoothMeshService import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType import com.bitchat.android.protocol.BitchatPacket @@ -34,37 +33,21 @@ class ChatViewModel( private const val TAG = "ChatViewModel" } - fun sendVoiceNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - mediaSendingManager.sendVoiceNote(toPeerIDOrNull, channelOrNull, filePath) - } - - fun sendFileNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - mediaSendingManager.sendFileNote(toPeerIDOrNull, channelOrNull, filePath) - } - - fun sendImageNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - mediaSendingManager.sendImageNote(toPeerIDOrNull, channelOrNull, filePath) - } - - // MARK: - State management + // State management private val state = ChatState() - - // Transfer progress tracking - private val transferMessageMap = mutableMapOf() - private val messageTransferMap = mutableMapOf() - + // Specialized managers private val dataManager = DataManager(application.applicationContext) private val messageManager = MessageManager(state) private val channelManager = ChannelManager(state, messageManager, dataManager, viewModelScope) - + // Create Noise session delegate for clean dependency injection private val noiseSessionDelegate = object : NoiseSessionDelegate { override fun hasEstablishedSession(peerID: String): Boolean = meshService.hasEstablishedSession(peerID) - override fun initiateHandshake(peerID: String) = meshService.initiateNoiseHandshake(peerID) + override fun initiateHandshake(peerID: String) = meshService.initiateNoiseHandshake(peerID) override fun getMyPeerID(): String = meshService.myPeerID } - + val privateChatManager = PrivateChatManager(state, messageManager, dataManager, noiseSessionDelegate) private val commandProcessor = CommandProcessor(state, messageManager, channelManager, privateChatManager) private val notificationManager = NotificationManager( @@ -72,9 +55,6 @@ class ChatViewModel( NotificationManagerCompat.from(application.applicationContext), NotificationIntervalManager() ) - - // Media file sending manager - private val mediaSendingManager = MediaSendingManager(state, messageManager, channelManager, meshService) // Delegate handler for mesh callbacks private val meshDelegateHandler = MeshDelegateHandler( @@ -141,27 +121,6 @@ class ChatViewModel( init { // Note: Mesh service delegate is now set by MainActivity loadAndInitialize() - // Subscribe to BLE transfer progress and reflect in message deliveryStatus - viewModelScope.launch { - com.bitchat.android.mesh.TransferProgressManager.events.collect { evt -> - mediaSendingManager.handleTransferProgressEvent(evt) - } - } - } - - fun cancelMediaSend(messageId: String) { - val transferId = synchronized(transferMessageMap) { messageTransferMap[messageId] } - if (transferId != null) { - val cancelled = meshService.cancelFileTransfer(transferId) - if (cancelled) { - // Remove the message from chat upon explicit cancel - messageManager.removeMessageById(messageId) - synchronized(transferMessageMap) { - transferMessageMap.remove(transferId) - messageTransferMap.remove(messageId) - } - } - } } private fun loadAndInitialize() { @@ -240,8 +199,6 @@ class ChatViewModel( messageManager.addMessage(welcomeMessage) } } - - // BLE receives are inserted by MessageHandler path; no VoiceNoteBus for Tor in this branch. } override fun onCleared() { @@ -762,14 +719,8 @@ class ChatViewModel( // Clear all notifications notificationManager.clearAllNotifications() - // Clear Nostr/geohash state, keys, connections, bookmarks, and reinitialize from scratch + // Clear Nostr/geohash state, keys, connections, and reinitialize from scratch try { - // Clear geohash bookmarks too (panic should remove everything) - try { - val store = com.bitchat.android.geohash.GeohashBookmarksStore.getInstance(getApplication()) - store.clearAll() - } catch (_: Exception) { } - geohashViewModel.panicReset() } catch (e: Exception) { Log.e(TAG, "Failed to reset Nostr/geohash: ${e.message}") diff --git a/app/src/main/java/com/bitchat/android/ui/GeohashViewModel.kt b/app/src/main/java/com/bitchat/android/ui/GeohashViewModel.kt index 060bb84e7..08865c1e1 100644 --- a/app/src/main/java/com/bitchat/android/ui/GeohashViewModel.kt +++ b/app/src/main/java/com/bitchat/android/ui/GeohashViewModel.kt @@ -30,25 +30,10 @@ class GeohashViewModel( companion object { private const val TAG = "GeohashViewModel" } - private val repo = GeohashRepository(application, state, dataManager) + private val repo = GeohashRepository(application, state) private val subscriptionManager = NostrSubscriptionManager(application, viewModelScope) - private val geohashMessageHandler = GeohashMessageHandler( - application = application, - state = state, - messageManager = messageManager, - repo = repo, - scope = viewModelScope, - dataManager = dataManager - ) - private val dmHandler = NostrDirectMessageHandler( - application = application, - state = state, - privateChatManager = privateChatManager, - meshDelegateHandler = meshDelegateHandler, - scope = viewModelScope, - repo = repo, - dataManager = dataManager - ) + private val geohashMessageHandler = GeohashMessageHandler(application, state, messageManager, repo, viewModelScope) + private val dmHandler = NostrDirectMessageHandler(application, state, privateChatManager, meshDelegateHandler, viewModelScope, repo) private var currentGeohashSubId: String? = null private var currentDmSubId: String? = null @@ -114,22 +99,14 @@ class GeohashViewModel( powDifficulty = if (pow.enabled) pow.difficulty else null ) messageManager.addChannelMessage("geo:${channel.geohash}", localMsg) - val startedMining = pow.enabled && pow.difficulty > 0 - if (startedMining) { + if (pow.enabled && pow.difficulty > 0) { com.bitchat.android.ui.PoWMiningTracker.startMiningMessage(tempId) } - try { - val identity = NostrIdentityBridge.deriveIdentity(forGeohash = channel.geohash, context = getApplication()) - val teleported = state.isTeleported.value ?: false - val event = NostrProtocol.createEphemeralGeohashEvent(content, channel.geohash, identity, nickname, teleported) - val relayManager = NostrRelayManager.getInstance(getApplication()) - relayManager.sendEventToGeohash(event, channel.geohash, includeDefaults = false, nRelays = 5) - } finally { - // Ensure we stop the per-message mining animation regardless of success/failure - if (startedMining) { - com.bitchat.android.ui.PoWMiningTracker.stopMiningMessage(tempId) - } - } + val identity = NostrIdentityBridge.deriveIdentity(forGeohash = channel.geohash, context = getApplication()) + val teleported = state.isTeleported.value ?: false + val event = NostrProtocol.createEphemeralGeohashEvent(content, channel.geohash, identity, nickname, teleported) + val relayManager = NostrRelayManager.getInstance(getApplication()) + relayManager.sendEventToGeohash(event, channel.geohash, includeDefaults = false, nRelays = 5) } catch (e: Exception) { Log.e(TAG, "Failed to send geohash message: ${e.message}") } @@ -159,15 +136,8 @@ class GeohashViewModel( fun startGeohashDM(pubkeyHex: String, onStartPrivateChat: (String) -> Unit) { val convKey = "nostr_${pubkeyHex.take(16)}" repo.putNostrKeyMapping(convKey, pubkeyHex) - // Record the conversation's geohash using the currently selected location channel (if any) - val current = state.selectedLocationChannel.value - val gh = (current as? com.bitchat.android.geohash.ChannelID.Location)?.channel?.geohash - if (!gh.isNullOrEmpty()) { - repo.setConversationGeohash(convKey, gh) - com.bitchat.android.nostr.GeohashConversationRegistry.set(convKey, gh) - } onStartPrivateChat(convKey) - Log.d(TAG, "🗨️ Started geohash DM with ${pubkeyHex} -> ${convKey} (geohash=${gh})") + Log.d(TAG, "🗨️ Started geohash DM with $pubkeyHex -> $convKey") } fun getNostrKeyMapping(): Map = repo.getNostrKeyMapping() @@ -176,15 +146,26 @@ class GeohashViewModel( val pubkey = repo.findPubkeyByNickname(targetNickname) if (pubkey != null) { dataManager.addGeohashBlockedUser(pubkey) - // Refresh people list and counts to remove blocked entry immediately - repo.refreshGeohashPeople() - repo.updateReactiveParticipantCounts() val sysMsg = com.bitchat.android.model.BitchatMessage( sender = "system", content = "blocked $targetNickname in geohash channels", timestamp = Date(), isRelay = false ) + fun startGeohashDM(pubkeyHex: String, onStartPrivateChat: (String) -> Unit) { + val convKey = "nostr_${'$'}{pubkeyHex.take(16)}" + repo.putNostrKeyMapping(convKey, pubkeyHex) + // Record the conversation's geohash using the currently selected location channel (if any) + val current = state.selectedLocationChannel.value + val gh = (current as? com.bitchat.android.geohash.ChannelID.Location)?.channel?.geohash + if (!gh.isNullOrEmpty()) { + repo.setConversationGeohash(convKey, gh) + com.bitchat.android.nostr.GeohashConversationRegistry.set(convKey, gh) + } + onStartPrivateChat(convKey) + Log.d(TAG, "🗨️ Started geohash DM with ${'$'}pubkeyHex -> ${'$'}convKey (geohash=${'$'}gh)") + } + messageManager.addMessage(sysMsg) } else { val sysMsg = com.bitchat.android.model.BitchatMessage( diff --git a/app/src/main/java/com/bitchat/android/ui/InputComponents.kt b/app/src/main/java/com/bitchat/android/ui/InputComponents.kt index eb1e744b4..6ebeb21da 100644 --- a/app/src/main/java/com/bitchat/android/ui/InputComponents.kt +++ b/app/src/main/java/com/bitchat/android/ui/InputComponents.kt @@ -1,6 +1,4 @@ package com.bitchat.android.ui -// [Goose] TODO: Replace inline file attachment stub with FilePickerButton abstraction that dispatches via FileShareDispatcher - import androidx.compose.foundation.* import androidx.compose.foundation.layout.* @@ -18,6 +16,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.SolidColor import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.TextRange import androidx.compose.ui.text.AnnotatedString import androidx.compose.ui.text.SpanStyle import androidx.compose.ui.text.buildAnnotatedString @@ -25,6 +24,7 @@ import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.input.ImeAction import androidx.compose.ui.text.input.TextFieldValue +import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.input.OffsetMapping import androidx.compose.ui.text.input.TransformedText import androidx.compose.ui.text.input.VisualTransformation @@ -33,16 +33,9 @@ import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import com.bitchat.android.R import androidx.compose.ui.focus.onFocusChanged -import androidx.compose.ui.focus.FocusRequester -import androidx.compose.ui.focus.focusRequester -import androidx.compose.ui.platform.LocalSoftwareKeyboardController import androidx.compose.ui.text.withStyle import com.bitchat.android.ui.theme.BASE_FONT_SIZE -import com.bitchat.android.features.voice.normalizeAmplitudeSample -import com.bitchat.android.features.voice.AudioWaveformExtractor -import com.bitchat.android.ui.media.RealtimeScrollingWaveform -import com.bitchat.android.ui.media.ImagePickerButton -import com.bitchat.android.ui.media.FilePickerButton +import androidx.compose.foundation.isSystemInDarkTheme /** * Input components for ChatScreen @@ -164,9 +157,6 @@ fun MessageInput( value: TextFieldValue, onValueChange: (TextFieldValue) -> Unit, onSend: () -> Unit, - onSendVoiceNote: (String?, String?, String) -> Unit, - onSendImageNote: (String?, String?, String) -> Unit, - onSendFileNote: (String?, String?, String) -> Unit, selectedPrivatePeer: String?, currentChannel: String?, nickname: String, @@ -175,22 +165,16 @@ fun MessageInput( val colorScheme = MaterialTheme.colorScheme val isFocused = remember { mutableStateOf(false) } val hasText = value.text.isNotBlank() // Check if there's text for send button state - val keyboard = LocalSoftwareKeyboardController.current - val focusRequester = remember { FocusRequester() } - var isRecording by remember { mutableStateOf(false) } - var elapsedMs by remember { mutableStateOf(0L) } - var amplitude by remember { mutableStateOf(0) } - + Row( modifier = modifier.padding(horizontal = 12.dp, vertical = 8.dp), // Reduced padding verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp) ) { - // Text input with placeholder OR visualizer when recording + // Text input with placeholder Box( modifier = Modifier.weight(1f) ) { - // Always keep the text field mounted to retain focus and avoid IME collapse BasicTextField( value = value, onValueChange = onValueChange, @@ -198,7 +182,7 @@ fun MessageInput( color = colorScheme.primary, fontFamily = FontFamily.Monospace ), - cursorBrush = SolidColor(if (isRecording) Color.Transparent else colorScheme.primary), + cursorBrush = SolidColor(colorScheme.primary), keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send), keyboardActions = KeyboardActions(onSend = { if (hasText) onSend() // Only send if there's text @@ -208,14 +192,13 @@ fun MessageInput( ), modifier = Modifier .fillMaxWidth() - .focusRequester(focusRequester) .onFocusChanged { focusState -> isFocused.value = focusState.isFocused } ) - - // Show placeholder when there's no text and not recording - if (value.text.isEmpty() && !isRecording) { + + // Show placeholder when there's no text + if (value.text.isEmpty()) { Text( text = "type a message...", style = MaterialTheme.typography.bodyMedium.copy( @@ -225,94 +208,23 @@ fun MessageInput( modifier = Modifier.fillMaxWidth() ) } - - // Overlay the real-time scrolling waveform while recording - if (isRecording) { - Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - RealtimeScrollingWaveform( - modifier = Modifier.weight(1f).height(32.dp), - amplitudeNorm = normalizeAmplitudeSample(amplitude) - ) - Spacer(Modifier.width(20.dp)) - val secs = (elapsedMs / 1000).toInt() - val mm = secs / 60 - val ss = secs % 60 - val maxSecs = 10 // 10 second max recording time - val maxMm = maxSecs / 60 - val maxSs = maxSecs % 60 - Text( - text = String.format("%02d:%02d / %02d:%02d", mm, ss, maxMm, maxSs), - fontFamily = FontFamily.Monospace, - color = colorScheme.primary, - fontSize = (BASE_FONT_SIZE - 4).sp - ) - } - } } Spacer(modifier = Modifier.width(8.dp)) // Reduced spacing - // Voice and image buttons when no text (always visible for mesh + channels + private) + // Command quick access button if (value.text.isEmpty()) { - // Hold-to-record microphone - val bg = if (colorScheme.background == Color.Black) Color(0xFF00FF00).copy(alpha = 0.75f) else Color(0xFF008000).copy(alpha = 0.75f) - - // Ensure latest values are used when finishing recording - val latestSelectedPeer = rememberUpdatedState(selectedPrivatePeer) - val latestChannel = rememberUpdatedState(currentChannel) - val latestOnSendVoiceNote = rememberUpdatedState(onSendVoiceNote) - - // Image button (image picker) - hide during recording - if (!isRecording) { - // Revert to original separate buttons: round File button (left) and the old Image plus button (right) - Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) { - // DISABLE FILE PICKER - //FilePickerButton( - // onFileReady = { path -> - // onSendFileNote(latestSelectedPeer.value, latestChannel.value, path) - // } - //) - ImagePickerButton( - onImageReady = { outPath -> - onSendImageNote(latestSelectedPeer.value, latestChannel.value, outPath) - } - ) - } - } - - Spacer(Modifier.width(1.dp)) - - VoiceRecordButton( - backgroundColor = bg, - onStart = { - isRecording = true - elapsedMs = 0L - // Keep existing focus to avoid IME collapse, but do not force-show keyboard - if (isFocused.value) { - try { focusRequester.requestFocus() } catch (_: Exception) {} - } - }, - onAmplitude = { amp, ms -> - amplitude = amp - elapsedMs = ms + FilledTonalIconButton( + onClick = { + onValueChange(TextFieldValue(text = "/", selection = TextRange("/".length))) }, - onFinish = { path -> - isRecording = false - // Extract and cache waveform from the actual audio file to match receiver rendering - AudioWaveformExtractor.extractAsync(path, sampleCount = 120) { arr -> - if (arr != null) { - try { com.bitchat.android.features.voice.VoiceWaveformCache.put(path, arr) } catch (_: Exception) {} - } - } - // BLE path (private or public) — use latest values to avoid stale captures - latestOnSendVoiceNote.value( - latestSelectedPeer.value, - latestChannel.value, - path - ) - } - ) - + modifier = Modifier.size(32.dp) + ) { + Text( + text = "/", + textAlign = TextAlign.Center + ) + } } else { // Send button with enabled/disabled state IconButton( @@ -360,8 +272,6 @@ fun MessageInput( } } } - - // Auto-stop handled inside VoiceRecordButton } @Composable diff --git a/app/src/main/java/com/bitchat/android/ui/LocationChannelsSheet.kt b/app/src/main/java/com/bitchat/android/ui/LocationChannelsSheet.kt index fd8ad1eb7..e21dd8f5c 100644 --- a/app/src/main/java/com/bitchat/android/ui/LocationChannelsSheet.kt +++ b/app/src/main/java/com/bitchat/android/ui/LocationChannelsSheet.kt @@ -3,20 +3,17 @@ package com.bitchat.android.ui import android.content.Intent import android.net.Uri import android.provider.Settings -import androidx.compose.animation.core.animateFloatAsState -import androidx.compose.foundation.background import androidx.compose.foundation.layout.* import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.lazy.items import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.foundation.text.BasicTextField import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Bookmark -import androidx.compose.material.icons.filled.Check import androidx.compose.material.icons.filled.Map import androidx.compose.material.icons.filled.PinDrop -import androidx.compose.material.icons.outlined.BookmarkBorder import androidx.compose.material3.* +import androidx.compose.ui.text.font.FontWeight import androidx.compose.runtime.* import androidx.compose.runtime.livedata.observeAsState import androidx.compose.ui.Alignment @@ -25,18 +22,17 @@ import androidx.compose.ui.focus.onFocusChanged import androidx.compose.ui.graphics.Color import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontFamily -import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import com.bitchat.android.geohash.ChannelID +import com.bitchat.android.ui.theme.BASE_FONT_SIZE import kotlinx.coroutines.launch +import com.bitchat.android.geohash.ChannelID import com.bitchat.android.geohash.GeohashChannel import com.bitchat.android.geohash.GeohashChannelLevel import com.bitchat.android.geohash.LocationChannelManager -import com.bitchat.android.geohash.GeohashBookmarksStore -import com.bitchat.android.ui.theme.BASE_FONT_SIZE +import java.util.* +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts /** * Location Channels Sheet for selecting geohash-based location channels @@ -52,45 +48,32 @@ fun LocationChannelsSheet( ) { val context = LocalContext.current val locationManager = LocationChannelManager.getInstance(context) - val bookmarksStore = remember { GeohashBookmarksStore.getInstance(context) } - + // Observe location manager state val permissionState by locationManager.permissionState.observeAsState() val availableChannels by locationManager.availableChannels.observeAsState(emptyList()) val selectedChannel by locationManager.selectedChannel.observeAsState() + val teleported by locationManager.teleported.observeAsState(false) val locationNames by locationManager.locationNames.observeAsState(emptyMap()) val locationServicesEnabled by locationManager.locationServicesEnabled.observeAsState(false) - - // Observe bookmarks state - val bookmarks by bookmarksStore.bookmarks.observeAsState(emptyList()) - val bookmarkNames by bookmarksStore.bookmarkNames.observeAsState(emptyMap()) - - // Observe reactive participant counts + + // CRITICAL FIX: Observe reactive participant counts for real-time updates val geohashParticipantCounts by viewModel.geohashParticipantCounts.observeAsState(emptyMap()) - + // UI state var customGeohash by remember { mutableStateOf("") } var customError by remember { mutableStateOf(null) } var isInputFocused by remember { mutableStateOf(false) } - + // Bottom sheet state val sheetState = rememberModalBottomSheetState( - skipPartiallyExpanded = true + skipPartiallyExpanded = isInputFocused ) val coroutineScope = rememberCoroutineScope() - - // Scroll state for LazyColumn with animated top bar + + // Scroll state for LazyColumn val listState = rememberLazyListState() - val isScrolled by remember { - derivedStateOf { - listState.firstVisibleItemIndex > 0 || listState.firstVisibleItemScrollOffset > 0 - } - } - val topBarAlpha by animateFloatAsState( - targetValue = if (isScrolled) 0.95f else 0f, - label = "topBarAlpha" - ) - + val mapPickerLauncher = rememberLauncherForActivityResult( contract = ActivityResultContracts.StartActivityForResult() ) { result -> @@ -102,148 +85,139 @@ fun LocationChannelsSheet( } } } - + // iOS system colors (matches iOS exactly) val colorScheme = MaterialTheme.colorScheme val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f val standardGreen = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D) // iOS green val standardBlue = Color(0xFF007AFF) // iOS blue - + if (isPresented) { ModalBottomSheet( - modifier = modifier.statusBarsPadding(), onDismissRequest = onDismiss, sheetState = sheetState, - containerColor = MaterialTheme.colorScheme.background, - dragHandle = null + modifier = modifier ) { - Box(modifier = Modifier.fillMaxWidth()) { - LazyColumn( - state = listState, - modifier = Modifier.fillMaxSize(), - contentPadding = PaddingValues(top = 48.dp, bottom = 16.dp) - ) { - // Header Section - item(key = "header") { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - .padding(bottom = 8.dp), - verticalArrangement = Arrangement.spacedBy(4.dp) - ) { - Text( - text = "#location channels", - style = MaterialTheme.typography.headlineSmall, - fontFamily = FontFamily.Monospace, - fontWeight = FontWeight.Bold, - color = MaterialTheme.colorScheme.onBackground - ) - - Text( - text = "chat with people near you using geohash channels. only a coarse geohash is shared, never exact gps. do not screenshot or share this screen to protect your privacy.", - fontSize = 12.sp, - fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f) - ) + Column( + modifier = Modifier + .fillMaxWidth() + .then( + if (isInputFocused) { + Modifier.fillMaxHeight().padding(horizontal = 16.dp, vertical = 24.dp) + } else { + Modifier.padding(horizontal = 16.dp, vertical = 12.dp) } - } - - // Permission controls if services enabled - if (locationServicesEnabled) { - item(key = "permissions") { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - .padding(bottom = 8.dp), - verticalArrangement = Arrangement.spacedBy(4.dp) + ), + verticalArrangement = Arrangement.spacedBy(12.dp) + ) { + // Header + Text( + text = "#location channels", + fontSize = 18.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface + ) + + Text( + text = "chat with people near you using geohash channels. only a coarse geohash is shared, never exact gps. do not screenshot or share this screen to protect your privacy.", + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f) + ) + + // Location Services Control - Show permission handling if enabled + if (locationServicesEnabled) { + when (permissionState) { + LocationChannelManager.PermissionState.NOT_DETERMINED -> { + Button( + onClick = { locationManager.enableLocationChannels() }, + colors = ButtonDefaults.buttonColors( + containerColor = standardGreen.copy(alpha = 0.12f), + contentColor = standardGreen + ), + modifier = Modifier.fillMaxWidth() ) { - when (permissionState) { - LocationChannelManager.PermissionState.NOT_DETERMINED -> { - Button( - onClick = { locationManager.enableLocationChannels() }, - colors = ButtonDefaults.buttonColors( - containerColor = standardGreen.copy(alpha = 0.12f), - contentColor = standardGreen - ), - modifier = Modifier.fillMaxWidth() - ) { - Text( - text = "grant location permission", - fontSize = 12.sp, - fontFamily = FontFamily.Monospace - ) - } - } - LocationChannelManager.PermissionState.DENIED, - LocationChannelManager.PermissionState.RESTRICTED -> { - Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { - Text( - text = "location permission denied. enable in settings to use location channels.", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace, - color = Color.Red.copy(alpha = 0.8f) - ) - TextButton( - onClick = { - val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply { - data = Uri.fromParts("package", context.packageName, null) - } - context.startActivity(intent) - } - ) { - Text( - text = "open settings", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace - ) - } - } - } - LocationChannelManager.PermissionState.AUTHORIZED -> { - Text( - text = "✓ location permission granted", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace, - color = standardGreen - ) - } - null -> { - Row( - horizontalArrangement = Arrangement.spacedBy(4.dp), - verticalAlignment = Alignment.CenterVertically - ) { - CircularProgressIndicator(modifier = Modifier.size(12.dp)) - Text( - text = "checking permissions...", - fontSize = 11.sp, - fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f) - ) + Text( + text = "grant location permission", + fontSize = 12.sp, + fontFamily = FontFamily.Monospace + ) + } + } + + LocationChannelManager.PermissionState.DENIED, + LocationChannelManager.PermissionState.RESTRICTED -> { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text( + text = "location permission denied. enable in settings to use location channels.", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = Color.Red.copy(alpha = 0.8f) + ) + + TextButton( + onClick = { + val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply { + data = Uri.fromParts("package", context.packageName, null) } + context.startActivity(intent) } + ) { + Text( + text = "open settings", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace + ) } } } + + LocationChannelManager.PermissionState.AUTHORIZED -> { + Text( + text = "✓ location permission granted", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = standardGreen + ) + } + + null -> { + Row( + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically + ) { + CircularProgressIndicator(modifier = Modifier.size(12.dp)) + Text( + text = "checking permissions...", + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f) + ) + } + } } - + } + + // Channel list (iOS-style plain list) + LazyColumn( + state = listState, + modifier = Modifier.weight(1f) + ) { // Mesh option first - item(key = "mesh") { + item { ChannelRow( title = meshTitleWithCount(viewModel), subtitle = "#bluetooth • ${bluetoothRangeString()}", isSelected = selectedChannel is ChannelID.Mesh, titleColor = standardBlue, titleBold = meshCount(viewModel) > 0, - trailingContent = null, onClick = { locationManager.select(ChannelID.Mesh) onDismiss() } ) } - + // Nearby options (only show if location services are enabled) if (availableChannels.isNotEmpty() && locationServicesEnabled) { items(availableChannels) { channel -> @@ -251,25 +225,16 @@ fun LocationChannelsSheet( val nameBase = locationNames[channel.level] val namePart = nameBase?.let { formattedNamePrefix(channel.level) + it } val subtitlePrefix = "#${channel.geohash} • $coverage" + // CRITICAL FIX: Use reactive participant count from LiveData val participantCount = geohashParticipantCounts[channel.geohash] ?: 0 val highlight = participantCount > 0 - val isBookmarked = bookmarksStore.isBookmarked(channel.geohash) - + ChannelRow( title = geohashTitleWithCount(channel, participantCount), subtitle = subtitlePrefix + (namePart?.let { " • $it" } ?: ""), isSelected = isChannelSelected(channel, selectedChannel), titleColor = standardGreen, titleBold = highlight, - trailingContent = { - IconButton(onClick = { bookmarksStore.toggle(channel.geohash) }) { - Icon( - imageVector = if (isBookmarked) Icons.Filled.Bookmark else Icons.Outlined.BookmarkBorder, - contentDescription = if (isBookmarked) "Unbookmark" else "Bookmark", - tint = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f), - ) - } - }, onClick = { // Selecting a suggested nearby channel is not a teleport locationManager.setTeleported(false) @@ -281,7 +246,7 @@ fun LocationChannelsSheet( } else if (permissionState == LocationChannelManager.PermissionState.AUTHORIZED && locationServicesEnabled) { item { Row( - horizontalArrangement = Arrangement.spacedBy(4.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically ) { CircularProgressIndicator(modifier = Modifier.size(16.dp)) @@ -293,311 +258,229 @@ fun LocationChannelsSheet( } } } - - // Bookmarked geohashes - if (bookmarks.isNotEmpty()) { - item(key = "bookmarked_header") { - Text( - text = "bookmarked", - style = MaterialTheme.typography.labelLarge, - fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f), - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - .padding(top = 8.dp, bottom = 4.dp) - ) - } - items(bookmarks) { gh -> - val level = levelForLength(gh.length) - val channel = GeohashChannel(level = level, geohash = gh) - val coverage = coverageString(gh.length) - val subtitlePrefix = "#${gh} • $coverage" - val name = bookmarkNames[gh] - val subtitle = subtitlePrefix + (name?.let { " • ${formattedNamePrefix(level)}$it" } ?: "") - val participantCount = geohashParticipantCounts[gh] ?: 0 - val title = geohashHashTitleWithCount(gh, participantCount) - - ChannelRow( - title = title, - subtitle = subtitle, - isSelected = isChannelSelected(channel, selectedChannel), - titleColor = null, - titleBold = participantCount > 0, - trailingContent = { - IconButton(onClick = { bookmarksStore.toggle(gh) }) { - Icon( - imageVector = Icons.Filled.Bookmark, - contentDescription = "Remove bookmark", - tint = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f), - ) - } - }, - onClick = { - // For bookmarked selection, mark teleported based on regional membership - val inRegional = availableChannels.any { it.geohash == gh } - if (!inRegional && availableChannels.isNotEmpty()) { - locationManager.setTeleported(true) - } else { - locationManager.setTeleported(false) - } - locationManager.select(ChannelID.Location(channel)) - onDismiss() - } - ) - LaunchedEffect(gh) { bookmarksStore.resolveNameIfNeeded(gh) } - } - } - + // Custom geohash teleport (iOS-style inline form) - item(key = "custom_geohash") { + item { Surface( - color = Color.Transparent, - shape = MaterialTheme.shapes.medium, modifier = Modifier .fillMaxWidth() - .padding(horizontal = 24.dp, vertical = 2.dp) + .padding(horizontal = 16.dp, vertical = 6.dp), + color = Color.Transparent ) { - Row( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 16.dp, vertical = 6.dp), - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.CenterVertically - ) { - Text( - text = "#", - fontSize = BASE_FONT_SIZE.sp, - fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) - ) - - BasicTextField( - value = customGeohash, - onValueChange = { newValue -> - // iOS-style geohash validation (base32 characters only) - val allowed = "0123456789bcdefghjkmnpqrstuvwxyz".toSet() - val filtered = newValue - .lowercase() - .replace("#", "") - .filter { it in allowed } - .take(12) - - customGeohash = filtered - customError = null - }, - textStyle = androidx.compose.ui.text.TextStyle( + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Row( + horizontalArrangement = Arrangement.spacedBy(1.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "#", fontSize = BASE_FONT_SIZE.sp, fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onSurface - ), - modifier = Modifier - .weight(1f) - .onFocusChanged { focusState -> - isInputFocused = focusState.isFocused - if (focusState.isFocused) { - coroutineScope.launch { - sheetState.expand() - // Scroll to bottom to show input and remove button - listState.animateScrollToItem( - index = listState.layoutInfo.totalItemsCount - 1 - ) + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) + ) + + BasicTextField( + value = customGeohash, + onValueChange = { newValue -> + // iOS-style geohash validation (base32 characters only) + val allowed = "0123456789bcdefghjkmnpqrstuvwxyz".toSet() + val filtered = newValue + .lowercase() + .replace("#", "") + .filter { it in allowed } + .take(12) + + customGeohash = filtered + customError = null + }, + textStyle = androidx.compose.ui.text.TextStyle( + fontSize = BASE_FONT_SIZE.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface + ), + modifier = Modifier + .weight(1f) + .onFocusChanged { focusState -> + isInputFocused = focusState.isFocused + if (focusState.isFocused) { + coroutineScope.launch { + sheetState.expand() + // Scroll to bottom to show input and remove button + listState.animateScrollToItem( + index = listState.layoutInfo.totalItemsCount - 1 + ) + } } + }, + singleLine = true, + decorationBox = { innerTextField -> + if (customGeohash.isEmpty()) { + Text( + text = "geohash", + fontSize = BASE_FONT_SIZE.sp, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.4f) + ) + } + innerTextField() + } + ) + + val normalized = customGeohash.trim().lowercase().replace("#", "") + + // Map picker button + IconButton(onClick = { + val initial = when { + normalized.isNotBlank() -> normalized + selectedChannel is ChannelID.Location -> (selectedChannel as ChannelID.Location).channel.geohash + else -> "" + } + val intent = Intent(context, GeohashPickerActivity::class.java).apply { + putExtra(GeohashPickerActivity.EXTRA_INITIAL_GEOHASH, initial) + } + mapPickerLauncher.launch(intent) + }) { + Icon( + imageVector = Icons.Filled.Map, + contentDescription = "Open map", + tint = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f) + ) + } + + val isValid = validateGeohash(normalized) + + // iOS-style teleport button + Button( + onClick = { + if (isValid) { + val level = levelForLength(normalized.length) + val channel = GeohashChannel(level = level, geohash = normalized) + // Mark this selection as a manual teleport + locationManager.setTeleported(true) + locationManager.select(ChannelID.Location(channel)) + onDismiss() + } else { + customError = "invalid geohash" } }, - singleLine = true, - decorationBox = { innerTextField -> - if (customGeohash.isEmpty()) { + enabled = isValid, + colors = ButtonDefaults.buttonColors( + containerColor = MaterialTheme.colorScheme.secondary.copy(alpha = 0.12f), + contentColor = MaterialTheme.colorScheme.onSurface + ) + ) { + Row( + horizontalArrangement = Arrangement.spacedBy(6.dp), + verticalAlignment = Alignment.CenterVertically + ) { Text( - text = "geohash", + text = "teleport", fontSize = BASE_FONT_SIZE.sp, - fontFamily = FontFamily.Monospace, - color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.4f) + fontFamily = FontFamily.Monospace + ) + // iOS has a face.dashed icon, use closest Material equivalent + Icon( + imageVector = Icons.Filled.PinDrop, + contentDescription = "Teleport", + modifier = Modifier.size(14.dp), + tint = MaterialTheme.colorScheme.onSurface ) } - innerTextField() } - ) - - val normalized = customGeohash.trim().lowercase().replace("#", "") - - // Map picker button - IconButton(onClick = { - val initial = when { - normalized.isNotBlank() -> normalized - selectedChannel is ChannelID.Location -> (selectedChannel as ChannelID.Location).channel.geohash - else -> "" - } - val intent = Intent(context, GeohashPickerActivity::class.java).apply { - putExtra(GeohashPickerActivity.EXTRA_INITIAL_GEOHASH, initial) - } - mapPickerLauncher.launch(intent) - }) { - Icon( - imageVector = Icons.Filled.Map, - contentDescription = "Open map", - tint = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f) - ) } - - val isValid = validateGeohash(normalized) - - // iOS-style teleport button - Button( - onClick = { - if (isValid) { - val level = levelForLength(normalized.length) - val channel = GeohashChannel(level = level, geohash = normalized) - // Mark this selection as a manual teleport - locationManager.setTeleported(true) - locationManager.select(ChannelID.Location(channel)) - onDismiss() - } else { - customError = "invalid geohash" - } - }, - enabled = isValid, - colors = ButtonDefaults.buttonColors( - containerColor = MaterialTheme.colorScheme.secondary.copy(alpha = 0.12f), - contentColor = MaterialTheme.colorScheme.onSurface + + customError?.let { error -> + Text( + text = error, + fontSize = 12.sp, + fontFamily = FontFamily.Monospace, + color = Color.Red ) - ) { - Row( - horizontalArrangement = Arrangement.spacedBy(4.dp), - verticalAlignment = Alignment.CenterVertically - ) { - Text( - text = "teleport", - fontSize = BASE_FONT_SIZE.sp, - fontFamily = FontFamily.Monospace - ) - // iOS has a face.dashed icon, use closest Material equivalent - Icon( - imageVector = Icons.Filled.PinDrop, - contentDescription = "Teleport", - modifier = Modifier.size(14.dp), - tint = MaterialTheme.colorScheme.onSurface - ) - } } } } } - - // Error message for custom geohash - if (customError != null) { - item(key = "geohash_error") { - Text( - text = customError!!, - fontSize = 12.sp, - fontFamily = FontFamily.Monospace, - color = Color.Red, - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - ) - } - } - + // Location services toggle button - item(key = "location_toggle") { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp) - .padding(top = 8.dp) + item { + Button( + onClick = { + if (locationServicesEnabled) { + locationManager.disableLocationServices() + } else { + locationManager.enableLocationServices() + } + }, + colors = ButtonDefaults.buttonColors( + containerColor = if (locationServicesEnabled) { + Color.Red.copy(alpha = 0.08f) + } else { + standardGreen.copy(alpha = 0.12f) + }, + contentColor = if (locationServicesEnabled) { + Color(0xFFBF1A1A) + } else { + standardGreen + } + ), + modifier = Modifier.fillMaxWidth() ) { - Button( - onClick = { - if (locationServicesEnabled) { - locationManager.disableLocationServices() - } else { - locationManager.enableLocationServices() - } + Text( + text = if (locationServicesEnabled) { + "disable location services" + } else { + "enable location services" }, - colors = ButtonDefaults.buttonColors( - containerColor = if (locationServicesEnabled) { - Color.Red.copy(alpha = 0.08f) - } else { - standardGreen.copy(alpha = 0.12f) - }, - contentColor = if (locationServicesEnabled) { - Color(0xFFBF1A1A) - } else { - standardGreen - } - ), - modifier = Modifier.fillMaxWidth() - ) { - Text( - text = if (locationServicesEnabled) { - "disable location services" - } else { - "enable location services" - }, - fontSize = 12.sp, - fontFamily = FontFamily.Monospace - ) - } + fontSize = 12.sp, + fontFamily = FontFamily.Monospace + ) } } } - - // TopBar (animated) - Box( - modifier = Modifier - .align(Alignment.TopCenter) - .fillMaxWidth() - .height(56.dp) - .background(MaterialTheme.colorScheme.background.copy(alpha = topBarAlpha)) - ) { - TextButton( - onClick = onDismiss, - modifier = Modifier - .align(Alignment.CenterEnd) - .padding(horizontal = 16.dp) - ) { - Text( - text = "Close", - style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Bold), - color = MaterialTheme.colorScheme.onBackground - ) - } - } } } } - - // Lifecycle management: when presented, sample both nearby and bookmarked geohashes - LaunchedEffect(isPresented, availableChannels, bookmarks) { + + // Lifecycle management + LaunchedEffect(isPresented) { if (isPresented) { + // Refresh channels when opening (only if location services are enabled) if (permissionState == LocationChannelManager.PermissionState.AUTHORIZED && locationServicesEnabled) { locationManager.refreshChannels() } + // Begin periodic refresh while sheet is open (only if location services are enabled) if (locationServicesEnabled) { locationManager.beginLiveRefresh() } - val geohashes = (availableChannels.map { it.geohash } + bookmarks).toSet().toList() + + // Begin multi-channel sampling for counts + val geohashes = availableChannels.map { it.geohash } viewModel.beginGeohashSampling(geohashes) } else { locationManager.endLiveRefresh() viewModel.endGeohashSampling() } } - + // React to permission changes LaunchedEffect(permissionState) { if (permissionState == LocationChannelManager.PermissionState.AUTHORIZED && locationServicesEnabled) { locationManager.refreshChannels() } } - + // React to location services enable/disable LaunchedEffect(locationServicesEnabled) { if (locationServicesEnabled && permissionState == LocationChannelManager.PermissionState.AUTHORIZED) { locationManager.refreshChannels() } } + + // React to available channels changes + LaunchedEffect(availableChannels) { + val geohashes = availableChannels.map { it.geohash } + viewModel.beginGeohashSampling(geohashes) + } } @Composable @@ -607,7 +490,6 @@ private fun ChannelRow( isSelected: Boolean, titleColor: Color? = null, titleBold: Boolean = false, - trailingContent: (@Composable (() -> Unit))? = null, onClick: () -> Unit ) { // iOS-style list row (plain button, no card background) @@ -619,24 +501,22 @@ private fun ChannelRow( Color.Transparent }, shape = MaterialTheme.shapes.medium, - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 24.dp, vertical = 2.dp) + modifier = Modifier.fillMaxWidth() ) { Row( modifier = Modifier .fillMaxWidth() - .padding(horizontal = 16.dp, vertical = 6.dp), + .padding(horizontal = 16.dp, vertical = 12.dp), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically ) { Column( modifier = Modifier.weight(1f), - verticalArrangement = Arrangement.spacedBy(2.dp) + verticalArrangement = Arrangement.spacedBy(4.dp) ) { // Split title to handle count part with smaller font (iOS style) val (baseTitle, countSuffix) = splitTitleAndCount(title) - + Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) { Text( text = baseTitle, @@ -645,7 +525,7 @@ private fun ChannelRow( fontWeight = if (titleBold) FontWeight.Bold else FontWeight.Normal, color = titleColor ?: MaterialTheme.colorScheme.onSurface ) - + countSuffix?.let { count -> Text( text = count, @@ -655,7 +535,7 @@ private fun ChannelRow( ) } } - + Text( text = subtitle, fontSize = 12.sp, @@ -663,20 +543,14 @@ private fun ChannelRow( color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) ) } - - Row(verticalAlignment = Alignment.CenterVertically) { - if (isSelected) { - Icon( - imageVector = Icons.Filled.Check, - contentDescription = "Selected", - tint = Color(0xFF32D74B), // iOS green for checkmark - modifier = Modifier.size(20.dp) - ) - } - - if (trailingContent != null) { - trailingContent() - } + + if (isSelected) { + Text( + text = "✔︎", + fontSize = 16.sp, + fontFamily = FontFamily.Monospace, + color = Color(0xFF32D74B) // iOS green for checkmark + ) } } } @@ -713,11 +587,6 @@ private fun geohashTitleWithCount(channel: GeohashChannel, participantCount: Int return "${channel.level.displayName.lowercase()} [$participantCount $noun]" } -private fun geohashHashTitleWithCount(geohash: String, participantCount: Int): String { - val noun = if (participantCount == 1) "person" else "people" - return "#$geohash [$participantCount $noun]" -} - private fun isChannelSelected(channel: GeohashChannel, selectedChannel: ChannelID?): Boolean { return when (selectedChannel) { is ChannelID.Location -> selectedChannel.channel == channel @@ -756,7 +625,7 @@ private fun coverageString(precision: Int): String { 10 -> 1.19 else -> if (precision <= 1) 5_000_000.0 else 1.19 * Math.pow(0.25, (precision - 10).toDouble()) } - + // Use metric system for simplicity (could be made locale-aware) val km = maxMeters / 1000.0 return "~${formatDistance(km)} km" @@ -776,5 +645,9 @@ private fun bluetoothRangeString(): String { } private fun formattedNamePrefix(level: GeohashChannelLevel): String { +// return when (level) { +// GeohashChannelLevel.REGION -> "" +// else -> "~" +// } return "~" } diff --git a/app/src/main/java/com/bitchat/android/ui/MatrixEncryptionAnimation.kt b/app/src/main/java/com/bitchat/android/ui/MatrixEncryptionAnimation.kt index 1ea59444c..97f5df24d 100644 --- a/app/src/main/java/com/bitchat/android/ui/MatrixEncryptionAnimation.kt +++ b/app/src/main/java/com/bitchat/android/ui/MatrixEncryptionAnimation.kt @@ -74,14 +74,12 @@ object PoWMiningTracker { @Composable fun MessageWithMatrixAnimation( message: com.bitchat.android.model.BitchatMessage, - messages: List = emptyList(), currentUserNickname: String, meshService: com.bitchat.android.mesh.BluetoothMeshService, colorScheme: androidx.compose.material3.ColorScheme, timeFormatter: java.text.SimpleDateFormat, onNicknameClick: ((String) -> Unit)?, onMessageLongPress: ((com.bitchat.android.model.BitchatMessage) -> Unit)?, - onImageClick: ((String, List, Int) -> Unit)?, modifier: Modifier = Modifier ) { val isAnimating = shouldAnimateMessage(message.id) diff --git a/app/src/main/java/com/bitchat/android/ui/MediaSendingManager.kt b/app/src/main/java/com/bitchat/android/ui/MediaSendingManager.kt deleted file mode 100644 index e9befa4ef..000000000 --- a/app/src/main/java/com/bitchat/android/ui/MediaSendingManager.kt +++ /dev/null @@ -1,329 +0,0 @@ -package com.bitchat.android.ui - -import android.util.Log -import com.bitchat.android.mesh.BluetoothMeshService -import com.bitchat.android.model.BitchatFilePacket -import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType -import java.util.Date -import java.security.MessageDigest - -/** - * Handles media file sending operations (voice notes, images, generic files) - * Separated from ChatViewModel for better separation of concerns - */ -class MediaSendingManager( - private val state: ChatState, - private val messageManager: MessageManager, - private val channelManager: ChannelManager, - private val meshService: BluetoothMeshService -) { - companion object { - private const val TAG = "MediaSendingManager" - private const val MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB limit - } - - // Track in-flight transfer progress: transferId -> messageId and reverse - private val transferMessageMap = mutableMapOf() - private val messageTransferMap = mutableMapOf() - - /** - * Send a voice note (audio file) - */ - fun sendVoiceNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - try { - val file = java.io.File(filePath) - if (!file.exists()) { - Log.e(TAG, "❌ File does not exist: $filePath") - return - } - Log.d(TAG, "📁 File exists: size=${file.length()} bytes, name=${file.name}") - - if (file.length() > MAX_FILE_SIZE) { - Log.e(TAG, "❌ File too large: ${file.length()} bytes (max: $MAX_FILE_SIZE)") - return - } - - val filePacket = BitchatFilePacket( - fileName = file.name, - fileSize = file.length(), - mimeType = "audio/mp4", - content = file.readBytes() - ) - - if (toPeerIDOrNull != null) { - sendPrivateFile(toPeerIDOrNull, filePacket, filePath, BitchatMessageType.Audio) - } else { - sendPublicFile(channelOrNull, filePacket, filePath, BitchatMessageType.Audio) - } - } catch (e: Exception) { - Log.e(TAG, "Failed to send voice note: ${e.message}") - } - } - - /** - * Send an image file - */ - fun sendImageNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - try { - Log.d(TAG, "🔄 Starting image send: $filePath") - val file = java.io.File(filePath) - if (!file.exists()) { - Log.e(TAG, "❌ File does not exist: $filePath") - return - } - Log.d(TAG, "📁 File exists: size=${file.length()} bytes, name=${file.name}") - - if (file.length() > MAX_FILE_SIZE) { - Log.e(TAG, "❌ File too large: ${file.length()} bytes (max: $MAX_FILE_SIZE)") - return - } - - val filePacket = BitchatFilePacket( - fileName = file.name, - fileSize = file.length(), - mimeType = "image/jpeg", - content = file.readBytes() - ) - - if (toPeerIDOrNull != null) { - sendPrivateFile(toPeerIDOrNull, filePacket, filePath, BitchatMessageType.Image) - } else { - sendPublicFile(channelOrNull, filePacket, filePath, BitchatMessageType.Image) - } - } catch (e: Exception) { - Log.e(TAG, "❌ CRITICAL: Image send failed completely", e) - Log.e(TAG, "❌ Image path: $filePath") - Log.e(TAG, "❌ Error details: ${e.message}") - Log.e(TAG, "❌ Error type: ${e.javaClass.simpleName}") - } - } - - /** - * Send a generic file - */ - fun sendFileNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) { - try { - Log.d(TAG, "🔄 Starting file send: $filePath") - val file = java.io.File(filePath) - if (!file.exists()) { - Log.e(TAG, "❌ File does not exist: $filePath") - return - } - Log.d(TAG, "📁 File exists: size=${file.length()} bytes, name=${file.name}") - - if (file.length() > MAX_FILE_SIZE) { - Log.e(TAG, "❌ File too large: ${file.length()} bytes (max: $MAX_FILE_SIZE)") - return - } - - // Use the real MIME type based on extension; fallback to octet-stream - val mimeType = try { - com.bitchat.android.features.file.FileUtils.getMimeTypeFromExtension(file.name) - } catch (_: Exception) { - "application/octet-stream" - } - Log.d(TAG, "🏷️ MIME type: $mimeType") - - // Try to preserve the original file name if our copier prefixed it earlier - val originalName = run { - val name = file.name - val base = name.substringBeforeLast('.') - val ext = name.substringAfterLast('.', "").let { if (it.isNotBlank()) ".${it}" else "" } - val stripped = Regex("^send_\\d+_(.+)$").matchEntire(base)?.groupValues?.getOrNull(1) ?: base - stripped + ext - } - Log.d(TAG, "📝 Original filename: $originalName") - - val filePacket = BitchatFilePacket( - fileName = originalName, - fileSize = file.length(), - mimeType = mimeType, - content = file.readBytes() - ) - Log.d(TAG, "📦 Created file packet successfully") - - val messageType = when { - mimeType.lowercase().startsWith("image/") -> BitchatMessageType.Image - mimeType.lowercase().startsWith("audio/") -> BitchatMessageType.Audio - else -> BitchatMessageType.File - } - - if (toPeerIDOrNull != null) { - sendPrivateFile(toPeerIDOrNull, filePacket, filePath, messageType) - } else { - sendPublicFile(channelOrNull, filePacket, filePath, messageType) - } - } catch (e: Exception) { - Log.e(TAG, "❌ CRITICAL: File send failed completely", e) - Log.e(TAG, "❌ File path: $filePath") - Log.e(TAG, "❌ Error details: ${e.message}") - Log.e(TAG, "❌ Error type: ${e.javaClass.simpleName}") - } - } - - /** - * Send a file privately (encrypted) - */ - private fun sendPrivateFile( - toPeerID: String, - filePacket: BitchatFilePacket, - filePath: String, - messageType: BitchatMessageType - ) { - val payload = filePacket.encode() - if (payload == null) { - Log.e(TAG, "❌ Failed to encode file packet for private send") - return - } - Log.d(TAG, "🔒 Encoded private packet: ${payload.size} bytes") - - val transferId = sha256Hex(payload) - val contentHash = sha256Hex(filePacket.content) - - Log.d(TAG, "📤 FILE_TRANSFER send (private): name='${filePacket.fileName}', size=${filePacket.fileSize}, mime='${filePacket.mimeType}', sha256=$contentHash, to=${toPeerID.take(8)} transferId=${transferId.take(16)}…") - - val msg = BitchatMessage( - id = java.util.UUID.randomUUID().toString().uppercase(), // Generate unique ID for each message - sender = state.getNicknameValue() ?: "me", - content = filePath, - type = messageType, - timestamp = Date(), - isRelay = false, - isPrivate = true, - recipientNickname = try { meshService.getPeerNicknames()[toPeerID] } catch (_: Exception) { null }, - senderPeerID = meshService.myPeerID - ) - - messageManager.addPrivateMessage(toPeerID, msg) - - synchronized(transferMessageMap) { - transferMessageMap[transferId] = msg.id - messageTransferMap[msg.id] = transferId - } - - // Seed progress so delivery icons render for media - messageManager.updateMessageDeliveryStatus( - msg.id, - com.bitchat.android.model.DeliveryStatus.PartiallyDelivered(0, 100) - ) - - Log.d(TAG, "📤 Calling meshService.sendFilePrivate to $toPeerID") - meshService.sendFilePrivate(toPeerID, filePacket) - Log.d(TAG, "✅ File send completed successfully") - } - - /** - * Send a file publicly (broadcast or channel) - */ - private fun sendPublicFile( - channelOrNull: String?, - filePacket: BitchatFilePacket, - filePath: String, - messageType: BitchatMessageType - ) { - val payload = filePacket.encode() - if (payload == null) { - Log.e(TAG, "❌ Failed to encode file packet for broadcast send") - return - } - Log.d(TAG, "🔓 Encoded broadcast packet: ${payload.size} bytes") - - val transferId = sha256Hex(payload) - val contentHash = sha256Hex(filePacket.content) - - Log.d(TAG, "📤 FILE_TRANSFER send (broadcast): name='${filePacket.fileName}', size=${filePacket.fileSize}, mime='${filePacket.mimeType}', sha256=$contentHash, transferId=${transferId.take(16)}…") - - val message = BitchatMessage( - id = java.util.UUID.randomUUID().toString().uppercase(), // Generate unique ID for each message - sender = state.getNicknameValue() ?: meshService.myPeerID, - content = filePath, - type = messageType, - timestamp = Date(), - isRelay = false, - senderPeerID = meshService.myPeerID, - channel = channelOrNull - ) - - if (!channelOrNull.isNullOrBlank()) { - channelManager.addChannelMessage(channelOrNull, message, meshService.myPeerID) - } else { - messageManager.addMessage(message) - } - - synchronized(transferMessageMap) { - transferMessageMap[transferId] = message.id - messageTransferMap[message.id] = transferId - } - - // Seed progress so animations start immediately - messageManager.updateMessageDeliveryStatus( - message.id, - com.bitchat.android.model.DeliveryStatus.PartiallyDelivered(0, 100) - ) - - Log.d(TAG, "📤 Calling meshService.sendFileBroadcast") - meshService.sendFileBroadcast(filePacket) - Log.d(TAG, "✅ File broadcast completed successfully") - } - - /** - * Cancel a media transfer by message ID - */ - fun cancelMediaSend(messageId: String) { - val transferId = synchronized(transferMessageMap) { messageTransferMap[messageId] } - if (transferId != null) { - val cancelled = meshService.cancelFileTransfer(transferId) - if (cancelled) { - // Remove the message from chat upon explicit cancel - messageManager.removeMessageById(messageId) - synchronized(transferMessageMap) { - transferMessageMap.remove(transferId) - messageTransferMap.remove(messageId) - } - } - } - } - - /** - * Update progress for a transfer - */ - fun updateTransferProgress(transferId: String, messageId: String) { - synchronized(transferMessageMap) { - transferMessageMap[transferId] = messageId - messageTransferMap[messageId] = transferId - } - } - - /** - * Handle transfer progress events - */ - fun handleTransferProgressEvent(evt: com.bitchat.android.mesh.TransferProgressEvent) { - val msgId = synchronized(transferMessageMap) { transferMessageMap[evt.transferId] } - if (msgId != null) { - if (evt.completed) { - messageManager.updateMessageDeliveryStatus( - msgId, - com.bitchat.android.model.DeliveryStatus.Delivered(to = "mesh", at = java.util.Date()) - ) - synchronized(transferMessageMap) { - val msgIdRemoved = transferMessageMap.remove(evt.transferId) - if (msgIdRemoved != null) messageTransferMap.remove(msgIdRemoved) - } - } else { - messageManager.updateMessageDeliveryStatus( - msgId, - com.bitchat.android.model.DeliveryStatus.PartiallyDelivered(evt.sent, evt.total) - ) - } - } - } - - private fun sha256Hex(bytes: ByteArray): String = try { - val md = MessageDigest.getInstance("SHA-256") - md.update(bytes) - md.digest().joinToString("") { "%02x".format(it) } - } catch (_: Exception) { - bytes.size.toString(16) - } -} 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..ea7fff683 100644 --- a/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt +++ b/app/src/main/java/com/bitchat/android/ui/MeshDelegateHandler.kt @@ -1,7 +1,6 @@ package com.bitchat.android.ui import com.bitchat.android.mesh.BluetoothMeshDelegate -import com.bitchat.android.ui.NotificationTextUtils import com.bitchat.android.mesh.BluetoothMeshService import com.bitchat.android.model.BitchatMessage import com.bitchat.android.model.DeliveryStatus @@ -56,11 +55,10 @@ class MeshDelegateHandler( message.senderPeerID?.let { senderPeerID -> // Use nickname if available, fall back to sender or senderPeerID val senderNickname = message.sender.takeIf { it != senderPeerID } ?: senderPeerID - val preview = NotificationTextUtils.buildPrivateMessagePreview(message) notificationManager.showPrivateMessageNotification( - senderPeerID = senderPeerID, - senderNickname = senderNickname, - messageContent = preview + senderPeerID = senderPeerID, + senderNickname = senderNickname, + messageContent = message.content ) } } else if (message.channel != null) { @@ -287,5 +285,4 @@ class MeshDelegateHandler( fun getPeerInfo(peerID: String): com.bitchat.android.mesh.PeerInfo? { return getMeshService().getPeerInfo(peerID) } - } diff --git a/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt b/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt index b926b1f19..c8452c3b1 100644 --- a/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt +++ b/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt @@ -1,7 +1,6 @@ package com.bitchat.android.ui import androidx.compose.foundation.ExperimentalFoundationApi -import androidx.compose.ui.draw.clip import androidx.compose.foundation.gestures.detectTapGestures import androidx.compose.foundation.layout.* import androidx.compose.foundation.lazy.LazyColumn @@ -16,9 +15,6 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.text.TextLayoutResult -import androidx.compose.ui.text.AnnotatedString -import androidx.compose.ui.text.SpanStyle -import androidx.compose.ui.text.buildAnnotatedString import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow @@ -34,17 +30,6 @@ import com.bitchat.android.model.DeliveryStatus import com.bitchat.android.mesh.BluetoothMeshService import java.text.SimpleDateFormat import java.util.* -import com.bitchat.android.ui.media.VoiceNotePlayer -import androidx.compose.material3.Icon -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Close -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.shape.CircleShape -import com.bitchat.android.ui.media.FileMessageItem -import com.bitchat.android.model.BitchatMessageType - -// VoiceNotePlayer moved to com.bitchat.android.ui.media.VoiceNotePlayer /** * Message display components for ChatScreen @@ -60,9 +45,7 @@ fun MessagesList( forceScrollToBottom: Boolean = false, onScrolledUpChanged: ((Boolean) -> Unit)? = null, onNicknameClick: ((String) -> Unit)? = null, - onMessageLongPress: ((BitchatMessage) -> Unit)? = null, - onCancelTransfer: ((BitchatMessage) -> Unit)? = null, - onImageClick: ((String, List, Int) -> Unit)? = null + onMessageLongPress: ((BitchatMessage) -> Unit)? = null ) { val listState = rememberLazyListState() @@ -114,19 +97,13 @@ fun MessagesList( modifier = modifier, reverseLayout = true ) { - items( - items = messages.asReversed(), - key = { it.id } - ) { message -> + items(messages.asReversed()) { message -> MessageItem( message = message, - messages = messages, currentUserNickname = currentUserNickname, meshService = meshService, onNicknameClick = onNicknameClick, - onMessageLongPress = onMessageLongPress, - onCancelTransfer = onCancelTransfer, - onImageClick = onImageClick + onMessageLongPress = onMessageLongPress ) } } @@ -138,11 +115,8 @@ fun MessageItem( message: BitchatMessage, currentUserNickname: String, meshService: BluetoothMeshService, - messages: List = emptyList(), onNicknameClick: ((String) -> Unit)? = null, - onMessageLongPress: ((BitchatMessage) -> Unit)? = null, - onCancelTransfer: ((BitchatMessage) -> Unit)? = null, - onImageClick: ((String, List, Int) -> Unit)? = null + onMessageLongPress: ((BitchatMessage) -> Unit)? = null ) { val colorScheme = MaterialTheme.colorScheme val timeFormatter = remember { SimpleDateFormat("HH:mm:ss", Locale.getDefault()) } @@ -151,42 +125,27 @@ fun MessageItem( modifier = Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(0.dp) ) { - Box(modifier = Modifier.fillMaxWidth()) { - Row( - modifier = Modifier.fillMaxWidth(), - horizontalArrangement = Arrangement.Start, - verticalAlignment = Alignment.Top - ) { - // Provide a small end padding for own private messages so overlay doesn't cover text - val endPad = if (message.isPrivate && message.sender == currentUserNickname) 16.dp else 0.dp - // Create a custom layout that combines selectable text with clickable nickname areas - MessageTextWithClickableNicknames( - message = message, - messages = messages, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter, - onNicknameClick = onNicknameClick, - onMessageLongPress = onMessageLongPress, - onCancelTransfer = onCancelTransfer, - onImageClick = onImageClick, - modifier = Modifier - .weight(1f) - .padding(end = endPad) - ) - } - - // Delivery status for private messages (overlay, non-displacing) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.Top + ) { + // Create a custom layout that combines selectable text with clickable nickname areas + MessageTextWithClickableNicknames( + message = message, + currentUserNickname = currentUserNickname, + meshService = meshService, + colorScheme = colorScheme, + timeFormatter = timeFormatter, + onNicknameClick = onNicknameClick, + onMessageLongPress = onMessageLongPress, + modifier = Modifier.weight(1f) + ) + + // Delivery status for private messages if (message.isPrivate && message.sender == currentUserNickname) { message.deliveryStatus?.let { status -> - Box( - modifier = Modifier - .align(Alignment.TopEnd) - .padding(top = 2.dp) - ) { - DeliveryStatusIcon(status = status) - } + DeliveryStatusIcon(status = status) } } } @@ -197,155 +156,16 @@ fun MessageItem( @OptIn(ExperimentalFoundationApi::class) @Composable - private fun MessageTextWithClickableNicknames( - message: BitchatMessage, - messages: List, - currentUserNickname: String, - meshService: BluetoothMeshService, - colorScheme: ColorScheme, - timeFormatter: SimpleDateFormat, - onNicknameClick: ((String) -> Unit)?, - onMessageLongPress: ((BitchatMessage) -> Unit)?, - onCancelTransfer: ((BitchatMessage) -> Unit)?, - onImageClick: ((String, List, Int) -> Unit)?, - modifier: Modifier = Modifier - ) { - // Image special rendering - if (message.type == BitchatMessageType.Image) { - com.bitchat.android.ui.media.ImageMessageItem( - message = message, - messages = messages, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter, - onNicknameClick = onNicknameClick, - onMessageLongPress = onMessageLongPress, - onCancelTransfer = onCancelTransfer, - onImageClick = onImageClick, - modifier = modifier - ) - return - } - - // Voice note special rendering - if (message.type == BitchatMessageType.Audio) { - com.bitchat.android.ui.media.AudioMessageItem( - message = message, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter, - onNicknameClick = onNicknameClick, - onMessageLongPress = onMessageLongPress, - onCancelTransfer = onCancelTransfer, - modifier = modifier - ) - return - } - - // File special rendering - if (message.type == BitchatMessageType.File) { - val path = message.content.trim() - // Derive sending progress if applicable - val (overrideProgress, _) = when (val st = message.deliveryStatus) { - is com.bitchat.android.model.DeliveryStatus.PartiallyDelivered -> { - if (st.total > 0 && st.reached < st.total) { - (st.reached.toFloat() / st.total.toFloat()) to Color(0xFF1E88E5) // blue while sending - } else null to null - } - else -> null to null - } - Column(modifier = modifier.fillMaxWidth()) { - // Header: nickname + timestamp line above the file, identical styling to text messages - val headerText = formatMessageHeaderAnnotatedString( - message = message, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter - ) - val haptic = LocalHapticFeedback.current - var headerLayout by remember { mutableStateOf(null) } - Text( - text = headerText, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface, - modifier = Modifier.pointerInput(message.id) { - detectTapGestures(onTap = { pos -> - val layout = headerLayout ?: return@detectTapGestures - val offset = layout.getOffsetForPosition(pos) - val ann = headerText.getStringAnnotations("nickname_click", offset, offset) - if (ann.isNotEmpty() && onNicknameClick != null) { - haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove) - onNicknameClick.invoke(ann.first().item) - } - }, onLongPress = { onMessageLongPress?.invoke(message) }) - }, - onTextLayout = { headerLayout = it } - ) - - // Try to load the file packet from the path - val packet = try { - val file = java.io.File(path) - if (file.exists()) { - // Create a temporary BitchatFilePacket for display - // In a real implementation, this would be stored with the packet metadata - com.bitchat.android.model.BitchatFilePacket( - fileName = file.name, - fileSize = file.length(), - mimeType = com.bitchat.android.features.file.FileUtils.getMimeTypeFromExtension(file.name), - content = file.readBytes() - ) - } else null - } catch (e: Exception) { - null - } - - Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { - Box { - if (packet != null) { - if (overrideProgress != null) { - // Show sending animation while in-flight - com.bitchat.android.ui.media.FileSendingAnimation( - fileName = packet.fileName, - progress = overrideProgress, - modifier = Modifier.fillMaxWidth() - ) - } else { - // Static file display with open/save dialog - FileMessageItem( - packet = packet, - onFileClick = { - // handled inside FileMessageItem via dialog - } - ) - } - - // Cancel button overlay during sending - val showCancel = message.sender == currentUserNickname && (message.deliveryStatus is DeliveryStatus.PartiallyDelivered) - if (showCancel) { - Box( - modifier = Modifier - .align(Alignment.TopEnd) - .padding(4.dp) - .size(22.dp) - .background(Color.Gray.copy(alpha = 0.6f), CircleShape) - .clickable { onCancelTransfer?.invoke(message) }, - contentAlignment = Alignment.Center - ) { - Icon(imageVector = Icons.Filled.Close, contentDescription = "Cancel", tint = Color.White, modifier = Modifier.size(14.dp)) - } - } - } else { - Text(text = "[file unavailable]", fontFamily = FontFamily.Monospace, color = Color.Gray) - } - } - } - } - return - } - +private fun MessageTextWithClickableNicknames( + message: BitchatMessage, + currentUserNickname: String, + meshService: BluetoothMeshService, + colorScheme: ColorScheme, + timeFormatter: SimpleDateFormat, + onNicknameClick: ((String) -> Unit)?, + onMessageLongPress: ((BitchatMessage) -> Unit)?, + modifier: Modifier = Modifier +) { // Check if this message should be animated during PoW mining val shouldAnimate = shouldAnimateMessage(message.id) @@ -354,14 +174,12 @@ fun MessageItem( // Display message with matrix animation for content MessageWithMatrixAnimation( message = message, - messages = messages, currentUserNickname = currentUserNickname, meshService = meshService, colorScheme = colorScheme, timeFormatter = timeFormatter, onNicknameClick = onNicknameClick, onMessageLongPress = onMessageLongPress, - onImageClick = onImageClick, modifier = modifier ) } else { @@ -508,9 +326,8 @@ fun DeliveryStatusIcon(status: DeliveryStatus) { ) } is DeliveryStatus.PartiallyDelivered -> { - // Show a single subdued check without numeric label Text( - text = "✓", + text = "✓${status.reached}/${status.total}", fontSize = 10.sp, color = colorScheme.primary.copy(alpha = 0.6f) ) 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 001d5fbd2..276a6bbe9 100644 --- a/app/src/main/java/com/bitchat/android/ui/MessageManager.kt +++ b/app/src/main/java/com/bitchat/android/ui/MessageManager.kt @@ -244,49 +244,6 @@ class MessageManager(private val state: ChatState) { } state.setChannelMessages(updatedChannelMessages) } - - // Remove a message from all locations (main timeline, private chats, channels) - fun removeMessageById(messageID: String) { - // Main timeline - run { - val list = state.getMessagesValue().toMutableList() - val idx = list.indexOfFirst { it.id == messageID } - if (idx >= 0) { - list.removeAt(idx) - state.setMessages(list) - } - } - // Private chats - run { - val chats = state.getPrivateChatsValue().toMutableMap() - var changed = false - chats.keys.toList().forEach { key -> - val msgs = chats[key]?.toMutableList() ?: mutableListOf() - val idx = msgs.indexOfFirst { it.id == messageID } - if (idx >= 0) { - msgs.removeAt(idx) - chats[key] = msgs - changed = true - } - } - if (changed) state.setPrivateChats(chats) - } - // Channels - run { - val chans = state.getChannelMessagesValue().toMutableMap() - var changed = false - chans.keys.toList().forEach { ch -> - val msgs = chans[ch]?.toMutableList() ?: mutableListOf() - val idx = msgs.indexOfFirst { it.id == messageID } - if (idx >= 0) { - msgs.removeAt(idx) - chans[ch] = msgs - changed = true - } - } - if (changed) state.setChannelMessages(chans) - } - } // MARK: - Utility Functions diff --git a/app/src/main/java/com/bitchat/android/ui/NotificationTextUtils.kt b/app/src/main/java/com/bitchat/android/ui/NotificationTextUtils.kt deleted file mode 100644 index a80a2ea69..000000000 --- a/app/src/main/java/com/bitchat/android/ui/NotificationTextUtils.kt +++ /dev/null @@ -1,48 +0,0 @@ -package com.bitchat.android.ui - -import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType - -/** - * Utilities for building human-friendly notification text/previews. - */ -object NotificationTextUtils { - /** - * Build a user-friendly notification preview for private messages, especially attachments. - * Examples: - * - Image: "📷 sent an image" - * - Audio: "🎤 sent a voice message" - * - File (pdf): "📄 file.pdf" - * - Text: original message content - */ - fun buildPrivateMessagePreview(message: BitchatMessage): String { - return try { - when (message.type) { - BitchatMessageType.Image -> "📷 sent an image" - BitchatMessageType.Audio -> "🎤 sent a voice message" - BitchatMessageType.File -> { - // Show just the filename (not the full path) - val name = try { java.io.File(message.content).name } catch (_: Exception) { null } - if (!name.isNullOrBlank()) { - val lower = name.lowercase() - val icon = when { - lower.endsWith(".pdf") -> "📄" - lower.endsWith(".zip") || lower.endsWith(".rar") || lower.endsWith(".7z") -> "🗜️" - lower.endsWith(".doc") || lower.endsWith(".docx") -> "📄" - lower.endsWith(".xls") || lower.endsWith(".xlsx") -> "📊" - lower.endsWith(".ppt") || lower.endsWith(".pptx") -> "📈" - else -> "📎" - } - "$icon $name" - } else { - "📎 sent a file" - } - } - else -> message.content - } - } catch (_: Exception) { - // Fallback to original content on any error - message.content - } - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/SidebarComponents.kt b/app/src/main/java/com/bitchat/android/ui/SidebarComponents.kt index b33a73301..973a817b3 100644 --- a/app/src/main/java/com/bitchat/android/ui/SidebarComponents.kt +++ b/app/src/main/java/com/bitchat/android/ui/SidebarComponents.kt @@ -123,7 +123,6 @@ fun SidebarOverlay( else -> { // Show mesh peer list when in mesh channel (default) PeopleSection( - modifier = modifier.padding(bottom = 16.dp), connectedPeers = connectedPeers, peerNicknames = peerNicknames, peerRSSI = peerRSSI, @@ -249,7 +248,6 @@ fun ChannelsSection( @Composable fun PeopleSection( - modifier: Modifier = Modifier, connectedPeers: List, peerNicknames: Map, peerRSSI: Map, @@ -259,7 +257,7 @@ fun PeopleSection( viewModel: ChatViewModel, onPrivateChatStart: (String) -> Unit ) { - Column(modifier = modifier) { + Column { Row( modifier = Modifier .fillMaxWidth() @@ -330,6 +328,8 @@ fun PeopleSection( return if (key == nickname) "You" else (peerNicknames[key] ?: (privateChats[key]?.lastOrNull()?.sender ?: key.take(12))) } + + val baseNameCounts = mutableMapOf() // Connected peers diff --git a/app/src/main/java/com/bitchat/android/ui/VoiceInputComponents.kt b/app/src/main/java/com/bitchat/android/ui/VoiceInputComponents.kt deleted file mode 100644 index 03ab53aa8..000000000 --- a/app/src/main/java/com/bitchat/android/ui/VoiceInputComponents.kt +++ /dev/null @@ -1,137 +0,0 @@ -package com.bitchat.android.ui - -import android.Manifest -import androidx.compose.foundation.background -import androidx.compose.foundation.gestures.detectTapGestures -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Mic -import androidx.compose.material3.Icon -import androidx.compose.runtime.* -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.input.pointer.pointerInput -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.platform.LocalHapticFeedback -import androidx.compose.ui.hapticfeedback.HapticFeedbackType -import androidx.compose.ui.unit.dp -import com.bitchat.android.features.voice.VoiceRecorder -import com.google.accompanist.permissions.ExperimentalPermissionsApi -import com.google.accompanist.permissions.PermissionStatus -import com.google.accompanist.permissions.rememberPermissionState -import kotlinx.coroutines.Job -import kotlinx.coroutines.delay -import kotlinx.coroutines.isActive -import kotlinx.coroutines.launch - -@OptIn(ExperimentalPermissionsApi::class) -@Composable -fun VoiceRecordButton( - modifier: Modifier = Modifier, - backgroundColor: Color, - onStart: () -> Unit, - onAmplitude: (amplitude: Int, elapsedMs: Long) -> Unit, - onFinish: (filePath: String) -> Unit -) { - val context = LocalContext.current - val haptic = LocalHapticFeedback.current - val micPermission = rememberPermissionState(Manifest.permission.RECORD_AUDIO) - - var isRecording by remember { mutableStateOf(false) } - var recorder by remember { mutableStateOf(null) } - var recordedFilePath by remember { mutableStateOf(null) } - var recordingStart by remember { mutableStateOf(0L) } - - val scope = rememberCoroutineScope() - var ampJob by remember { mutableStateOf(null) } - - // Ensure latest callbacks are used inside gesture coroutine - val latestOnStart = rememberUpdatedState(onStart) - val latestOnAmplitude = rememberUpdatedState(onAmplitude) - val latestOnFinish = rememberUpdatedState(onFinish) - - Box( - modifier = modifier - .size(32.dp) - .background(backgroundColor, CircleShape) - .pointerInput(Unit) { - detectTapGestures( - onPress = { - if (!isRecording) { - if (micPermission.status !is PermissionStatus.Granted) { - micPermission.launchPermissionRequest() - return@detectTapGestures - } - val rec = VoiceRecorder(context) - val f = rec.start() - recorder = rec - isRecording = f != null - recordedFilePath = f?.absolutePath - recordingStart = System.currentTimeMillis() - if (isRecording) { - latestOnStart.value() - // Haptic "knock" when recording starts - try { haptic.performHapticFeedback(HapticFeedbackType.LongPress) } catch (_: Exception) {} - // Start amplitude polling loop - ampJob?.cancel() - ampJob = scope.launch { - while (isActive && isRecording) { - val amp = recorder?.pollAmplitude() ?: 0 - val elapsedMs = (System.currentTimeMillis() - recordingStart).coerceAtLeast(0L) - latestOnAmplitude.value(amp, elapsedMs) - // Auto-stop after 10 seconds - if (elapsedMs >= 10_000 && isRecording) { - val file = recorder?.stop() - isRecording = false - recorder = null - val path = file?.absolutePath - if (!path.isNullOrBlank()) { - // Haptic "knock" on auto stop - try { haptic.performHapticFeedback(HapticFeedbackType.LongPress) } catch (_: Exception) {} - latestOnFinish.value(path) - } - break - } - delay(80) - } - } - } - } - try { - awaitRelease() - } finally { - if (isRecording) { - // Extend recording for 500ms after release to avoid clipping - delay(500) - } - if (isRecording) { - val file = recorder?.stop() - isRecording = false - recorder = null - val path = (file?.absolutePath ?: recordedFilePath) - recordedFilePath = null - if (!path.isNullOrBlank()) { - // Haptic "knock" when recording stops - try { haptic.performHapticFeedback(HapticFeedbackType.LongPress) } catch (_: Exception) {} - latestOnFinish.value(path) - } - } - ampJob?.cancel() - ampJob = null - } - } - ) - }, - contentAlignment = Alignment.Center - ) { - Icon( - imageVector = Icons.Filled.Mic, - contentDescription = "Record voice note", - tint = Color.Black, - modifier = Modifier.size(20.dp) - ) - } -} 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..84b624f7d 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 @@ -16,10 +16,6 @@ object DebugPreferenceManager { private const val KEY_MAX_CONN_OVERALL = "max_connections_overall" private const val KEY_MAX_CONN_SERVER = "max_connections_server" private const val KEY_MAX_CONN_CLIENT = "max_connections_client" - private const val KEY_SEEN_PACKET_CAP = "seen_packet_capacity" - // 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" private lateinit var prefs: SharedPreferences @@ -78,26 +74,4 @@ object DebugPreferenceManager { fun setMaxConnectionsClient(value: Int) { if (ready()) prefs.edit().putInt(KEY_MAX_CONN_CLIENT, value).apply() } - - // Sync/GCS settings - fun getSeenPacketCapacity(default: Int = 500): Int = - if (ready()) prefs.getInt(KEY_SEEN_PACKET_CAP, default) else default - - fun setSeenPacketCapacity(value: Int) { - if (ready()) prefs.edit().putInt(KEY_SEEN_PACKET_CAP, value).apply() - } - - fun getGcsMaxFilterBytes(default: Int = 400): Int = - if (ready()) prefs.getInt(KEY_GCS_MAX_BYTES, default) else default - - fun setGcsMaxFilterBytes(value: Int) { - if (ready()) prefs.edit().putInt(KEY_GCS_MAX_BYTES, value).apply() - } - - fun getGcsFprPercent(default: Double = 1.0): Double = - if (ready()) java.lang.Double.longBitsToDouble(prefs.getLong(KEY_GCS_FPR, java.lang.Double.doubleToRawLongBits(default))) else default - - fun setGcsFprPercent(value: Double) { - if (ready()) prefs.edit().putLong(KEY_GCS_FPR, java.lang.Double.doubleToRawLongBits(value)).apply() - } } 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..81538058f 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 @@ -201,37 +201,6 @@ class DebugSettingsManager private constructor() { fun updateRelayStats(stats: PacketRelayStats) { _relayStats.value = stats } - - // Sync/GCS settings (UI-configurable) - private val _seenPacketCapacity = MutableStateFlow(DebugPreferenceManager.getSeenPacketCapacity(500)) - val seenPacketCapacity: StateFlow = _seenPacketCapacity.asStateFlow() - - private val _gcsMaxBytes = MutableStateFlow(DebugPreferenceManager.getGcsMaxFilterBytes(400)) - val gcsMaxBytes: StateFlow = _gcsMaxBytes.asStateFlow() - - private val _gcsFprPercent = MutableStateFlow(DebugPreferenceManager.getGcsFprPercent(1.0)) - val gcsFprPercent: StateFlow = _gcsFprPercent.asStateFlow() - - fun setSeenPacketCapacity(value: Int) { - val clamped = value.coerceIn(10, 1000) - DebugPreferenceManager.setSeenPacketCapacity(clamped) - _seenPacketCapacity.value = clamped - addDebugMessage(DebugMessage.SystemMessage("🧩 max packets per sync set to $clamped")) - } - - fun setGcsMaxBytes(value: Int) { - val clamped = value.coerceIn(128, 1024) - DebugPreferenceManager.setGcsMaxFilterBytes(clamped) - _gcsMaxBytes.value = clamped - addDebugMessage(DebugMessage.SystemMessage("🌸 max GCS filter size set to $clamped bytes")) - } - - fun setGcsFprPercent(value: Double) { - val clamped = value.coerceIn(0.1, 5.0) - DebugPreferenceManager.setGcsFprPercent(clamped) - _gcsFprPercent.value = clamped - addDebugMessage(DebugMessage.SystemMessage("🎯 GCS FPR set to ${String.format("%.2f", clamped)}%")) - } // MARK: - Debug Message Creation Helpers @@ -257,10 +226,11 @@ class DebugSettingsManager private constructor() { val who = if (!senderNickname.isNullOrBlank()) "$senderNickname ($senderPeerID)" else senderPeerID val routeInfo = if (!viaDeviceId.isNullOrBlank()) " via $viaDeviceId" else " (direct)" addDebugMessage(DebugMessage.PacketEvent( - "📦 Received $messageType from $who$routeInfo" + "📥 Received $messageType from $who$routeInfo" )) } } + fun logPacketRelay( packetType: String, originalPeerID: String, @@ -278,11 +248,9 @@ class DebugSettingsManager private constructor() { toPeerID = null, toNickname = null, toDeviceAddress = null, - ttl = null, - isRelay = true + ttl = null ) } - // New, more detailed relay logger used by the mesh/broadcaster fun logPacketRelayDetailed( @@ -295,8 +263,7 @@ class DebugSettingsManager private constructor() { toPeerID: String?, toNickname: String?, toDeviceAddress: String?, - ttl: UByte?, - isRelay: Boolean = true + ttl: UByte? ) { // Build message only if verbose logging is enabled, but always update stats val senderLabel = when { @@ -321,26 +288,16 @@ class DebugSettingsManager private constructor() { val ttlStr = ttl?.toString() ?: "?" if (verboseLoggingEnabled.value) { - if (isRelay) { - addDebugMessage( - DebugMessage.RelayEvent( - "♻️ Relayed $packetType by $senderLabel from $fromName (${fromPeerID ?: "?"}, $fromAddr) to $toName (${toPeerID ?: "?"}, $toAddr) with TTL $ttlStr" - ) + addDebugMessage( + DebugMessage.RelayEvent( + "♻️ Relayed $packetType by $senderLabel from $fromName (${fromPeerID ?: "?"}, $fromAddr) to $toName (${toPeerID ?: "?"}, $toAddr) with TTL $ttlStr" ) - } else { - addDebugMessage( - DebugMessage.PacketEvent( - "📤 Sent $packetType by $senderLabel to $toName (${toPeerID ?: "?"}, $toAddr) with TTL $ttlStr" - ) - ) - } + ) } - // Update rolling statistics only for relays - if (isRelay) { - relayTimestamps.offer(System.currentTimeMillis()) - updateRelayStatsFromTimestamps() - } + // Update rolling statistics + relayTimestamps.offer(System.currentTimeMillis()) + updateRelayStatsFromTimestamps() } // MARK: - Clear Data 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 23bfc5245..cdaeee53a 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 @@ -24,7 +24,92 @@ import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import androidx.compose.ui.draw.rotate import com.bitchat.android.mesh.BluetoothMeshService +import com.bitchat.android.services.meshgraph.MeshGraphService import kotlinx.coroutines.launch +import androidx.compose.ui.graphics.toArgb +import androidx.compose.ui.graphics.drawscope.drawIntoCanvas +import androidx.compose.ui.graphics.nativeCanvas + +@Composable +fun MeshTopologySection() { + val colorScheme = MaterialTheme.colorScheme + val graphService = remember { MeshGraphService.getInstance() } + val snapshot by graphService.graphState.collectAsState() + + Surface(shape = RoundedCornerShape(12.dp), color = colorScheme.surfaceVariant.copy(alpha = 0.2f)) { + Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + Icon(Icons.Filled.SettingsEthernet, contentDescription = null, tint = Color(0xFF8E8E93)) + Text("mesh topology", fontFamily = FontFamily.Monospace, fontSize = 14.sp, fontWeight = FontWeight.Medium) + } + val nodes = snapshot.nodes + val edges = snapshot.edges + val empty = nodes.isEmpty() + if (empty) { + Text("no gossip yet", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.6f)) + } else { + androidx.compose.foundation.Canvas(Modifier.fillMaxWidth().height(220.dp).background(colorScheme.surface.copy(alpha = 0.4f))) { + val w = size.width + val h = size.height + val cx = w / 2f + val cy = h / 2f + val radius = (minOf(w, h) * 0.36f) + val n = nodes.size + if (n == 1) { + // Single node centered + drawCircle(color = Color(0xFF00C851), radius = 12f, center = androidx.compose.ui.geometry.Offset(cx, cy)) + } else { + // Circular layout + val positions = nodes.mapIndexed { i, node -> + val angle = (2 * Math.PI * i.toDouble()) / n + val x = cx + (radius * Math.cos(angle)).toFloat() + val y = cy + (radius * Math.sin(angle)).toFloat() + node.peerID to androidx.compose.ui.geometry.Offset(x, y) + }.toMap() + + // Draw edges + edges.forEach { e -> + val p1 = positions[e.a] + val p2 = positions[e.b] + if (p1 != null && p2 != null) { + drawLine(color = Color(0xFF4A90E2), start = p1, end = p2, strokeWidth = 2f) + } + } + + // Draw nodes + nodes.forEach { node -> + val pos = positions[node.peerID] ?: androidx.compose.ui.geometry.Offset(cx, cy) + drawCircle(color = Color(0xFF00C851), radius = 10f, center = pos) + } + + // Draw labels near nodes (nickname or short ID) + val labelColor = colorScheme.onSurface.toArgb() + val textSizePx = 10.sp.toPx() + drawIntoCanvas { canvas -> + val paint = android.graphics.Paint().apply { + isAntiAlias = true + color = labelColor + textSize = textSizePx + } + nodes.forEach { node -> + val pos = positions[node.peerID] ?: androidx.compose.ui.geometry.Offset(cx, cy) + val label = (node.nickname?.takeIf { it.isNotBlank() } ?: node.peerID.take(8)) + canvas.nativeCanvas.drawText(label, pos.x + 12f, pos.y - 12f, paint) + } + } + } + } + // Label list for clarity under the canvas + LazyColumn(modifier = Modifier.fillMaxWidth().heightIn(max = 140.dp)) { + items(nodes) { node -> + val label = "${node.peerID.take(8)} • ${node.nickname ?: "unknown"}" + Text(label, fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.85f)) + } + } + } + } + } +} @OptIn(ExperimentalMaterial3Api::class) @Composable @@ -48,9 +133,6 @@ fun DebugSettingsSheet( val scanResults by manager.scanResults.collectAsState() val connectedDevices by manager.connectedDevices.collectAsState() val relayStats by manager.relayStats.collectAsState() - val seenCapacity by manager.seenPacketCapacity.collectAsState() - val gcsMaxBytes by manager.gcsMaxBytes.collectAsState() - val gcsFpr by manager.gcsFprPercent.collectAsState() // Push live connected devices from mesh service whenever sheet is visible LaunchedEffect(isPresented) { @@ -127,6 +209,11 @@ fun DebugSettingsSheet( } } + // Mesh topology visualization (moved below verbose logging) + item { + MeshTopologySection() + } + // GATT controls item { Surface(shape = RoundedCornerShape(12.dp), color = colorScheme.surfaceVariant.copy(alpha = 0.2f)) { @@ -253,60 +340,82 @@ fun DebugSettingsSheet( } } } - // 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) - ) - } - Spacer(Modifier.weight(1f)) + // Y-axis ticks (min/max) in the left margin + Text("0", fontFamily = FontFamily.Monospace, fontSize = 10.sp, color = colorScheme.onSurface.copy(alpha = 0.7f), modifier = Modifier.align(Alignment.BottomStart).padding(start = 4.dp, bottom = 2.dp)) + Text("${maxVal.toInt()}", fontFamily = FontFamily.Monospace, fontSize = 10.sp, color = colorScheme.onSurface.copy(alpha = 0.7f), modifier = Modifier.align(Alignment.TopStart).padding(start = 4.dp, top = 2.dp)) + // Y-axis unit label (vertical) + Text("p/s", fontFamily = FontFamily.Monospace, fontSize = 9.sp, color = colorScheme.onSurface.copy(alpha = 0.7f), modifier = Modifier.align(Alignment.CenterStart).padding(start = 2.dp).rotate(-90f)) + } + } + } +} + +@Composable +fun MeshTopologySection() { + val colorScheme = MaterialTheme.colorScheme + val graphService = remember { MeshGraphService.getInstance() } + val snapshot by graphService.graphState.collectAsState() + + Surface(shape = RoundedCornerShape(12.dp), color = colorScheme.surfaceVariant.copy(alpha = 0.2f)) { + Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + Icon(Icons.Filled.SettingsEthernet, contentDescription = null, tint = Color(0xFF8E8E93)) + Text("mesh topology", fontFamily = FontFamily.Monospace, fontSize = 14.sp, fontWeight = FontWeight.Medium) + } + val nodes = snapshot.nodes + val edges = snapshot.edges + val empty = nodes.isEmpty() + if (empty) { + Text("no gossip yet", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.6f)) + } else { + androidx.compose.foundation.Canvas(Modifier.fillMaxWidth().height(220.dp).background(colorScheme.surface.copy(alpha = 0.4f))) { + val w = size.width + val h = size.height + val cx = w / 2f + val cy = h / 2f + val radius = (minOf(w, h) * 0.36f) + val n = nodes.size + if (n == 1) { + // Single node centered + drawCircle(color = Color(0xFF00C851), radius = 12f, center = androidx.compose.ui.geometry.Offset(cx, cy)) + } else { + // Circular layout + val positions = nodes.mapIndexed { i, node -> + val angle = (2 * Math.PI * i.toDouble()) / n + val x = cx + (radius * Math.cos(angle)).toFloat() + val y = cy + (radius * Math.sin(angle)).toFloat() + node.peerID to androidx.compose.ui.geometry.Offset(x, y) + }.toMap() + + // Draw edges + edges.forEach { e -> + val p1 = positions[e.a] + val p2 = positions[e.b] + if (p1 != null && p2 != null) { + drawLine(color = Color(0xFF4A90E2), start = p1, end = p2, strokeWidth = 2f) } } - } - } - } - // Connected devices - item { - Surface(shape = RoundedCornerShape(12.dp), color = colorScheme.surfaceVariant.copy(alpha = 0.2f)) { - Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) { - Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { - Icon(Icons.Filled.SettingsEthernet, contentDescription = null, tint = Color(0xFF9C27B0)) - Text("sync settings", fontFamily = FontFamily.Monospace, fontSize = 14.sp, fontWeight = FontWeight.Medium) + // Draw nodes + nodes.forEach { node -> + val pos = positions[node.peerID] ?: androidx.compose.ui.geometry.Offset(cx, cy) + drawCircle(color = Color(0xFF00C851), radius = 10f, center = pos) } - Text("max packets per sync: $seenCapacity", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f)) - Slider(value = seenCapacity.toFloat(), onValueChange = { manager.setSeenPacketCapacity(it.toInt()) }, valueRange = 10f..1000f, steps = 99) - Text("max GCS filter size: $gcsMaxBytes bytes (128–1024)", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f)) - Slider(value = gcsMaxBytes.toFloat(), onValueChange = { manager.setGcsMaxBytes(it.toInt()) }, valueRange = 128f..1024f, steps = 0) - Text("target FPR: ${String.format("%.2f", gcsFpr)}%", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f)) - Slider(value = gcsFpr.toFloat(), onValueChange = { manager.setGcsFprPercent(it.toDouble()) }, valueRange = 0.1f..5.0f, steps = 49) - val p = remember(gcsFpr) { com.bitchat.android.sync.GCSFilter.deriveP(gcsFpr / 100.0) } - val nmax = remember(gcsFpr, gcsMaxBytes) { com.bitchat.android.sync.GCSFilter.estimateMaxElementsForSize(gcsMaxBytes, p) } - Text("derived P: $p • est. max elements: $nmax", fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.7f)) + } + } + // Label list for clarity under the canvas + LazyColumn(modifier = Modifier.fillMaxWidth().heightIn(max = 140.dp)) { + items(nodes) { node -> + val label = "${node.peerID.take(8)} • ${node.nickname ?: "unknown"}" + Text(label, fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = colorScheme.onSurface.copy(alpha = 0.85f)) } } } + } + } +} + + // Connected devices item { diff --git a/app/src/main/java/com/bitchat/android/ui/events/FileShareDispatcher.kt b/app/src/main/java/com/bitchat/android/ui/events/FileShareDispatcher.kt deleted file mode 100644 index 13bda8d7e..000000000 --- a/app/src/main/java/com/bitchat/android/ui/events/FileShareDispatcher.kt +++ /dev/null @@ -1,17 +0,0 @@ -package com.bitchat.android.ui.events - -/** - * Lightweight dispatcher so lower-level UI (MessageInput) can trigger - * file sending without holding a direct reference to ChatViewModel. - */ -object FileShareDispatcher { - @Volatile private var handler: ((String?, String?, String) -> Unit)? = null - - fun setHandler(h: ((String?, String?, String) -> Unit)?) { - handler = h - } - - fun dispatch(peerIdOrNull: String?, channelOrNull: String?, path: String) { - handler?.invoke(peerIdOrNull, channelOrNull, path) - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/AudioMessageItem.kt b/app/src/main/java/com/bitchat/android/ui/media/AudioMessageItem.kt deleted file mode 100644 index d01e7a30d..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/AudioMessageItem.kt +++ /dev/null @@ -1,99 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.gestures.detectTapGestures -import androidx.compose.foundation.layout.* -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Close -import androidx.compose.material3.Icon -import androidx.compose.material3.Text -import androidx.compose.runtime.* -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.hapticfeedback.HapticFeedbackType -import androidx.compose.ui.input.pointer.pointerInput -import androidx.compose.ui.platform.LocalHapticFeedback -import androidx.compose.ui.text.TextLayoutResult -import androidx.compose.ui.text.font.FontFamily -import androidx.compose.ui.unit.dp -import com.bitchat.android.mesh.BluetoothMeshService -import com.bitchat.android.model.BitchatMessage -import androidx.compose.material3.ColorScheme -import java.text.SimpleDateFormat - -@Composable -fun AudioMessageItem( - message: BitchatMessage, - currentUserNickname: String, - meshService: BluetoothMeshService, - colorScheme: ColorScheme, - timeFormatter: SimpleDateFormat, - onNicknameClick: ((String) -> Unit)?, - onMessageLongPress: ((BitchatMessage) -> Unit)?, - onCancelTransfer: ((BitchatMessage) -> Unit)?, - modifier: Modifier = Modifier -) { - val path = message.content.trim() - // Derive sending progress if applicable - val (overrideProgress, overrideColor) = when (val st = message.deliveryStatus) { - is com.bitchat.android.model.DeliveryStatus.PartiallyDelivered -> { - if (st.total > 0 && st.reached < st.total) { - (st.reached.toFloat() / st.total.toFloat()) to Color(0xFF1E88E5) // blue while sending - } else null to null - } - else -> null to null - } - Column(modifier = modifier.fillMaxWidth()) { - // Header: nickname + timestamp line above the audio note, identical styling to text messages - val headerText = com.bitchat.android.ui.formatMessageHeaderAnnotatedString( - message = message, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter - ) - val haptic = LocalHapticFeedback.current - var headerLayout by remember { mutableStateOf(null) } - Text( - text = headerText, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface, - modifier = Modifier.pointerInput(message.id) { - detectTapGestures(onTap = { pos -> - val layout = headerLayout ?: return@detectTapGestures - val offset = layout.getOffsetForPosition(pos) - val ann = headerText.getStringAnnotations("nickname_click", offset, offset) - if (ann.isNotEmpty() && onNicknameClick != null) { - haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove) - onNicknameClick.invoke(ann.first().item) - } - }, onLongPress = { onMessageLongPress?.invoke(message) }) - }, - onTextLayout = { headerLayout = it } - ) - - Row(verticalAlignment = Alignment.CenterVertically) { - VoiceNotePlayer( - path = path, - progressOverride = overrideProgress, - progressColor = overrideColor - ) - val showCancel = message.sender == currentUserNickname && (message.deliveryStatus is com.bitchat.android.model.DeliveryStatus.PartiallyDelivered) - if (showCancel) { - Spacer(Modifier.width(8.dp)) - Box( - modifier = Modifier - .size(26.dp) - .background(Color.Gray.copy(alpha = 0.6f), CircleShape) - .clickable { onCancelTransfer?.invoke(message) }, - contentAlignment = Alignment.Center - ) { - Icon(imageVector = Icons.Filled.Close, contentDescription = "Cancel", tint = Color.White, modifier = Modifier.size(16.dp)) - } - } - } - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt b/app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt deleted file mode 100644 index e0f08ccc1..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt +++ /dev/null @@ -1,95 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.runtime.Composable -import androidx.compose.ui.Modifier -import androidx.compose.ui.geometry.Rect -import androidx.compose.ui.graphics.ImageBitmap -import androidx.compose.ui.graphics.drawscope.DrawScope -import androidx.compose.ui.graphics.drawscope.drawIntoCanvas -import androidx.compose.ui.unit.IntOffset -import androidx.compose.ui.unit.IntSize - -/** - * Draws an image progressively, revealing it block-by-block based on progress [0f..1f]. - * blocksX * blocksY defines the grid density; higher numbers look more "modem-era". - */ -@Composable -fun BlockRevealImage( - bitmap: ImageBitmap, - progress: Float, - blocksX: Int = 24, - blocksY: Int = 16, - modifier: Modifier = Modifier -) { - val frac = progress.coerceIn(0f, 1f) - Canvas(modifier = modifier.fillMaxWidth()) { - drawProgressive(bitmap, frac, blocksX, blocksY) - } -} - -private fun DrawScope.drawProgressive( - bitmap: ImageBitmap, - progress: Float, - blocksX: Int, - blocksY: Int -) { - val canvasW = size.width - val canvasH = size.height - if (canvasW <= 0f || canvasH <= 0f) return - - val totalBlocks = (blocksX * blocksY).coerceAtLeast(1) - val toShow = (totalBlocks * progress).toInt().coerceIn(0, totalBlocks) - if (toShow <= 0) return - - val imgW = bitmap.width - val imgH = bitmap.height - if (imgW <= 0 || imgH <= 0) return - - // Compute scaled destination rect maintaining aspect fit - val canvasRatio = canvasW / canvasH - val imageRatio = imgW.toFloat() / imgH.toFloat() - val dstW: Float - val dstH: Float - if (imageRatio >= canvasRatio) { - dstW = canvasW - dstH = canvasW / imageRatio - } else { - dstH = canvasH - dstW = canvasH * imageRatio - } - val left = 0f - val top = (canvasH - dstH) / 2f - - // Precompute integer edges to avoid 1px gaps due to rounding - val xDstEdges = IntArray(blocksX + 1) { i -> (left + (dstW * i / blocksX)).toInt().coerceAtLeast(0) } - val yDstEdges = IntArray(blocksY + 1) { i -> (top + (dstH * i / blocksY)).toInt().coerceAtLeast(0) } - val xSrcEdges = IntArray(blocksX + 1) { i -> (imgW * i / blocksX) } - val ySrcEdges = IntArray(blocksY + 1) { i -> (imgH * i / blocksY) } - - var shown = 0 - outer@ for (by in 0 until blocksY) { - for (bx in 0 until blocksX) { - if (shown >= toShow) break@outer - val sx = xSrcEdges[bx] - val sy = ySrcEdges[by] - val sw = xSrcEdges[bx + 1] - xSrcEdges[bx] - val sh = ySrcEdges[by + 1] - ySrcEdges[by] - val dx = xDstEdges[bx] - val dy = yDstEdges[by] - val dw = xDstEdges[bx + 1] - xDstEdges[bx] - val dh = yDstEdges[by + 1] - yDstEdges[by] - - drawImage( - image = bitmap, - srcOffset = IntOffset(sx, sy), - srcSize = IntSize(sw, sh), - dstOffset = IntOffset(dx, dy), - dstSize = IntSize(dw.coerceAtLeast(1), dh.coerceAtLeast(1)), - alpha = 1f - ) - shown++ - } - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/FileMessageItem.kt b/app/src/main/java/com/bitchat/android/ui/media/FileMessageItem.kt deleted file mode 100644 index 8d7318af9..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/FileMessageItem.kt +++ /dev/null @@ -1,154 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.layout.width -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Description -import androidx.compose.material3.Card -import androidx.compose.material3.CardDefaults -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.text.style.TextOverflow -import androidx.compose.ui.unit.dp -import com.bitchat.android.features.file.FileUtils -import com.bitchat.android.model.BitchatFilePacket - -/** - * Modern chat-style file message display - */ -@Composable -fun FileMessageItem( - packet: BitchatFilePacket, - onFileClick: () -> Unit, - modifier: Modifier = Modifier -) { - var showDialog by remember { mutableStateOf(false) } - - Card( - modifier = modifier - .fillMaxWidth(0.8f) - .clickable { showDialog = true }, - shape = RoundedCornerShape(12.dp), - colors = CardDefaults.cardColors( - containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.8f) - ) - ) { - Row( - modifier = Modifier.padding(16.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(12.dp) - ) { - // File icon - Icon( - imageVector = Icons.Filled.Description, - contentDescription = "File", - tint = getFileIconColor(packet.fileName), - modifier = Modifier.size(32.dp) - ) - - Column( - modifier = Modifier.weight(1f), - verticalArrangement = Arrangement.spacedBy(4.dp) - ) { - // File name - Text( - text = packet.fileName, - style = MaterialTheme.typography.bodyLarge, - fontWeight = androidx.compose.ui.text.font.FontWeight.Medium, - maxLines = 1, - overflow = TextOverflow.Ellipsis - ) - - // File details - Row( - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp) - ) { - Text( - text = FileUtils.formatFileSize(packet.fileSize), - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant - ) - - // File type indicator - FileTypeBadge(mimeType = packet.mimeType) - } - } - } - } - - // File viewer dialog - if (showDialog) { - FileViewerDialog( - packet = packet, - onDismiss = { showDialog = false }, - onSaveToDevice = { content, fileName -> - // In a real implementation, this would save to Downloads - // For now, just log that file was "saved" - android.util.Log.d("FileSharing", "Would save file: $fileName") - } - ) - } -} - -/** - * Small badge showing file type - */ -@Composable -private fun FileTypeBadge(mimeType: String) { - val (text, color) = when { - mimeType.startsWith("application/pdf") -> "PDF" to Color(0xFFDC2626) - mimeType.startsWith("text/") -> "TXT" to Color(0xFF059669) - mimeType.startsWith("image/") -> "IMG" to Color(0xFF7C3AED) - mimeType.startsWith("audio/") -> "AUD" to Color(0xFFEA580C) - mimeType.startsWith("video/") -> "VID" to Color(0xFF2563EB) - mimeType.contains("document") -> "DOC" to Color(0xFF1D4ED8) - mimeType.contains("zip") || mimeType.contains("rar") -> "ZIP" to Color(0xFF7C2D12) - else -> "FILE" to MaterialTheme.colorScheme.onSurfaceVariant - } - - Text( - text = text, - style = MaterialTheme.typography.labelSmall, - color = color, - fontWeight = androidx.compose.ui.text.font.FontWeight.Bold - ) -} - -/** - * Get appropriate icon color based on file extension - */ -private fun getFileIconColor(fileName: String): Color { - val extension = fileName.substringAfterLast(".", "").lowercase() - return when (extension) { - "pdf" -> Color(0xFFDC2626) // Red - "doc", "docx" -> Color(0xFF1D4ED8) // Blue - "xls", "xlsx" -> Color(0xFF059669) // Green - "ppt", "pptx" -> Color(0xFFEA580C) // Orange - "txt", "json", "xml" -> Color(0xFF7C3AED) // Purple - "jpg", "png", "gif", "webp" -> Color(0xFF2563EB) // Blue - "mp3", "wav", "m4a" -> Color(0xFFEA580C) // Orange - "mp4", "avi", "mov" -> Color(0xFFDC2626) // Red - "zip", "rar", "7z" -> Color(0xFF7C2D12) // Brown - else -> Color(0xFF6B7280) // Gray - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/FilePickerButton.kt b/app/src/main/java/com/bitchat/android/ui/media/FilePickerButton.kt deleted file mode 100644 index 384e9c9d0..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/FilePickerButton.kt +++ /dev/null @@ -1,52 +0,0 @@ -package com.bitchat.android.ui.media - -import android.net.Uri -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import androidx.compose.foundation.layout.size -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Attachment -import androidx.compose.material3.Icon -import androidx.compose.material3.IconButton -import androidx.compose.runtime.Composable -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.rotate -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import com.bitchat.android.features.file.FileUtils - -@Composable -fun FilePickerButton( - modifier: Modifier = Modifier, - onFileReady: (String) -> Unit -) { - val context = LocalContext.current - - // Use SAF - supports all file types - val filePicker = rememberLauncherForActivityResult( - contract = ActivityResultContracts.OpenDocument() - ) { uri: Uri? -> - if (uri != null) { - // Persist temporary read permission so we can copy - try { context.contentResolver.takePersistableUriPermission(uri, android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION) } catch (_: Exception) {} - val path = FileUtils.copyFileForSending(context, uri) - if (!path.isNullOrBlank()) onFileReady(path) - } - } - - IconButton( - onClick = { - // Allow any MIME type; user asked to choose between image or file at higher level UI - filePicker.launch(arrayOf("*/*")) - }, - modifier = modifier.size(32.dp) - ) { - Icon( - imageVector = Icons.Filled.Attachment, - contentDescription = "Pick file", - tint = Color.Gray, - modifier = Modifier.size(20.dp).rotate(90f) - ) - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/FileSendingAnimation.kt b/app/src/main/java/com/bitchat/android/ui/media/FileSendingAnimation.kt deleted file mode 100644 index a41a7551a..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/FileSendingAnimation.kt +++ /dev/null @@ -1,152 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.animation.core.LinearEasing -import androidx.compose.animation.core.animateFloatAsState -import androidx.compose.animation.core.tween -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Description -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableFloatStateOf -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.geometry.Offset -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.drawscope.Stroke -import androidx.compose.ui.unit.dp -import kotlinx.coroutines.delay - -/** - * Matrix-style file sending animation with character-by-character reveal - * Shows a file icon with filename being "typed" out character by character - * and progress visualization - */ -@Composable -fun FileSendingAnimation( - modifier: Modifier = Modifier, - fileName: String, - progress: Float = 0f -) { - var revealedChars by remember(fileName) { mutableFloatStateOf(0f) } - var showCursor by remember { mutableStateOf(true) } - - // Animate character reveal - val animatedChars by animateFloatAsState( - targetValue = revealedChars, - animationSpec = tween( - durationMillis = 50 * fileName.length, - easing = LinearEasing - ), - label = "fileNameReveal" - ) - - // Cursor blinking - LaunchedEffect(Unit) { - while (true) { - delay(500) - showCursor = !showCursor - } - } - - // Trigger reveal animation - LaunchedEffect(fileName) { - revealedChars = fileName.length.toFloat() - } - - Row( - modifier = modifier - .fillMaxWidth() - .padding(16.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(12.dp) - ) { - // File icon - Icon( - imageVector = Icons.Filled.Description, - contentDescription = "File", - tint = Color(0xFF00C851), // Green like app theme - modifier = Modifier.size(32.dp) - ) - - Column( - modifier = Modifier.weight(1f), - verticalArrangement = Arrangement.spacedBy(8.dp) - ) { - // Filename reveal animation (Matrix-style) - Row(verticalAlignment = Alignment.Bottom) { - // Revealed part of filename - val revealedText = fileName.substring(0, animatedChars.toInt()) - androidx.compose.material3.Text( - text = revealedText, - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace, - color = Color.White - ), - modifier = Modifier.padding(end = 2.dp) - ) - - // Blinking cursor (only if not fully revealed) - if (animatedChars < fileName.length && showCursor) { - androidx.compose.material3.Text( - text = "_", - style = MaterialTheme.typography.bodyMedium.copy( - fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace, - color = Color.White - ) - ) - } - } - - // Progress visualization - FileProgressBars( - progress = progress, - modifier = Modifier.fillMaxWidth().height(20.dp) - ) - } - } -} - -/** - * ASCII-style progress bars for file transfer - */ -@Composable -private fun FileProgressBars( - progress: Float, - modifier: Modifier = Modifier -) { - val bars = 12 - val filledBars = (progress * bars).toInt() - - // Create a matrix-style progress bar string - val progressString = buildString { - append("[") - for (i in 0 until bars) { - append(if (i < filledBars) "█" else "░") - } - append("] ") - append("${(progress * 100).toInt()}%") - } - - androidx.compose.material3.Text( - text = progressString, - style = MaterialTheme.typography.bodySmall.copy( - fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace, - color = Color(0xFF00FF7F) // Matrix green - ), - modifier = modifier - ) -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/FileViewerDialog.kt b/app/src/main/java/com/bitchat/android/ui/media/FileViewerDialog.kt deleted file mode 100644 index 0293eabd6..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/FileViewerDialog.kt +++ /dev/null @@ -1,161 +0,0 @@ -package com.bitchat.android.ui.media - -import android.content.ActivityNotFoundException -import android.content.Context -import android.content.Intent -import android.net.Uri -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.material3.Button -import androidx.compose.material3.ButtonDefaults -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.rememberCoroutineScope -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import androidx.compose.ui.window.Dialog -import com.bitchat.android.features.file.FileUtils -import com.bitchat.android.model.BitchatFilePacket -import kotlinx.coroutines.launch -import java.io.File - -/** - * Dialog for handling received file messages in modern chat style - */ -@Composable -fun FileViewerDialog( - packet: BitchatFilePacket, - onDismiss: () -> Unit, - onSaveToDevice: (ByteArray, String) -> Unit -) { - val context = LocalContext.current - val coroutineScope = rememberCoroutineScope() - - Dialog(onDismissRequest = onDismiss) { - androidx.compose.material3.Card( - modifier = Modifier.fillMaxWidth(), - shape = RoundedCornerShape(12.dp) - ) { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(24.dp), - horizontalAlignment = Alignment.CenterHorizontally, - verticalArrangement = Arrangement.spacedBy(16.dp) - ) { - // File received header - Text( - text = "📎 File Received", - style = MaterialTheme.typography.headlineSmall, - color = MaterialTheme.colorScheme.primary - ) - - // File info - Column( - verticalArrangement = Arrangement.spacedBy(8.dp), - horizontalAlignment = Alignment.Start - ) { - Text( - text = "📄 ${packet.fileName}", - style = MaterialTheme.typography.bodyLarge, - fontWeight = androidx.compose.ui.text.font.FontWeight.Medium - ) - Text( - text = "📏 Size: ${FileUtils.formatFileSize(packet.fileSize)}", - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant - ) - Text( - text = "🏷️ Type: ${packet.mimeType}", - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant - ) - } - - Spacer(modifier = Modifier.height(8.dp)) - - // Action buttons - Row( - modifier = Modifier.fillMaxWidth(), - horizontalArrangement = Arrangement.spacedBy(12.dp) - ) { - // Open/Save button - Button( - onClick = { - coroutineScope.launch { - // Try to save to Downloads first - try { - onSaveToDevice(packet.content, packet.fileName) - onDismiss() - } catch (e: Exception) { - // If save fails, try to open directly - tryOpenFile(context, packet) - onDismiss() - } - } - }, - modifier = Modifier.weight(1f), - colors = ButtonDefaults.buttonColors( - containerColor = MaterialTheme.colorScheme.primary - ) - ) { - Text("📂 Open / Save") - } - - // Dismiss button - Button( - onClick = onDismiss, - modifier = Modifier.weight(1f), - colors = ButtonDefaults.buttonColors( - containerColor = MaterialTheme.colorScheme.secondary - ) - ) { - Text("❌ Close") - } - } - } - } - } -} - -/** - * Attempts to open a file using system viewers or save to device - */ -private fun tryOpenFile(context: Context, packet: BitchatFilePacket) { - try { - // First try to save to temp file and open - val tempFile = File.createTempFile("bitchat_", ".${packet.fileName.substringAfterLast(".")}", context.cacheDir) - tempFile.writeBytes(packet.content) - tempFile.deleteOnExit() - - val uri = androidx.core.content.FileProvider.getUriForFile( - context, - "${context.packageName}.fileprovider", - tempFile - ) - - val intent = Intent(Intent.ACTION_VIEW).apply { - setDataAndType(uri, packet.mimeType) - addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) - addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) - } - - try { - context.startActivity(intent) - } catch (e: ActivityNotFoundException) { - // No app can handle this file type - just show a message - // In a real app, you'd show a toast or snackbar - } - } catch (e: Exception) { - // Handle any errors gracefully - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt b/app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt deleted file mode 100644 index 24e2fa070..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt +++ /dev/null @@ -1,170 +0,0 @@ -package com.bitchat.android.ui.media - -import android.content.ContentValues -import android.os.Build -import android.provider.MediaStore -import android.widget.Toast -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.* -import androidx.compose.foundation.pager.HorizontalPager -import androidx.compose.foundation.pager.rememberPagerState -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Close -import androidx.compose.material.icons.filled.Download -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.asImageBitmap -import androidx.compose.ui.layout.ContentScale -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import androidx.compose.ui.unit.sp -import androidx.compose.foundation.Image -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.ui.window.Dialog -import androidx.compose.ui.window.DialogProperties -import java.io.File - -/** - * Fullscreen image viewer with swipe navigation between multiple images - * @param imagePaths List of all image file paths in the current chat - * @param initialIndex Starting index of the current image in the list - * @param onClose Callback when the viewer should be dismissed - */ -// Backward compatibility for single image (can be removed after updating all callers) -@Composable -fun FullScreenImageViewer(path: String, onClose: () -> Unit) { - FullScreenImageViewer(listOf(path), 0, onClose) -} - -/** - * Fullscreen image viewer with swipe navigation between multiple images - * @param imagePaths List of all image file paths in the current chat - * @param initialIndex Starting index of the current image in the list - * @param onClose Callback when the viewer should be dismissed - */ -@Composable -fun FullScreenImageViewer(imagePaths: List, initialIndex: Int = 0, onClose: () -> Unit) { - val context = LocalContext.current - val pagerState = rememberPagerState(initialPage = initialIndex, pageCount = imagePaths::size) - - if (imagePaths.isEmpty()) { - onClose() - return - } - - Dialog(onDismissRequest = onClose, properties = DialogProperties(usePlatformDefaultWidth = false)) { - Surface(color = Color.Black) { - Box(modifier = Modifier.fillMaxSize()) { - HorizontalPager( - state = pagerState, - modifier = Modifier.fillMaxSize() - ) { page -> - val currentPath = imagePaths[page] - val bmp = remember(currentPath) { try { android.graphics.BitmapFactory.decodeFile(currentPath) } catch (_: Exception) { null } } - - bmp?.let { - androidx.compose.foundation.Image( - bitmap = it.asImageBitmap(), - contentDescription = "Image ${page + 1} of ${imagePaths.size}", - modifier = Modifier.fillMaxSize(), - contentScale = ContentScale.Fit - ) - } ?: run { - Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { - Text(text = "Image unavailable", color = Color.White) - } - } - } - - // Image counter - if (imagePaths.size > 1) { - Box( - modifier = Modifier - .padding(horizontal = 16.dp, vertical = 8.dp) - .align(Alignment.TopCenter) - .background(Color(0x66000000), androidx.compose.foundation.shape.RoundedCornerShape(12.dp)) - .padding(horizontal = 12.dp, vertical = 4.dp) - ) { - Text( - text = "${(pagerState.currentPage ?: 0) + 1} / ${imagePaths.size}", - color = Color.White, - fontSize = 14.sp, - fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace - ) - } - } - - Row( - modifier = Modifier - .fillMaxWidth() - .padding(12.dp) - .align(Alignment.TopEnd), - horizontalArrangement = Arrangement.End - ) { - Box( - modifier = Modifier - .size(36.dp) - .background(Color(0x66000000), CircleShape) - .clickable { saveToDownloads(context, imagePaths[pagerState.currentPage].toString()) }, - contentAlignment = Alignment.Center - ) { - androidx.compose.material3.Icon(Icons.Filled.Download, "Save current image", tint = Color.White) - } - Spacer(Modifier.width(12.dp)) - Box( - modifier = Modifier - .size(36.dp) - .background(Color(0x66000000), CircleShape) - .clickable { onClose() }, - contentAlignment = Alignment.Center - ) { - androidx.compose.material3.Icon(Icons.Filled.Close, "Close", tint = Color.White) - } - } - } - } - } -} - -private fun saveToDownloads(context: android.content.Context, path: String) { - runCatching { - val name = File(path).name - val mime = when { - name.endsWith(".png", true) -> "image/png" - name.endsWith(".webp", true) -> "image/webp" - else -> "image/jpeg" - } - val values = ContentValues().apply { - put(MediaStore.Downloads.DISPLAY_NAME, name) - put(MediaStore.Downloads.MIME_TYPE, mime) - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { - put(MediaStore.Downloads.IS_PENDING, 1) - } - } - val uri = context.contentResolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, values) - if (uri != null) { - context.contentResolver.openOutputStream(uri)?.use { out -> - File(path).inputStream().use { it.copyTo(out) } - } - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { - val v2 = ContentValues().apply { put(MediaStore.Downloads.IS_PENDING, 0) } - context.contentResolver.update(uri, v2, null, null) - } - // Show toast message indicating the image has been saved - Toast.makeText(context, "Image saved to Downloads", Toast.LENGTH_SHORT).show() - } - }.onFailure { - // Optionally handle failure case (e.g., show error toast) - Toast.makeText(context, "Failed to save image", Toast.LENGTH_SHORT).show() - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/ImageMessageItem.kt b/app/src/main/java/com/bitchat/android/ui/media/ImageMessageItem.kt deleted file mode 100644 index a2206594f..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/ImageMessageItem.kt +++ /dev/null @@ -1,149 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.Image -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.gestures.detectTapGestures -import androidx.compose.foundation.layout.* -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Close -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.* -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.asImageBitmap -import androidx.compose.ui.hapticfeedback.HapticFeedbackType -import androidx.compose.ui.layout.ContentScale -import androidx.compose.ui.draw.clip -import androidx.compose.ui.input.pointer.pointerInput -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.platform.LocalHapticFeedback -import androidx.compose.ui.text.TextLayoutResult -import androidx.compose.ui.text.font.FontFamily -import androidx.compose.ui.unit.dp -import com.bitchat.android.mesh.BluetoothMeshService -import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType -import androidx.compose.material3.ColorScheme -import java.text.SimpleDateFormat -import java.util.* - -@Composable -fun ImageMessageItem( - message: BitchatMessage, - messages: List, - currentUserNickname: String, - meshService: BluetoothMeshService, - colorScheme: ColorScheme, - timeFormatter: SimpleDateFormat, - onNicknameClick: ((String) -> Unit)?, - onMessageLongPress: ((BitchatMessage) -> Unit)?, - onCancelTransfer: ((BitchatMessage) -> Unit)?, - onImageClick: ((String, List, Int) -> Unit)?, - modifier: Modifier = Modifier -) { - val path = message.content.trim() - Column(modifier = modifier.fillMaxWidth()) { - val headerText = com.bitchat.android.ui.formatMessageHeaderAnnotatedString( - message = message, - currentUserNickname = currentUserNickname, - meshService = meshService, - colorScheme = colorScheme, - timeFormatter = timeFormatter - ) - val haptic = LocalHapticFeedback.current - var headerLayout by remember { mutableStateOf(null) } - Text( - text = headerText, - fontFamily = FontFamily.Monospace, - color = colorScheme.onSurface, - modifier = Modifier.pointerInput(message.id) { - detectTapGestures(onTap = { pos -> - val layout = headerLayout ?: return@detectTapGestures - val offset = layout.getOffsetForPosition(pos) - val ann = headerText.getStringAnnotations("nickname_click", offset, offset) - if (ann.isNotEmpty() && onNicknameClick != null) { - haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove) - onNicknameClick.invoke(ann.first().item) - } - }, onLongPress = { onMessageLongPress?.invoke(message) }) - }, - onTextLayout = { headerLayout = it } - ) - - val context = LocalContext.current - val bmp = remember(path) { try { android.graphics.BitmapFactory.decodeFile(path) } catch (_: Exception) { null } } - - // Collect all image paths from messages for swipe navigation - val imagePaths = remember(messages) { - messages.filter { it.type == BitchatMessageType.Image } - .map { it.content.trim() } - } - - if (bmp != null) { - val img = bmp.asImageBitmap() - val aspect = (bmp.width.toFloat() / bmp.height.toFloat()).takeIf { it.isFinite() && it > 0 } ?: 1f - val progressFraction: Float? = when (val st = message.deliveryStatus) { - is com.bitchat.android.model.DeliveryStatus.PartiallyDelivered -> if (st.total > 0) st.reached.toFloat() / st.total.toFloat() else 0f - else -> null - } - Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { - Box { - if (progressFraction != null && progressFraction < 1f && message.sender == currentUserNickname) { - // Cyberpunk block-reveal while sending - BlockRevealImage( - bitmap = img, - progress = progressFraction, - blocksX = 24, - blocksY = 16, - modifier = Modifier - .widthIn(max = 300.dp) - .aspectRatio(aspect) - .clip(androidx.compose.foundation.shape.RoundedCornerShape(10.dp)) - .clickable { - val currentIndex = imagePaths.indexOf(path) - onImageClick?.invoke(path, imagePaths, currentIndex) - } - ) - } else { - // Fully revealed image - Image( - bitmap = img, - contentDescription = "Image", - modifier = Modifier - .widthIn(max = 300.dp) - .aspectRatio(aspect) - .clip(androidx.compose.foundation.shape.RoundedCornerShape(10.dp)) - .clickable { - val currentIndex = imagePaths.indexOf(path) - onImageClick?.invoke(path, imagePaths, currentIndex) - }, - contentScale = ContentScale.Fit - ) - } - // Cancel button overlay during sending - val showCancel = message.sender == currentUserNickname && (message.deliveryStatus is com.bitchat.android.model.DeliveryStatus.PartiallyDelivered) - if (showCancel) { - Box( - modifier = Modifier - .align(Alignment.TopEnd) - .padding(4.dp) - .size(22.dp) - .background(Color.Gray.copy(alpha = 0.6f), CircleShape) - .clickable { onCancelTransfer?.invoke(message) }, - contentAlignment = Alignment.Center - ) { - Icon(imageVector = Icons.Filled.Close, contentDescription = "Cancel", tint = Color.White, modifier = Modifier.size(14.dp)) - } - } - } - } - } else { - Text(text = "[image unavailable]", fontFamily = FontFamily.Monospace, color = Color.Gray) - } - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt b/app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt deleted file mode 100644 index aa3a0b7c7..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt +++ /dev/null @@ -1,44 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import androidx.compose.foundation.layout.size -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Photo -import androidx.compose.material3.Icon -import androidx.compose.material3.IconButton -import androidx.compose.runtime.Composable -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import com.bitchat.android.features.media.ImageUtils - -@Composable -fun ImagePickerButton( - modifier: Modifier = Modifier, - onImageReady: (String) -> Unit -) { - val context = LocalContext.current - val imagePicker = rememberLauncherForActivityResult( - contract = ActivityResultContracts.GetContent() - ) { uri: android.net.Uri? -> - if (uri != null) { - val outPath = ImageUtils.downscaleAndSaveToAppFiles(context, uri) - if (!outPath.isNullOrBlank()) onImageReady(outPath) - } - } - - IconButton( - onClick = { imagePicker.launch("image/*") }, - modifier = modifier.size(32.dp) - ) { - Icon( - imageVector = Icons.Filled.Photo, - contentDescription = "Pick image", - tint = Color.Gray, - modifier = Modifier.size(20.dp) - ) - } -} - diff --git a/app/src/main/java/com/bitchat/android/ui/media/MediaPickerOptions.kt b/app/src/main/java/com/bitchat/android/ui/media/MediaPickerOptions.kt deleted file mode 100644 index e638512c7..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/MediaPickerOptions.kt +++ /dev/null @@ -1,149 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Add -import androidx.compose.material.icons.filled.Description -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.runtime.Composable -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.clip -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.graphicsLayer -import androidx.compose.ui.unit.dp -import androidx.compose.ui.zIndex - -/** - * Media picker that offers image and file options - * Clicking opens a quick selection menu - */ -@Composable -fun MediaPickerOptions( - modifier: Modifier = Modifier, - onImagePick: (() -> Unit)? = null, - onFilePick: (() -> Unit)? = null -) { - var showOptions by remember { mutableStateOf(false) } - - Box(modifier = modifier) { - // Main button - Box( - modifier = Modifier - .size(32.dp) - .clip(RoundedCornerShape(4.dp)) - .background(color = Color.Gray.copy(alpha = 0.5f)) - .clickable { - showOptions = true - }, - contentAlignment = Alignment.Center - ) { - Icon( - imageVector = Icons.Filled.Add, - contentDescription = "Pick media", - tint = Color.Black, - modifier = Modifier.size(20.dp) - ) - } - - // Options menu (shown when clicked) - if (showOptions) { - Column( - modifier = Modifier - .graphicsLayer { - translationY = -120f // Position above the button - scaleX = 0.8f - scaleY = 0.8f - } - .zIndex(1f) - .clip(RoundedCornerShape(8.dp)) - .background(color = MaterialTheme.colorScheme.surface) - .clickable { - showOptions = false - } - .padding(8.dp), - verticalArrangement = Arrangement.spacedBy(4.dp) - ) { - // Image option - onImagePick?.let { imagePick -> - Row( - modifier = Modifier - .clip(RoundedCornerShape(4.dp)) - .background(color = MaterialTheme.colorScheme.primaryContainer) - .clickable { - showOptions = false - imagePick() - } - .padding(horizontal = 12.dp, vertical = 8.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp) - ) { - Icon( - imageVector = Icons.Default.Add, - contentDescription = null, - tint = MaterialTheme.colorScheme.onPrimaryContainer, - modifier = Modifier.size(16.dp) - ) - androidx.compose.material3.Text( - text = "Image", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onPrimaryContainer - ) - } - } - - // File option - onFilePick?.let { filePick -> - Row( - modifier = Modifier - .clip(RoundedCornerShape(4.dp)) - .background(color = MaterialTheme.colorScheme.secondaryContainer) - .clickable { - showOptions = false - filePick() - } - .padding(horizontal = 12.dp, vertical = 8.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp) - ) { - Icon( - imageVector = Icons.Default.Description, - contentDescription = null, - tint = MaterialTheme.colorScheme.onSecondaryContainer, - modifier = Modifier.size(16.dp) - ) - androidx.compose.material3.Text( - text = "File", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSecondaryContainer - ) - } - } - } - } - - // Clickable overlay to dismiss options - if (showOptions) { - Box( - modifier = Modifier - .size(400.dp) - .clickable { - showOptions = false - } - ) - } - } -} diff --git a/app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt b/app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt deleted file mode 100644 index 484c18b74..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt +++ /dev/null @@ -1,79 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateListOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.rememberUpdatedState -import androidx.compose.runtime.snapshots.SnapshotStateList -import androidx.compose.runtime.withFrameNanos -import androidx.compose.ui.Modifier -import androidx.compose.ui.geometry.Offset -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.StrokeCap -import androidx.compose.ui.unit.dp - -/** - * Real-time scrolling waveform for recording: maintains a dense sliding window of bars. - * Pass in normalized amplitude [0f..1f]; the component handles sampling and drawing. - */ -@Composable -fun RealtimeScrollingWaveform( - modifier: Modifier = Modifier, - amplitudeNorm: Float, - bars: Int = 240, - barColor: Color = Color(0xFF00FF7F), - baseColor: Color = Color(0xFF444444) -) { - val latestAmp by rememberUpdatedState(amplitudeNorm) - val samples: SnapshotStateList = remember { - mutableStateListOf().also { list -> repeat(bars) { list.add(0f) } } - } - - // Append samples on a steady cadence to create a smooth scroll - LaunchedEffect(bars) { - while (true) { - withFrameNanos { _: Long -> } - val v = latestAmp.coerceIn(0f, 1f) - samples.add(v) - val overflow = samples.size - bars - if (overflow > 0) repeat(overflow) { if (samples.isNotEmpty()) samples.removeAt(0) } - kotlinx.coroutines.delay(20) - } - } - - Canvas(modifier = modifier.fillMaxWidth()) { - val w = size.width - val h = size.height - if (w <= 0f || h <= 0f) return@Canvas - val n = samples.size - if (n <= 0) return@Canvas - val stepX = w / n - val midY = h / 2f - val stroke = .5f.dp.toPx() - - // Optional faint base to match chat density - // Draw bars with heavy dynamic range compression: quiet sounds almost at zero, loud sounds still prominent - for (i in 0 until n) { - val amp = samples[i].coerceIn(0f, 1f) - // Use squared amplitude to heavily compress small values while preserving high amplitudes - // This makes quiet sounds almost invisible but loud sounds still show prominently - val compressedAmp = amp * amp // amp^2 - val lineH = (compressedAmp * (h * 0.9f)).coerceAtLeast(1f) - val x = i * stepX + stepX / 2f - val yTop = midY - lineH / 2f - val yBot = midY + lineH / 2f - drawLine( - color = barColor, - start = Offset(x, yTop), - end = Offset(x, yBot), - strokeWidth = stroke, - cap = StrokeCap.Round - ) - } - } -} - diff --git a/app/src/main/java/com/bitchat/android/ui/media/VoiceNotePlayer.kt b/app/src/main/java/com/bitchat/android/ui/media/VoiceNotePlayer.kt deleted file mode 100644 index 67719d87d..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/VoiceNotePlayer.kt +++ /dev/null @@ -1,116 +0,0 @@ -package com.bitchat.android.ui.media - -import android.media.MediaPlayer -import androidx.compose.foundation.background -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.* -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Pause -import androidx.compose.material.icons.filled.PlayArrow -import androidx.compose.material3.FilledTonalIconButton -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.* -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.unit.dp -import androidx.compose.ui.unit.sp -import androidx.compose.ui.text.font.FontFamily - -@Composable -fun VoiceNotePlayer( - path: String, - progressOverride: Float? = null, - progressColor: Color? = null -) { - var isPlaying by remember { mutableStateOf(false) } - var isPrepared by remember { mutableStateOf(false) } - var isError by remember { mutableStateOf(false) } - var progress by remember { mutableStateOf(0f) } - var durationMs by remember { mutableStateOf(0) } - val player = remember { MediaPlayer() } - - // Seek function - position is a fraction from 0.0 to 1.0 - val seekTo: (Float) -> Unit = { position -> - if (isPrepared && durationMs > 0) { - val seekMs = (position * durationMs).toInt().coerceIn(0, durationMs) - try { - player.seekTo(seekMs) - progress = position // Update progress immediately for UI responsiveness - } catch (_: Exception) {} - } - } - - LaunchedEffect(path) { - isPrepared = false - isError = false - progress = 0f - durationMs = 0 - isPlaying = false - try { - player.reset() - player.setOnPreparedListener { - isPrepared = true - durationMs = try { player.duration } catch (_: Exception) { 0 } - } - player.setOnCompletionListener { - isPlaying = false - progress = 1f - } - player.setOnErrorListener { _, _, _ -> - isError = true - isPlaying = false - true - } - player.setDataSource(path) - player.prepareAsync() - } catch (_: Exception) { - isError = true - } - } - - LaunchedEffect(isPlaying, isPrepared) { - try { - if (isPlaying && isPrepared) player.start() else if (isPrepared && player.isPlaying) player.pause() - } catch (_: Exception) {} - } - LaunchedEffect(isPlaying, isPrepared) { - while (isPlaying && isPrepared) { - progress = try { player.currentPosition.toFloat() / (player.duration.toFloat().coerceAtLeast(1f)) } catch (_: Exception) { 0f } - kotlinx.coroutines.delay(100) - } - } - DisposableEffect(Unit) { onDispose { try { player.release() } catch (_: Exception) {} } } - - Row( - modifier = Modifier.fillMaxWidth(), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp) - ) { - // Disable play/pause while showing send progress override (optional UX choice) - val controlsEnabled = isPrepared && !isError && progressOverride == null - FilledTonalIconButton(onClick = { if (controlsEnabled) isPlaying = !isPlaying }, enabled = controlsEnabled, modifier = Modifier.size(28.dp)) { - Icon( - imageVector = if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow, - contentDescription = if (isPlaying) "Pause" else "Play" - ) - } - val progressBarColor = progressColor ?: MaterialTheme.colorScheme.primary - com.bitchat.android.ui.media.WaveformPreview( - modifier = Modifier - .height(24.dp) - .weight(1f) - .padding(horizontal = 8.dp, vertical = 4.dp), - path = path, - sendProgress = progressOverride, - playbackProgress = if (progressOverride == null) progress else null, - onSeek = seekTo - ) - val durText = if (durationMs > 0) String.format("%02d:%02d", (durationMs / 1000) / 60, (durationMs / 1000) % 60) else "--:--" - Text(text = durText, fontFamily = FontFamily.Monospace, fontSize = 12.sp) - } -} - diff --git a/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt b/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt deleted file mode 100644 index 64261d47a..000000000 --- a/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt +++ /dev/null @@ -1,134 +0,0 @@ -package com.bitchat.android.ui.media - -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.snapshots.SnapshotStateList -import androidx.compose.runtime.mutableStateListOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.withFrameNanos -import androidx.compose.runtime.getValue -import androidx.compose.runtime.rememberUpdatedState -import androidx.compose.foundation.gestures.detectTapGestures -import androidx.compose.ui.input.pointer.pointerInput -import androidx.compose.ui.Modifier -import androidx.compose.ui.geometry.Offset -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.StrokeCap -import androidx.compose.ui.graphics.drawscope.Stroke -import androidx.compose.ui.unit.dp -import com.bitchat.android.features.voice.AudioWaveformExtractor -import com.bitchat.android.features.voice.VoiceWaveformCache -import com.bitchat.android.features.voice.resampleWave - -@Composable -fun ScrollingWaveformRecorder( - modifier: Modifier = Modifier, - currentAmplitude: Float, - samples: SnapshotStateList, - maxSamples: Int = 120 -) { - // Append samples at a fixed cadence while visible - val latestAmp by rememberUpdatedState(currentAmplitude) - LaunchedEffect(Unit) { - while (true) { - withFrameNanos { _: Long -> } - val v = latestAmp.coerceIn(0f, 1f) - samples.add(v) - val overflow = samples.size - maxSamples - if (overflow > 0) repeat(overflow) { if (samples.isNotEmpty()) samples.removeAt(0) } - kotlinx.coroutines.delay(80) - } - } - WaveformCanvas(modifier = modifier, samples = samples, fillProgress = 1f, baseColor = Color(0xFF444444), fillColor = Color(0xFF00FF7F)) -} - -@Composable -fun WaveformPreview( - modifier: Modifier = Modifier, - path: String, - sendProgress: Float?, - playbackProgress: Float?, - onLoaded: ((FloatArray) -> Unit)? = null, - onSeek: ((Float) -> Unit)? = null -) { - val cached = remember(path) { VoiceWaveformCache.get(path) } - val stateSamples = remember { mutableStateListOf() } - val progress = (sendProgress ?: playbackProgress)?.coerceIn(0f, 1f) ?: 0f - LaunchedEffect(cached) { - if (cached != null) { - val normalized = if (cached.size != 120) resampleWave(cached, 120) else cached - stateSamples.clear(); stateSamples.addAll(normalized.toList()) - } else { - AudioWaveformExtractor.extractAsync(path, sampleCount = 120) { arr -> - if (arr != null) { - VoiceWaveformCache.put(path, arr) - stateSamples.clear(); stateSamples.addAll(arr.toList()) - onLoaded?.invoke(arr) - } - } - } - } - WaveformCanvas( - modifier = modifier, - samples = stateSamples, - fillProgress = if (stateSamples.isEmpty()) 0f else progress, - baseColor = Color(0x2200FF7F), - fillColor = when { - sendProgress != null -> Color(0xFF1E88E5) // blue while sending - else -> Color(0xFF00C851) // green during playback - }, - onSeek = onSeek - ) -} - -@Composable -private fun WaveformCanvas( - modifier: Modifier, - samples: List, - fillProgress: Float, - baseColor: Color, - fillColor: Color, - onSeek: ((Float) -> Unit)? = null -) { - val seekModifier = if (onSeek != null) { - modifier.pointerInput(onSeek) { - detectTapGestures { offset -> - // Calculate the seek position as a fraction (0.0 to 1.0) - val position = offset.x / size.width.toFloat() - val clampedPosition = position.coerceIn(0f, 1f) - onSeek(clampedPosition) - } - } - } else { - modifier - } - - Canvas(modifier = seekModifier.fillMaxWidth()) { - val w = size.width - val h = size.height - if (w <= 0f || h <= 0f) return@Canvas - val n = samples.size - if (n <= 0) return@Canvas - val stepX = w / n - val midY = h / 2f - val radius = 2.dp.toPx() - val stroke = Stroke(width = 2.dp.toPx(), cap = StrokeCap.Round) - val filledUntil = (n * fillProgress).toInt() - for (i in 0 until n) { - val amp = samples[i].coerceIn(0f, 1f) - val lineH = (amp * (h * 0.8f)).coerceAtLeast(2f) - val x = i * stepX + stepX / 2f - val yTop = midY - lineH / 2f - val yBot = midY + lineH / 2f - drawLine( - color = if (i <= filledUntil) fillColor else baseColor, - start = Offset(x, yTop), - end = Offset(x, yBot), - strokeWidth = stroke.width, - cap = StrokeCap.Round - ) - } - } -} diff --git a/app/src/main/res/xml/file_paths.xml b/app/src/main/res/xml/file_paths.xml deleted file mode 100644 index 725040b71..000000000 --- a/app/src/main/res/xml/file_paths.xml +++ /dev/null @@ -1,9 +0,0 @@ - - - - - diff --git a/app/src/test/java/com/bitchat/android/ui/CommandProcessorTest.kt b/app/src/test/java/com/bitchat/android/ui/CommandProcessorTest.kt index 6afdf6d60..5d8388934 100644 --- a/app/src/test/java/com/bitchat/android/ui/CommandProcessorTest.kt +++ b/app/src/test/java/com/bitchat/android/ui/CommandProcessorTest.kt @@ -5,32 +5,41 @@ import androidx.test.core.app.ApplicationProvider import com.bitchat.android.mesh.BluetoothMeshService import com.bitchat.android.model.BitchatMessage import junit.framework.TestCase.assertEquals - +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.test.StandardTestDispatcher import org.junit.Before -import org.junit.Ignore import org.junit.Test import org.junit.runner.RunWith import org.mockito.Mockito +import org.mockito.Spy +import org.mockito.kotlin.anyOrNull +import org.mockito.kotlin.eq import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.refEq +import org.mockito.kotlin.verify import org.robolectric.RobolectricTestRunner import java.util.Date @RunWith(RobolectricTestRunner::class) class CommandProcessorTest() { private val context: Context = ApplicationProvider.getApplicationContext() + private val meshService = BluetoothMeshService(context = context) private val chatState = ChatState() private lateinit var commandProcessor: CommandProcessor + @Spy + val messageManager: MessageManager = Mockito.spy(MessageManager(state = chatState)) - val messageManager: MessageManager = MessageManager(state = chatState) - val channelManager: ChannelManager = ChannelManager( - state = chatState, - messageManager = messageManager, - dataManager = DataManager(context = context), - coroutineScope = kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.Dispatchers.Main.immediate) + @Spy + val channelManager: ChannelManager = Mockito.spy( + ChannelManager( + state = chatState, + messageManager = messageManager, + dataManager = DataManager(context = context), + coroutineScope = CoroutineScope(StandardTestDispatcher()) + ) ) - private val meshService: BluetoothMeshService = mock() - @Before fun setup() { commandProcessor = CommandProcessor( @@ -46,10 +55,15 @@ class CommandProcessorTest() { ) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test - fun `when using lower case join command, command returns true`() { + fun `when using lower case join command, user is correctly added to channel`() { val channel = "channel-1" + val expectedMessage = BitchatMessage( + sender = "system", + content = "joined channel #$channel", + timestamp = Date(), + isRelay = false + ) val result = commandProcessor.processCommand( command = "/j $channel", @@ -60,12 +74,18 @@ class CommandProcessorTest() { ) assertEquals(result, true) + verify(messageManager).addMessage(refEq(expectedMessage, "timestamp", "id")) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test - fun `when using upper case join command, command returns true`() { + fun `when using upper case join command, user is correctly added to channel`() { val channel = "channel-1" + val expectedMessage = BitchatMessage( + sender = "system", + content = "joined channel #$channel", + timestamp = Date(), + isRelay = false + ) val result = commandProcessor.processCommand( command = "/JOIN $channel", @@ -76,11 +96,11 @@ class CommandProcessorTest() { ) assertEquals(result, true) + verify(messageManager).addMessage(refEq(expectedMessage, "timestamp", "id")) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test - fun `when unknown command lower case is given, command returns true but does not process special handling`() { + fun `when unknown command lower case is given, channel is not joined`() { val channel = "channel-1" val result = commandProcessor.processCommand( @@ -89,5 +109,6 @@ class CommandProcessorTest() { ) assertEquals(result, true) + verify(channelManager, never()).joinChannel(eq("#$channel"), anyOrNull(), eq("peer-id")) } } diff --git a/app/src/test/kotlin/com/bitchat/FileTransferTest.kt b/app/src/test/kotlin/com/bitchat/FileTransferTest.kt deleted file mode 100644 index 1798f5fe7..000000000 --- a/app/src/test/kotlin/com/bitchat/FileTransferTest.kt +++ /dev/null @@ -1,263 +0,0 @@ -package com.bitchat - -import com.bitchat.android.model.BitchatFilePacket -import com.bitchat.android.model.BitchatMessage -import com.bitchat.android.model.BitchatMessageType -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Test -import org.junit.runner.RunWith -import org.robolectric.RobolectricTestRunner -import java.io.File -import java.nio.ByteBuffer -import java.nio.ByteOrder -import java.util.Date - -@RunWith(RobolectricTestRunner::class) -class FileTransferTest { - - @Test - fun `encode and decode file packet with all fields should preserve data`() { - // Given: Complete file packet - val contentArray = ByteArray(1024) { (it % 256).toByte() } - val originalPacket = BitchatFilePacket( - fileName = "test.png", - mimeType = "image/png", - fileSize = 1024000, - content = contentArray - ) - - // When: Encode and decode - val encoded = originalPacket.encode() - val decoded = BitchatFilePacket.decode(encoded!!) - - // Then: Data should be preserved - assertNotNull(decoded) - assertEquals(originalPacket.fileName, decoded!!.fileName) - assertEquals(originalPacket.mimeType, decoded.mimeType) - assertEquals(originalPacket.fileSize, decoded.fileSize) - assertEquals(originalPacket.content.size, decoded.content.size) - for (i in 0 until originalPacket.content.size) { - assertEquals(originalPacket.content[i], decoded.content[i]) - } - } - - @Test - fun `encode file packet with filename should include filename TLV`() { - // Given: Packet with filename - val packet = BitchatFilePacket( - fileName = "myimage.jpg", - mimeType = "image/jpeg", - fileSize = 2048, - content = ByteArray(256) { 0xFF.toByte() } - ) - - // When: Encode - val encoded = packet.encode() - assertNotNull(encoded) - - // Then: Should contain filename TLV - // FILE_NAME type (0x01) + length (11) + "myimage.jpg" (UTF-8 with null terminator might add 1 byte) - val expectedType = 0x01.toByte() - val expectedFilename = "myimage.jpg".toByteArray(Charsets.UTF_8) - val expectedLength = expectedFilename.size // Should be 10 for UTF-8 "myimage.jpg" - - - - assertEquals(expectedType, encoded!![0]) - // Calculate the actual length from little-endian encoded data - val actualLength = (encoded[2].toInt() and 0xFF) or ((encoded[1].toInt() and 0xFF) shl 8) - // The encoding seems to be including a null terminator or extended bytes - assertEquals(11, actualLength) // The encoding produces 11 bytes for "myimage.jpg" - - val actualFilename = encoded!!.sliceArray(3 until 3 + expectedLength) - for (i in expectedFilename.indices) { - assertEquals(expectedFilename[i], actualFilename[i]) - } - } - - @Test - fun `encode file size should use big endian byte order for file size`() { - // Given: File with specific size - val fileSize = 0x12345678L - val packet = BitchatFilePacket( - fileName = "test.bin", - mimeType = "application/octet-stream", - fileSize = fileSize, - content = ByteArray(10) - ) - - // When: Encode - val encoded = packet.encode() - assertNotNull(encoded) - - // Then: File size should be in big endian order - // Find FILE_SIZE TLV (type 0x02) - var offset = 0 - while (offset < encoded!!.size - 1) { - if (encoded!![offset] == 0x02.toByte()) { - // This is FILE_SIZE TLV - offset += 1 // Skip type byte - val length = (encoded!![offset].toInt() and 0xFF) or ((encoded[offset + 1].toInt() and 0xFF) shl 8) - offset += 2 // Skip length bytes - if (length == 4) { // FILE_SIZE always has 4 bytes - val decodedFileSize = ByteBuffer.wrap(encoded!!.sliceArray(offset until offset + 4)) - .order(ByteOrder.BIG_ENDIAN) - .int.toLong() - assertEquals(fileSize, decodedFileSize) - break - } - } - offset += 1 - } - } - - @Test - fun `decode minimal file packet should handle defaults correctly`() { - // Given: Minimal valid packet (the constructor requires non-null values) - val originalPacket = BitchatFilePacket( - fileName = "test", - mimeType = "application/octet-stream", - fileSize = 32, // Matches content size - content = ByteArray(32) { 0xAA.toByte() } - ) - - // When: Encode and decode - val encoded = originalPacket.encode() - val decoded = BitchatFilePacket.decode(encoded!!) - - // Then: Data should be preserved completely - assertNotNull(decoded) - assertEquals(32, decoded!!.content.size) - for (i in 0 until 32) { - assertEquals(0xAA.toByte(), decoded.content[i]) - } - assertEquals("test", decoded.fileName) - assertEquals("application/octet-stream", decoded.mimeType) - assertEquals(32L, decoded.fileSize) - } - - @Test - fun `replaceFilePathInContent should correctly format content markers for different file types`() { - // Given: Different file types - val imageMessage = BitchatMessage( - id = "test1", - sender = "alice", - senderPeerID = "12345678", - content = "/data/user/0/com.bitchat.android/files/images/photo.jpg", - type = BitchatMessageType.Image, - timestamp = Date(System.currentTimeMillis()), - isPrivate = false - ) - - val audioMessage = BitchatMessage( - id = "test2", - sender = "bob", - senderPeerID = "87654321", - content = "/data/user/0/com.bitchat.android/files/audio/voice.amr", - type = BitchatMessageType.Audio, - timestamp = Date(System.currentTimeMillis()), - isPrivate = false - ) - - val fileMessage = BitchatMessage( - id = "test3", - sender = "charlie", - senderPeerID = "11223344", - content = "/data/user/0/com.bitchat.android/files/documents/document.pdf", - type = BitchatMessageType.File, - timestamp = Date(System.currentTimeMillis()), - isPrivate = false - ) - - // When: Converting to display format (this would be done in MessageMutable) - var result = imageMessage.content - result = result.replace( - "/data/user/0/com.bitchat.android/files/images/photo.jpg", - "[image] photo.jpg" - ) - - // Then: Should match expected pattern - assertEquals("[image] photo.jpg", result) - - // Similar pattern for audio and file would be used in the actual implementation - } - - @Test - fun `buildPrivateMessagePreview should generate user-friendly notifications for file types`() { - // Note: This test is for the NotificationTextUtils.buildPrivateMessagePreview function - // The actual function is in a separate utility file as part of the refactoring - - // Given: Incoming image message - val imageMessage = BitchatMessage( - id = "test1", - sender = "alice", - senderPeerID = "1234abcd", - content = "📷 sent an image", // This would be the result of the utility function - type = BitchatMessageType.Image, - timestamp = Date(System.currentTimeMillis()), - isPrivate = true - ) - - // When: Building preview (this would call NotificationTextUtils.buildPrivateMessagePreview) - val preview = imageMessage.content // In actual code, this would be generated - - // Then: Should provide user-friendly preview - assertEquals("📷 sent an image", preview) - - // Additional assertions would test different file types - // Audio: "🎤 sent a voice message" - // File with specific extension: "📄 document.pdf" - // Generic file: "📎 sent a file" - } - - @Test - fun `waveform extraction should handle empty audio data gracefully`() { - // This test would verify that empty or very short audio files - // don't cause crashes in waveform extraction - - // Given: Empty audio data - val emptyAudioData = ByteArray(0) - - // When: Attempting to extract waveform - // Note: Actual waveform extraction would be tested in the Waveform class - // This is a unit test placeholder - - // Then: Should not crash and should return reasonable result - // For empty data, waveform might be empty array or default values - assertEquals(0, emptyAudioData.size) - } - - @Test - fun `media picker should handle file size limits correctly`() { - // This test would verify that media file selection - // respects size limits before attempting transfer - - // Given: Large file size (simulated) - val largeFileSize = 100L * 1024 * 1024 // 100MB - val maxAllowedSize = 50L * 1024 * 1024 // 50MB - - // When: Checking if file can be transferred - val isAllowed = largeFileSize <= maxAllowedSize - - // Then: Should be rejected - assert(!isAllowed) - } - - @Test - fun `transfer cancellation should cleanup resources properly`() { - // This test would verify that when a file transfer is cancelled, - // all associated resources are cleaned up - - // Given: Active transfer in progress - val transferId = "test_transfer_123" - - // When: Transfer is cancelled - // In the actual implementation, this would call cancellation logic - val cancelled = true // Simulated cancellation - - // Then: Resources should be cleaned up - // This would verify temp files are deleted, progress tracking is cleared, etc. - assert(cancelled) - } -} diff --git a/app/src/test/kotlin/com/bitchat/NotificationManagerTest.kt b/app/src/test/kotlin/com/bitchat/NotificationManagerTest.kt index cfe8e5b46..9f821fcb6 100644 --- a/app/src/test/kotlin/com/bitchat/NotificationManagerTest.kt +++ b/app/src/test/kotlin/com/bitchat/NotificationManagerTest.kt @@ -6,7 +6,6 @@ import androidx.test.core.app.ApplicationProvider import com.bitchat.android.ui.NotificationManager import com.bitchat.android.util.NotificationIntervalManager import org.junit.Before -import org.junit.Ignore import org.junit.Test import org.junit.runner.RunWith import org.mockito.Mockito @@ -24,7 +23,10 @@ class NotificationManagerTest { private val context: Context = ApplicationProvider.getApplicationContext() private val notificationIntervalManager = NotificationIntervalManager() lateinit var notificationManager: NotificationManager - private val notificationManagerCompat: NotificationManagerCompat = Mockito.mock(NotificationManagerCompat::class.java) + + @Spy + val notificationManagerCompat: NotificationManagerCompat = + Mockito.spy(NotificationManagerCompat.from(context)) @Before fun setup() { @@ -36,7 +38,6 @@ class NotificationManagerTest { ) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when there are no active peers, do not send active peer notification`() { notificationManager.setAppBackgroundState(true) @@ -44,7 +45,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, never()).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when app is in foreground, do not send active peer notification`() { notificationManager.setAppBackgroundState(false) @@ -52,7 +52,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, never()).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when there is an active peer, send notification`() { notificationManager.setAppBackgroundState(true) @@ -60,7 +59,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(1)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when there is an active peer but less than 5 minutes have passed since last notification, do not send notification`() { notificationManager.setAppBackgroundState(true) @@ -69,7 +67,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(1)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when there is an active peer and more than 5 minutes have passed since last notification, send notification`() { notificationManager.setAppBackgroundState(true) @@ -79,7 +76,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(2)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when there is a recently seen peer but no new active peers, no notification is sent`() { notificationManager.setAppBackgroundState(true) @@ -88,7 +84,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(0)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when an active peer is a recently seen peer, do not send notification`() { notificationManager.setAppBackgroundState(true) @@ -97,7 +92,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(0)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when an active peer is a new peer, send notification`() { notificationManager.setAppBackgroundState(true) @@ -106,7 +100,6 @@ class NotificationManagerTest { verify(notificationManagerCompat, times(1)).notify(any(), any()) } - @Ignore // Temporarily disabled due to Mockito final class issues @Test fun `when an active peer is a new peer and there are already multiple recently seen peers, send notification`() { notificationManager.setAppBackgroundState(true) diff --git a/app/src/test/kotlin/com/bitchat/android/mesh/PacketRelayManagerTest.kt b/app/src/test/kotlin/com/bitchat/android/mesh/PacketRelayManagerTest.kt new file mode 100644 index 000000000..ae896e530 --- /dev/null +++ b/app/src/test/kotlin/com/bitchat/android/mesh/PacketRelayManagerTest.kt @@ -0,0 +1,117 @@ + +package com.bitchat.android.mesh + +import com.bitchat.android.model.RoutedPacket +import com.bitchat.android.protocol.BitchatPacket +import com.bitchat.android.protocol.MessageType +import com.bitchat.android.util.toHexString +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.runTest +import org.junit.Before +import org.junit.Test +import org.mockito.kotlin.any +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +@ExperimentalCoroutinesApi +class PacketRelayManagerTest { + + private lateinit var packetRelayManager: PacketRelayManager + private val delegate: PacketRelayManagerDelegate = mock() + + private val myPeerID = "1111111111111111" + private val otherPeerID = "2222222222222222" + private val nextHopPeerID = "3333333333333333" + private val finalRecipientID = "4444444444444444" + + @Before + fun setUp() { + packetRelayManager = PacketRelayManager(myPeerID) + packetRelayManager.delegate = delegate + whenever(delegate.getNetworkSize()).thenReturn(10) + whenever(delegate.getBroadcastRecipient()).thenReturn(byteArrayOf(0,0,0,0,0,0,0,0)) + } + + private fun createPacket(route: List?, recipient: String? = null): BitchatPacket { + return BitchatPacket( + type = MessageType.MESSAGE.value, + senderID = hexStringToPeerBytes(otherPeerID), + recipientID = recipient?.let { hexStringToPeerBytes(it) }, + timestamp = System.currentTimeMillis().toULong(), + payload = "hello".toByteArray(), + ttl = 5u, + route = route + ) + } + + @Test + fun `packet with duplicate hops is dropped`() = runTest { + val route = listOf( + hexStringToPeerBytes(nextHopPeerID), + hexStringToPeerBytes(nextHopPeerID) + ) + val packet = createPacket(route) + val routedPacket = RoutedPacket(packet, otherPeerID) + + packetRelayManager.handlePacketRelay(routedPacket) + + verify(delegate, never()).sendToPeer(any(), any()) + verify(delegate, never()).broadcastPacket(any()) + } + + @Test + fun `valid source-routed packet is relayed to next hop`() = runTest { + val route = listOf( + hexStringToPeerBytes(myPeerID), + hexStringToPeerBytes(nextHopPeerID) + ) + val packet = createPacket(route, finalRecipientID) + val routedPacket = RoutedPacket(packet, otherPeerID) + whenever(delegate.sendToPeer(any(), any())).thenReturn(true) + + packetRelayManager.handlePacketRelay(routedPacket) + + verify(delegate).sendToPeer(org.mockito.kotlin.eq(nextHopPeerID), any()) + verify(delegate, never()).broadcastPacket(any()) + } + + @Test + fun `last hop does not relay further`() = runTest { + val route = listOf( + hexStringToPeerBytes(myPeerID) + ) + val packet = createPacket(route, finalRecipientID) + val routedPacket = RoutedPacket(packet, otherPeerID) + whenever(delegate.sendToPeer(any(), any())).thenReturn(true) + + packetRelayManager.handlePacketRelay(routedPacket) + + verify(delegate).sendToPeer(org.mockito.kotlin.eq(finalRecipientID), any()) + verify(delegate, never()).broadcastPacket(any()) + } + + @Test + fun `packet with empty route is broadcast`() = runTest { + val packet = createPacket(null) + val routedPacket = RoutedPacket(packet, otherPeerID) + + packetRelayManager.handlePacketRelay(routedPacket) + + verify(delegate, never()).sendToPeer(any(), any()) + verify(delegate).broadcastPacket(any()) + } + + private fun hexStringToPeerBytes(hex: String): ByteArray { + val result = ByteArray(8) + var idx = 0 + var out = 0 + while (idx + 1 < hex.length && out < 8) { + val b = hex.substring(idx, idx + 2).toIntOrNull(16)?.toByte() ?: 0 + result[out++] = b + idx += 2 + } + return result + } +} diff --git a/docs/SOURCE_ROUTING.md b/docs/SOURCE_ROUTING.md index f6d101e25..9bb4529b6 100644 --- a/docs/SOURCE_ROUTING.md +++ b/docs/SOURCE_ROUTING.md @@ -30,7 +30,7 @@ Unknown flags are ignored by older implementations (they will simply not see a r ## Sender Behavior - Applicability: Intended for addressed packets (i.e., where `recipientID` is set and is not the broadcast ID). For broadcast packets, omit the route. -- Path computation: Use Dijkstra’s shortest path (unit weights) on your internal mesh topology to find a route from `src` (your peerID) to `dst` (recipient peerID). The hop list SHOULD include the full path `[src, ..., dst]`. +- Path computation: Use Dijkstra’s shortest path (unit weights) on your internal mesh topology to find a route from the sender (your peerID) to the recipient (the destination peerID). The `BitchatPacket` already contains dedicated `senderID` and `recipientID` fields. The `Route` field's `hops` list **SHOULD** contain the sequence of intermediate peer IDs that the packet should traverse. It **SHOULD NOT** duplicate the `senderID` or `recipientID` if they are already present in the `BitchatPacket`'s dedicated fields. Instead, the `hops` list represents the explicit path *between* the sender and recipient, starting from the first relay and ending with the last relay before the recipient. - Encoding: Set `HAS_ROUTE`, write `count = path.length`, then the 8‑byte hop IDs in order. Keep `count <= 255`. - Signing: The route is covered by the Ed25519 signature (recommended): - Signature input is the canonical encoding with `signature` omitted and `ttl = 0` (TTL excluded to allow relay decrement) — same rule as base protocol. @@ -40,11 +40,13 @@ Unknown flags are ignored by older implementations (they will simply not see a r When receiving a packet that is not addressed to you: 1) If `HAS_ROUTE` is not set, or the route is empty, relay using your normal broadcast logic (subject to TTL/probability policies). -2) If `HAS_ROUTE` is set and your peer ID appears at index `i` in the hop list: - - If there is a next hop at `i+1`, attempt a targeted unicast to that next hop if you have a direct connection to it. - - If successful, do NOT broadcast this packet further. - - If not directly connected (or the send fails), fall back to broadcast relaying. - - If you are the last hop (no `i+1`), proceed with standard handling (e.g., if not addressed to you, do not relay further). +2) If `HAS_ROUTE` is set: + - **Route Sanity Check**: Before processing, the relay **MUST** validate the route. If the route contains duplicate hops (i.e., the same peer ID appears more than once), the packet **MUST** be dropped to prevent loops. + - If your peer ID appears at index `i` in the hop list: + - If there is a next hop at `i+1`, attempt a targeted unicast to that next hop if you have a direct connection to it. + - If successful, do NOT broadcast this packet further. + - If not directly connected (or the send fails), fall back to broadcast relaying. + - If you are the last hop (no `i+1`), the packet has reached the end of its explicit route. The relay should then attempt to deliver it to the final `recipientID` if directly connected, but SHOULD NOT relay it further as a broadcast. TTL handling remains unchanged: relays decrement TTL by 1 before forwarding (whether targeted or broadcast). If TTL reaches 0, do not relay. @@ -64,11 +66,11 @@ TTL handling remains unchanged: relays decrement TTL by 1 before forwarding (whe - Variable sections (ordered): - `SenderID(8)` - `RecipientID(8)` (if present) - - `HAS_ROUTE` set → `count=3`, `hops = [H0 H1 H2]` where each `Hk` is 8 bytes + - `HAS_ROUTE` set → `count=1`, `hops = [H1]` where `H1` is 8 bytes - Payload (optionally compressed) - Signature (64) -Where `H0` is the sender’s peer ID, `H2` is the recipient’s peer ID, and `H1` is an intermediate relay. The receiver verifies the signature over the packet encoding (with `ttl = 0` and `signature` omitted), which includes the `hops` when `HAS_ROUTE` is set. +In this example, `SENDER_ID` is the sender, `RECIPIENT_ID` is the final recipient, and `H1` is the single intermediate relay. The `hops` list explicitly defines the path *between* the sender and recipient. The receiver verifies the signature over the packet encoding (with `ttl = 0` and `signature` omitted), which includes the `hops` when `HAS_ROUTE` is set. ## Operational Notes diff --git a/docs/device_manager.md b/docs/device_manager.md deleted file mode 100644 index 092403b04..000000000 --- a/docs/device_manager.md +++ /dev/null @@ -1,114 +0,0 @@ -# Device Monitoring Manager — Design and Integration - -This change introduces a lean DeviceMonitoringManager to strictly manage BLE device connections while keeping the existing code structure intact. - -## Goals - -- Maintain a blocklist of device MAC addresses to deny incoming/outgoing connections. -- Drop and block connections that never ANNOUNCE within 15 seconds of establishment. -- Drop and block connections that go silent (no packets) for over 60 seconds. -- Block devices that experience 5 error disconnects within a 5-minute window. -- Auto-unblock devices after 15 minutes. - -## Implementation Overview - -File: `app/src/main/java/com/bitchat/android/mesh/DeviceMonitoringManager.kt` - -- Thread-safe maps with coroutine-based timers. -- Minimal surface area: a few clearly named entry points to hook into existing flows. -- Callbacks to perform disconnects without coupling to GATT APIs. - -Key logic: -- `isBlocked(address)`: check if a MAC is blocked (auto-clears on expiry). -- `block(address, reason)`: add MAC to blocklist (15m), disconnect via callback, auto-unblock later. -- `onConnectionEstablished(address)`: start 15s “first ANNOUNCE” timer and a 60s inactivity timer. -- `onAnnounceReceived(address)`: cancel the 15s ANNOUNCE timer for that device. -- `onAnyPacketReceived(address)`: refresh 60s inactivity timer. -- `onDeviceDisconnected(address, status)`: track error disconnects and block on 5 within 5 minutes. - -Timers: -- ANNOUNCE timer: 15 seconds from connection establishment. -- Inactivity timer: resets on any packet; fires after 60 seconds of silence. -- Blocklist TTL: 15 minutes per device (auto-unblock job per entry). - -## Wiring Points (Minimal Changes) - -1) Connection Manager -- File: `BluetoothConnectionManager.kt` -- Added a `DeviceMonitoringManager` instance and provided a `disconnectCallback` that: - - disconnects client GATT connections via `BluetoothConnectionTracker`. - - cancels server connections via `BluetoothGattServer.cancelConnection`. -- Exposed `noteAnnounceReceived(address)` as a small helper for higher layers. -- Updated `componentDelegate.onPacketReceived` to notify per-device activity to the monitor. - -2) GATT Client -- File: `BluetoothGattClientManager.kt` -- Constructor now receives `deviceMonitor`. -- Before attempting any outgoing connection (from scan or direct connect), deny if blocked. -- On connection setup complete (after CCCD enable), call `deviceMonitor.onConnectionEstablished(addr)`. -- On incoming packet (`onCharacteristicChanged`), call `deviceMonitor.onAnyPacketReceived(addr)`. -- On disconnect, call `deviceMonitor.onDeviceDisconnected(addr, status)` to track error bursts. - -3) GATT Server -- File: `BluetoothGattServerManager.kt` -- Constructor now receives `deviceMonitor`. -- On incoming connection, immediately deny (cancelConnection) if blocked, before tracking it. -- On connection setup complete (descriptor enable) and also after initial connect, start monitoring via `onConnectionEstablished(addr)`. -- On packet write, call `deviceMonitor.onAnyPacketReceived(addr)`. -- On disconnect, call `deviceMonitor.onDeviceDisconnected(addr, status)`. - -4) ANNOUNCE Binding -- File: `BluetoothMeshService.kt` (in the ANNOUNCE handler where we first map device → peer) -- After mapping a device address to a peer on first verified ANNOUNCE, call `connectionManager.noteAnnounceReceived(address)` to cancel the 15s timer for that device. - -## Behavior Summary - -- Blocked devices: - - Outgoing: client will not initiate connections. - - Incoming: server cancels the connection immediately. - - Existing connection: monitor disconnects instantly and blocks for 15 minutes. - -- No ANNOUNCE within 15s of connection: - - Connection is dropped and device is blocked for 15 minutes. - -- No packets for >60s: - - Connection is dropped and device is blocked for 15 minutes. - -- >=5 error disconnects within 5 minutes: - - Device is blocked for 15 minutes. - -- Auto-unblock: - - Every block entry automatically expires after 15 minutes. - -## Debug Logging - -- The manager emits chat-visible debug messages through `DebugSettingsManager` (SystemMessage), e.g.: - - Blocking decisions and reasons - - Auto-unblock events - - ANNOUNCE wait start/cancel - - Inactivity timer set and inactivity-triggered blocks - - Burst error disconnect threshold reached -- Additional enforcement logs are added in GATT client/server when a blocked device is denied. -- Logs appear in the chat when verbose logging is enabled in Debug settings. - -## Panic Triple-Tap - -- Triple-tapping the title now also clears the device blocklist and all device tracking: - - Calls `BluetoothMeshService.clearAllInternalData()` which triggers `BluetoothConnectionManager.clearDeviceMonitoringAndTracking()`. - - This disconnects active connections, clears the monitor’s blocklist and timers, and resets the `BluetoothConnectionTracker` state. - -## Notes and Rationale - -- The monitoring manager is intentionally decoupled from GATT specifics via a disconnect callback. This keeps responsibilities separate and avoids plumbing GATT instances through unrelated classes. -- Packet activity is captured in both client and server data paths as early as possible to ensure the inactivity timer is accurate even before higher-level processing. -- The “first ANNOUNCE” check uses the same mapping event that sets `addressPeerMap` to avoid false positives on unverified announces. - -## Touched Files - -- Added: `mesh/DeviceMonitoringManager.kt` -- Updated: `mesh/BluetoothConnectionManager.kt` -- Updated: `mesh/BluetoothGattClientManager.kt` -- Updated: `mesh/BluetoothGattServerManager.kt` -- Updated: `mesh/BluetoothMeshService.kt` - -These changes are small, local, and respect existing structure without broad refactors. diff --git a/docs/file_transfer.md b/docs/file_transfer.md deleted file mode 100644 index 01b3e6f72..000000000 --- a/docs/file_transfer.md +++ /dev/null @@ -1,442 +0,0 @@ -# Bitchat Bluetooth File Transfer: Images, Audio, and Generic Files (with Interactive Features) - -This document is the exhaustive implementation guide for Bitchat’s Bluetooth file transfer protocol for voice notes (audio) and images, including interactive features like waveform seeking. It describes the on‑wire packet format (both v1 and v2), fragmentation/progress/cancellation, sender/receiver behaviors, and the complete UX we implemented in the Android client so that other implementers can interoperate and match the user experience precisely. - -**Protocol Versions:** -- **v1**: Original protocol with 2‑byte payload length (≤ 64 KiB files) -- **v2**: Extended protocol with 4-byte payload length (≤ 4 GiB files) - use for all file transfers -- File transfer packets use v2 format by default for optimal compatibility - -**Interactive Features:** -- **Waveform Seeking**: Tap anywhere on audio waveforms to jump to that playback position -- **Large File Support**: v2 protocol enables multi-GiB file transfers through fragmentation -- **Unified Experience**: Identical UX between platforms with enhanced user control - -The guide is organized into: - -- Protocol overview (BitchatPacket + File Transfer payload) -- Fragmentation, progress reporting, and cancellation -- Receive path, validation, and persistence -- Sender path (audio + images) -- Interactive features (audio waveform seeking) -- UI/UX behavior (recording, sending, playback, image rendering) -- File inventory (source files and their roles) - - ---- - -## 1) Protocol Overview - -Bitchat BLE transport carries application messages inside the common `BitchatPacket` envelope. File transfer reuses the same envelope as public and private messages, with a distinct `type` and a TLV‑encoded payload. - -### 1.1 BitchatPacket envelope - -Fields (subset relevant to file transfer): - -- `version: UByte` — protocol version (`1` for v1, `2` for v2 with extended payload length). -- `type: UByte` — message type. File transfer uses `MessageType.FILE_TRANSFER (0x22)`. -- `senderID: ByteArray (8)` — 8‑byte binary peer ID. -- `recipientID: ByteArray (8)` — 8‑byte recipient. For public: `SpecialRecipients.BROADCAST (0xFF…FF)`; for private: the target peer’s 8‑byte ID. -- `timestamp: ULong` — milliseconds since epoch. -- `payload: ByteArray` — TLV file payload (see below). -- `signature: ByteArray?` — optional signature (present for private sends in our implementation, to match iOS integrity path). -- `ttl: UByte` — hop TTL (we use `MAX_TTL` for broadcast, `7` for private). - -Envelope creation and broadcast paths are implemented in: - -- `app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt) -- `app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt) - -Private sends are additionally encrypted at the higher layer (Noise) for text messages, but file transfers use the `FILE_TRANSFER` message type in the clear at the envelope level with content carried inside a TLV. See code for any deployment‑specific enforcement. - -### 1.2 Binary Protocol Extensions (v2) - -#### v2 Header Format Changes - -**v1 Format (original):** -``` -Header (13 bytes): -Version: 1 byte -Type: 1 byte -TTL: 1 byte -Timestamp: 8 bytes -Flags: 1 byte -PayloadLength: 2 bytes (big-endian, max 64 KiB) -``` - -**v2 Format (extended):** -``` -Header (15 bytes): -Version: 1 byte (set to 2 for v2 packets) -Type: 1 byte -TTL: 1 byte -Timestamp: 8 bytes -Flags: 1 byte -PayloadLength: 4 bytes (big-endian, max ~4 GiB) -``` - -- **Header Size**: Increased from 13 to 15 bytes. -- **Payload Length Field**: Extended from 16 bits (2 bytes) to 32 bits (4 bytes), allowing file transfers up to ~4 GiB. -- **Backward Compatibility**: Clients must support both v1 and v2 decoding. File transfer packets always use v2. -- **Implementation**: See `BinaryProtocol.kt` with `getHeaderSize(version)` logic. - -#### Use Cases for v2 -- **Large Audio Files**: Professional recordings, podcasts, or music samples. -- **High-Resolution Images**: Full-resolution photos from modern smartphones. -- **Future File Types**: PDFs, documents, archives, or other large media. - -#### Interoperability Requirements -- Clients receiving v2 packets must decode 4-byte `PayloadLength` fields. -- Clients sending file transfers should preferentially use v2 format. -- Fragmentation still applies: large files are split into fragments that fit within BLE MTU constraints (~128 KiB per fragment). - -### 1.3 File Transfer TLV payload (BitchatFilePacket) - -The file payload is a TLV structure with mixed length field sizes to support large contents efficiently. - -- Defined in `app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt) - -Canonical TLVs (v2 spec): - -- `0x01 FILE_NAME` — UTF‑8 bytes - - Encoding: `type(1) + len(2) + value` -- `0x02 FILE_SIZE` — 4 bytes (UInt32, big‑endian) - - Encoding: `type(1) + len(2=4) + value(4)` - - Note: v1 used 8 bytes (UInt64). v2 standardizes to 4 bytes. See Legacy Compatibility below. -- `0x03 MIME_TYPE` — UTF‑8 bytes (e.g., `image/jpeg`, `audio/mp4`, `application/pdf`) - - Encoding: `type(1) + len(2) + value` -- `0x04 CONTENT` — raw file bytes - - Encoding: `type(1) + len(4) + value(len)` - - Exactly one CONTENT TLV per file payload in v2 (no TLV‑level chunking); overall packet fragmentation happens at the transport layer. - -Encoding rules: - -- Standard TLVs use `1 byte type + 2 bytes big‑endian length + value`. -- CONTENT uses a 4‑byte big‑endian length to allow payloads well beyond 64 KiB. -- With the v2 envelope (4‑byte payload length), CONTENT can be large; transport still fragments oversize packets to fit BLE MTU. -- Implementations should validate TLV boundaries; decoding should fail fast on malformed structures. - -Decoding rules (v2): - -- Accept the canonical TLVs above. Unknown TLVs should be ignored or cause failure per implementation policy (current Android rejects unknown types). -- FILE_SIZE expects `len=4` and is parsed as UInt32; receivers may upcast to 64‑bit internally. -- CONTENT expects a 4‑byte length field and a single occurrence; if multiple CONTENT TLVs are present, concatenate in order (defensive tolerance). -- If FILE_SIZE is missing, receivers may fall back to `content.size`. -- If MIME_TYPE is missing, default to `application/octet-stream`. - -Legacy Compatibility (optional, for mixed‑version meshes): - -- FILE_SIZE (0x02): Some legacy senders used 8‑byte UInt64. Decoders MAY accept `len=8` and clamp to 32‑bit if needed. -- CONTENT (0x04): Legacy payloads might have used a 2‑byte TLV length with multiple CONTENT chunks. Decoders MAY support concatenating multiple CONTENT TLVs with 2‑byte lengths if encountered. - - ---- - -## 2) Fragmentation, Progress, and Cancellation - -### 2.1 Fragmentation - -File transfers reuse the mesh broadcaster’s fragmentation logic: - -- `BluetoothPacketBroadcaster` checks if the serialized envelope exceeds the configured MTU and splits it into fragments via `FragmentManager`. -- Fragments are sent with a short inter‑fragment delay (currently ~200 ms; matches iOS/Rust behavior notes in code). -- When only one fragment is needed, send as a single packet. - -### 2.2 Transfer ID and progress events - -We derive a deterministic transfer ID to track progress: - -- `transferId = sha256Hex(packet.payload)` (hex string of the file TLV payload). - -The broadcaster emits progress events to a shared flow: - -- `TransferProgressManager.start(id, totalFragments)` -- `TransferProgressManager.progress(id, sent, totalFragments)` -- `TransferProgressManager.complete(id, totalFragments)` - -The UI maps `transferId → messageId`, then updates `DeliveryStatus.PartiallyDelivered(sent, total)` as events arrive; when `complete`, switches to `Delivered`. - -### 2.3 Cancellation - -Transfers are cancellable mid‑flight: - -- The broadcaster keeps a `transferId → Job` map and cancels the job to stop sending remaining fragments. -- API path: - - `BluetoothPacketBroadcaster.cancelTransfer(transferId)` - - Exposed via `BluetoothConnectionManager.cancelTransfer` and `BluetoothMeshService.cancelFileTransfer`. - - `ChatViewModel.cancelMediaSend(messageId)` resolves `messageId → transferId` and cancels. -- UX: tapping the “X” on a sending media removes the message from the timeline immediately. - -Implementation files: - -- `app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt) -- `app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt) - - ---- - -## 3) Receive Path and Persistence - -Receiver dispatch is in `MessageHandler`: - -- For both broadcast and private paths we try `BitchatFilePacket.decode(payload)`. If it decodes: - - The file is persisted under app files with type‑specific subfolders: - - Audio: `files/voicenotes/incoming/` - - Image: `files/images/incoming/` - - Other files: `files/files/incoming/` - - Filename strategy: - - Prefer the transmitted `fileName` when present; sanitize path separators. - - Ensure uniqueness by appending `" (n)"` before the extension when a name exists already. - - If `fileName` is absent, derive from MIME with a sensible default extension. - - MIME determines extension hints (`.m4a`, `.mp3`, `.wav`, `.ogg` for audio; `.jpg`, `.png`, `.webp` for images; otherwise based on MIME or `.bin`). -- A synthetic chat message is created with content markers pointing to the local path: - - Audio: `"[voice] /abs/path/to/file"` - - Image: `"[image] /abs/path/to/file"` - - Other: `"[file] /abs/path/to/file"` - - `senderPeerID` is set to the origin, `isPrivate` set appropriately. - -Files: - -- `app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt) - - ---- - -## 4) Sender Path - -### 4.1 Audio (Voice Notes) - -1) Capture - - Hold‑to‑record mic button starts `MediaRecorder` with AAC in MP4 (`audio/mp4`). - - Sample rate: 44100 Hz, channels: mono, bitrate: ~32 kbps (to reduce payload size for BLE). - - On release, we pad 500 ms before stopping to avoid clipping endings. - - Files saved under `files/voicenotes/outgoing/voice_YYYYMMDD_HHMMSS.m4a`. - -2) Local echo - - We create a `BitchatMessage` with content `"[voice] "` and add to the appropriate timeline (public/channel/private). - - For private: `messageManager.addPrivateMessage(peerID, message)`. For public/channel: `messageManager.addMessage(message)` or add to channel. - -3) Packet creation - - Build a `BitchatFilePacket`: - - `fileName`: basename (e.g., `voice_… .m4a`) - - `fileSize`: file length - - `mimeType`: `audio/mp4` - - `content`: full bytes (ensure content ≤ 64 KiB; with chosen codec params typical short notes fit fragmentation constraints) - - Encode TLV; compute `transferId = sha256Hex(payload)`. - - Map `transferId → messageId` for UI progress. - -4) Send - - Public: `BluetoothMeshService.sendFileBroadcast(filePacket)`. - - Private: `BluetoothMeshService.sendFilePrivate(peerID, filePacket)`. - - Broadcaster handles fragmentation and progress emission. - -5) Waveform - - We extract a 120‑bin waveform from the recorded file (the same extractor used for the receiver) and cache by file path, so sender and receiver waveforms are identical. - -Core files: - -- `app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt` (sendVoiceNote) (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt) -- `app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt) -- `app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt) -- `app/src/main/java/com/bitchat/android/features/voice/Waveform.kt` (cache + extractor) (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt) - -### 4.2 Images - -1) Selection and processing - - System picker (Storage Access Framework) with `GetContent()` (`image/*`). No storage permission required. - - Selected image is downscaled so longest edge is 512 px; saved as JPEG (85% quality) under `files/images/outgoing/img_.jpg`. - - Helper: `ImageUtils.downscaleAndSaveToAppFiles(context, uri, maxDim=512)`. - -2) Local echo - - Insert a message with `"[image] "` in the current context (public/channel/private). - -3) Packet creation - - Build `BitchatFilePacket` with mime `image/jpeg` and file content. - - Encode TLV + compute `transferId` and map to `messageId`. - -4) Send - - Same paths as audio (broadcast/private), including fragmentation and progress emission. - -Core files: - -- `app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt) -- `app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt` (sendImageNote) (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt) - - ---- - -## 5) UI / UX Details - -This section specifies exactly what users see and how inputs behave, so alternative clients can match the experience. - -### 5.1 Message input area - -- The input field remains mounted at all times to prevent the IME (keyboard) from collapsing during long‑press interactions (recording). We overlay recording UI atop the text field rather than replacing it. -- While recording, the text caret (cursor) is hidden by setting a transparent cursor brush. -- Mentions and slash commands are styled with a monospace look and color coding. - -Files: - -- `app/src/main/java/com/bitchat/android/ui/InputComponents.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/InputComponents.kt) - -### 5.2 Recording UX - -- Hold the mic button to start recording. Recording runs until release, then we pad 500 ms and stop. -- While recording, a dense, real‑time scrolling waveform overlays the input showing live audio; a timer is shown to the right. - - Component: `RealtimeScrollingWaveform` (dense bars, ~240 columns, ~20 FPS) in `app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt`. - - The keyboard stays visible; the caret is hidden. -- On release, we immediately show a local echo message for the voice note and start sending. - -### 5.3 Voice note rendering - -- Displayed with a header (nickname + timestamp) then the waveform + controls row. -- Waveform - - A 120‑bin static waveform is rendered per file, identical for sender and receiver, extracted from the actual audio file. - - During send, the waveform fills left→right in blue based on fragment progress. - - During playback, the waveform fills left→right in green based on player progress. -- Controls - - Play/Pause toggle to the left of the waveform; duration text to the right. -- Cancel sending - - While sending a voice note, a round “X” cancel button appears to the right of the controls. Tapping cancels the transfer mid‑flight. - -Files: - -- `app/src/main/java/com/bitchat/android/ui/MessageComponents.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt) -- `app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt) -- `app/src/main/java/com/bitchat/android/features/voice/Waveform.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt) - -### 5.4 Image sending UX - -- A circular “+” button next to the mic opens the system image picker. After selection, we downscale to 512 px longest edge and show a local echo; the send begins immediately. -- Progress visualization - - Instead of a linear progress bar, we reveal the image block‑by‑block (modem‑era homage). - - The image is divided into a constant grid (default 24×16), and the blocks are rendered in order based on fragment progress; there are no gaps between tiles. - - The cancel “X” button overlays the top‑right corner during sending. -- On cancel, the message is removed from the chat immediately. - -Files: - -- `app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt) -- `app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt) -- `app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt) -- `app/src/main/java/com/bitchat/android/ui/MessageComponents.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt) - -### 5.5 Image receiving UX - -- Received images render fully with rounded corners and are left‑aligned like text messages. -- Tapping an image opens a fullscreen viewer with an option to save to the device Downloads via `MediaStore`. - -Files: - -- `app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt) - - ---- - -## 5.6 Interactive Audio Features - -### 5.6.1 Waveform Seeking - -- Audio waveforms in chat messages are fully interactive: users can tap anywhere on the waveform to jump to that position in the audio playback. -- On tap, the seek position is calculated as a fraction of the waveform width (0.0 = beginning, 1.0 = end). -- This works for both playing and paused audio states. -- The MediaPlayer is seeked to the calculated position immediately, with visual feedback via progress bar update. -- Tapping provides precise control - e.g., tap 25% through waveform jumps to 25% through audio. -- No haptic feedback or visual indicator; the progress bar update serves as immediate feedback. - -Waveform Canvas Implementation: -- `WaveformCanvas` uses `pointerInput` with `detectTapGestures` to capture tap events. -- Tap position is converted to a fraction: `position.x / size.width.toFloat()`. -- Clamped to 0.0-1.0 range for safety. -- `onSeek` callback is invoked with the calculated position fraction. -- Only enabled when `onSeek` is provided (disabled for sending in progress). - -VoiceNotePlayer Seeking: -- Accepts position fraction (0.0-1.0) and converts to milliseconds: `seekMs = (position * durationMs).toInt()`. -- Calls `MediaPlayer.seekTo(seekMs)` to jump to the exact position. -- Updates progress state immediately for UI responsiveness even before playback reaches the new position. - -Files: -- `app/src/main/java/com/bitchat/android/ui/MessageComponents.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt) — VoiceNotePlayer with seekTo function -- `app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt` (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt) — Interactive WaveformCanvas with tap handling - ---- - -## 6) Edge Cases and Notes - -- Filename collisions on receiver: prefer the sender‑supplied name if present; always uniquify with a ` (n)` suffix before the extension to prevent overwrites. -- Path markers in messages - - We use simple content markers: `"[voice] ", "[image] ", "[file] "` for local rendering. These are not sent on the wire; the actual file bytes are inside the TLV payload. -- Progress math for images relies on `(sent / total)` from `TransferProgressManager` (fragment‑level granularity). The block grid density can be tuned; currently 24×16. -- Private vs public: both use the same file TLV; only the envelope `recipientID` differs. Private may have signatures; code shows a signing step consistent with iOS behavior prior to broadcast to ensure integrity. -- BLE timing: there is a 200 ms inter‑fragment delay for stability. Adjust as needed for your radio stack while maintaining compatibility. - - ---- - -## 7) File Inventory (Added/Changed) - -Core protocol and transport: - -- `app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt` — TLV payload model + encode/decode. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/model/BitchatFilePacket.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt` — packet creation and broadcast for file messages. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt) -- `app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt` — fragmentation, progress, cancellation via transfer jobs. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt) -- `app/src/main/java/com/bitchat/android/mesh/TransferProgressManager.kt` — progress events bus. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/TransferProgressManager.kt) -- `app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt` — receive path: decode, persist to files, create chat messages. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt) - -Audio capture and waveform: - -- `app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt` — MediaRecorder wrapper. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/voice/VoiceRecorder.kt) -- `app/src/main/java/com/bitchat/android/features/voice/Waveform.kt` — cache + extractor + resampler. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/voice/Waveform.kt) -- `app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt` — Compose waveform preview components. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/WaveformViews.kt) - -Image pipeline: - -- `app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt` — downscale and save to app files. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/features/media/ImageUtils.kt) -- `app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt` — SAF picker button. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/ImagePickerButton.kt) -- `app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt` — block‑reveal progress renderer (no gaps, dense grid). (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/BlockRevealImage.kt) - -Recording overlay: - -- `app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt` — dense, real‑time scrolling waveform during recording. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/RealtimeScrollingWaveform.kt) - -UI composition and view model coordination: - -- `app/src/main/java/com/bitchat/android/ui/InputComponents.kt` — input field, overlays (recording), picker button, mic. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/InputComponents.kt) -- `app/src/main/java/com/bitchat/android/ui/MessageComponents.kt` — message rendering for text/audio/images including progress UIs and cancel overlays. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/MessageComponents.kt) -- `app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt` — sendVoiceNote/sendImageNote, progress mapping, cancelMediaSend. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt) -- `app/src/main/java/com/bitchat/android/ui/MessageManager.kt` — add/remove/update messages across main, private, and channels. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/MessageManager.kt) - -Fullscreen image: - -- `app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt` — fullscreen viewer + save to Downloads. (/Users/cc/git/bitchat-android/app/src/main/java/com/bitchat/android/ui/media/FullScreenImageViewer.kt) - - ---- - -## 8) Implementation Checklist for Other Clients - -1. **Implement v2 protocol support**: Support both v1 (2-byte payload length) and v2 (4-byte payload length) packet decoding. Use v2 format for file transfer packets to enable large file transfers. -2. Implement `BitchatFilePacket` TLV exactly as specified: - - FILE_NAME and MIME_TYPE: `type(1) + len(2) + value` - - FILE_SIZE: `type(1) + len(2=4) + value(4, UInt32 BE)` - - CONTENT: `type(1) + len(4) + value` -3. Embed the TLV into a `BitchatPacket` envelope with `type = FILE_TRANSFER (0x22)` and the correct `recipientID` (broadcast vs private). -4. Fragment, send, and report progress using a transfer ID derived from `sha256(payload)` so the UI can map progress to a message. -5. Support cancellation at the fragment sender: stop sending remaining fragments and propagate a cancel to the UI (we remove the message). -6. On receive, decode TLV, persist to an app directory (separate audio/images/other), and create a chat message with content marker `"[voice] path"`, `"[image] path"`, or `"[file] path"` for local rendering. -7. Audio sender and receiver should use the same waveform extractor so visuals match; a 120‑bin histogram is a good balance. -8. **Implement interactive waveform seeking**: Tap waveforms to jump to that audio position. Calculate tap position as fraction (0.0-1.0) of waveform width. -9. For images, optionally downscale to keep TLV small; JPEG 85% at 512 px longest edge is a good baseline. -10. Mirror the UX: - - Recording overlay that does not collapse the IME; hide the caret while recording; add 500 ms end padding. - - Voice: waveform fill for send/playback; cancel overlay; **tap-to-seek support**. - - Images: dense block‑reveal with no gaps during sending; cancel overlay; fullscreen viewer with save. - - Generic files: render as a file pill with icon + filename; support open/save via the host OS. - -Following the above should produce an interoperable and matching experience across platforms. diff --git a/docs/sync.md b/docs/sync.md deleted file mode 100644 index 0bbd0735b..000000000 --- a/docs/sync.md +++ /dev/null @@ -1,149 +0,0 @@ -# GCS Filter Sync (REQUEST_SYNC) - -This document specifies the gossip-based synchronization feature for BitChat, inspired by Plumtree. It ensures eventual consistency of public packets (ANNOUNCE and broadcast MESSAGE) across nodes via periodic sync requests containing a compact Golomb‑Coded Set (GCS) of recently seen packets. - -## Overview - -- Each node maintains a rolling set of public BitChat packets it has seen recently: - - Broadcast messages (MessageType.MESSAGE where recipient is broadcast) - - Identity announcements (MessageType.ANNOUNCE) - - Default retention is 100 recent packets (configurable in the debug sheet). This value is the maximum number of packets that are synchronized per request (across both types combined). -- Nodes do not maintain a rolling Bloom filter. Instead, they compute a GCS filter on demand when sending a REQUEST_SYNC. -- Every 30 seconds, a node sends a REQUEST_SYNC packet to all immediate neighbors (local only; not relayed). -- Additionally, 5 seconds after the first announcement from a newly directly connected peer is detected, a node sends a REQUEST_SYNC only to that peer (unicast; local only). -- The receiver checks which packets are not in the sender’s filter and sends those packets back. For announcements, only the latest announcement per peerID is sent; for broadcast messages, all missing ones are sent. - -This synchronization is strictly local (not relayed), ensuring only immediate neighbors participate and preventing wide-area flooding while converging content across the mesh. - -## Packet ID - -To compare packets across peers, a deterministic packet ID is used: - -- ID = first 16 bytes of SHA-256 over: [type | senderID | timestamp | payload] -- This yields a 128-bit ID used in the filter. - -Implementation: `com.bitchat.android.sync.PacketIdUtil`. - -## GCS Filter (On-demand) - -Implementation: `com.bitchat.android.sync.GCSFilter`. - -- Parameters (configurable): - - size: 128–1024 bytes (default 256) - - target false positive rate (FPR): default 1% (range 0.1%–5%) -- Derivations: - - P = ceil(log2(1/FPR)) - - Maximum number of elements that fit into the filter is estimated as: N_max ≈ floor((8 * sizeBytes) / (P + 2)) - - This estimate is used to cap the set; the actual encoder will trim further if needed to stay within the configured size. -- What goes into the set: - - Combine the following and sort by packet timestamp (descending): - - Broadcast messages (MessageType 1) - - The most recent ANNOUNCE per peer - - Take at most `min(N_max, maxPacketsPerSync)` items from this ordered list. - - Compute the 16-byte Packet ID (see below), then for hashing use the first 8 bytes of SHA‑256 over the 16‑byte ID. - - Map each hash to [0, M) with M = N * 2^P; sort ascending and encode deltas with Golomb‑Rice parameter P. - -Hashing scheme (fixed for cross‑impl compatibility): -- Packet ID: first 16 bytes of SHA‑256 over [type | senderID | timestamp | payload]. -- GCS hash: h64 = first 8 bytes of SHA‑256 over the 16‑byte Packet ID, interpreted as an unsigned 64‑bit integer. Value = h64 % M. - -## REQUEST_SYNC Packet - -MessageType: `REQUEST_SYNC (0x21)` - -- Header: normal BitChat header with TTL indicating “local-only” semantics. Implementations SHOULD set TTL=0 to prevent any relay; neighbors still receive the packet over the direct link-layer. For periodic sync, recipient is broadcast; for per-peer initial sync, recipient is the specific peer. -- Payload: TLV with 16‑bit big‑endian length fields (type, length16, value) - - 0x01: P (uint8) — Golomb‑Rice parameter - - 0x02: M (uint32) — hash range N * 2^P - - 0x03: data (opaque) — GCS bitstream (MSB‑first bit packing) - -Notes: -- The GCS bitstream uses MSB‑first packing (bit 7 is the first bit in each byte). -- Receivers MUST reject filters with data length exceeding the local maximum (default 1024 bytes) to avoid DoS. - -Encode/Decode implementation: `com.bitchat.android.model.RequestSyncPacket`. - -## Behavior - -Sender behavior: -- Periodic: every 30 seconds, send REQUEST_SYNC with a freshly computed GCS snapshot, broadcast to immediate neighbors, and mark as local‑only (TTL=0 recommended; do not relay). -- Initial per-peer: upon receiving the first ANNOUNCE from a new directly connected peer, send a REQUEST_SYNC only to that peer after ~5 seconds (unicast; TTL=0 recommended; do not relay). - -Receiver behavior: -- Decode the REQUEST_SYNC payload and reconstruct the sorted set of mapped values using the provided P, M, and bitstream. -- For each locally stored public packet ID: - - Compute h64(ID) % M and check if it is in the reconstructed set; if NOT present, send the original packet back with `ttl=0` to the requester only. - - For announcements, send only the latest announcement per (sender peerID). - - For broadcast messages, send all missing ones. - -Announcement retention and pruning (consensus): -- Store only the most recent announcement per peerID for sync purposes. -- Age-out policy: announcements older than 60 seconds MUST be removed from the sync candidate set. -- Pruning cadence: run pruning every 15 seconds to drop expired announcements. -- LEAVE handling: upon receiving a LEAVE message from a peer, immediately remove that peer’s stored announcement from the sync candidate set. -- Stale/offline peer handling: when a peer is considered stale/offline (e.g., last announcement older than 60 seconds), immediately remove that peer’s stored announcement from the sync candidate set. - -Important: original packets are sent unmodified to preserve original signatures (e.g., ANNOUNCE). They MUST NOT be relayed beyond immediate neighbors. Implementations SHOULD send these response packets with TTL=0 (local-only) and, when possible, route them only to the requesting peer without altering the original packet contents. - -## Scope and Types Included - -Included in sync: -- Public broadcast messages: `MessageType.MESSAGE` with BROADCAST recipient (or null recipient). -- Identity announcements: `MessageType.ANNOUNCE`. -- Both packets produced by other peers and packets produced by the requester itself MUST be represented in the requester’s GCS; the responder MUST track and consider its own produced public packets as candidates to return when they are missing on the requester. -- Announcements included in the GCS MUST be at most 60 seconds old at the time of filter construction; older announcements are excluded by pruning. - -Not included: -- Private messages and any packets addressed to a non-broadcast recipient. - -## Configuration (Debug Sheet) - -Exposed under “sync settings” in the debug settings sheet: -- Max packets per sync (default 100) -- Max GCS filter size in bytes (default 256, min 128, max 1024) -- GCS target FPR in percent (default 1%, 0.1%–5%) -- Derived values (display only): P and the estimated maximum number of elements that fit into the filter. - -Backed by `DebugPreferenceManager` getters and setters: -- `getSeenPacketCapacity` / `setSeenPacketCapacity` -- `getGcsMaxFilterBytes` / `setGcsMaxFilterBytes` -- `getGcsFprPercent` / `setGcsFprPercent` - -## Android Integration - -- New/updated types and classes: - - `MessageType.REQUEST_SYNC` (0x21) in `BinaryProtocol.kt` - - `RequestSyncPacket` in `model/RequestSyncPacket.kt` - - `GCSFilter` and `PacketIdUtil` in `sync/` - - `GossipSyncManager` in `sync/` -- `BluetoothMeshService` wires and starts the sync manager, schedules per-peer initial (unicast) and periodic (broadcast) syncs, and forwards seen public packets (including our own) to the manager. -- `PacketProcessor` handles REQUEST_SYNC and forwards to `BluetoothMeshService` which responds via the sync manager with responses targeted only to the requester. - -## Compatibility Notes - -- GCS hashing and TLV structures are fully specified above; other implementations should use the same hashing scheme and payload layout for interoperability. -- REQUEST_SYNC and responses are local-only and MUST NOT be relayed. Implementations SHOULD use TTL=0 to prevent relaying. If an implementation requires TTL>0 for local delivery, it MUST still ensure that REQUEST_SYNC and responses are not relayed beyond direct neighbors (e.g., by special-casing these types in relay logic). - -## Consensus vs. Configurable - -The following items require consensus across all implementations to ensure interoperability: - -- Packet ID recipe: first 16 bytes of SHA‑256(type | senderID | timestamp | payload). -- GCS hashing function and mapping to [0, M) as specified above (v1), and MSB‑first bit packing for the bitstream. -- Payload encoding: TLV with 16‑bit big‑endian lengths; TLV types 0x01 = P (uint8), 0x02 = M (uint32), 0x03 = data (opaque). -- Packet type and scope: REQUEST_SYNC = 0x21; local-only (not relayed); only ANNOUNCE and broadcast MESSAGE are synchronized; ANNOUNCE de‑dupe is “latest per sender peerID”. - -The following are requester‑defined and communicated or local policy (no global agreement required): - -- GCS parameters: P and M are carried in the REQUEST_SYNC and must be used by the receiver for membership tests. The sender chooses size and FPR; receivers MUST cap accepted data length for DoS protection. -- Local storage policy: how many packets to consider and how you determine the “latest” announcement per peer. -- Sync cadence: how often to send REQUEST_SYNC and initial delay after new neighbor connection; whether to use unicast for initial per-peer sync versus broadcast for periodic sync. The number of packets included is bounded by the debug setting and filter capacity. - -Validation and limits (recommended): - -- Reject malformed REQUEST_SYNC payloads (e.g., P < 1, M <= 0, or data length too large for local limits). -- Practical bounds: data length in [0, 1024]; P in [1, 24]; M up to 2^32‑1. - -Versioning: - -- This document defines a fixed GCS hashing scheme (“v1”) with no explicit version field in the payload. Changing the hashing or ID recipe would require a new message or an additional TLV in a future revision; current deployments must adhere to the constants above.