Liquid

app/build.gradle.kts

@@ -17,7 +17,7 @@ android {
     applicationId = "app.marlboroadvance.mpvex"
     minSdk = 26
     targetSdk = 36
-    versionCode = 128
+    versionCode = 129
     versionName = "1.2.9"
 
     vectorDrawables {
@@ -237,6 +237,17 @@ dependencies {
   implementation(libs.nanohttpd)
   implementation(libs.lazycolumnscrollbar)
   implementation(libs.reorderable)
+
+  // LIQUID GLASS DEPENDENCIES
+  // AndroidLiquidGlass 2.0.0-alpha03 (Contains the advanced lens effects)
+  implementation("io.github.kyant0:backdrop:2.0.0-alpha03")
+
+  // SHAPES LIBRARY 1.2.0 (MINIMUM REQUIRED for G2 continuous curves)
+  implementation("io.github.kyant0:shapes:1.2.0")
+
+  // DataStore for preferences persistence (To toggle the UI on/off)
+  implementation("androidx.datastore:datastore-preferences:1.0.0")
+  implementation("androidx.graphics:graphics-core:1.0.4")
 }
 
 /* ---------------- Git helpers ---------------- */

app/src/main/java/app/marlboroadvance/mpvex/MainActivity.kt

@@ -22,6 +22,7 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.TransformOrigin
 import androidx.compose.ui.graphics.toArgb
@@ -50,17 +51,20 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.withContext
 import org.koin.android.ext.android.inject
 
+// --- NEW LIQUID IMPORTS ---
+import com.kyant.backdrop.backdrops.layerBackdrop
+import com.kyant.backdrop.backdrops.rememberLayerBackdrop
+import app.marlboroadvance.mpvex.ui.components.liquid.LocalLiquidBackdrop
+
 /**
  * Main entry point for the application
  */
 class MainActivity : ComponentActivity() {
   private val appearancePreferences by inject<AppearancePreferences>()
   private val networkRepository by inject<NetworkRepository>()
 
-  // Create a coroutine scope tied to the activity lifecycle
   private val activityScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
 
-  // Register the ActivityResultLauncher at class level
   private val mediaAccessLauncher = registerForActivityResult(
     ActivityResultContracts.StartIntentSenderForResult()
   ) { result ->
@@ -72,11 +76,9 @@ class MainActivity : ComponentActivity() {
 
     PermissionUtils.setMediaAccessLauncher(mediaAccessLauncher)
 
-    // Register proxy lifecycle observer for network streaming
     lifecycle.addObserver(app.marlboroadvance.mpvex.ui.browser.networkstreaming.proxy.ProxyLifecycleObserver())
 
     setContent {
-      // Set up theme and edge-to-edge display
       val dark by appearancePreferences.darkMode.collectAsState()
       val isSystemInDarkTheme = isSystemInDarkTheme()
       val isDarkMode = dark == DarkMode.Dark || (dark == DarkMode.System && isSystemInDarkTheme)
@@ -87,14 +89,20 @@ class MainActivity : ComponentActivity() {
         ) { isDarkMode },
       )
 
-      // Auto-connect to saved network connections
       LaunchedEffect(Unit) {
         autoConnectToNetworks()
       }
 
       MpvexTheme {
+        // Correct initialization of the backdrop engine
+        val backdrop = rememberLayerBackdrop()
+
         Surface {
-          Navigator()
+          CompositionLocalProvider(
+            LocalLiquidBackdrop provides backdrop
+          ) {
+            Navigator()
+          }
         }
       }
     }
@@ -108,14 +116,9 @@ class MainActivity : ComponentActivity() {
     }
   }
 
-  /**
-   * Auto-connect to network connections that are marked for auto-connection
-   */
   private suspend fun autoConnectToNetworks() {
-    // Delay auto-connect to let UI settle first
     kotlinx.coroutines.delay(500)
 
-    // Use coroutineScope for properly structured concurrency
     withContext(Dispatchers.IO) {
       try {
         val autoConnectConnections = networkRepository.getAutoConnectConnections()
@@ -137,15 +140,12 @@ class MainActivity : ComponentActivity() {
         }
       } catch (e: Exception) {
         withContext(Dispatchers.Main) {
-          Log.e("MainActivity", "Error during auto-connect", e)
+         Log.e("MainActivity", "Error during auto-connect", e)
         }
       }
     }
   }
 
-  /**
-   * Navigator that handles screen transitions and provides shared states
-   */
   @Composable
   fun Navigator() {
     val backstack = rememberNavBackStack(MainScreen)
@@ -156,7 +156,6 @@ class MainActivity : ComponentActivity() {
     val context = LocalContext.current
     val currentVersion = BuildConfig.VERSION_NAME.replace("-dev", "")
 
-    // Conditionally initialize update feature based on build config
     val updateViewModel: UpdateViewModel? = if (BuildConfig.ENABLE_UPDATE_FEATURE) {
       viewModel(context as ComponentActivity)
     } else {
@@ -166,7 +165,6 @@ class MainActivity : ComponentActivity() {
     val isDownloading by (updateViewModel?.isDownloading ?: MutableStateFlow(false)).collectAsState()
     val downloadProgress by (updateViewModel?.downloadProgress ?: MutableStateFlow(0f)).collectAsState()
 
-    // Provide both LocalBackStack and the LazyList/Grid states to all screens
     CompositionLocalProvider(
       LocalBackStack provides typedBackstack
     ) {
@@ -186,35 +184,34 @@ class MainActivity : ComponentActivity() {
         transitionSpec = {
           (
             fadeIn(animationSpec = tween(220)) +
-              slideIn(animationSpec = tween(220)) { IntOffset(it.width / 2, 0) }
+             slideIn(animationSpec = tween(220)) { IntOffset(it.width / 2, 0) }
           ) togetherWith (
               fadeOut(animationSpec = tween(220)) +
                 slideOut(animationSpec = tween(220)) { IntOffset(-it.width / 2, 0) }
           )
         },
         predictivePopTransitionSpec = {
-          (
+         (
             fadeIn(animationSpec = tween(220)) +
               scaleIn(
                 animationSpec = tween(220, delayMillis = 30),
                 initialScale = .9f,
                 TransformOrigin(-1f, .5f),
-              )
+               )
           ) togetherWith (
               fadeOut(animationSpec = tween(220)) +
                 scaleOut(
                   animationSpec = tween(220, delayMillis = 30),
                   targetScale = .9f,
-                  TransformOrigin(-1f, .5f),
+                   TransformOrigin(-1f, .5f),
                 )
           )
         },
       )
 
-      // Display Update Dialog when appropriate (only if update feature is enabled)
       if (BuildConfig.ENABLE_UPDATE_FEATURE && updateViewModel != null) {
         when (updateState) {
-          is UpdateViewModel.UpdateState.Available -> {
+           is UpdateViewModel.UpdateState.Available -> {
             val release = (updateState as UpdateViewModel.UpdateState.Available).release
             UpdateDialog(
               release = release,
@@ -227,7 +224,7 @@ class MainActivity : ComponentActivity() {
               onIgnore = { updateViewModel.ignoreVersion(release.tagName.removePrefix("v")) }
             )
           }
-          is UpdateViewModel.UpdateState.ReadyToInstall -> {
+           is UpdateViewModel.UpdateState.ReadyToInstall -> {
             val release = (updateState as UpdateViewModel.UpdateState.ReadyToInstall).release
             UpdateDialog(
               release = release,
@@ -240,7 +237,7 @@ class MainActivity : ComponentActivity() {
               onIgnore = { updateViewModel.ignoreVersion(release.tagName.removePrefix("v")) }
             )
           }
-          else -> {}
+           else -> {}
         }
       }
     }

app/src/main/java/app/marlboroadvance/mpvex/preferences/LiquidUIPreferences.kt

@@ -0,0 +1,78 @@
+package app.marlboroadvance.mpvex.preferences
+
+import android.content.Context
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.floatPreferencesKey
+import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+private val Context.liquidUIDataStore by preferencesDataStore(name = "liquid_ui_prefs")
+
+// --- THE TARGET ENUM ---
+// Adding CARD here automatically generates the entire UI tab in AppearancePreferencesScreen!
+enum class LiquidTarget(val id: String, val title: String) {
+    NAV("nav", "Navigation"),
+    BUTTON("btn", "Buttons"),
+    DIALOG("dlg", "Dialogs"),
+    CARD("card", "Browser Cards") 
+}
+
+class LiquidUIPreferences(context: Context) {
+    private val dataStore = context.liquidUIDataStore
+
+    companion object {
+        val LIQUID_UI_ENABLED = booleanPreferencesKey("liquid_ui_enabled")
+        val LIQUID_TOGGLE_COLOR = longPreferencesKey("liquid_toggle_color")
+        val LIQUID_SLIDER_COLOR = longPreferencesKey("liquid_slider_color")
+
+        // Legacy Keys to prevent crashes in other screens
+        val LIQUID_BLUR_ENABLED = booleanPreferencesKey("liquid_blur_enabled")
+        val LIQUID_LENS_ENABLED = booleanPreferencesKey("liquid_lens_enabled")
+        val LIQUID_VIBRANCY_ENABLED_LEGACY = booleanPreferencesKey("liquid_vibrancy_enabled_legacy")
+    }
+
+    // Master Toggles
+    val liquidUIEnabledFlow: Flow<Boolean> = dataStore.data.map { it[LIQUID_UI_ENABLED] ?: false }
+    val liquidToggleColorFlow: Flow<Long> = dataStore.data.map { it[LIQUID_TOGGLE_COLOR] ?: 0xFF4CAF50 }
+    val liquidSliderColorFlow: Flow<Long> = dataStore.data.map { it[LIQUID_SLIDER_COLOR] ?: 0xFF2196F3 }
+
+    suspend fun setLiquidUIEnabled(enabled: Boolean) { dataStore.edit { it[LIQUID_UI_ENABLED] = enabled } }
+    suspend fun setToggleColor(color: Long) { dataStore.edit { it[LIQUID_TOGGLE_COLOR] = color } }
+    suspend fun setSliderColor(color: Long) { dataStore.edit { it[LIQUID_SLIDER_COLOR] = color } }
+
+    // --- DYNAMIC TARGET FLOWS ---
+    fun blurRadiusFlow(target: LiquidTarget): Flow<Float> = dataStore.data.map { it[floatPreferencesKey("${target.id}_blur")] ?: 0f }
+    fun refractionHeightFlow(target: LiquidTarget): Flow<Float> = dataStore.data.map { it[floatPreferencesKey("${target.id}_height")] ?: 40f }
+    fun refractionAmountFlow(target: LiquidTarget): Flow<Float> = dataStore.data.map { it[floatPreferencesKey("${target.id}_amount")] ?: 23f }
+    // CHANGED: default raised 0.15f → 0.5f. Old value let backdrop text bleed through navigation/dialog
+    // glass; 0.5f is the Backdrop docs' recommended balance of "glass look" vs. text readability.
+    fun tintAlphaFlow(target: LiquidTarget): Flow<Float> = dataStore.data.map { it[floatPreferencesKey("${target.id}_alpha")] ?: 0.5f }
+
+    fun chromaticAberrationFlow(target: LiquidTarget): Flow<Boolean> = dataStore.data.map { it[booleanPreferencesKey("${target.id}_chromatic")] ?: false }
+    fun depthEffectFlow(target: LiquidTarget): Flow<Boolean> = dataStore.data.map { it[booleanPreferencesKey("${target.id}_depth")] ?: true }
+    fun vibrancyEnabledFlow(target: LiquidTarget): Flow<Boolean> = dataStore.data.map { it[booleanPreferencesKey("${target.id}_vibrancy")] ?: true }
+
+    // --- DYNAMIC TARGET SETTERS ---
+    suspend fun setBlurRadius(target: LiquidTarget, value: Float) { dataStore.edit { it[floatPreferencesKey("${target.id}_blur")] = value } }
+    suspend fun setRefractionHeight(target: LiquidTarget, value: Float) { dataStore.edit { it[floatPreferencesKey("${target.id}_height")] = value } }
+    suspend fun setRefractionAmount(target: LiquidTarget, value: Float) { dataStore.edit { it[floatPreferencesKey("${target.id}_amount")] = value } }
+    suspend fun setTintAlpha(target: LiquidTarget, value: Float) { dataStore.edit { it[floatPreferencesKey("${target.id}_alpha")] = value } }
+
+    suspend fun setChromaticAberration(target: LiquidTarget, enabled: Boolean) { dataStore.edit { it[booleanPreferencesKey("${target.id}_chromatic")] = enabled } }
+    suspend fun setDepthEffect(target: LiquidTarget, enabled: Boolean) { dataStore.edit { it[booleanPreferencesKey("${target.id}_depth")] = enabled } }
+    suspend fun setVibrancyEnabled(target: LiquidTarget, enabled: Boolean) { dataStore.edit { it[booleanPreferencesKey("${target.id}_vibrancy")] = enabled } }
+
+    // --- LEGACY FALLBACKS (Keeps LiquidUISettingsScreen.kt from crashing!) ---
+    val liquidBlurEnabledFlow: Flow<Boolean> = dataStore.data.map { it[LIQUID_BLUR_ENABLED] ?: true }
+    val liquidLensEnabledFlow: Flow<Boolean> = dataStore.data.map { it[LIQUID_LENS_ENABLED] ?: true }
+    val liquidVibrancyEnabledFlow: Flow<Boolean> = dataStore.data.map { it[LIQUID_VIBRANCY_ENABLED_LEGACY] ?: true }
+
+    suspend fun setBlurEnabled(enabled: Boolean) { dataStore.edit { it[LIQUID_BLUR_ENABLED] = enabled } }
+    suspend fun setLensEnabled(enabled: Boolean) { dataStore.edit { it[LIQUID_LENS_ENABLED] = enabled } }
+
+    // This perfectly satisfies the old screen while leaving the new engine untouched!
+    suspend fun setVibrancyEnabled(enabled: Boolean) { dataStore.edit { it[LIQUID_VIBRANCY_ENABLED_LEGACY] = enabled } }
+}

app/src/main/java/app/marlboroadvance/mpvex/preferences/PlayerButton.kt

@@ -2,6 +2,7 @@ package app.marlboroadvance.mpvex.preferences
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.outlined.ArrowBack
+import androidx.compose.material.icons.automirrored.outlined.Segment
 import androidx.compose.material.icons.outlined.AspectRatio
 import androidx.compose.material.icons.outlined.Audiotrack
 import androidx.compose.material.icons.outlined.Bookmarks
@@ -16,6 +17,7 @@ import androidx.compose.material.icons.outlined.Subtitles
 import androidx.compose.material.icons.outlined.Title
 import androidx.compose.material.icons.outlined.Flip
 import androidx.compose.material.icons.outlined.Repeat
+import androidx.compose.material.icons.outlined.Segment
 import androidx.compose.material.icons.outlined.ZoomIn
 import androidx.compose.material.icons.outlined.FastForward
 import androidx.compose.material.icons.outlined.Shuffle
@@ -52,7 +54,7 @@ enum class PlayerButton(
   SHUFFLE(Icons.Outlined.Shuffle),
   MIRROR(Icons.Outlined.Flip),
   VERTICAL_FLIP(Icons.Outlined.Flip),
-  AB_LOOP(Icons.Outlined.Repeat),
+  AB_LOOP(Icons.AutoMirrored.Outlined.Segment),
   CUSTOM_SKIP(Icons.Outlined.FastForward),
   BACKGROUND_PLAYBACK(Icons.Outlined.Headset),
   AMBIENT_MODE(Icons.Outlined.BlurOn),

app/src/main/java/app/marlboroadvance/mpvex/preferences/PlayerPreferences.kt

@@ -74,15 +74,6 @@ class PlayerPreferences(
   val customButtons = preferenceStore.getString("custom_buttons_json", "[]")
 
   // Ambience Mode
-  val ambientBlurSamples = preferenceStore.getInt("ambient_blur_samples", 24)
-  val ambientMaxRadius = preferenceStore.getFloat("ambient_max_radius", 0.18f)
-  val ambientGlowIntensity = preferenceStore.getFloat("ambient_glow_intensity", 1.4f)
-  val ambientSatBoost = preferenceStore.getFloat("ambient_sat_boost", 1.2f)
-  val ambientDitherNoise = preferenceStore.getFloat("ambient_dither_noise", 0.0f)
-  val ambientBezelDepth = preferenceStore.getFloat("ambient_bezel_depth", 0.0f)
-  val ambientVignetteStrength = preferenceStore.getFloat("ambient_vignette_strength", 0.5f)
-  val ambientWarmth = preferenceStore.getFloat("ambient_warmth", 0.0f)
-  val ambientEdgeSmooth = preferenceStore.getFloat("ambient_edge_smooth", 0.02f)
-  val ambientFadeCurve = preferenceStore.getFloat("ambient_fade_curve", 1.5f)
-  val ambientOpacity = preferenceStore.getFloat("ambient_opacity", 1.0f)
+  val isAmbientEnabled = preferenceStore.getBoolean("ambient_enabled", false)
+
 }

app/src/main/java/app/marlboroadvance/mpvex/preferences/SeekbarStyle.kt

@@ -4,4 +4,5 @@ enum class SeekbarStyle {
     Standard,
     Wavy,
     Thick,
+    Liquid,
 }