Merge "Use DockManager instead of BatteryController for Falsing." into sc-dev

packages/SystemUI/src/com/android/systemui/classifier/BrightLineFalsingManager.java

@@ -33,7 +33,6 @@ import com.android.internal.logging.MetricsLogger;
 import com.android.systemui.classifier.FalsingDataProvider.SessionListener;
 import com.android.systemui.classifier.HistoryTracker.BeliefListener;
 import com.android.systemui.dagger.qualifiers.TestHarness;
-import com.android.systemui.dock.DockManager;
 import com.android.systemui.plugins.FalsingManager;
 import com.android.systemui.statusbar.policy.KeyguardStateController;
 
@@ -66,7 +65,6 @@ public class BrightLineFalsingManager implements FalsingManager {
     private static final double FALSE_BELIEF_THRESHOLD = 0.9;
 
     private final FalsingDataProvider mDataProvider;
-    private final DockManager mDockManager;
     private final SingleTapClassifier mSingleTapClassifier;
     private final DoubleTapClassifier mDoubleTapClassifier;
     private final HistoryTracker mHistoryTracker;
@@ -173,14 +171,13 @@ public class BrightLineFalsingManager implements FalsingManager {
 
     @Inject
     public BrightLineFalsingManager(FalsingDataProvider falsingDataProvider,
-            DockManager dockManager, MetricsLogger metricsLogger,
+            MetricsLogger metricsLogger,
             @Named(BRIGHT_LINE_GESTURE_CLASSIFERS) Set<FalsingClassifier> classifiers,
             SingleTapClassifier singleTapClassifier, DoubleTapClassifier doubleTapClassifier,
             HistoryTracker historyTracker, KeyguardStateController keyguardStateController,
             AccessibilityManager accessibilityManager,
             @TestHarness boolean testHarness) {
         mDataProvider = falsingDataProvider;
-        mDockManager = dockManager;
         mMetricsLogger = metricsLogger;
         mClassifiers = classifiers;
         mSingleTapClassifier = singleTapClassifier;
@@ -332,7 +329,7 @@ public class BrightLineFalsingManager implements FalsingManager {
                 || !mKeyguardStateController.isShowing()
                 || mTestHarness
                 || mDataProvider.isJustUnlockedWithFace()
-                || mDockManager.isDocked()
+                || mDataProvider.isDocked()
                 || mAccessibilityManager.isEnabled();
     }
 
@@ -400,7 +397,7 @@ public class BrightLineFalsingManager implements FalsingManager {
         ipw.print("mJustUnlockedWithFace=");
         ipw.println(mDataProvider.isJustUnlockedWithFace() ? 1 : 0);
         ipw.print("isDocked=");
-        ipw.println(mDockManager.isDocked() ? 1 : 0);
+        ipw.println(mDataProvider.isDocked() ? 1 : 0);
         ipw.print("width=");
         ipw.println(mDataProvider.getWidthPixels());
         ipw.print("height=");

packages/SystemUI/src/com/android/systemui/classifier/FalsingCollectorImpl.java

@@ -16,6 +16,8 @@
 
 package com.android.systemui.classifier;
 
+import static com.android.systemui.dock.DockManager.DockEventListener;
+
 import android.hardware.SensorManager;
 import android.hardware.biometrics.BiometricSourceType;
 import android.util.Log;
@@ -25,9 +27,12 @@ import com.android.keyguard.KeyguardUpdateMonitor;
 import com.android.keyguard.KeyguardUpdateMonitorCallback;
 import com.android.systemui.dagger.SysUISingleton;
 import com.android.systemui.dagger.qualifiers.Main;
+import com.android.systemui.dock.DockManager;
 import com.android.systemui.plugins.FalsingManager;
 import com.android.systemui.plugins.statusbar.StatusBarStateController;
 import com.android.systemui.statusbar.StatusBarState;
+import com.android.systemui.statusbar.policy.BatteryController;
+import com.android.systemui.statusbar.policy.BatteryController.BatteryStateChangeCallback;
 import com.android.systemui.statusbar.policy.KeyguardStateController;
 import com.android.systemui.util.concurrency.DelayableExecutor;
 import com.android.systemui.util.sensors.ProximitySensor;
@@ -53,6 +58,8 @@ class FalsingCollectorImpl implements FalsingCollector {
     private final ProximitySensor mProximitySensor;
     private final StatusBarStateController mStatusBarStateController;
     private final KeyguardStateController mKeyguardStateController;
+    private final BatteryController mBatteryController;
+    private final DockManager mDockManager;
     private final DelayableExecutor mMainExecutor;
     private final SystemClock mSystemClock;
 
@@ -89,12 +96,46 @@ class FalsingCollectorImpl implements FalsingCollector {
                 }
             };
 
+
+    private final BatteryStateChangeCallback mBatteryListener = new BatteryStateChangeCallback() {
+        @Override
+        public void onBatteryLevelChanged(int level, boolean pluggedIn, boolean charging) {
+        }
+
+        @Override
+        public void onWirelessChargingChanged(boolean isWirelessCharging) {
+            if (isWirelessCharging || mDockManager.isDocked()) {
+                mProximitySensor.pause();
+            } else {
+                mProximitySensor.resume();
+            }
+        }
+    };
+
+    private final DockEventListener mDockEventListener = new DockEventListener() {
+        @Override
+        public void onEvent(int event) {
+            if (event == DockManager.STATE_NONE && !mBatteryController.isWirelessCharging()) {
+                mProximitySensor.resume();
+            } else {
+                mProximitySensor.pause();
+            }
+        }
+    };
+
     @Inject
-    FalsingCollectorImpl(FalsingDataProvider falsingDataProvider, FalsingManager falsingManager,
+    FalsingCollectorImpl(
-            KeyguardUpdateMonitor keyguardUpdateMonitor, HistoryTracker historyTracker,
+            FalsingDataProvider falsingDataProvider,
-            ProximitySensor proximitySensor, StatusBarStateController statusBarStateController,
+            FalsingManager falsingManager,
+            KeyguardUpdateMonitor keyguardUpdateMonitor,
+            HistoryTracker historyTracker,
+            ProximitySensor proximitySensor,
+            StatusBarStateController statusBarStateController,
             KeyguardStateController keyguardStateController,
-            @Main DelayableExecutor mainExecutor, SystemClock systemClock) {
+            BatteryController batteryController,
+            DockManager dockManager,
+            @Main DelayableExecutor mainExecutor,
+            SystemClock systemClock) {
         mFalsingDataProvider = falsingDataProvider;
         mFalsingManager = falsingManager;
         mKeyguardUpdateMonitor = keyguardUpdateMonitor;
@@ -102,10 +143,11 @@ class FalsingCollectorImpl implements FalsingCollector {
         mProximitySensor = proximitySensor;
         mStatusBarStateController = statusBarStateController;
         mKeyguardStateController = keyguardStateController;
+        mBatteryController = batteryController;
+        mDockManager = dockManager;
         mMainExecutor = mainExecutor;
         mSystemClock = systemClock;
 
-
         mProximitySensor.setTag(PROXIMITY_SENSOR_TAG);
         mProximitySensor.setDelay(SensorManager.SENSOR_DELAY_GAME);
 
@@ -113,6 +155,9 @@ class FalsingCollectorImpl implements FalsingCollector {
         mState = mStatusBarStateController.getState();
 
         mKeyguardUpdateMonitor.registerCallback(mKeyguardUpdateCallback);
+
+        mBatteryController.addCallback(mBatteryListener);
+        mDockManager.addListener(mDockEventListener);
     }
 
     @Override
@@ -312,6 +357,8 @@ class FalsingCollectorImpl implements FalsingCollector {
         unregisterSensors();
         mKeyguardUpdateMonitor.removeCallback(mKeyguardUpdateCallback);
         mStatusBarStateController.removeCallback(mStatusBarStateListener);
+        mBatteryController.removeCallback(mBatteryListener);
+        mDockManager.removeListener(mDockEventListener);
     }
 
     @Override
@@ -351,9 +398,7 @@ class FalsingCollectorImpl implements FalsingCollector {
     }
 
     private void registerSensors() {
-        if (!mFalsingDataProvider.isWirelessCharging()) {
+        mProximitySensor.register(mSensorEventListener);
-            mProximitySensor.register(mSensorEventListener);
-        }
     }
 
     private void unregisterSensors() {

packages/SystemUI/src/com/android/systemui/classifier/FalsingDataProvider.java

@@ -22,6 +22,7 @@ import android.view.MotionEvent.PointerCoords;
 import android.view.MotionEvent.PointerProperties;
 
 import com.android.systemui.dagger.SysUISingleton;
+import com.android.systemui.dock.DockManager;
 import com.android.systemui.statusbar.policy.BatteryController;
 
 import java.util.ArrayList;
@@ -40,7 +41,8 @@ public class FalsingDataProvider {
 
     private final int mWidthPixels;
     private final int mHeightPixels;
-    private final BatteryController mBatteryController;
+    private BatteryController mBatteryController;
+    private final DockManager mDockManager;
     private final float mXdpi;
     private final float mYdpi;
     private final List<SessionListener> mSessionListeners = new ArrayList<>();
@@ -59,12 +61,16 @@ public class FalsingDataProvider {
     private boolean mJustUnlockedWithFace;
 
     @Inject
-    public FalsingDataProvider(DisplayMetrics displayMetrics, BatteryController batteryController) {
+    public FalsingDataProvider(
+            DisplayMetrics displayMetrics,
+            BatteryController batteryController,
+            DockManager dockManager) {
         mXdpi = displayMetrics.xdpi;
         mYdpi = displayMetrics.ydpi;
         mWidthPixels = displayMetrics.widthPixels;
         mHeightPixels = displayMetrics.heightPixels;
         mBatteryController = batteryController;
+        mDockManager = dockManager;
 
         FalsingClassifier.logInfo("xdpi, ydpi: " + getXdpi() + ", " + getYdpi());
         FalsingClassifier.logInfo("width, height: " + getWidthPixels() + ", " + getHeightPixels());
@@ -219,11 +225,6 @@ public class FalsingDataProvider {
         return mLastMotionEvent.getY() < mFirstRecentMotionEvent.getY();
     }
 
-    /** Returns true if phone is being charged without a cable. */
-    public boolean isWirelessCharging() {
-        return mBatteryController.isWirelessCharging();
-    }
-
     private void recalculateData() {
         if (!mDirty) {
             return;
@@ -357,6 +358,11 @@ public class FalsingDataProvider {
         mJustUnlockedWithFace = justUnlockedWithFace;
     }
 
+    /** Returns true if phone is sitting in a dock or is wirelessly charging. */
+    public boolean isDocked() {
+        return mBatteryController.isWirelessCharging() || mDockManager.isDocked();
+    }
+
     /** Implement to be alerted abotu the beginning and ending of falsing tracking. */
     public interface SessionListener {
         /** Called when the lock screen is shown and falsing-tracking begins. */

packages/SystemUI/tests/src/com/android/systemui/classifier/BrightLineClassifierTest.java

@@ -39,7 +39,6 @@ import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.testing.FakeMetricsLogger;
 import com.android.systemui.SysuiTestCase;
 import com.android.systemui.classifier.FalsingDataProvider.GestureFinalizedListener;
-import com.android.systemui.dock.DockManagerFake;
 import com.android.systemui.statusbar.policy.KeyguardStateController;
 import com.android.systemui.util.concurrency.FakeExecutor;
 import com.android.systemui.util.time.FakeSystemClock;
@@ -62,7 +61,6 @@ public class BrightLineClassifierTest extends SysuiTestCase {
     private BrightLineFalsingManager mBrightLineFalsingManager;
     @Mock
     private FalsingDataProvider mFalsingDataProvider;
-    private final DockManagerFake mDockManager = new DockManagerFake();
     private final MetricsLogger mMetricsLogger = new FakeMetricsLogger();
     private final Set<FalsingClassifier> mClassifiers = new HashSet<>();
     @Mock
@@ -102,7 +100,7 @@ public class BrightLineClassifierTest extends SysuiTestCase {
         mClassifiers.add(mClassifierB);
         when(mFalsingDataProvider.getRecentMotionEvents()).thenReturn(mMotionEventList);
         when(mKeyguardStateController.isShowing()).thenReturn(true);
-        mBrightLineFalsingManager = new BrightLineFalsingManager(mFalsingDataProvider, mDockManager,
+        mBrightLineFalsingManager = new BrightLineFalsingManager(mFalsingDataProvider,
                 mMetricsLogger, mClassifiers, mSingleTapClassfier, mDoubleTapClassifier,
                 mHistoryTracker, mKeyguardStateController, mAccessibilityManager,
                 false);
@@ -168,7 +166,7 @@ public class BrightLineClassifierTest extends SysuiTestCase {
         // Even when the classifiers report a false, we should allow.
         when(mClassifierA.classifyGesture(anyInt(), anyDouble(), anyDouble()))
                 .thenReturn(mPassedResult);
-        mDockManager.setIsDocked(true);
+        when(mFalsingDataProvider.isDocked()).thenReturn(true);
 
         assertThat(mBrightLineFalsingManager.isFalseTouch(0)).isFalse();
     }

packages/SystemUI/tests/src/com/android/systemui/classifier/BrightLineFalsingManagerTest.java

@@ -32,7 +32,6 @@ import androidx.test.filters.SmallTest;
 import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.testing.FakeMetricsLogger;
 import com.android.systemui.SysuiTestCase;
-import com.android.systemui.dock.DockManagerFake;
 import com.android.systemui.statusbar.policy.KeyguardStateController;
 
 import org.junit.Before;
@@ -52,7 +51,6 @@ public class BrightLineFalsingManagerTest extends SysuiTestCase {
     private BrightLineFalsingManager mBrightLineFalsingManager;
     @Mock
     private FalsingDataProvider mFalsingDataProvider;
-    private final DockManagerFake mDockManager = new DockManagerFake();
     private final MetricsLogger mMetricsLogger = new FakeMetricsLogger();
     private final Set<FalsingClassifier> mClassifiers = new HashSet<>();
     @Mock
@@ -84,7 +82,7 @@ public class BrightLineFalsingManagerTest extends SysuiTestCase {
         mClassifiers.add(mClassifierA);
         when(mFalsingDataProvider.getRecentMotionEvents()).thenReturn(mMotionEventList);
         when(mKeyguardStateController.isShowing()).thenReturn(true);
-        mBrightLineFalsingManager = new BrightLineFalsingManager(mFalsingDataProvider, mDockManager,
+        mBrightLineFalsingManager = new BrightLineFalsingManager(mFalsingDataProvider,
                 mMetricsLogger, mClassifiers, mSingleTapClassifier, mDoubleTapClassifier,
                 mHistoryTracker, mKeyguardStateController, mAccessibilityManager,
                 false);

packages/SystemUI/tests/src/com/android/systemui/classifier/ClassifierTest.java

@@ -19,30 +19,35 @@ package com.android.systemui.classifier;
 import android.util.DisplayMetrics;
 import android.view.MotionEvent;
 
-import com.android.systemui.utils.leaks.FakeBatteryController;
+import com.android.systemui.SysuiTestCase;
-import com.android.systemui.utils.leaks.LeakCheckedTest;
+import com.android.systemui.dock.DockManagerFake;
+import com.android.systemui.statusbar.policy.BatteryController;
 
 import org.junit.After;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class ClassifierTest extends LeakCheckedTest {
+public class ClassifierTest extends SysuiTestCase {
 
     private FalsingDataProvider mDataProvider;
-    private List<MotionEvent> mMotionEvents = new ArrayList<>();
+    private final List<MotionEvent> mMotionEvents = new ArrayList<>();
     private float mOffsetX = 0;
     private float mOffsetY = 0;
-    private FakeBatteryController mFakeBatteryController;
+    @Mock
+    private BatteryController mBatteryController;
+    private final DockManagerFake mDockManager = new DockManagerFake();
 
     public void setup() {
+        MockitoAnnotations.initMocks(this);
         DisplayMetrics displayMetrics = new DisplayMetrics();
         displayMetrics.xdpi = 100;
         displayMetrics.ydpi = 100;
         displayMetrics.widthPixels = 1000;
         displayMetrics.heightPixels = 1000;
-        mFakeBatteryController = new FakeBatteryController(getLeakCheck());
+        mDataProvider = new FalsingDataProvider(displayMetrics, mBatteryController, mDockManager);
-        mDataProvider = new FalsingDataProvider(displayMetrics, mFakeBatteryController);
     }
 
     @After
@@ -54,10 +59,6 @@ public class ClassifierTest extends LeakCheckedTest {
         return mDataProvider;
     }
 
-    FakeBatteryController getFakeBatteryController() {
-        return mFakeBatteryController;
-    }
-
     protected void setOffsetX(float offsetX) {
         mOffsetX = offsetX;
     }

packages/SystemUI/tests/src/com/android/systemui/classifier/FalsingCollectorImplTest.java

@@ -32,9 +32,12 @@ import androidx.test.filters.SmallTest;
 
 import com.android.keyguard.KeyguardUpdateMonitor;
 import com.android.systemui.SysuiTestCase;
+import com.android.systemui.dock.DockManager;
+import com.android.systemui.dock.DockManagerFake;
 import com.android.systemui.plugins.statusbar.StatusBarStateController;
 import com.android.systemui.statusbar.StatusBarState;
 import com.android.systemui.statusbar.SysuiStatusBarStateController;
+import com.android.systemui.statusbar.policy.BatteryController;
 import com.android.systemui.statusbar.policy.KeyguardStateController;
 import com.android.systemui.util.concurrency.FakeExecutor;
 import com.android.systemui.util.sensors.ProximitySensor;
@@ -67,6 +70,9 @@ public class FalsingCollectorImplTest extends SysuiTestCase {
     private SysuiStatusBarStateController mStatusBarStateController;
     @Mock
     private KeyguardStateController mKeyguardStateController;
+    @Mock
+    private BatteryController mBatteryController;
+    private final DockManagerFake mDockManager = new DockManagerFake();
     private final FakeSystemClock mFakeSystemClock = new FakeSystemClock();
     private final FakeExecutor mFakeExecutor = new FakeExecutor(mFakeSystemClock);
 
@@ -79,8 +85,8 @@ public class FalsingCollectorImplTest extends SysuiTestCase {
 
         mFalsingCollector = new FalsingCollectorImpl(mFalsingDataProvider, mFalsingManager,
                 mKeyguardUpdateMonitor, mHistoryTracker, mProximitySensor,
-                mStatusBarStateController, mKeyguardStateController, mFakeExecutor,
+                mStatusBarStateController, mKeyguardStateController, mBatteryController,
-                mFakeSystemClock);
+                mDockManager, mFakeExecutor, mFakeSystemClock);
     }
 
     @Test
@@ -91,9 +97,32 @@ public class FalsingCollectorImplTest extends SysuiTestCase {
 
     @Test
     public void testNoProximityWhenWirelessCharging() {
-        when(mFalsingDataProvider.isWirelessCharging()).thenReturn(true);
+        ArgumentCaptor<BatteryController.BatteryStateChangeCallback> batteryCallbackCaptor =
-        mFalsingCollector.onScreenTurningOn();
+                ArgumentCaptor.forClass(BatteryController.BatteryStateChangeCallback.class);
-        verify(mProximitySensor, never()).register(any(ThresholdSensor.Listener.class));
+        verify(mBatteryController).addCallback(batteryCallbackCaptor.capture());
+        batteryCallbackCaptor.getValue().onWirelessChargingChanged(true);
+        verify(mProximitySensor).pause();
+    }
+
+    @Test
+    public void testProximityWhenOffWirelessCharging() {
+        ArgumentCaptor<BatteryController.BatteryStateChangeCallback> batteryCallbackCaptor =
+                ArgumentCaptor.forClass(BatteryController.BatteryStateChangeCallback.class);
+        verify(mBatteryController).addCallback(batteryCallbackCaptor.capture());
+        batteryCallbackCaptor.getValue().onWirelessChargingChanged(false);
+        verify(mProximitySensor).resume();
+    }
+
+    @Test
+    public void testNoProximityWhenDocked() {
+        mDockManager.setDockEvent(DockManager.STATE_DOCKED);
+        verify(mProximitySensor).pause();
+    }
+
+    @Test
+    public void testProximityWhenUndocked() {
+        mDockManager.setDockEvent(DockManager.STATE_NONE);
+        verify(mProximitySensor).resume();
     }
 
     @Test

packages/SystemUI/tests/src/com/android/systemui/classifier/FalsingDataProviderTest.java

@@ -22,6 +22,7 @@ import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import android.testing.AndroidTestingRunner;
 import android.util.DisplayMetrics;
@@ -30,12 +31,15 @@ import android.view.MotionEvent;
 import androidx.test.filters.SmallTest;
 
 import com.android.systemui.classifier.FalsingDataProvider.GestureFinalizedListener;
-import com.android.systemui.utils.leaks.FakeBatteryController;
+import com.android.systemui.dock.DockManagerFake;
+import com.android.systemui.statusbar.policy.BatteryController;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
 import java.util.List;
 
@@ -43,19 +47,21 @@ import java.util.List;
 @RunWith(AndroidTestingRunner.class)
 public class FalsingDataProviderTest extends ClassifierTest {
 
-    private FakeBatteryController mFakeBatteryController;
     private FalsingDataProvider mDataProvider;
+    @Mock
+    private BatteryController mBatteryController;
+    private final DockManagerFake mDockManager = new DockManagerFake();
 
     @Before
     public void setup() {
         super.setup();
-        mFakeBatteryController = new FakeBatteryController(getLeakCheck());
+        MockitoAnnotations.initMocks(this);
         DisplayMetrics displayMetrics = new DisplayMetrics();
         displayMetrics.xdpi = 100;
         displayMetrics.ydpi = 100;
         displayMetrics.widthPixels = 1000;
         displayMetrics.heightPixels = 1000;
-        mDataProvider = new FalsingDataProvider(displayMetrics, mFakeBatteryController);
+        mDataProvider = new FalsingDataProvider(displayMetrics, mBatteryController, mDockManager);
     }
 
     @After
@@ -250,10 +256,17 @@ public class FalsingDataProviderTest extends ClassifierTest {
 
     @Test
     public void test_isWirelessCharging() {
-        assertThat(mDataProvider.isWirelessCharging()).isFalse();
+        assertThat(mDataProvider.isDocked()).isFalse();
 
-        mFakeBatteryController.setWirelessCharging(true);
+        when(mBatteryController.isWirelessCharging()).thenReturn(true);
-        assertThat(mDataProvider.isWirelessCharging()).isTrue();
+        assertThat(mDataProvider.isDocked()).isTrue();
+    }
+
+    @Test
+    public void test_isDocked() {
+        assertThat(mDataProvider.isDocked()).isFalse();
+        mDockManager.setIsDocked(true);
+        assertThat(mDataProvider.isDocked()).isTrue();
     }
 
     @Test