Merge pull request #48 from sameerasw/develop

Develop

Author: sameerasw

app/build.gradle.kts

@@ -15,8 +15,8 @@ android {
         applicationId = "com.sameerasw.airsync"
         minSdk = 30
         targetSdk = 36
-        versionCode = 9
-        versionName = "2.1.2"
+        versionCode = 11
+        versionName = "2.1.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -53,6 +53,9 @@ dependencies {
     implementation(libs.androidx.ui.tooling.preview)
     implementation(libs.androidx.material3)
 
+    // Smartspacer SDK
+    implementation("com.kieronquinn.smartspacer:sdk-plugin:1.1")
+
     // Material Components (XML themes: Theme.Material3.*)
     implementation("com.google.android.material:material:1.12.0")
 

app/src/main/AndroidManifest.xml

@@ -138,6 +138,27 @@
                 <action android:name="com.sameerasw.airsync.CONTINUE_BROWSING_DISMISS" />
             </intent-filter>
         </receiver>
+
+        <!-- Smartspacer Target Provider -->
+        <provider
+            android:name=".smartspacer.AirSyncDeviceTarget"
+            android:authorities="${applicationId}.target.airsync_device"
+            android:permission="com.kieronquinn.app.smartspacer.permission.ACCESS_SMARTSPACER_TARGETS"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="com.kieronquinn.app.smartspacer.TARGET" />
+            </intent-filter>
+        </provider>
+
+        <!-- Smartspacer Target Update Receiver -->
+        <receiver
+            android:name=".smartspacer.AirSyncTargetUpdateReceiver"
+            android:exported="true"
+            android:permission="com.kieronquinn.app.smartspacer.permission.SEND_UPDATE_BROADCAST">
+            <intent-filter>
+                <action android:name="com.kieronquinn.app.smartspacer.REQUEST_TARGET_UPDATE" />
+            </intent-filter>
+        </receiver>
     </application>
 
     <queries>

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

@@ -14,6 +14,9 @@ import com.sameerasw.airsync.domain.model.NetworkDeviceConnection
 import com.sameerasw.airsync.domain.model.NotificationApp
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.flow.first
+import org.json.JSONObject
 
 val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "airsync_settings")
 
@@ -54,7 +57,9 @@ class DataStoreManager(private val context: Context) {
         private val SEND_NOW_PLAYING_ENABLED = booleanPreferencesKey("send_now_playing_enabled")
         // New: Keep previous link toggle
         private val KEEP_PREVIOUS_LINK_ENABLED = booleanPreferencesKey("keep_previous_link_enabled")
-        private val TAILSCALE_SUPPORT_ENABLED = booleanPreferencesKey("tailscale_support_enabled")
+        // New: Always show in Smartspacer toggle
+        private val SMARTSPACER_SHOW_WHEN_DISCONNECTED = booleanPreferencesKey("smartspacer_show_when_disconnected")
+        private val EXPAND_NETWORKING_ENABLED = booleanPreferencesKey("expand_networking_enabled")
 
         // Network-aware device connections
         private val NETWORK_DEVICES_PREFIX = "network_device_"
@@ -197,15 +202,28 @@ class DataStoreManager(private val context: Context) {
         }
     }
 
-    suspend fun setTailscaleSupportEnabled(enabled: Boolean) {
+    // New: Always show in Smartspacer toggle
+    suspend fun setSmartspacerShowWhenDisconnected(enabled: Boolean) {
+        context.dataStore.edit { preferences ->
+            preferences[SMARTSPACER_SHOW_WHEN_DISCONNECTED] = enabled
+        }
+    }
+
+    fun getSmartspacerShowWhenDisconnected(): Flow<Boolean> {
+        return context.dataStore.data.map { preferences ->
+            preferences[SMARTSPACER_SHOW_WHEN_DISCONNECTED] ?: false
+        }
+    }
+
+    suspend fun setExpandNetworkingEnabled(enabled: Boolean) {
         context.dataStore.edit { prefs ->
-            prefs[TAILSCALE_SUPPORT_ENABLED] = enabled
+            prefs[EXPAND_NETWORKING_ENABLED] = enabled
         }
     }
 
-    fun getTailscaleSupportEnabled(): Flow<Boolean> {
+    fun getExpandNetworkingEnabled(): Flow<Boolean> {
         return context.dataStore.data.map { prefs ->
-            prefs[TAILSCALE_SUPPORT_ENABLED] ?: false
+            prefs[EXPAND_NETWORKING_ENABLED] ?: false
         }
     }
 
@@ -543,4 +561,146 @@ class DataStoreManager(private val context: Context) {
             preferences[stringPreferencesKey("${NETWORK_DEVICES_PREFIX}${deviceName}_last_connected")] = timestamp.toString()
         }
     }
-}
+
+    /**
+     * Export all DataStore preferences to a JSON string.
+     * Excludes very large strings and anything that looks like a base64 image (data:image/...base64,...)
+     */
+    suspend fun exportAllDataToJson(): String {
+        val prefs = context.dataStore.data.first()
+        val exportObj = JSONObject()
+        val dataObj = JSONObject()
+        val mutedArray = org.json.JSONArray()
+
+        prefs.asMap().forEach { (key, value) ->
+            try {
+                // Skip nulls
+                if (value == null) return@forEach
+
+                // If string looks like an embedded image or is very large, skip
+                if (value is String) {
+                    val lower = value.lowercase()
+                    if (lower.contains("data:image") || lower.contains("base64,") || value.length > 10000) {
+                        // mark skipped
+                        return@forEach
+                    }
+                }
+
+                // Collect muted apps: keys like app_<package>_enabled with value false
+                if (key.name.startsWith("app_") && key.name.endsWith("_enabled")) {
+                    val pkg = key.name.removePrefix("app_").removeSuffix("_enabled")
+                    val enabled = (value as? Boolean) ?: true
+                    if (!enabled) {
+                        mutedArray.put(pkg)
+                    }
+                }
+
+                val entry = JSONObject()
+                when (value) {
+                    is String -> {
+                        entry.put("type", "string")
+                        entry.put("value", value)
+                    }
+                    is Boolean -> {
+                        entry.put("type", "boolean")
+                        entry.put("value", value)
+                    }
+                    is Int -> {
+                        entry.put("type", "int")
+                        entry.put("value", value)
+                    }
+                    is Long -> {
+                        entry.put("type", "long")
+                        entry.put("value", value)
+                    }
+                    else -> {
+                        // Fallback to string representation
+                        entry.put("type", "string")
+                        entry.put("value", value.toString())
+                    }
+                }
+                dataObj.put(key.name, entry)
+            } catch (_: Exception) {
+                // ignore problematic entries
+            }
+        }
+
+        exportObj.put("version", 1)
+        exportObj.put("preferences", dataObj)
+        // Include list of apps explicitly disabled for notification syncing so import can restore this
+        exportObj.put("muted_apps", mutedArray)
+        return exportObj.toString()
+    }
+
+    /**
+     * Import preferences from JSON produced by exportAllDataToJson.
+     * Only writes keys present in the JSON; missing keys are left unchanged.
+     */
+    suspend fun importAllDataFromJson(json: String): Boolean {
+        try {
+            val root = JSONObject(json)
+            val prefsObj = root.optJSONObject("preferences") ?: return false
+            val mutedApps = mutableListOf<String>()
+            val mutedJson = root.optJSONArray("muted_apps")
+            if (mutedJson != null) {
+                for (i in 0 until mutedJson.length()) {
+                    try { mutedApps.add(mutedJson.getString(i)) } catch (_: Exception) {}
+                }
+            }
+
+            context.dataStore.edit { preferences ->
+                val keys = prefsObj.keys()
+                while (keys.hasNext()) {
+                    val keyName = keys.next()
+                    try {
+                        val entry = prefsObj.getJSONObject(keyName)
+                        val type = entry.optString("type", "string")
+                        when (type) {
+                            "boolean" -> {
+                                val key = booleanPreferencesKey(keyName)
+                                val v = entry.getBoolean("value")
+                                preferences[key] = v
+                            }
+                            "int" -> {
+                                val key = intPreferencesKey(keyName)
+                                val v = entry.getInt("value")
+                                preferences[key] = v
+                            }
+                            "long" -> {
+                                val key = longPreferencesKey(keyName)
+                                val v = entry.getLong("value")
+                                preferences[key] = v
+                            }
+                            else -> {
+                                val key = stringPreferencesKey(keyName)
+                                val v = entry.optString("value", "")
+                                // Skip if value looks like embedded image or very large
+                                val lower = v.lowercase()
+                                if (lower.contains("data:image") || lower.contains("base64,") || v.length > 10000) {
+                                    // skip this key
+                                } else {
+                                    preferences[key] = v
+                                }
+                            }
+                        }
+                    } catch (_: Exception) {
+                        // ignore specific key import errors
+                    }
+                }
+
+                // Apply muted apps (explicitly disable per-app notification flags)
+                mutedApps.forEach { pkg ->
+                    try {
+                        val enabledKey = booleanPreferencesKey("app_${pkg}_enabled")
+                        preferences[enabledKey] = false
+                    } catch (_: Exception) {}
+                }
+            }
+
+            return true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+    }
+}

app/src/main/java/com/sameerasw/airsync/data/repository/AirSyncRepositoryImpl.kt

@@ -150,6 +150,14 @@ class AirSyncRepositoryImpl(
         return dataStoreManager.getKeepPreviousLinkEnabled()
     }
 
+    override suspend fun setSmartspacerShowWhenDisconnected(enabled: Boolean) {
+        dataStoreManager.setSmartspacerShowWhenDisconnected(enabled)
+    }
+
+    override fun getSmartspacerShowWhenDisconnected(): Flow<Boolean> {
+        return dataStoreManager.getSmartspacerShowWhenDisconnected()
+    }
+
     override suspend fun setUserManuallyDisconnected(disconnected: Boolean) {
         dataStoreManager.setUserManuallyDisconnected(disconnected)
     }

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

@@ -26,6 +26,7 @@ data class UiState(
     val isContinueBrowsingEnabled: Boolean = true,
     val isSendNowPlayingEnabled: Boolean = true,
     val isKeepPreviousLinkEnabled: Boolean = true,
+    val isSmartspacerShowWhenDisconnected: Boolean = false,
     // Mac device status
     val macDeviceStatus: MacDeviceStatus? = null,
     // Auth failure dialog

app/src/main/java/com/sameerasw/airsync/domain/repository/AirSyncRepository.kt

@@ -64,6 +64,10 @@ interface AirSyncRepository {
     suspend fun setKeepPreviousLinkEnabled(enabled: Boolean)
     fun getKeepPreviousLinkEnabled(): Flow<Boolean>
 
+    // Smartspacer settings
+    suspend fun setSmartspacerShowWhenDisconnected(enabled: Boolean)
+    fun getSmartspacerShowWhenDisconnected(): Flow<Boolean>
+
     // User manual disconnect tracking
     suspend fun setUserManuallyDisconnected(disconnected: Boolean)
     fun getUserManuallyDisconnected(): Flow<Boolean>

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

@@ -30,11 +30,13 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.platform.LocalHapticFeedback
 import com.sameerasw.airsync.domain.model.ConnectedDevice
 import com.sameerasw.airsync.domain.model.UiState
 import com.sameerasw.airsync.ui.theme.ExtraCornerRadius
 import com.sameerasw.airsync.ui.theme.minCornerRadius
 import com.sameerasw.airsync.utils.DevicePreviewResolver
+import com.sameerasw.airsync.utils.HapticUtil
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
@@ -46,6 +48,8 @@ fun ConnectionStatusCard(
     lastConnected: Boolean,
     uiState: UiState,
 ) {
+    val haptics = androidx.compose.ui.platform.LocalHapticFeedback.current
+
     val cardShape = if (!isConnected) {
         RoundedCornerShape(
             topStart = ExtraCornerRadius,
@@ -172,7 +176,10 @@ fun ConnectionStatusCard(
                 )
 
                 if (isConnected) {
-                    OutlinedButton(onClick = onDisconnect) {
+                    OutlinedButton(onClick = {
+                        HapticUtil.performClick(haptics)
+                        onDisconnect()
+                    }) {
                         Text("Disconnect")
                     }
                 }