Merge "Disable hinge sensor while the screen is off" into tm-qpr-dev am: c912c03106

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/19457214

Change-Id: I12a26e98c2b0bdcbd52998f619f0e81cc219ba8c
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

packages/SystemUI/shared/src/com/android/systemui/shared/recents/IOverviewProxy.aidl

@@ -100,4 +100,14 @@ oneway interface IOverviewProxy {
      * Sent when the desired dark intensity of the nav buttons has changed
      */
     void onNavButtonsDarkIntensityChanged(float darkIntensity) = 22;
+
+     /**
+      * Sent when screen started turning on.
+      */
+     void onScreenTurningOn() = 23;
+
+     /**
+      * Sent when screen started turning off.
+      */
+     void onScreenTurningOff() = 24;
 }

packages/SystemUI/src/com/android/systemui/keyguard/LifecycleScreenStatusProvider.kt

@@ -41,4 +41,12 @@ class LifecycleScreenStatusProvider @Inject constructor(screenLifecycle: ScreenL
     override fun onScreenTurnedOn() {
         listeners.forEach(ScreenListener::onScreenTurnedOn)
     }
+
+    override fun onScreenTurningOff() {
+        listeners.forEach(ScreenListener::onScreenTurningOff)
+    }
+
+    override fun onScreenTurningOn(ignored: Runnable) {
+        listeners.forEach(ScreenListener::onScreenTurningOn)
+    }
 }

packages/SystemUI/src/com/android/systemui/recents/OverviewProxyService.java

@@ -638,12 +638,7 @@ public class OverviewProxyService extends CurrentUserTracker implements
         // Listen for user setup
         startTracking();
 
-        screenLifecycle.addObserver(new ScreenLifecycle.Observer() {
+        screenLifecycle.addObserver(mLifecycleObserver);
-            @Override
-            public void onScreenTurnedOn() {
-                notifyScreenTurnedOn();
-            }
-        });
 
         // Connect to the service
         updateEnabledState();
@@ -951,20 +946,55 @@ public class OverviewProxyService extends CurrentUserTracker implements
         }
     }
 
-    /**
+    private final ScreenLifecycle.Observer mLifecycleObserver = new ScreenLifecycle.Observer() {
-     * Notifies the Launcher that screen turned on and ready to use
+        /**
-     */
+         * Notifies the Launcher that screen turned on and ready to use
-    public void notifyScreenTurnedOn() {
+         */
-        try {
+        @Override
-            if (mOverviewProxy != null) {
+        public void onScreenTurnedOn() {
-                mOverviewProxy.onScreenTurnedOn();
+            try {
-            } else {
+                if (mOverviewProxy != null) {
-                Log.e(TAG_OPS, "Failed to get overview proxy for screen turned on event.");
+                    mOverviewProxy.onScreenTurnedOn();
+                } else {
+                    Log.e(TAG_OPS, "Failed to get overview proxy for screen turned on event.");
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG_OPS, "Failed to call onScreenTurnedOn()", e);
             }
-        } catch (RemoteException e) {
-            Log.e(TAG_OPS, "Failed to call notifyScreenTurnedOn()", e);
         }
-    }
+
+        /**
+         * Notifies the Launcher that screen is starting to turn on.
+         */
+        @Override
+        public void onScreenTurningOff() {
+            try {
+                if (mOverviewProxy != null) {
+                    mOverviewProxy.onScreenTurningOff();
+                } else {
+                    Log.e(TAG_OPS, "Failed to get overview proxy for screen turning off event.");
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG_OPS, "Failed to call onScreenTurningOff()", e);
+            }
+        }
+
+        /**
+         * Notifies the Launcher that screen is starting to turn on.
+         */
+        @Override
+        public void onScreenTurningOn(@NonNull Runnable ignored) {
+            try {
+                if (mOverviewProxy != null) {
+                    mOverviewProxy.onScreenTurningOn();
+                } else {
+                    Log.e(TAG_OPS, "Failed to get overview proxy for screen turning on event.");
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG_OPS, "Failed to call onScreenTurningOn()", e);
+            }
+        }
+    };
 
     void notifyToggleRecentApps() {
         for (int i = mConnectionCallbacks.size() - 1; i >= 0; --i) {

packages/SystemUI/tests/src/com/android/systemui/unfold/updates/DeviceFoldStateProviderTest.kt

@@ -30,13 +30,13 @@ import com.android.systemui.unfold.updates.screen.ScreenStatusProvider
 import com.android.systemui.unfold.updates.screen.ScreenStatusProvider.ScreenListener
 import com.android.systemui.util.mockito.any
 import com.google.common.truth.Truth.assertThat
+import java.util.concurrent.Executor
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mock
-import org.mockito.MockitoAnnotations
-import java.util.concurrent.Executor
 import org.mockito.Mockito.`when` as whenever
+import org.mockito.MockitoAnnotations
 
 @RunWith(AndroidTestingRunner::class)
 @SmallTest
@@ -331,6 +331,47 @@ class DeviceFoldStateProviderTest : SysuiTestCase() {
         assertThat(foldUpdates).containsExactly(FOLD_UPDATE_START_CLOSING)
     }
 
+    @Test
+    fun screenOff_whileFolded_hingeAngleProviderRemainsOff() {
+        setFoldState(folded = true)
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+
+        screenOnStatusProvider.notifyScreenTurningOff()
+
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+    }
+
+    @Test
+    fun screenOff_whileUnfolded_hingeAngleProviderStops() {
+        setFoldState(folded = false)
+        assertThat(testHingeAngleProvider.isStarted).isTrue()
+
+        screenOnStatusProvider.notifyScreenTurningOff()
+
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+    }
+
+    @Test
+    fun screenOn_whileUnfoldedAndScreenOff_hingeAngleProviderStarted() {
+        setFoldState(folded = false)
+        screenOnStatusProvider.notifyScreenTurningOff()
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+
+        screenOnStatusProvider.notifyScreenTurningOn()
+
+        assertThat(testHingeAngleProvider.isStarted).isTrue()
+    }
+
+    @Test
+    fun screenOn_whileFolded_hingeAngleRemainsOff() {
+        setFoldState(folded = true)
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+
+        screenOnStatusProvider.notifyScreenTurningOn()
+
+        assertThat(testHingeAngleProvider.isStarted).isFalse()
+    }
+
     private fun setupForegroundActivityType(isHomeActivity: Boolean?) {
         whenever(activityTypeProvider.isHomeActivity).thenReturn(isHomeActivity)
     }
@@ -391,6 +432,14 @@ class DeviceFoldStateProviderTest : SysuiTestCase() {
         fun notifyScreenTurnedOn() {
             callbacks.forEach { it.onScreenTurnedOn() }
         }
+
+        fun notifyScreenTurningOn() {
+            callbacks.forEach { it.onScreenTurningOn() }
+        }
+
+        fun notifyScreenTurningOff() {
+            callbacks.forEach { it.onScreenTurningOff() }
+        }
     }
 
     private class TestHingeAngleProvider : HingeAngleProvider {
@@ -398,11 +447,11 @@ class DeviceFoldStateProviderTest : SysuiTestCase() {
         var isStarted: Boolean = false
 
         override fun start() {
-            isStarted = true;
+            isStarted = true
         }
 
         override fun stop() {
-            isStarted = false;
+            isStarted = false
         }
 
         override fun addCallback(listener: Consumer<Float>) {

packages/SystemUI/unfold/src/com/android/systemui/unfold/updates/DeviceFoldStateProvider.kt

@@ -65,6 +65,7 @@ constructor(
     private val halfOpenedTimeoutMillis: Int = config.halfFoldedTimeoutMillis
 
     private var isFolded = false
+    private var isScreenOn = false
     private var isUnfoldHandled = true
 
     override fun start() {
@@ -198,6 +199,25 @@ constructor(
                 isUnfoldHandled = true
             }
         }
+
+        override fun onScreenTurningOn() {
+            isScreenOn = true
+            updateHingeAngleProviderState()
+        }
+
+        override fun onScreenTurningOff() {
+            isScreenOn = false
+            updateHingeAngleProviderState()
+        }
+    }
+
+    /** While the screen is off or the device is folded, hinge angle updates are not needed. */
+    private fun updateHingeAngleProviderState() {
+        if (isScreenOn && !isFolded) {
+            hingeAngleProvider.start()
+        } else {
+            hingeAngleProvider.stop()
+        }
     }
 
     private inner class HingeAngleListener : Consumer<Float> {

packages/SystemUI/unfold/src/com/android/systemui/unfold/updates/hinge/HingeSensorAngleProvider.kt

@@ -30,8 +30,10 @@ internal class HingeSensorAngleProvider(
 
     private val sensorListener = HingeAngleSensorListener()
     private val listeners: MutableList<Consumer<Float>> = arrayListOf()
+    var started = false
 
     override fun start() = executor.execute {
+        if (started) return@execute
         Trace.beginSection("HingeSensorAngleProvider#start")
         val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_HINGE_ANGLE)
         sensorManager.registerListener(
@@ -40,10 +42,13 @@ internal class HingeSensorAngleProvider(
             SensorManager.SENSOR_DELAY_FASTEST
         )
         Trace.endSection()
+        started = true
     }
 
     override fun stop() = executor.execute {
+        if (!started) return@execute
         sensorManager.unregisterListener(sensorListener)
+        started = false
     }
 
     override fun removeCallback(listener: Consumer<Float>) {

packages/SystemUI/unfold/src/com/android/systemui/unfold/updates/screen/ScreenStatusProvider.kt

@@ -25,5 +25,15 @@ interface ScreenStatusProvider : CallbackController<ScreenListener> {
          * Called when the screen is on and ready (windows are drawn and screen blocker is removed)
          */
         fun onScreenTurnedOn()
+
+        /**
+         * Called when the screen is starting to be turned off.
+         */
+        fun onScreenTurningOff()
+
+        /**
+         * Called when the screen is starting to be turned on.
+         */
+        fun onScreenTurningOn()
     }
 }