Merge "When posture changes, re-register prox listeners" into tm-qpr-dev am: 7d5e5e36ad

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

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

packages/SystemUI/src/com/android/systemui/util/sensors/PostureDependentProximitySensor.java

@@ -23,6 +23,8 @@ import com.android.systemui.statusbar.policy.DevicePostureController;
 import com.android.systemui.util.concurrency.DelayableExecutor;
 import com.android.systemui.util.concurrency.Execution;
 
+import java.util.HashSet;
+
 import javax.inject.Inject;
 
 /**
@@ -37,6 +39,7 @@ class PostureDependentProximitySensor extends ProximitySensorImpl {
     private final ThresholdSensor[] mPostureToPrimaryProxSensorMap;
     private final ThresholdSensor[] mPostureToSecondaryProxSensorMap;
 
+    private final HashSet<Listener> mListenersRegisteredWhenProxUnavailable = new HashSet<>();
     private final DevicePostureController mDevicePostureController;
 
     @Inject
@@ -69,6 +72,25 @@ class PostureDependentProximitySensor extends ProximitySensorImpl {
         mDevicePostureController.removeCallback(mDevicePostureCallback);
     }
 
+    @Override
+    public void register(ThresholdSensor.Listener listener) {
+        if (!isLoaded()) {
+            logDebug("No prox sensor when registering listener=" + listener);
+            mListenersRegisteredWhenProxUnavailable.add(listener);
+        }
+
+        super.register(listener);
+    }
+
+    @Override
+    public void unregister(ThresholdSensor.Listener listener) {
+        if (mListenersRegisteredWhenProxUnavailable.remove(listener)) {
+            logDebug("Removing listener from mListenersRegisteredWhenProxUnavailable "
+                    + listener);
+        }
+        super.unregister(listener);
+    }
+
     private void chooseSensors() {
         if (mDevicePosture >= mPostureToPrimaryProxSensorMap.length
                 || mDevicePosture >= mPostureToSecondaryProxSensorMap.length) {
@@ -98,6 +120,14 @@ class PostureDependentProximitySensor extends ProximitySensorImpl {
 
             mInitializedListeners = false;
             registerInternal();
+
+            final Listener[] listenersToReregister =
+                    mListenersRegisteredWhenProxUnavailable.toArray(new Listener[0]);
+            mListenersRegisteredWhenProxUnavailable.clear();
+            for (Listener listener : listenersToReregister) {
+                logDebug("Re-register listener " + listener);
+                register(listener);
+            }
         }
     }
 

packages/SystemUI/tests/src/com/android/systemui/util/sensors/PostureDependentProximitySensorTest.java

@@ -16,10 +16,16 @@
 
 package com.android.systemui.util.sensors;
 
+import static com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_CLOSED;
+
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
 import android.content.res.Resources;
+import android.hardware.Sensor;
 import android.testing.AndroidTestingRunner;
 import android.testing.TestableLooper;
 
@@ -46,28 +52,52 @@ public class PostureDependentProximitySensorTest extends SysuiTestCase {
     @Mock private Resources mResources;
     @Mock private DevicePostureController mDevicePostureController;
     @Mock private AsyncSensorManager mSensorManager;
+    @Mock private Sensor mMockedPrimaryProxSensor;
 
     @Captor private ArgumentCaptor<DevicePostureController.Callback> mPostureListenerCaptor =
             ArgumentCaptor.forClass(DevicePostureController.Callback.class);
     private DevicePostureController.Callback mPostureListener;
 
-    private PostureDependentProximitySensor mProximitySensor;
+    private PostureDependentProximitySensor mPostureDependentProximitySensor;
-    private FakeExecutor mFakeExecutor = new FakeExecutor(new FakeSystemClock());
+    private ThresholdSensor[] mPrimaryProxSensors;
+    private ThresholdSensor[] mSecondaryProxSensors;
 
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
         allowTestableLooperAsMainThread();
 
-        mProximitySensor = new PostureDependentProximitySensor(
+        setupProximitySensors(DEVICE_POSTURE_CLOSED);
-                new ThresholdSensor[DevicePostureController.SUPPORTED_POSTURES_SIZE],
+        mPostureDependentProximitySensor = new PostureDependentProximitySensor(
-                new ThresholdSensor[DevicePostureController.SUPPORTED_POSTURES_SIZE],
+                mPrimaryProxSensors,
-                mFakeExecutor,
+                mSecondaryProxSensors,
+                new FakeExecutor(new FakeSystemClock()),
                 new FakeExecution(),
                 mDevicePostureController
         );
     }
 
+    /**
+     * Support a proximity sensor only for the given devicePosture for the primary sensor.
+     * Otherwise, all other postures don't support prox.
+     */
+    private void setupProximitySensors(
+            @DevicePostureController.DevicePostureInt int proxExistsForPosture) {
+        final ThresholdSensorImpl.Builder sensorBuilder = new ThresholdSensorImpl.BuilderFactory(
+                mResources, mSensorManager, new FakeExecution()).createBuilder();
+
+        mPrimaryProxSensors = new ThresholdSensor[DevicePostureController.SUPPORTED_POSTURES_SIZE];
+        mSecondaryProxSensors =
+                new ThresholdSensor[DevicePostureController.SUPPORTED_POSTURES_SIZE];
+        for (int i = 0; i < DevicePostureController.SUPPORTED_POSTURES_SIZE; i++) {
+            mPrimaryProxSensors[i] = sensorBuilder.setSensor(null).setThresholdValue(0).build();
+            mSecondaryProxSensors[i] = sensorBuilder.setSensor(null).setThresholdValue(0).build();
+        }
+
+        mPrimaryProxSensors[proxExistsForPosture] = sensorBuilder
+                .setSensor(mMockedPrimaryProxSensor).setThresholdValue(5).build();
+    }
+
     @Test
     public void testPostureChangeListenerAdded() {
         capturePostureListener();
@@ -83,30 +113,59 @@ public class PostureDependentProximitySensorTest extends SysuiTestCase {
 
         // THEN device posture is updated to DEVICE_POSTURE_OPENED
         assertEquals(DevicePostureController.DEVICE_POSTURE_OPENED,
-                mProximitySensor.mDevicePosture);
+                mPostureDependentProximitySensor.mDevicePosture);
 
         // WHEN the posture changes to DEVICE_POSTURE_CLOSED
-        mPostureListener.onPostureChanged(DevicePostureController.DEVICE_POSTURE_CLOSED);
+        mPostureListener.onPostureChanged(DEVICE_POSTURE_CLOSED);
 
         // THEN device posture is updated to DEVICE_POSTURE_CLOSED
-        assertEquals(DevicePostureController.DEVICE_POSTURE_CLOSED,
+        assertEquals(DEVICE_POSTURE_CLOSED,
-                mProximitySensor.mDevicePosture);
+                mPostureDependentProximitySensor.mDevicePosture);
 
         // WHEN the posture changes to DEVICE_POSTURE_FLIPPED
         mPostureListener.onPostureChanged(DevicePostureController.DEVICE_POSTURE_FLIPPED);
 
         // THEN device posture is updated to DEVICE_POSTURE_FLIPPED
         assertEquals(DevicePostureController.DEVICE_POSTURE_FLIPPED,
-                mProximitySensor.mDevicePosture);
+                mPostureDependentProximitySensor.mDevicePosture);
 
         // WHEN the posture changes to DEVICE_POSTURE_HALF_OPENED
         mPostureListener.onPostureChanged(DevicePostureController.DEVICE_POSTURE_HALF_OPENED);
 
         // THEN device posture is updated to DEVICE_POSTURE_HALF_OPENED
         assertEquals(DevicePostureController.DEVICE_POSTURE_HALF_OPENED,
-                mProximitySensor.mDevicePosture);
+                mPostureDependentProximitySensor.mDevicePosture);
     }
 
+    @Test
+    public void proxSensorRegisters_proxSensorValid() {
+        // GIVEN posture that supports a valid posture with a prox sensor
+        capturePostureListener();
+        mPostureListener.onPostureChanged(DEVICE_POSTURE_CLOSED);
+
+        // WHEN a listener registers
+        mPostureDependentProximitySensor.register(mock(ThresholdSensor.Listener.class));
+
+        // THEN PostureDependentProximitySensor is registered
+        assertTrue(mPostureDependentProximitySensor.isRegistered());
+    }
+
+    @Test
+    public void proxSensorReregisters_postureChangesAndNewlySupportsProx() {
+        // GIVEN there's a registered listener but posture doesn't support prox
+        assertFalse(mPostureDependentProximitySensor.isRegistered());
+        mPostureDependentProximitySensor.register(mock(ThresholdSensor.Listener.class));
+        assertFalse(mPostureDependentProximitySensor.isRegistered());
+
+        // WHEN posture that supports a valid posture with a prox sensor
+        capturePostureListener();
+        mPostureListener.onPostureChanged(DEVICE_POSTURE_CLOSED);
+
+        // THEN PostureDependentProximitySensor is registered
+        assertTrue(mPostureDependentProximitySensor.isRegistered());
+    }
+
+
     private void capturePostureListener() {
         verify(mDevicePostureController).addCallback(mPostureListenerCaptor.capture());
         mPostureListener = mPostureListenerCaptor.getValue();