Create new class for instance of Region Sampler

This change abstracts out the creation of RegionSamplingHelper. All the necessary fields are initialized and accessable through getters. Bug: 202758428 Test: atest ClockEventControllerTest Change-Id: I6b32776dac1853eeab87c2a65da69478e4da5b75
2022-07-11 21:03:24 +00:00
parent 69bc1961bf
commit 0201aca5b3
5 changed files with 185 additions and 107 deletions
--- a/packages/SystemUI/plugin/src/com/android/systemui/plugins/ClockProviderPlugin.kt
+++ b/packages/SystemUI/plugin/src/com/android/systemui/plugins/ClockProviderPlugin.kt
@@ -61,11 +61,7 @@ interface Clock {

    /** Initializes various rendering parameters. If never called, provides reasonable defaults. */
    fun initialize(resources: Resources, dozeFraction: Float, foldFraction: Float) {
-        events.onColorPaletteChanged(
-                resources,
-                ClockDarkness.DEFAULT,
-                ClockDarkness.DEFAULT
-        )
+        events.onColorPaletteChanged(resources, RegionDarkness.DEFAULT, RegionDarkness.DEFAULT)
        animations.doze(dozeFraction)
        animations.fold(foldFraction)
        events.onTimeTick()
@@ -95,8 +91,8 @@ interface ClockEvents {
    /** Call whenever the color palette should update */
    fun onColorPaletteChanged(
            resources: Resources,
-            smallClockIsDark: ClockDarkness,
-            largeClockIsDark: ClockDarkness
+            smallClockIsDark: RegionDarkness,
+            largeClockIsDark: RegionDarkness
    ) { }
 }

@@ -124,8 +120,8 @@ data class ClockMetadata(
 /**
 * Enum for whether clock region is dark or light.
 */
-enum class ClockDarkness(val isDark: Boolean) {
-    DEFAULT(true),
+enum class RegionDarkness(val isDark: Boolean) {
+    DEFAULT(false),
    DARK(true),
    LIGHT(false)
 }
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/clocks/DefaultClockProvider.kt
+++ b/packages/SystemUI/shared/src/com/android/systemui/shared/clocks/DefaultClockProvider.kt
@@ -22,11 +22,11 @@ import android.view.LayoutInflater
 import com.android.systemui.dagger.qualifiers.Main
 import com.android.systemui.plugins.Clock
 import com.android.systemui.plugins.ClockAnimations
-import com.android.systemui.plugins.ClockDarkness
 import com.android.systemui.plugins.ClockEvents
 import com.android.systemui.plugins.ClockId
 import com.android.systemui.plugins.ClockMetadata
 import com.android.systemui.plugins.ClockProvider
+import com.android.systemui.plugins.RegionDarkness
 import com.android.systemui.shared.R
 import java.io.PrintWriter
 import java.util.Locale
@@ -84,11 +84,11 @@ class DefaultClock(
        resources.getFloat(R.dimen.keyguard_clock_line_spacing_scale_burmese)
    private val defaultLineSpacing = resources.getFloat(R.dimen.keyguard_clock_line_spacing_scale)

-    private fun updateClockColor(clock: AnimatableClockView, darkValue: ClockDarkness) {
-        val color = if (darkValue.isDark) {
-            resources.getColor(android.R.color.system_accent2_600)
+    private fun updateClockColor(clock: AnimatableClockView, isRegionDark: RegionDarkness) {
+        val color = if (isRegionDark.isDark) {
+            resources.getColor(android.R.color.system_accent2_100)
        } else {
-            resources.getColor(android.R.color.system_accent1_100)
+            resources.getColor(android.R.color.system_accent1_600)
        }
        clock.setColors(DOZE_COLOR, color)
    }
@@ -116,8 +116,8 @@ class DefaultClock(

        override fun onColorPaletteChanged(
                resources: Resources,
-                smallClockIsDark: ClockDarkness,
-                largeClockIsDark: ClockDarkness
+                smallClockIsDark: RegionDarkness,
+                largeClockIsDark: RegionDarkness
        ) {
            updateClockColor(smallClock, smallClockIsDark)
            updateClockColor(largeClock, largeClockIsDark)
@@ -198,13 +198,17 @@ class DefaultClock(
        clocks.forEach { it.setColors(DOZE_COLOR, DOZE_COLOR) }
    }

-    override fun initialize(resources: Resources, dozeFraction: Float, foldFraction: Float) {
+    override fun initialize(
+            resources: Resources,
+            dozeFraction: Float,
+            foldFraction: Float
+    ) {
        recomputePadding()
        animations = DefaultClockAnimations(dozeFraction, foldFraction)
        events.onColorPaletteChanged(
                resources,
-                ClockDarkness.DEFAULT,
-                ClockDarkness.DEFAULT
+                RegionDarkness.DEFAULT,
+                RegionDarkness.DEFAULT
        )
        events.onTimeTick()
    }
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/regionsampling/RegionSamplingInstance.kt
+++ b/packages/SystemUI/shared/src/com/android/systemui/shared/regionsampling/RegionSamplingInstance.kt
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.regionsampling
+
+import android.content.res.Resources
+import android.graphics.Rect
+import android.view.View
+import com.android.systemui.plugins.Clock
+import com.android.systemui.plugins.RegionDarkness
+import com.android.systemui.shared.navigationbar.RegionSamplingHelper
+import com.android.systemui.shared.navigationbar.RegionSamplingHelper.SamplingCallback
+import java.io.PrintWriter
+import java.util.concurrent.Executor
+
+/**
+ * Class for instance of RegionSamplingHelper
+ */
+class RegionSamplingInstance(
+        sampledView: View?,
+        mainExecutor: Executor?,
+        bgExecutor: Executor?,
+        regionSamplingEnabled: Boolean,
+        clock: Clock?,
+        resources: Resources
+) {
+    private var isDark = RegionDarkness.DEFAULT
+    private var samplingBounds = Rect()
+    private var regionSampler: RegionSamplingHelper? = null
+
+    private fun convertToClockDarkness(isRegionDark: Boolean): RegionDarkness {
+        return if (isRegionDark) {
+            RegionDarkness.DARK
+        } else {
+            RegionDarkness.LIGHT
+        }
+    }
+
+    fun createRegionSamplingInstance(): Pair<RegionDarkness, Rect> {
+        return Pair(isDark, samplingBounds)
+    }
+
+    fun currentClockDarkness(): RegionDarkness {
+        return isDark
+    }
+
+    /**
+     * Start region sampler
+     */
+    fun startRegionSampler() {
+        regionSampler?.start(samplingBounds)
+    }
+
+    /**
+     * Stop region sampler
+     */
+    fun stopRegionSampler() {
+        regionSampler?.stop()
+    }
+
+    /**
+     * Dump region sampler
+     */
+    fun dump(pw: PrintWriter) {
+        regionSampler?.dump(pw)
+    }
+
+    /**
+     * Restart
+     */
+    fun restart(sampledView: View?) {
+        regionSampler?.onViewAttachedToWindow(sampledView)
+    }
+
+    init {
+        if (regionSamplingEnabled && sampledView != null) {
+            regionSampler = RegionSamplingHelper(sampledView,
+                    object : SamplingCallback {
+                        override fun onRegionDarknessChanged(isRegionDark: Boolean) {
+                            isDark = convertToClockDarkness(isRegionDark)
+                            clock?.events?.onColorPaletteChanged(resources, isDark, isDark)
+                        }
+
+                        override fun getSampledRegion(sampledView: View): Rect {
+                            samplingBounds = Rect(sampledView.left, sampledView.top,
+                                    sampledView.right, sampledView.bottom)
+                            return samplingBounds
+                        }
+
+                        override fun isSamplingEnabled(): Boolean {
+                            return regionSamplingEnabled
+                        }
+                    }, mainExecutor, bgExecutor)
+        }
+        regionSampler?.setWindowVisible(true)
+    }
+}
--- a/packages/SystemUI/src/com/android/keyguard/ClockEventController.kt
+++ b/packages/SystemUI/src/com/android/keyguard/ClockEventController.kt
@@ -20,17 +20,14 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.content.res.Resources
-import android.graphics.Rect
 import android.text.format.DateFormat
-import android.view.View
 import com.android.systemui.broadcast.BroadcastDispatcher
 import com.android.systemui.dagger.qualifiers.Background
 import com.android.systemui.dagger.qualifiers.Main
 import com.android.systemui.flags.FeatureFlags
 import com.android.systemui.plugins.Clock
-import com.android.systemui.plugins.ClockDarkness
 import com.android.systemui.plugins.statusbar.StatusBarStateController
-import com.android.systemui.shared.navigationbar.RegionSamplingHelper
+import com.android.systemui.shared.regionsampling.RegionSamplingInstance
 import com.android.systemui.statusbar.policy.BatteryController
 import com.android.systemui.statusbar.policy.BatteryController.BatteryStateChangeCallback
 import com.android.systemui.statusbar.policy.ConfigurationController
@@ -61,6 +58,7 @@ class ClockEventController @Inject constructor(
            field = value
            if (value != null) {
                value.initialize(resources, dozeAmount, 0f)
+                updateRegionSamplers(value)
            }
        }

@@ -71,94 +69,65 @@ class ClockEventController @Inject constructor(
    private var dozeAmount = 0f
    private var isKeyguardShowing = false

-    private var smallClockIsDark = ClockDarkness.DEFAULT
-    private var largeClockIsDark = ClockDarkness.DEFAULT
-    private var smallSamplingBounds = Rect()
-    private var largeSamplingBounds = Rect()
-
    private val regionSamplingEnabled =
            featureFlags.isEnabled(com.android.systemui.flags.Flags.REGION_SAMPLING)

-    private fun setClockDarkness(isRegionDark: Boolean): ClockDarkness {
-        return if (isRegionDark) {
-            ClockDarkness.DARK
-        } else {
-            ClockDarkness.LIGHT
-        }
+    private fun updateColors(currentClock: Clock?) {
+        smallClockIsDark = smallRegionSamplingInstance.currentClockDarkness()
+        largeClockIsDark = largeRegionSamplingInstance.currentClockDarkness()
+
+        currentClock?.events?.onColorPaletteChanged(resources, smallClockIsDark, largeClockIsDark)
    }

-    // TODO: Abstract out the creation of RegionSampler and its fields
-    var smallRegionSampling: RegionSamplingHelper? =
-            if (!regionSamplingEnabled || clock == null) {
-                null
-            } else {
-                RegionSamplingHelper(clock?.smallClock,
-                        object : RegionSamplingHelper.SamplingCallback {
-                            override fun onRegionDarknessChanged(isRegionDark: Boolean) {
-                                smallClockIsDark = setClockDarkness(isRegionDark)
-                                clock?.events?.onColorPaletteChanged(
-                                        resources,
-                                        smallClockIsDark,
-                                        largeClockIsDark
-                                )
-                            }
+    fun updateRegionSamplers(currentClock: Clock?) {
+        smallRegionSamplingInstance = RegionSamplingInstance(
+                currentClock?.smallClock,
+                mainExecutor,
+                bgExecutor,
+                regionSamplingEnabled,
+                currentClock,
+                resources
+        )

-                            override fun getSampledRegion(sampledView: View): Rect {
-                                smallSamplingBounds = Rect(
-                                        sampledView.left,
-                                        sampledView.top,
-                                        sampledView.right,
-                                        sampledView.bottom
-                                )
-                                return smallSamplingBounds
-                            }
+        largeRegionSamplingInstance = RegionSamplingInstance(
+                currentClock?.largeClock,
+                mainExecutor,
+                bgExecutor,
+                regionSamplingEnabled,
+                currentClock,
+                resources
+        )

-                            override fun isSamplingEnabled(): Boolean {
-                                return regionSamplingEnabled
-                            }
-                        },
-                        mainExecutor, bgExecutor)
-            }
+        smallRegionSamplingInstance.startRegionSampler()
+        largeRegionSamplingInstance.startRegionSampler()

-    var largeRegionSampling: RegionSamplingHelper? =
-            if (!regionSamplingEnabled || clock == null) {
-                null
-            } else {
-                RegionSamplingHelper(clock?.largeClock,
-                        object : RegionSamplingHelper.SamplingCallback {
-                            override fun onRegionDarknessChanged(isRegionDark: Boolean) {
-                                largeClockIsDark = setClockDarkness(isRegionDark)
-                                clock?.events?.onColorPaletteChanged(
-                                        resources,
-                                        smallClockIsDark,
-                                        largeClockIsDark
-                                )
-                            }
+        updateColors(currentClock)
+    }

-                            override fun getSampledRegion(sampledView: View): Rect {
-                                largeSamplingBounds = Rect(
-                                        sampledView.left,
-                                        sampledView.top,
-                                        sampledView.right,
-                                        sampledView.bottom
-                                )
-                                return largeSamplingBounds
-                            }
+    var smallRegionSamplingInstance: RegionSamplingInstance = RegionSamplingInstance(
+            clock?.smallClock,
+            mainExecutor,
+            bgExecutor,
+            regionSamplingEnabled,
+            clock,
+            resources
+    )

-                            override fun isSamplingEnabled(): Boolean {
-                                return regionSamplingEnabled
-                            }
-                        },
-                        mainExecutor, bgExecutor)
-            }
+    var largeRegionSamplingInstance: RegionSamplingInstance = RegionSamplingInstance(
+            clock?.largeClock,
+            mainExecutor,
+            bgExecutor,
+            regionSamplingEnabled,
+            clock,
+            resources
+    )
+
+    private var smallClockIsDark = smallRegionSamplingInstance.currentClockDarkness()
+    private var largeClockIsDark = largeRegionSamplingInstance.currentClockDarkness()

    private val configListener = object : ConfigurationController.ConfigurationListener {
        override fun onThemeChanged() {
-            clock?.events?.onColorPaletteChanged(
-                    resources,
-                    smallClockIsDark,
-                    largeClockIsDark
-            )
+            updateColors(clock)
        }
    }

@@ -209,8 +178,6 @@ class ClockEventController @Inject constructor(

    init {
        isDozing = statusBarStateController.isDozing
-        smallRegionSampling?.setWindowVisible(true)
-        largeRegionSampling?.setWindowVisible(true)
        clock?.events?.onColorPaletteChanged(resources, smallClockIsDark, largeClockIsDark)
    }

@@ -226,8 +193,8 @@ class ClockEventController @Inject constructor(
        batteryController.addCallback(batteryCallback)
        keyguardUpdateMonitor.registerCallback(keyguardUpdateMonitorCallback)
        statusBarStateController.addCallback(statusBarStateListener)
-        smallRegionSampling?.start(smallSamplingBounds)
-        largeRegionSampling?.start(largeSamplingBounds)
+        smallRegionSamplingInstance.startRegionSampler()
+        largeRegionSamplingInstance.startRegionSampler()
    }

    fun unregisterListeners() {
@@ -236,8 +203,8 @@ class ClockEventController @Inject constructor(
        batteryController.removeCallback(batteryCallback)
        keyguardUpdateMonitor.removeCallback(keyguardUpdateMonitorCallback)
        statusBarStateController.removeCallback(statusBarStateListener)
-        smallRegionSampling?.stop()
-        largeRegionSampling?.stop()
+        smallRegionSamplingInstance.stopRegionSampler()
+        largeRegionSamplingInstance.stopRegionSampler()
    }

    /**
@@ -246,8 +213,8 @@ class ClockEventController @Inject constructor(
    fun dump(pw: PrintWriter) {
        pw.println(this)
        clock?.dump(pw)
-        smallRegionSampling?.dump(pw)
-        largeRegionSampling?.dump(pw)
+        smallRegionSamplingInstance.dump(pw)
+        largeRegionSamplingInstance.dump(pw)
    }

    companion object {
--- a/packages/SystemUI/tests/src/com/android/keyguard/ClockEventControllerTest.kt
+++ b/packages/SystemUI/tests/src/com/android/keyguard/ClockEventControllerTest.kt
@@ -107,13 +107,15 @@ class ClockEventControllerTest : SysuiTestCase() {
    @Test
    fun themeChanged_verifyClockPaletteUpdated() {
        clockEventController.clock = clock
+        verify(events).onColorPaletteChanged(any(), any(), any())
+
        clockEventController.registerListeners()

        val captor = argumentCaptor<ConfigurationController.ConfigurationListener>()
        verify(configurationController).addCallback(capture(captor))
        captor.value.onThemeChanged()

-        verify(events).onColorPaletteChanged(any(), any(), any())
+        verify(events, times(2)).onColorPaletteChanged(any(), any(), any())
    }

    @Test