Develop - prevent ambient glance with Android Auto, Fix Shizuku permissions label, Live wallpapers and translations

app/build.gradle.kts

@@ -148,4 +148,9 @@ dependencies {
     implementation("org.jsoup:jsoup:1.15.3")
     implementation(libs.sentry.android)
     implementation(libs.androidx.graphics.shapes)
+
+    // Media3 for Live Wallpaper
+    implementation(libs.androidx.media3.exoplayer)
+    implementation(libs.androidx.media3.common)
+
 }

app/src/main/AndroidManifest.xml

@@ -793,6 +793,25 @@
             </intent-filter>
         </service>
 
+        <service
+            android:name=".services.LiveWallpaperService"
+            android:label="@string/live_wallpaper_label"
+            android:permission="android.permission.BIND_WALLPAPER"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.service.wallpaper.WallpaperService" />
+            </intent-filter>
+            <meta-data
+                android:name="android.service.wallpaper"
+                android:resource="@xml/live_wallpaper_info" />
+        </service>
+
+        <activity
+            android:name=".ui.activities.LiveWallpaperActivity"
+            android:exported="true"
+            android:label="@string/live_wallpaper_label" />
+
+
         <provider
             android:name="androidx.core.content.FileProvider"
             android:authorities="${applicationId}.fileprovider"

app/src/main/java/com/sameerasw/essentials/FeatureSettingsActivity.kt

@@ -64,6 +64,7 @@ import com.sameerasw.essentials.ui.composables.configs.ButtonRemapSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.CaffeinateSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.DynamicNightLightSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.KeyboardSettingsUI
+import com.sameerasw.essentials.ui.composables.configs.LiveWallpaperSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.LocationReachedSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.MapsPowerSavingSettingsUI
 import com.sameerasw.essentials.ui.composables.configs.NotificationLightingSettingsUI
@@ -649,6 +650,14 @@ class FeatureSettingsActivity : AppCompatActivity() {
                                         )
                                     }
 
+                                    "LiveWallpaper" -> {
+                                        LiveWallpaperSettingsUI(
+                                            viewModel = viewModel,
+                                            modifier = Modifier.padding(top = 16.dp),
+                                            highlightSetting = highlightSetting
+                                        )
+                                    }
+
                                     "Other customizations" -> {
                                         OtherCustomizationsSettingsUI(
                                             viewModel = viewModel,

app/src/main/java/com/sameerasw/essentials/data/repository/SettingsRepository.kt

@@ -212,6 +212,15 @@ class SettingsRepository(private val context: Context) {
         const val KEY_REFRESH_RATE_MIN = "refresh_rate_min"
         const val KEY_REFRESH_RATE_PEAK = "refresh_rate_peak"
         const val KEY_REFRESH_RATE_DEFAULT_PEAK_INFINITY = "refresh_rate_default_peak_infinity"
+
+        // Live Wallpaper
+        const val LIVE_WALLPAPER_PREFS_NAME = "live_wallpaper_prefs"
+        const val KEY_LIVE_WALLPAPER_SELECTED_VIDEO = "selected_video"
+        const val KEY_LIVE_WALLPAPER_PLAYBACK_TRIGGER = "playback_trigger"
+        const val KEY_LIVE_WALLPAPER_CUSTOM_VIDEOS = "custom_videos"
+        const val LIVE_WALLPAPER_DEFAULT_VIDEO = "my_video"
+        const val LIVE_WALLPAPER_TRIGGER_UNLOCK = "unlock"
+        const val LIVE_WALLPAPER_TRIGGER_SCREEN_ON = "screen_on"
     }
 
     // Observe changes
@@ -580,7 +589,8 @@ class SettingsRepository(private val context: Context) {
                 "essentials_prefs",
                 "caffeinate_prefs",
                 "link_prefs",
-                "diy_automations_prefs"
+                "diy_automations_prefs",
+                "live_wallpaper_prefs"
             )
 
             prefFiles.forEach { fileName ->
@@ -794,6 +804,61 @@ class SettingsRepository(private val context: Context) {
     fun isBatteryNotificationEnabled(): Boolean = getBoolean(KEY_BATTERY_NOTIFICATION_ENABLED, false)
     fun setBatteryNotificationEnabled(enabled: Boolean) = putBoolean(KEY_BATTERY_NOTIFICATION_ENABLED, enabled)
 
+    // Live Wallpaper Helpers
+    private val liveWallpaperPrefs: SharedPreferences by lazy {
+        context.getSharedPreferences(LIVE_WALLPAPER_PREFS_NAME, Context.MODE_PRIVATE)
+    }
+
+    fun getLiveWallpaperSelectedVideo(): String =
+        liveWallpaperPrefs.getString(KEY_LIVE_WALLPAPER_SELECTED_VIDEO, LIVE_WALLPAPER_DEFAULT_VIDEO)
+            ?: LIVE_WALLPAPER_DEFAULT_VIDEO
+
+    fun saveLiveWallpaperSelectedVideo(video: String) =
+        liveWallpaperPrefs.edit().putString(KEY_LIVE_WALLPAPER_SELECTED_VIDEO, video).apply()
+
+    fun getLiveWallpaperPlaybackTrigger(): String =
+        liveWallpaperPrefs.getString(KEY_LIVE_WALLPAPER_PLAYBACK_TRIGGER, LIVE_WALLPAPER_TRIGGER_UNLOCK)
+            ?: LIVE_WALLPAPER_TRIGGER_UNLOCK
+
+    fun saveLiveWallpaperPlaybackTrigger(trigger: String) =
+        liveWallpaperPrefs.edit().putString(KEY_LIVE_WALLPAPER_PLAYBACK_TRIGGER, trigger).apply()
+
+    fun getLiveWallpaperCustomVideos(): List<String> =
+        liveWallpaperPrefs.getString(KEY_LIVE_WALLPAPER_CUSTOM_VIDEOS, "")?.split(",")?.filter { it.isNotEmpty() }
+            ?: emptyList()
+
+    fun saveLiveWallpaperCustomVideos(videos: List<String>) =
+        liveWallpaperPrefs.edit().putString(KEY_LIVE_WALLPAPER_CUSTOM_VIDEOS, videos.joinToString(",")).apply()
+
+    fun addLiveWallpaperCustomVideo(uri: String) {
+        val current = getLiveWallpaperCustomVideos().toMutableList()
+        if (current.contains(uri)) {
+            current.remove(uri)
+        }
+        current.add(0, uri)
+        saveLiveWallpaperCustomVideos(if (current.size > 5) current.take(5) else current)
+    }
+
+    fun getLiveWallpaperAvailableVideos(): List<String> {
+        val raws = com.sameerasw.essentials.R.raw::class.java.fields.mapNotNull { field ->
+            try { 
+                if (field.name == "keep") null else field.name 
+            } catch (e: Exception) { null }
+        }
+        return raws + getLiveWallpaperCustomVideos()
+    }
+
+    fun removeLiveWallpaperCustomVideo(videoUri: String) {
+        val current = getLiveWallpaperCustomVideos().toMutableList()
+        if (current.remove(videoUri)) {
+            saveLiveWallpaperCustomVideos(current)
+            // If the removed video was selected, revert to default
+            if (getLiveWallpaperSelectedVideo() == videoUri) {
+                saveLiveWallpaperSelectedVideo(LIVE_WALLPAPER_DEFAULT_VIDEO)
+            }
+        }
+    }
+
     fun getFontScale(): Float {
         return try {
             android.provider.Settings.System.getFloat(context.contentResolver, android.provider.Settings.System.FONT_SCALE)

app/src/main/java/com/sameerasw/essentials/domain/registry/FeatureRegistry.kt

@@ -149,6 +149,7 @@ object FeatureRegistry {
             override fun isEnabled(viewModel: MainViewModel) = true
             override fun onToggle(viewModel: MainViewModel, context: Context, enabled: Boolean) {}
         },
+
         object : Feature(
             id = "Always on Display",
             title = R.string.feat_always_on_display_title,
@@ -730,6 +731,21 @@ object FeatureRegistry {
                 viewModel.setDynamicNightLightEnabled(enabled, context)
         },
 
+        object : Feature(
+            id = "LiveWallpaper",
+            title = R.string.feat_live_wallpaper_title,
+            iconRes = R.drawable.rounded_slow_motion_video_24,
+            category = R.string.cat_interface,
+            parentFeatureId = "Display",
+            description = R.string.feat_live_wallpaper_desc,
+            aboutDescription = R.string.about_desc_live_wallpaper,
+            showToggle = false
+        ) {
+            override fun isEnabled(viewModel: MainViewModel) = true
+            override fun onToggle(viewModel: MainViewModel, context: Context, enabled: Boolean) {}
+        },
+
+
 
         object : Feature(
             id = "Other customizations",

app/src/main/java/com/sameerasw/essentials/services/LiveWallpaperService.kt

@@ -0,0 +1,155 @@
+package com.sameerasw.essentials.services
+
+import android.app.KeyguardManager
+import android.net.Uri
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.SharedPreferences
+import android.service.wallpaper.WallpaperService
+import android.view.SurfaceHolder
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.ExoPlayer
+import com.sameerasw.essentials.data.repository.SettingsRepository
+
+class LiveWallpaperService : WallpaperService() {
+    override fun onCreateEngine(): Engine = VideoEngine()
+
+    inner class VideoEngine : Engine() {
+        private var exoPlayer: ExoPlayer? = null
+        private lateinit var repository: SettingsRepository
+        private val executor = android.os.Handler(android.os.Looper.getMainLooper())
+        private val keyguardManager by lazy { getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager }
+
+        private val prefsListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
+            when (key) {
+                SettingsRepository.KEY_LIVE_WALLPAPER_SELECTED_VIDEO -> loadSelectedVideo()
+                SettingsRepository.KEY_LIVE_WALLPAPER_PLAYBACK_TRIGGER -> {
+                    // Update current playback state if screen is on
+                    if (isVisible && !keyguardManager.isKeyguardLocked) {
+                        exoPlayer?.play()
+                    } else if (isVisible && repository.getLiveWallpaperPlaybackTrigger() == SettingsRepository.LIVE_WALLPAPER_TRIGGER_SCREEN_ON) {
+                        exoPlayer?.play()
+                    }
+                }
+            }
+        }
+
+        private val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                when (intent?.action) {
+                    Intent.ACTION_USER_PRESENT -> exoPlayer?.play()
+                    Intent.ACTION_SCREEN_OFF -> {
+                        executor.removeCallbacksAndMessages(null)
+                        executor.postDelayed({
+                            exoPlayer?.pause()
+                            exoPlayer?.seekTo(0)
+                        }, 500)
+                    }
+                    Intent.ACTION_SCREEN_ON -> {
+                        val shouldPlay = isPreview || 
+                                       !keyguardManager.isKeyguardLocked || 
+                                       repository.getLiveWallpaperPlaybackTrigger() == SettingsRepository.LIVE_WALLPAPER_TRIGGER_SCREEN_ON
+
+                        if (shouldPlay) {
+                            executor.removeCallbacksAndMessages(null)
+                            exoPlayer?.play()
+                        } else {
+                            executor.removeCallbacksAndMessages(null)
+                            executor.postDelayed({
+                                exoPlayer?.pause()
+                                exoPlayer?.seekTo(0)
+                            }, 500)
+                        }
+                    }
+                }
+            }
+        }
+
+        @OptIn(UnstableApi::class)
+        override fun onCreate(surfaceHolder: SurfaceHolder?) {
+            super.onCreate(surfaceHolder)
+            repository = SettingsRepository(applicationContext)
+
+            val filter = IntentFilter().apply {
+                addAction(Intent.ACTION_USER_PRESENT)
+                addAction(Intent.ACTION_SCREEN_OFF)
+                addAction(Intent.ACTION_SCREEN_ON)
+            }
+            registerReceiver(receiver, filter)
+
+            repository.registerOnSharedPreferenceChangeListener(prefsListener)
+        }
+
+        override fun onVisibilityChanged(visible: Boolean) {
+            if (visible) {
+                val shouldPlay = isPreview || 
+                               !keyguardManager.isKeyguardLocked || 
+                               repository.getLiveWallpaperPlaybackTrigger() == SettingsRepository.LIVE_WALLPAPER_TRIGGER_SCREEN_ON
+                if (shouldPlay) exoPlayer?.play()
+            } else {
+                exoPlayer?.pause()
+            }
+        }
+
+        @OptIn(UnstableApi::class)
+        override fun onSurfaceCreated(holder: SurfaceHolder) {
+            super.onSurfaceCreated(holder)
+            val renderersFactory = DefaultRenderersFactory(applicationContext)
+            val player = ExoPlayer.Builder(applicationContext, renderersFactory).build()
+            exoPlayer = player
+
+            player.apply {
+                setVideoSurfaceHolder(holder)
+                repeatMode = Player.REPEAT_MODE_OFF
+                volume = 0f
+                videoScalingMode = C.VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING
+                loadSelectedVideo()
+                val shouldPlay = isPreview || 
+                               !keyguardManager.isKeyguardLocked || 
+                               repository.getLiveWallpaperPlaybackTrigger() == SettingsRepository.LIVE_WALLPAPER_TRIGGER_SCREEN_ON
+                playWhenReady = shouldPlay
+            }
+        }
+
+        @OptIn(UnstableApi::class)
+        private fun loadSelectedVideo() {
+            val videoName = repository.getLiveWallpaperSelectedVideo()
+            val resId = resources.getIdentifier(videoName, "raw", packageName)
+            val mediaItem = if (resId != 0) {
+                MediaItem.fromUri("android.resource://$packageName/$resId")
+            } else {
+                try {
+                    MediaItem.fromUri(Uri.parse(videoName))
+                } catch (e: Exception) {
+                    null
+                }
+            }
+
+            mediaItem?.let {
+                exoPlayer?.setMediaItem(it)
+                exoPlayer?.prepare()
+            }
+        }
+
+        override fun onSurfaceChanged(holder: SurfaceHolder, f: Int, w: Int, h: Int) {
+            super.onSurfaceChanged(holder, f, w, h)
+            exoPlayer?.videoScalingMode = C.VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING
+        }
+
+        override fun onDestroy() {
+            super.onDestroy()
+            executor.removeCallbacksAndMessages(null)
+            try { unregisterReceiver(receiver) } catch (e: Exception) { }
+            repository.unregisterOnSharedPreferenceChangeListener(prefsListener)
+            exoPlayer?.release()
+            exoPlayer = null
+        }
+    }
+}

app/src/main/java/com/sameerasw/essentials/services/NotificationListener.kt

@@ -383,6 +383,11 @@ class NotificationListener : NotificationListenerService() {
         )
 
         if (isEnabled) {
+            // Skip if Android Auto is running
+            if (AppUtil.isAndroidAutoRunning(this)) {
+                return
+            }
+
             val metadata = activeSession.metadata
             val title = metadata?.getString(android.media.MediaMetadata.METADATA_KEY_TITLE)
             val artist = metadata?.getString(android.media.MediaMetadata.METADATA_KEY_ARTIST)

app/src/main/java/com/sameerasw/essentials/services/dreams/AmbientDreamService.kt

@@ -132,6 +132,13 @@ class AmbientDreamService : DreamService() {
 
     private val burnInProtectionRunnable = object : Runnable {
         override fun run() {
+            if (isDetached) return
+
+            // Revert to clock if Android Auto is running
+            if (com.sameerasw.essentials.utils.AppUtil.isAndroidAutoRunning(this@AmbientDreamService)) {
+                switchToClockMode()
+            }
+
             shiftUi()
             handler.postDelayed(this, 60000) // Every minute
         }
@@ -140,6 +147,13 @@ class AmbientDreamService : DreamService() {
     private val progressUpdateRunnable = object : Runnable {
         override fun run() {
             if (isDetached) return
+
+            // Revert to clock if Android Auto is running
+            if (com.sameerasw.essentials.utils.AppUtil.isAndroidAutoRunning(this@AmbientDreamService)) {
+                switchToClockMode()
+                return
+            }
+
             handler.postDelayed(this, 1000L)
         }
     }
@@ -452,6 +466,13 @@ class AmbientDreamService : DreamService() {
 
     private fun handleIntent(intent: Intent) {
         if (isDetached) return
+
+        // Skip if Android Auto is running
+        if (com.sameerasw.essentials.utils.AppUtil.isAndroidAutoRunning(this)) {
+            switchToClockMode()
+            return
+        }
+
         eventType = intent.getStringExtra("event_type")
         targetPackage = intent.getStringExtra("package_name")
         val newTitle = intent.getStringExtra("track_title")
@@ -565,6 +586,11 @@ class AmbientDreamService : DreamService() {
 
     private fun switchToMusicMode() {
         if (isMusicMode) return
+
+        // Skip if Android Auto is running
+        if (com.sameerasw.essentials.utils.AppUtil.isAndroidAutoRunning(this)) {
+            return
+        }
         isMusicMode = true
 
         // Move Clock to Top