[Catalyst] Add the store and get API into BrightnessLevelPreference

NO_IFTTT=Catalyst migration

Test: atest DisplayScreenTest
Bug: 375895862
Flag: com.android.settings.flags.catalyst_display_settings_screen
Change-Id: Ifb4fcf6553b070959ae233ed32e806c4c13d7136

src/com/android/settings/display/BrightnessLevelPreference.kt

@@ -31,16 +31,20 @@ import com.android.settings.R
 import com.android.settings.Utils
 import com.android.settings.core.SettingsBaseActivity
 import com.android.settingslib.RestrictedPreference
+import com.android.settingslib.datastore.AbstractKeyedDataObservable
+import com.android.settingslib.datastore.DataChangeReason
 import com.android.settingslib.datastore.HandlerExecutor
+import com.android.settingslib.datastore.KeyValueStore
 import com.android.settingslib.datastore.KeyedObserver
 import com.android.settingslib.datastore.SettingsSystemStore
 import com.android.settingslib.display.BrightnessUtils.GAMMA_SPACE_MAX
 import com.android.settingslib.display.BrightnessUtils.GAMMA_SPACE_MIN
 import com.android.settingslib.display.BrightnessUtils.convertLinearToGammaFloat
-import com.android.settingslib.metadata.PreferenceLifecycleContext
+import com.android.settingslib.metadata.PersistentPreference
-import com.android.settingslib.metadata.PreferenceLifecycleProvider
 import com.android.settingslib.metadata.PreferenceMetadata
 import com.android.settingslib.metadata.PreferenceSummaryProvider
+import com.android.settingslib.metadata.ReadWritePermit
+import com.android.settingslib.metadata.SensitivityLevel
 import com.android.settingslib.preference.PreferenceBinding
 import com.android.settingslib.transition.SettingsTransitionHelper
 import java.text.NumberFormat
@@ -48,15 +52,12 @@ import java.text.NumberFormat
 // LINT.IfChange
 class BrightnessLevelPreference :
     PreferenceMetadata,
+    PersistentPreference<Float>,
     PreferenceBinding,
     PreferenceRestrictionMixin,
     PreferenceSummaryProvider,
-    PreferenceLifecycleProvider,
     Preference.OnPreferenceClickListener {
 
-    private var brightnessObserver: KeyedObserver<String>? = null
-    private var displayListener: DisplayListener? = null
-
     override val key: String
         get() = KEY
 
@@ -67,7 +68,7 @@ class BrightnessLevelPreference :
         get() = R.string.keywords_display_brightness_level
 
     override fun getSummary(context: Context): CharSequence? =
-        NumberFormat.getPercentInstance().format(getCurrentBrightness(context))
+        NumberFormat.getPercentInstance().format(context.brightness)
 
     override fun isEnabled(context: Context) = super<PreferenceRestrictionMixin>.isEnabled(context)
 
@@ -77,91 +78,113 @@ class BrightnessLevelPreference :
     override val useAdminDisabledSummary: Boolean
         get() = true
 
+    override fun intent(context: Context) =
+        Intent(ACTION_SHOW_BRIGHTNESS_DIALOG)
+            .setPackage(Utils.SYSTEMUI_PACKAGE_NAME)
+            .putExtra(
+                SettingsBaseActivity.EXTRA_PAGE_TRANSITION_TYPE,
+                SettingsTransitionHelper.TransitionType.TRANSITION_NONE,
+            )
+            .putExtra(EXTRA_BRIGHTNESS_DIALOG_IS_FULL_WIDTH, true)
+
     override fun createWidget(context: Context) = RestrictedPreference(context)
 
     override fun bind(preference: Preference, metadata: PreferenceMetadata) {
         super.bind(preference, metadata)
         preference.onPreferenceClickListener = this
+        preference.isPersistent = false
     }
 
-    override fun onStart(context: PreferenceLifecycleContext) {
+    override fun getReadPermit(context: Context, callingPid: Int, callingUid: Int) =
-        val observer = KeyedObserver<String> { _, _ -> context.notifyPreferenceChange(KEY) }
+        ReadWritePermit.ALLOW
-        brightnessObserver = observer
-        SettingsSystemStore.get(context)
-            .addObserver(System.SCREEN_AUTO_BRIGHTNESS_ADJ, observer, HandlerExecutor.main)
 
-        val listener =
+    override fun getWritePermit(context: Context, value: Float?, callingPid: Int, callingUid: Int) =
-            object : DisplayListener {
+        ReadWritePermit.DISALLOW
-                override fun onDisplayAdded(displayId: Int) {}
 
-                override fun onDisplayRemoved(displayId: Int) {}
+    override val sensitivityLevel
+        get() = SensitivityLevel.NO_SENSITIVITY
 
-                override fun onDisplayChanged(displayId: Int) {
+    override fun storage(context: Context): KeyValueStore = BrightnessStorage(context)
-                    context.notifyPreferenceChange(KEY)
-                }
-            }
-        displayListener = listener
-        context.displayManager.registerDisplayListener(
-            listener,
-            HandlerExecutor.main,
-            /* eventFlags= */ 0,
-            DisplayManager.PRIVATE_EVENT_FLAG_DISPLAY_BRIGHTNESS,
-        )
-    }
 
-    override fun onStop(context: PreferenceLifecycleContext) {
+    private class BrightnessStorage(private val context: Context) :
-        brightnessObserver?.let {
+        AbstractKeyedDataObservable<String>(),
-            SettingsSystemStore.get(context).removeObserver(System.SCREEN_AUTO_BRIGHTNESS_ADJ, it)
+        KeyValueStore,
-            brightnessObserver = null
+        KeyedObserver<String>,
+        DisplayListener {
+
+        override fun contains(key: String) = key == KEY
+
+        @Suppress("UNCHECKED_CAST")
+        override fun <T : Any> getValue(key: String, valueType: Class<T>) =
+            context.brightness.toFloat() as T
+
+        override fun <T : Any> setValue(key: String, valueType: Class<T>, value: T?) {}
+
+        override fun onFirstObserverAdded() {
+            SettingsSystemStore.get(context)
+                .addObserver(System.SCREEN_AUTO_BRIGHTNESS_ADJ, this, HandlerExecutor.main)
+
+            context.displayManager.registerDisplayListener(
+                this,
+                HandlerExecutor.main,
+                /* eventFlags= */ 0,
+                DisplayManager.PRIVATE_EVENT_FLAG_DISPLAY_BRIGHTNESS,
+            )
         }
 
-        displayListener?.let {
+        override fun onLastObserverRemoved() {
-            context.displayManager.unregisterDisplayListener(it)
+            SettingsSystemStore.get(context).removeObserver(System.SCREEN_AUTO_BRIGHTNESS_ADJ, this)
-            displayListener = null
+
+            context.displayManager.unregisterDisplayListener(this)
+        }
+
+        override fun onKeyChanged(key: String, reason: Int) {
+            notifyChange(KEY, DataChangeReason.UPDATE)
+        }
+
+        override fun onDisplayAdded(displayId: Int) {}
+
+        override fun onDisplayRemoved(displayId: Int) {}
+
+        override fun onDisplayChanged(displayId: Int) {
+            notifyChange(KEY, DataChangeReason.UPDATE)
         }
     }
 
-    private val Context.displayManager: DisplayManager
-        get() = getSystemService(DisplayManager::class.java)!!
-
     override fun onPreferenceClick(preference: Preference): Boolean {
         val context = preference.context
-        val intent =
-            Intent(ACTION_SHOW_BRIGHTNESS_DIALOG)
-                .setPackage(Utils.SYSTEMUI_PACKAGE_NAME)
-                .putExtra(
-                    SettingsBaseActivity.EXTRA_PAGE_TRANSITION_TYPE,
-                    SettingsTransitionHelper.TransitionType.TRANSITION_NONE,
-                )
-                .putExtra(EXTRA_BRIGHTNESS_DIALOG_IS_FULL_WIDTH, true)
         val options =
             ActivityOptions.makeCustomAnimation(
                 context,
                 android.R.anim.fade_in,
                 android.R.anim.fade_out,
             )
-        context.startActivityForResult(preference.key, intent, 0, options.toBundle())
+        context.startActivityForResult(preference.key, intent(context), 0, options.toBundle())
         return true
     }
 
-    private fun getCurrentBrightness(context: Context): Double {
-        val info: BrightnessInfo? = context.display.brightnessInfo
-        val value =
-            info?.run {
-                convertLinearToGammaFloat(brightness, brightnessMinimum, brightnessMaximum)
-            }
-        return getPercentage(value?.toDouble() ?: 0.0)
-    }
-
-    private fun getPercentage(value: Double): Double =
-        when {
-            value > GAMMA_SPACE_MAX -> 1.0
-            value < GAMMA_SPACE_MIN -> 0.0
-            else -> (value - GAMMA_SPACE_MIN) / (GAMMA_SPACE_MAX - GAMMA_SPACE_MIN)
-        }
-
     companion object {
         const val KEY = "brightness"
+
+        private val Context.displayManager: DisplayManager
+            get() = getSystemService(DisplayManager::class.java)!!
+
+        private val Context.brightness: Double
+            get() {
+                val info: BrightnessInfo? = display.brightnessInfo
+                val value =
+                    info?.run {
+                        convertLinearToGammaFloat(brightness, brightnessMinimum, brightnessMaximum)
+                    }
+                return getPercentage(value?.toDouble() ?: 0.0)
+            }
+
+        private fun getPercentage(value: Double): Double =
+            when {
+                value > GAMMA_SPACE_MAX -> 1.0
+                value < GAMMA_SPACE_MIN -> 0.0
+                else -> (value - GAMMA_SPACE_MIN) / (GAMMA_SPACE_MAX - GAMMA_SPACE_MIN)
+            }
     }
 }
 // LINT.ThenChange(BrightnessLevelPreferenceController.java)