feat: AirBridge relay - connect Mac and Android when not on the same network (Android Integration)

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

@@ -4,8 +4,13 @@ import android.app.Activity
 import android.app.Application
 import android.os.Bundle
 import com.sameerasw.airsync.data.local.DataStoreManager
+import com.sameerasw.airsync.utils.AirBridgeClient
+import com.sameerasw.airsync.utils.WebSocketMessageHandler
 import io.sentry.android.core.SentryAndroid
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 
 class AirSyncApp : Application() {
@@ -20,6 +25,7 @@ class AirSyncApp : Application() {
         super.onCreate()
         instance = this
         initSentry()
+        initAirBridge()
         registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
             override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
             override fun onActivityStarted(activity: Activity) {
@@ -48,4 +54,20 @@ class AirSyncApp : Application() {
             options.isEnabled = true
         }
     }
+
+    private fun initAirBridge() {
+        // Wire message handler: relay messages → existing WebSocket message pipeline
+        AirBridgeClient.setMessageHandler { context, message ->
+            WebSocketMessageHandler.handleIncomingMessage(context, message)
+        }
+
+        // Auto-connect if previously enabled
+        CoroutineScope(Dispatchers.IO).launch {
+            val ds = DataStoreManager.getInstance(this@AirSyncApp)
+            val enabled = ds.getAirBridgeEnabled().first()
+            if (enabled) {
+                AirBridgeClient.connect(this@AirSyncApp)
+            }
+        }
+    }
 }

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

@@ -45,6 +45,7 @@ import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.unit.dp
 import androidx.core.animation.doOnEnd
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
@@ -54,13 +55,15 @@ import com.sameerasw.airsync.presentation.ui.screens.AirSyncMainScreen
 import com.sameerasw.airsync.ui.theme.AirSyncTheme
 import com.sameerasw.airsync.presentation.viewmodel.AirSyncViewModel
 import com.sameerasw.airsync.utils.AdbMdnsDiscovery
+import com.sameerasw.airsync.utils.AirBridgeClient
 import com.sameerasw.airsync.utils.ContentCaptureManager
 import com.sameerasw.airsync.utils.DevicePreviewResolver
 import com.sameerasw.airsync.utils.KeyguardHelper
 import com.sameerasw.airsync.utils.NotesRoleManager
 import com.sameerasw.airsync.utils.PermissionUtil
 import com.sameerasw.airsync.utils.WebSocketUtil
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import java.net.URLDecoder
 
@@ -348,21 +351,48 @@ class MainActivity : ComponentActivity() {
         var pcName: String? = null
         var isPlus = false
         var symmetricKey: String? = null
+        var relayUrl: String? = null
+        var airBridgePairingId: String? = null
+        var airBridgeSecret: String? = null
 
         data?.let { uri ->
             val urlString = uri.toString()
-            val queryPart = urlString.substringAfter('?', "")
-            if (queryPart.isNotEmpty()) {
-                val params = queryPart.split('?')
-                val paramMap = params.associate {
-                    val parts = it.split('=', limit = 2)
-                    val key = parts.getOrNull(0) ?: ""
-                    val value = parts.getOrNull(1) ?: ""
-                    key to value
+            val paramMap = parseAirsyncParams(urlString)
+            pcName = paramMap["name"]?.let { android.net.Uri.decode(it) }
+            isPlus = paramMap["plus"]?.toBooleanStrictOrNull() ?: false
+            symmetricKey = paramMap["key"]?.let {
+                android.net.Uri.decode(it)
+            }
+            relayUrl = paramMap["relay"]?.let { android.net.Uri.decode(it) }
+            airBridgePairingId =
+                paramMap["pairingId"]?.let { android.net.Uri.decode(it) }
+            airBridgeSecret =
+                paramMap["secret"]?.let { android.net.Uri.decode(it) }
+        }
+
+        if (!relayUrl.isNullOrBlank() &&
+            !airBridgePairingId.isNullOrBlank() &&
+            !airBridgeSecret.isNullOrBlank()
+        ) {
+            lifecycleScope.launch {
+                try {
+                    val ds = DataStoreManager.getInstance(this@MainActivity)
+                    ds.setAirBridgeRelayUrl(relayUrl!!)
+                    ds.setAirBridgePairingId(airBridgePairingId!!)
+                    ds.setAirBridgeSecret(airBridgeSecret!!)
+                    ds.setAirBridgeEnabled(true)
+
+                    // Provide symmetric key to AirBridgeClient immediately so it doesn't
+                    // refuse connection waiting for a completed LAN handshake first
+                    if (!symmetricKey.isNullOrEmpty()) {
+                        AirBridgeClient.updateSymmetricKey(symmetricKey)
+                    }
+
+                    AirBridgeClient.disconnect()
+                    AirBridgeClient.connect(this@MainActivity)
+                } catch (e: Exception) {
+                    Log.e("MainActivity", "Failed to apply AirBridge QR config: ${e.message}", e)
                 }
-                pcName = paramMap["name"]?.let { URLDecoder.decode(it, "UTF-8") }
-                isPlus = paramMap["plus"]?.toBooleanStrictOrNull() ?: false
-                symmetricKey = paramMap["key"]
             }
         }
 
@@ -580,6 +610,22 @@ class MainActivity : ComponentActivity() {
         return AdbDiscoveryHolder.getDiscoveredServices()
     }
 
+    private fun parseAirsyncParams(urlString: String): Map<String, String> {
+        val queryPart = urlString.substringAfter('?', "")
+        if (queryPart.isEmpty()) return emptyMap()
+
+        return queryPart.split('?')
+            .mapNotNull { raw ->
+                if (raw.isBlank()) return@mapNotNull null
+                val parts = raw.split('=', limit = 2)
+                val key = parts.getOrNull(0)?.trim().orEmpty()
+                if (key.isEmpty()) return@mapNotNull null
+                val value = parts.getOrNull(1).orEmpty()
+                key to value
+            }
+            .toMap()
+    }
+
     /**
      * Handles intents related to the Notes Role feature.
      * Extracts stylus mode hint and lock screen status from the intent.

app/src/main/java/com/sameerasw/airsync/data/local/DataStoreManager.kt

@@ -96,6 +96,12 @@ class DataStoreManager(private val context: Context) {
         // Widget preferences
         private val WIDGET_TRANSPARENCY = androidx.datastore.preferences.core.floatPreferencesKey("widget_transparency")
 
+        // AirBridge relay preferences
+        private val AIRBRIDGE_ENABLED = booleanPreferencesKey("airbridge_enabled")
+        private val AIRBRIDGE_RELAY_URL = stringPreferencesKey("airbridge_relay_url")
+        private val AIRBRIDGE_PAIRING_ID = stringPreferencesKey("airbridge_pairing_id")
+        private val AIRBRIDGE_SECRET = stringPreferencesKey("airbridge_secret")
+
         private const val NETWORK_DEVICES_PREFIX = "network_device_"
         private const val NETWORK_CONNECTIONS_PREFIX = "network_connections_"
 
@@ -604,6 +610,40 @@ class DataStoreManager(private val context: Context) {
         }
     }
 
+    // --- AirBridge Relay ---
+
+    suspend fun setAirBridgeEnabled(enabled: Boolean) {
+        context.dataStore.edit { prefs -> prefs[AIRBRIDGE_ENABLED] = enabled }
+    }
+
+    fun getAirBridgeEnabled(): Flow<Boolean> {
+        return context.dataStore.data.map { it[AIRBRIDGE_ENABLED] ?: false }
+    }
+
+    suspend fun setAirBridgeRelayUrl(url: String) {
+        context.dataStore.edit { prefs -> prefs[AIRBRIDGE_RELAY_URL] = url }
+    }
+
+    fun getAirBridgeRelayUrl(): Flow<String> {
+        return context.dataStore.data.map { it[AIRBRIDGE_RELAY_URL] ?: "" }
+    }
+
+    suspend fun setAirBridgePairingId(id: String) {
+        context.dataStore.edit { prefs -> prefs[AIRBRIDGE_PAIRING_ID] = id }
+    }
+
+    fun getAirBridgePairingId(): Flow<String> {
+        return context.dataStore.data.map { it[AIRBRIDGE_PAIRING_ID] ?: "" }
+    }
+
+    suspend fun setAirBridgeSecret(secret: String) {
+        context.dataStore.edit { prefs -> prefs[AIRBRIDGE_SECRET] = secret }
+    }
+
+    fun getAirBridgeSecret(): Flow<String> {
+        return context.dataStore.data.map { it[AIRBRIDGE_SECRET] ?: "" }
+    }
+
     // Network-aware device connections
     suspend fun saveNetworkDeviceConnection(
         deviceName: String,

app/src/main/java/com/sameerasw/airsync/domain/model/UiState.kt

@@ -39,6 +39,7 @@ data class UiState(
     val defaultTab: String = "dynamic",
     val isEssentialsConnectionEnabled: Boolean = false,
     val activeIp: String? = null,
+    val isRelayConnection: Boolean = false,
     val connectingDeviceId: String? = null,
     val isDeviceDiscoveryEnabled: Boolean = true,
     val shouldShowRatingPrompt: Boolean = false,

app/src/main/java/com/sameerasw/airsync/presentation/ui/components/SettingsView.kt

@@ -48,6 +48,7 @@ import com.sameerasw.airsync.presentation.ui.components.cards.MediaSyncCard
 import com.sameerasw.airsync.presentation.ui.components.cards.NotificationSyncCard
 import com.sameerasw.airsync.presentation.ui.components.cards.PermissionsCard
 import com.sameerasw.airsync.presentation.ui.components.cards.QuickSettingsTilesCard
+import com.sameerasw.airsync.presentation.ui.components.cards.AirBridgeCard
 import com.sameerasw.airsync.presentation.ui.components.cards.SendNowPlayingCard
 import com.sameerasw.airsync.presentation.ui.components.cards.SmartspacerCard
 import com.sameerasw.airsync.presentation.viewmodel.AirSyncViewModel
@@ -363,6 +364,8 @@ fun SettingsView(
                 )
 
                 ExpandNetworkingCard(context)
+
+                AirBridgeCard(context)
             }
         }