Develop - BLE, UI generalization, Seekbar, WebDAV, Refactor and AGP upgrades, Native call controls, Notifying app picker, background discovery and more

.gitignore

@@ -35,3 +35,4 @@ app/release
 local.properties
 .vscode/launch.json
 build/reports/problems/problems-report.html
+.agents/

app/build.gradle.kts

@@ -11,14 +11,13 @@ plugins {
 
 android {
     namespace = "com.sameerasw.airsync"
-    compileSdk = 36
+    compileSdk = 37
 
     defaultConfig {
         applicationId = "com.sameerasw.airsync"
         minSdk = 30
-        targetSdk = 36
-        versionCode = 27
-        versionName = "3.1.0"
+        versionCode = 29
+        versionName = "4.0.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -47,21 +46,23 @@ android {
         }
     }
     compileOptions {
-        sourceCompatibility = VERSION_11
-        targetCompatibility = VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
 kotlin {
     compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
+        jvmTarget.set(JvmTarget.JVM_21)
     }
 }
     buildFeatures {
         compose = true
         buildConfig = true
     }
+    compileSdkMinor = 0
 
     defaultConfig {
-        buildConfigField("String", "MIN_MAC_APP_VERSION", "\"3.0.0\"")
+        targetSdk = 37
+        buildConfigField("String", "MIN_MAC_APP_VERSION", "\"4.0.0\"")
     }
 }
 
@@ -154,6 +155,14 @@ dependencies {
 
     implementation(libs.wire.runtime)
     implementation(libs.bouncycastle)
+
+    // Ktor Server for WebDAV
+    implementation(libs.ktor.server.core)
+    implementation(libs.ktor.server.cio)
+    implementation(libs.ktor.server.host.common)
+    implementation(libs.ktor.server.status.pages)
+    implementation(libs.ktor.server.content.negotiation)
+    implementation(libs.ktor.serialization.gson)
 }
 
 wire {

app/proguard-rules.pro

@@ -29,4 +29,9 @@
 -keep class com.sameerasw.airsync.domain.model.** { *; }
 
 # Data Layer
--keep class com.sameerasw.airsync.data.** { *; }
+-keep class com.sameerasw.airsync.data.** { *; }
+
+# Ktor & SLF4J missing classes on Android
+-dontwarn java.lang.management.ManagementFactory
+-dontwarn java.lang.management.RuntimeMXBean
+-dontwarn org.slf4j.impl.StaticLoggerBinder

app/src/main/AndroidManifest.xml

@@ -12,6 +12,14 @@
     <uses-permission android:name="android.permission.POST_PROMOTED_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
+
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+    <uses-feature android:name="android.hardware.bluetooth_le" android:required="false" />
 
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
@@ -38,6 +46,7 @@
     <uses-permission android:name="android.permission.READ_CALL_LOG" />
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
     <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
 
     <uses-permission android:name="com.sameerasw.permission.ESSENTIALS_AIRSYNC_BRIDGE" />
 

app/src/main/java/com/sameerasw/airsync/AirSyncApp.kt

@@ -10,16 +10,21 @@ import kotlinx.coroutines.runBlocking
 
 class AirSyncApp : Application() {
     private var activityCount = 0
+    private lateinit var bleConnectionManager: com.sameerasw.airsync.data.ble.BleConnectionManager
 
     companion object {
         private var instance: AirSyncApp? = null
         fun isAppForeground(): Boolean = instance?.isForeground() ?: false
+        fun getBleConnectionManager(): com.sameerasw.airsync.data.ble.BleConnectionManager? = instance?.bleConnectionManager
     }
 
     override fun onCreate() {
         super.onCreate()
         instance = this
         initSentry()
+
+        bleConnectionManager = com.sameerasw.airsync.data.ble.BleConnectionManager(this)
+        bleConnectionManager.start()
         registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
             override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
             override fun onActivityStarted(activity: Activity) {

app/src/main/java/com/sameerasw/airsync/MainActivity.kt

@@ -60,6 +60,7 @@ import com.sameerasw.airsync.utils.KeyguardHelper
 import com.sameerasw.airsync.utils.NotesRoleManager
 import com.sameerasw.airsync.utils.PermissionUtil
 import com.sameerasw.airsync.utils.ShortcutUtil
+import com.sameerasw.airsync.utils.UDPDiscoveryManager
 import com.sameerasw.airsync.utils.WebSocketUtil
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.runBlocking
@@ -339,8 +340,12 @@ class MainActivity : ComponentActivity() {
         handleNotesRoleIntent(intent)
 
         // Start ADB discovery once at app startup and keep it running
-        AdbDiscoveryHolder.initialize(this)
-        Log.d("MainActivity", "Started persistent ADB discovery at app startup")
+        if (PermissionUtil.isLocalNetworkPermissionGranted(this)) {
+            AdbDiscoveryHolder.initialize(this)
+            Log.d("MainActivity", "Started persistent ADB discovery at app startup")
+        } else {
+            Log.d("MainActivity", "Skipping persistent ADB discovery at startup: ACCESS_LOCAL_NETWORK permission not granted")
+        }
 
         // Check if this is a QS tile long-press intent and device is not connected
         if (intent?.action == "android.service.quicksettings.action.QS_TILE_PREFERENCES") {
@@ -581,11 +586,26 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    override fun onResume() {
+        super.onResume()
+        if (PermissionUtil.isLocalNetworkPermissionGranted(this)) {
+            AdbDiscoveryHolder.initialize(this)
+            val ds = DataStoreManager.getInstance(applicationContext)
+            val isDiscoveryEnabled = runBlocking {
+                ds.getDeviceDiscoveryEnabled().first()
+            }
+            UDPDiscoveryManager.start(this, isDiscoveryEnabled)
+            UDPDiscoveryManager.burstBroadcast(this)
+        }
+    }
+
     /**
      * Ensure ADB discovery is running (started at app startup, this just verifies it's active).
      */
     fun initializeAdbDiscovery() {
-        AdbDiscoveryHolder.initialize(this)
+        if (PermissionUtil.isLocalNetworkPermissionGranted(this)) {
+            AdbDiscoveryHolder.initialize(this)
+        }
     }
 
     /**

app/src/main/java/com/sameerasw/airsync/data/ble/BleChunkUtil.kt

@@ -0,0 +1,115 @@
+package com.sameerasw.airsync.data.ble
+
+import android.util.Log
+
+object BleChunkUtil {
+    private const val TAG = "BleChunkUtil"
+
+    /**
+     * Splits a string payload into chunks suitable for BLE transmission.
+     * Each chunk starts with a 2-byte header: [currentIndex, totalChunks]
+     */
+    fun splitIntoChunks(payload: String, mtu: Int): List<ByteArray> {
+        val data = payload.toByteArray(Charsets.UTF_8)
+        val maxPayloadSize = mtu - BleConstants.CHUNK_HEADER_SIZE
+
+        if (maxPayloadSize <= 0) {
+            Log.e(TAG, "MTU too small: $mtu")
+            return emptyList()
+        }
+
+        val totalChunks = (data.size + maxPayloadSize - 1) / maxPayloadSize
+        val chunks = mutableListOf<ByteArray>()
+
+        for (i in 0 until totalChunks) {
+            val start = i * maxPayloadSize
+            val end = minOf(start + maxPayloadSize, data.size)
+            val chunkData = data.sliceArray(start until end)
+
+            val chunk = ByteArray(BleConstants.CHUNK_HEADER_SIZE + chunkData.size)
+            val buffer = java.nio.ByteBuffer.wrap(chunk)
+            buffer.putShort(i.toShort())
+            buffer.putShort(totalChunks.toShort())
+
+            chunkData.copyInto(chunk, BleConstants.CHUNK_HEADER_SIZE)
+            chunks.add(chunk)
+        }
+
+        return chunks
+    }
+
+    /**
+     * Reassembles chunks into the original string.
+     * Expects a map of index to chunk data (without the header).
+     */
+    fun reassemble(chunks: Map<Int, ByteArray>): String {
+        val sortedIndices = chunks.keys.sorted()
+        if (sortedIndices.isEmpty()) return ""
+
+        val totalSize = chunks.values.sumOf { it.size }
+        val result = ByteArray(totalSize)
+
+        var offset = 0
+        for (index in sortedIndices) {
+            val chunk = chunks[index] ?: continue
+            chunk.copyInto(result, offset)
+            offset += chunk.size
+        }
+
+        return String(result, Charsets.UTF_8)
+    }
+
+    /**
+     * Extracts header information from a raw BLE packet.
+     */
+    fun parseHeader(packet: ByteArray): Pair<Int, Int>? {
+        if (packet.size < BleConstants.CHUNK_HEADER_SIZE) return null
+        val buffer = java.nio.ByteBuffer.wrap(packet)
+        val current = buffer.short.toInt() and 0xFFFF
+        val total = buffer.short.toInt() and 0xFFFF
+        return Pair(current, total)
+    }
+
+    /**
+     * Extracts payload data from a raw BLE packet (strips header).
+     */
+    fun getPayload(packet: ByteArray): ByteArray {
+        if (packet.size <= BleConstants.CHUNK_HEADER_SIZE) return byteArrayOf()
+        return packet.sliceArray(BleConstants.CHUNK_HEADER_SIZE until packet.size)
+    }
+
+    /**
+     * Helper class to reassemble chunks as they arrive.
+     */
+    class Reassembler {
+        private val chunks = mutableMapOf<Int, ByteArray>()
+        private var totalChunks = -1
+
+        fun addChunk(packet: ByteArray): String? {
+            val header = parseHeader(packet) ?: return null
+            val current = header.first
+            val total = header.second
+
+            if (totalChunks != -1 && totalChunks != total) {
+                // New transmission started or mismatch, reset
+                chunks.clear()
+            }
+            totalChunks = total
+
+            chunks[current] = getPayload(packet)
+
+            if (chunks.size == totalChunks) {
+                val result = reassemble(chunks)
+                chunks.clear()
+                totalChunks = -1
+                return result
+            }
+            return null
+        }
+
+        fun clear() {
+            chunks.clear()
+            totalChunks = -1
+        }
+    }
+}

app/src/main/java/com/sameerasw/airsync/data/ble/BleConnectionManager.kt

@@ -0,0 +1,90 @@
+package com.sameerasw.airsync.data.ble
+
+import android.content.Context
+import android.util.Log
+import com.sameerasw.airsync.data.local.DataStoreManager
+import com.sameerasw.airsync.utils.WebSocketUtil
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+
+class BleConnectionManager(private val context: Context) {
+    companion object {
+        private const val TAG = "BleConnectionManager"
+    }
+
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private val dataStoreManager = DataStoreManager(context)
+    private var bleServer: BleGattServer? = null
+
+    private var isBleEnabled = false
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val _serverFlow = kotlinx.coroutines.flow.MutableStateFlow<BleGattServer?>(null)
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val connectionState = _serverFlow.flatMapLatest { server ->
+        server?.connectionState ?: kotlinx.coroutines.flow.MutableStateFlow(BleGattServer.BleConnectionState.DISCONNECTED)
+    }
+
+    fun start() {
+        if (bleServer == null) {
+            bleServer = BleGattServer(context)
+            _serverFlow.value = bleServer
+            BleTransportBridge.initialize(bleServer!!)
+        }
+
+        scope.launch {
+            combine(
+                dataStoreManager.getBleSyncEnabled(),
+                dataStoreManager.getBleAutoConnectEnabled(),
+                WebSocketUtil.connectionState
+            ) { enabled, auto, wsConnected ->
+                Triple(enabled, auto, wsConnected)
+            }.collectLatest { (enabled, _, wsConnected) ->
+                isBleEnabled = enabled
+                updateBleState(regularConnectionActive = wsConnected)
+            }
+        }
+    }
+
+    private fun updateBleState(regularConnectionActive: Boolean) {
+        if (!isBleEnabled) {
+            Log.d(TAG, "BLE disabled, stopping server")
+            bleServer?.stop()
+            return
+        }
+
+        if (regularConnectionActive) {
+            // Regular Wi-Fi/USB connection is up — pause advertising to save power.
+            Log.d(TAG, "Regular connection active — pausing BLE advertising")
+            bleServer?.pauseAdvertising()
+        } else {
+            // No regular connection — ensure server is started and advertising.
+            Log.d(TAG, "No regular connection — resuming BLE advertising")
+            bleServer?.start()
+            bleServer?.resumeAdvertising()
+        }
+    }
+
+    fun stop() {
+        scope.cancel()
+        bleServer?.stop()
+    }
+
+    val isAuthenticated: Boolean
+        get() = bleServer?.isAuthenticated ?: false
+
+    fun sendChunkedNotification(characteristicUuid: java.util.UUID, payload: String) {
+        bleServer?.sendChunkedNotification(characteristicUuid, payload)
+    }
+
+    fun sendNotification(characteristicUuid: java.util.UUID, data: ByteArray) {
+        bleServer?.sendNotification(characteristicUuid, data)
+    }
+
+    fun disconnectAllConnectedDevices() {
+        bleServer?.disconnectAllConnectedDevices()
+    }
+}