packages/SystemUI/src/com/android/systemui/classifier/FalsingManagerImpl.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2019 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.classifier;

 import android.content.Context;
 import android.database.ContentObserver;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.hardware.biometrics.BiometricSourceType;
 import android.net.Uri;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.PowerManager;
 import android.os.UserHandle;
 import android.provider.Settings;
 import android.view.InputDevice;
 import android.view.MotionEvent;
 import android.view.accessibility.AccessibilityManager;

 import com.android.internal.logging.MetricsLogger;
 import com.android.keyguard.KeyguardUpdateMonitor;
 import com.android.keyguard.KeyguardUpdateMonitorCallback;
 import com.android.systemui.Dependency;
 import com.android.systemui.UiOffloadThread;
 import com.android.systemui.analytics.DataCollector;
 import com.android.systemui.plugins.FalsingManager;
 import com.android.systemui.plugins.statusbar.StatusBarStateController;
 import com.android.systemui.plugins.statusbar.StatusBarStateController.StateListener;
 import com.android.systemui.statusbar.StatusBarState;
 import com.android.systemui.util.AsyncSensorManager;

 import java.io.PrintWriter;

 /**
  * When the phone is locked, listens to touch, sensor and phone events and sends them to
  * DataCollector and HumanInteractionClassifier.
  *
  * It does not collect touch events when the bouncer shows up.
  */
 public class FalsingManagerImpl implements FalsingManager {
     private static final String ENFORCE_BOUNCER = "falsing_manager_enforce_bouncer";

     private static final int[] CLASSIFIER_SENSORS = new int[] {
             Sensor.TYPE_PROXIMITY,
     };

     private static final int[] COLLECTOR_SENSORS = new int[] {
             Sensor.TYPE_ACCELEROMETER,
             Sensor.TYPE_GYROSCOPE,
             Sensor.TYPE_PROXIMITY,
             Sensor.TYPE_LIGHT,
             Sensor.TYPE_ROTATION_VECTOR,
     };
     public static final String FALSING_REMAIN_LOCKED = "falsing_failure_after_attempts";
     public static final String FALSING_SUCCESS = "falsing_success_after_attempts";

     private final Handler mHandler = new Handler(Looper.getMainLooper());
     private final Context mContext;

     private final SensorManager mSensorManager;
     private final DataCollector mDataCollector;
     private final HumanInteractionClassifier mHumanInteractionClassifier;
     private final AccessibilityManager mAccessibilityManager;
     private final UiOffloadThread mUiOffloadThread;

     private boolean mEnforceBouncer = false;
     private boolean mBouncerOn = false;
     private boolean mBouncerOffOnDown = false;
     private boolean mSessionActive = false;
     private boolean mIsTouchScreen = true;
     private boolean mJustUnlockedWithFace = false;
     private int mState = StatusBarState.SHADE;
     private boolean mScreenOn;
     private boolean mShowingAod;
     private Runnable mPendingWtf;
     private int mIsFalseTouchCalls;
     private MetricsLogger mMetricsLogger;

     private SensorEventListener mSensorEventListener = new SensorEventListener() {
         @Override
         public synchronized void onSensorChanged(SensorEvent event) {
             mDataCollector.onSensorChanged(event);
             mHumanInteractionClassifier.onSensorChanged(event);
         }

         @Override
         public void onAccuracyChanged(Sensor sensor, int accuracy) {
             mDataCollector.onAccuracyChanged(sensor, accuracy);
         }
     };

     public StateListener mStatusBarStateListener = new StateListener() {
         @Override
         public void onStateChanged(int newState) {
             if (FalsingLog.ENABLED) {
                 FalsingLog.i("setStatusBarState", new StringBuilder()
                         .append("from=").append(StatusBarState.toShortString(mState))
                         .append(" to=").append(StatusBarState.toShortString(newState))
                         .toString());
             }
             mState = newState;
             updateSessionActive();
         }
     };

     protected final ContentObserver mSettingsObserver = new ContentObserver(mHandler) {
         @Override
         public void onChange(boolean selfChange) {
             updateConfiguration();
         }
     };
     private final KeyguardUpdateMonitorCallback mKeyguardUpdateCallback =
             new KeyguardUpdateMonitorCallback() {
                 @Override
                 public void onBiometricAuthenticated(int userId,
                         BiometricSourceType biometricSourceType) {
                     if (userId == KeyguardUpdateMonitor.getCurrentUser()
                             && biometricSourceType == BiometricSourceType.FACE) {
                         mJustUnlockedWithFace = true;
                     }
                 }
             };

     FalsingManagerImpl(Context context) {
         mContext = context;
         mSensorManager = Dependency.get(AsyncSensorManager.class);
         mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
         mDataCollector = DataCollector.getInstance(mContext);
         mHumanInteractionClassifier = HumanInteractionClassifier.getInstance(mContext);
         mUiOffloadThread = Dependency.get(UiOffloadThread.class);
         mScreenOn = context.getSystemService(PowerManager.class).isInteractive();
         mMetricsLogger = new MetricsLogger();

         mContext.getContentResolver().registerContentObserver(
                 Settings.Secure.getUriFor(ENFORCE_BOUNCER), false,
                 mSettingsObserver,
                 UserHandle.USER_ALL);

         updateConfiguration();
         Dependency.get(StatusBarStateController.class).addCallback(mStatusBarStateListener);
         KeyguardUpdateMonitor.getInstance(context).registerCallback(mKeyguardUpdateCallback);
     }

     private void updateConfiguration() {
         mEnforceBouncer = 0 != Settings.Secure.getInt(mContext.getContentResolver(),
                 ENFORCE_BOUNCER, 0);
     }

     private boolean shouldSessionBeActive() {
         if (FalsingLog.ENABLED && FalsingLog.VERBOSE) {
             FalsingLog.v("shouldBeActive", new StringBuilder()
                     .append("enabled=").append(isEnabled() ? 1 : 0)
                     .append(" mScreenOn=").append(mScreenOn ? 1 : 0)
                     .append(" mState=").append(StatusBarState.toShortString(mState))
                     .toString()
             );
         }
         return isEnabled() && mScreenOn && (mState == StatusBarState.KEYGUARD) && !mShowingAod;
     }

     private boolean sessionEntrypoint() {
         if (!mSessionActive && shouldSessionBeActive()) {
             onSessionStart();
             return true;
         }
         return false;
     }

     private void sessionExitpoint(boolean force) {
         if (mSessionActive && (force || !shouldSessionBeActive())) {
             mSessionActive = false;
             if (mIsFalseTouchCalls != 0) {
                 if (FalsingLog.ENABLED) {
                     FalsingLog.i(
                             "isFalseTouchCalls", "Calls before failure: " + mIsFalseTouchCalls);
                 }
                 mMetricsLogger.histogram(FALSING_REMAIN_LOCKED, mIsFalseTouchCalls);
                 mIsFalseTouchCalls = 0;
             }

             // This can be expensive, and doesn't need to happen on the main thread.
             mUiOffloadThread.submit(() -> {
                 mSensorManager.unregisterListener(mSensorEventListener);
             });
         }
     }

     public void updateSessionActive() {
         if (shouldSessionBeActive()) {
             sessionEntrypoint();
         } else {
             sessionExitpoint(false /* force */);
         }
     }

     private void onSessionStart() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onSessionStart", "classifierEnabled=" + isClassiferEnabled());
             clearPendingWtf();
         }
         mBouncerOn = false;
         mSessionActive = true;
         mJustUnlockedWithFace = false;
         mIsFalseTouchCalls = 0;

         if (mHumanInteractionClassifier.isEnabled()) {
             registerSensors(CLASSIFIER_SENSORS);
         }
         if (mDataCollector.isEnabledFull()) {
             registerSensors(COLLECTOR_SENSORS);
         }
         if (mDataCollector.isEnabled()) {
             mDataCollector.onFalsingSessionStarted();
         }
     }

     private void registerSensors(int [] sensors) {
         for (int sensorType : sensors) {
             Sensor s = mSensorManager.getDefaultSensor(sensorType);
             if (s != null) {

                 // This can be expensive, and doesn't need to happen on the main thread.
                 mUiOffloadThread.submit(() -> {
                     mSensorManager.registerListener(
                             mSensorEventListener, s, SensorManager.SENSOR_DELAY_GAME);
                 });
             }
         }
     }

     public boolean isClassiferEnabled() {
         return mHumanInteractionClassifier.isEnabled();
     }

     private boolean isEnabled() {
         return mHumanInteractionClassifier.isEnabled() || mDataCollector.isEnabled();
     }

     public boolean isUnlockingDisabled() {
         return mDataCollector.isUnlockingDisabled();
     }
     /**
      * @return true if the classifier determined that this is not a human interacting with the phone
      */
     public boolean isFalseTouch() {
         if (FalsingLog.ENABLED) {
             // We're getting some false wtfs from touches that happen after the device went
             // to sleep. Only report missing sessions that happen when the device is interactive.
             if (!mSessionActive && mContext.getSystemService(PowerManager.class).isInteractive()
                     && mPendingWtf == null) {
                 int enabled = isEnabled() ? 1 : 0;
                 int screenOn = mScreenOn ? 1 : 0;
                 String state = StatusBarState.toShortString(mState);
                 Throwable here = new Throwable("here");
                 FalsingLog.wLogcat("isFalseTouch", new StringBuilder()
                         .append("Session is not active, yet there's a query for a false touch.")
                         .append(" enabled=").append(enabled)
                         .append(" mScreenOn=").append(screenOn)
                         .append(" mState=").append(state)
                         .append(". Escalating to WTF if screen does not turn on soon.")
                         .toString());

                 // Unfortunately we're also getting false positives for touches that happen right
                 // after the screen turns on, but before that notification has made it to us.
                 // Unfortunately there's no good way to catch that, except to wait and see if we get
                 // the screen on notification soon.
                 mPendingWtf = () -> FalsingLog.wtf("isFalseTouch", new StringBuilder()
                         .append("Session did not become active after query for a false touch.")
                         .append(" enabled=").append(enabled)
                         .append('/').append(isEnabled() ? 1 : 0)
                         .append(" mScreenOn=").append(screenOn)
                         .append('/').append(mScreenOn ? 1 : 0)
                         .append(" mState=").append(state)
                         .append('/').append(StatusBarState.toShortString(mState))
                         .append(". Look for warnings ~1000ms earlier to see root cause.")
                         .toString(), here);
                 mHandler.postDelayed(mPendingWtf, 1000);
             }
         }
         if (mAccessibilityManager.isTouchExplorationEnabled()) {
             // Touch exploration triggers false positives in the classifier and
             // already sufficiently prevents false unlocks.
             return false;
         }
         if (!mIsTouchScreen) {
             // Unlocking with input devices besides the touchscreen should already be sufficiently
             // anti-falsed.
             return false;
         }
         if (mJustUnlockedWithFace) {
             // Unlocking with face is a strong user presence signal, we can assume the user
             // is present until the next session starts.
             return false;
         }
         mIsFalseTouchCalls++;
         boolean isFalse = mHumanInteractionClassifier.isFalseTouch();
         if (!isFalse) {
             if (FalsingLog.ENABLED) {
                 FalsingLog.i("isFalseTouchCalls", "Calls before success: " + mIsFalseTouchCalls);
             }
             mMetricsLogger.histogram(FALSING_SUCCESS, mIsFalseTouchCalls);
             mIsFalseTouchCalls = 0;
         }
         return isFalse;
     }

     private void clearPendingWtf() {
         if (mPendingWtf != null) {
             mHandler.removeCallbacks(mPendingWtf);
             mPendingWtf = null;
         }
     }


     public boolean shouldEnforceBouncer() {
         return mEnforceBouncer;
     }

     public void setShowingAod(boolean showingAod) {
         mShowingAod = showingAod;
         updateSessionActive();
     }

     public void onScreenTurningOn() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onScreenTurningOn", new StringBuilder()
                     .append("from=").append(mScreenOn ? 1 : 0)
                     .toString());
             clearPendingWtf();
         }
         mScreenOn = true;
         if (sessionEntrypoint()) {
             mDataCollector.onScreenTurningOn();
         }
     }

     public void onScreenOnFromTouch() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onScreenOnFromTouch", new StringBuilder()
                     .append("from=").append(mScreenOn ? 1 : 0)
                     .toString());
         }
         mScreenOn = true;
         if (sessionEntrypoint()) {
             mDataCollector.onScreenOnFromTouch();
         }
     }

     public void onScreenOff() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onScreenOff", new StringBuilder()
                     .append("from=").append(mScreenOn ? 1 : 0)
                     .toString());
         }
         mDataCollector.onScreenOff();
         mScreenOn = false;
         sessionExitpoint(false /* force */);
     }

     public void onSucccessfulUnlock() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onSucccessfulUnlock", "");
         }
         mDataCollector.onSucccessfulUnlock();
     }

     public void onBouncerShown() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onBouncerShown", new StringBuilder()
                     .append("from=").append(mBouncerOn ? 1 : 0)
                     .toString());
         }
         if (!mBouncerOn) {
             mBouncerOn = true;
             mDataCollector.onBouncerShown();
         }
     }

     public void onBouncerHidden() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onBouncerHidden", new StringBuilder()
                     .append("from=").append(mBouncerOn ? 1 : 0)
                     .toString());
         }
         if (mBouncerOn) {
             mBouncerOn = false;
             mDataCollector.onBouncerHidden();
         }
     }

     public void onQsDown() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onQsDown", "");
         }
         mHumanInteractionClassifier.setType(Classifier.QUICK_SETTINGS);
         mDataCollector.onQsDown();
     }

     public void setQsExpanded(boolean expanded) {
         mDataCollector.setQsExpanded(expanded);
     }

     public void onTrackingStarted(boolean secure) {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onTrackingStarted", "");
         }
         mHumanInteractionClassifier.setType(secure
                 ? Classifier.BOUNCER_UNLOCK : Classifier.UNLOCK);
         mDataCollector.onTrackingStarted();
     }

     public void onTrackingStopped() {
         mDataCollector.onTrackingStopped();
     }

     public void onNotificationActive() {
         mDataCollector.onNotificationActive();
     }

     public void onNotificationDoubleTap(boolean accepted, float dx, float dy) {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onNotificationDoubleTap", "accepted=" + accepted
                     + " dx=" + dx + " dy=" + dy + " (px)");
         }
         mDataCollector.onNotificationDoubleTap();
     }

     public void setNotificationExpanded() {
         mDataCollector.setNotificationExpanded();
     }

     public void onNotificatonStartDraggingDown() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onNotificatonStartDraggingDown", "");
         }
         mHumanInteractionClassifier.setType(Classifier.NOTIFICATION_DRAG_DOWN);
         mDataCollector.onNotificatonStartDraggingDown();
     }

     public void onStartExpandingFromPulse() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onStartExpandingFromPulse", "");
         }
         mHumanInteractionClassifier.setType(Classifier.PULSE_EXPAND);
         mDataCollector.onStartExpandingFromPulse();
     }

     public void onNotificatonStopDraggingDown() {
         mDataCollector.onNotificatonStopDraggingDown();
     }

     public void onExpansionFromPulseStopped() {
         mDataCollector.onExpansionFromPulseStopped();
     }

     public void onNotificationDismissed() {
         mDataCollector.onNotificationDismissed();
     }

     public void onNotificatonStartDismissing() {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onNotificatonStartDismissing", "");
         }
         mHumanInteractionClassifier.setType(Classifier.NOTIFICATION_DISMISS);
         mDataCollector.onNotificatonStartDismissing();
     }

     public void onNotificatonStopDismissing() {
         mDataCollector.onNotificatonStopDismissing();
     }

     public void onCameraOn() {
         mDataCollector.onCameraOn();
     }

     public void onLeftAffordanceOn() {
         mDataCollector.onLeftAffordanceOn();
     }

     public void onAffordanceSwipingStarted(boolean rightCorner) {
         if (FalsingLog.ENABLED) {
             FalsingLog.i("onAffordanceSwipingStarted", "");
         }
         if (rightCorner) {
             mHumanInteractionClassifier.setType(Classifier.RIGHT_AFFORDANCE);
         } else {
             mHumanInteractionClassifier.setType(Classifier.LEFT_AFFORDANCE);
         }
         mDataCollector.onAffordanceSwipingStarted(rightCorner);
     }

     public void onAffordanceSwipingAborted() {
         mDataCollector.onAffordanceSwipingAborted();
     }

     public void onUnlockHintStarted() {
         mDataCollector.onUnlockHintStarted();
     }

     public void onCameraHintStarted() {
         mDataCollector.onCameraHintStarted();
     }

     public void onLeftAffordanceHintStarted() {
         mDataCollector.onLeftAffordanceHintStarted();
     }

     public void onTouchEvent(MotionEvent event, int width, int height) {
         if (event.getAction() == MotionEvent.ACTION_DOWN) {
             mIsTouchScreen = event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN);
             // If the bouncer was not shown during the down event,
             // we want the entire gesture going to HumanInteractionClassifier
             mBouncerOffOnDown = !mBouncerOn;
         }
         if (mSessionActive) {
             if (!mBouncerOn) {
                 // In case bouncer is "visible", but onFullyShown has not yet been called,
                 // avoid adding the event to DataCollector
                 mDataCollector.onTouchEvent(event, width, height);
             }
             if (mBouncerOffOnDown) {
                 mHumanInteractionClassifier.onTouchEvent(event);
             }
         }
     }

     public void dump(PrintWriter pw) {
         pw.println("FALSING MANAGER");
         pw.print("classifierEnabled="); pw.println(isClassiferEnabled() ? 1 : 0);
         pw.print("mSessionActive="); pw.println(mSessionActive ? 1 : 0);
         pw.print("mBouncerOn="); pw.println(mSessionActive ? 1 : 0);
         pw.print("mState="); pw.println(StatusBarState.toShortString(mState));
         pw.print("mScreenOn="); pw.println(mScreenOn ? 1 : 0);
         pw.println();
     }

     public Uri reportRejectedTouch() {
         if (mDataCollector.isEnabled()) {
             return mDataCollector.reportRejectedTouch();
         }
         return null;
     }

     public boolean isReportingEnabled() {
         return mDataCollector.isReportingEnabled();
     }
 }
	/*
	* Copyright (C) 2019 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.classifier;

	import android.content.Context;
	import android.database.ContentObserver;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.hardware.biometrics.BiometricSourceType;
	import android.net.Uri;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.PowerManager;
	import android.os.UserHandle;
	import android.provider.Settings;
	import android.view.InputDevice;
	import android.view.MotionEvent;
	import android.view.accessibility.AccessibilityManager;

	import com.android.internal.logging.MetricsLogger;
	import com.android.keyguard.KeyguardUpdateMonitor;
	import com.android.keyguard.KeyguardUpdateMonitorCallback;
	import com.android.systemui.Dependency;
	import com.android.systemui.UiOffloadThread;
	import com.android.systemui.analytics.DataCollector;
	import com.android.systemui.plugins.FalsingManager;
	import com.android.systemui.plugins.statusbar.StatusBarStateController;
	import com.android.systemui.plugins.statusbar.StatusBarStateController.StateListener;
	import com.android.systemui.statusbar.StatusBarState;
	import com.android.systemui.util.AsyncSensorManager;

	import java.io.PrintWriter;

	/**
	* When the phone is locked, listens to touch, sensor and phone events and sends them to
	* DataCollector and HumanInteractionClassifier.
	*
	* It does not collect touch events when the bouncer shows up.
	*/
	public class FalsingManagerImpl implements FalsingManager {
	private static final String ENFORCE_BOUNCER = "falsing_manager_enforce_bouncer";

	private static final int[] CLASSIFIER_SENSORS = new int[] {
	Sensor.TYPE_PROXIMITY,
	};

	private static final int[] COLLECTOR_SENSORS = new int[] {
	Sensor.TYPE_ACCELEROMETER,
	Sensor.TYPE_GYROSCOPE,
	Sensor.TYPE_PROXIMITY,
	Sensor.TYPE_LIGHT,
	Sensor.TYPE_ROTATION_VECTOR,
	};
	public static final String FALSING_REMAIN_LOCKED = "falsing_failure_after_attempts";
	public static final String FALSING_SUCCESS = "falsing_success_after_attempts";

	private final Handler mHandler = new Handler(Looper.getMainLooper());
	private final Context mContext;

	private final SensorManager mSensorManager;
	private final DataCollector mDataCollector;
	private final HumanInteractionClassifier mHumanInteractionClassifier;
	private final AccessibilityManager mAccessibilityManager;
	private final UiOffloadThread mUiOffloadThread;

	private boolean mEnforceBouncer = false;
	private boolean mBouncerOn = false;
	private boolean mBouncerOffOnDown = false;
	private boolean mSessionActive = false;
	private boolean mIsTouchScreen = true;
	private boolean mJustUnlockedWithFace = false;
	private int mState = StatusBarState.SHADE;
	private boolean mScreenOn;
	private boolean mShowingAod;
	private Runnable mPendingWtf;
	private int mIsFalseTouchCalls;
	private MetricsLogger mMetricsLogger;

	private SensorEventListener mSensorEventListener = new SensorEventListener() {
	@Override
	public synchronized void onSensorChanged(SensorEvent event) {
	mDataCollector.onSensorChanged(event);
	mHumanInteractionClassifier.onSensorChanged(event);
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	mDataCollector.onAccuracyChanged(sensor, accuracy);
	}
	};

	public StateListener mStatusBarStateListener = new StateListener() {
	@Override
	public void onStateChanged(int newState) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("setStatusBarState", new StringBuilder()
	.append("from=").append(StatusBarState.toShortString(mState))
	.append(" to=").append(StatusBarState.toShortString(newState))
	.toString());
	}
	mState = newState;
	updateSessionActive();
	}
	};

	protected final ContentObserver mSettingsObserver = new ContentObserver(mHandler) {
	@Override
	public void onChange(boolean selfChange) {
	updateConfiguration();
	}
	};
	private final KeyguardUpdateMonitorCallback mKeyguardUpdateCallback =
	new KeyguardUpdateMonitorCallback() {
	@Override
	public void onBiometricAuthenticated(int userId,
	BiometricSourceType biometricSourceType) {
	if (userId == KeyguardUpdateMonitor.getCurrentUser()
	&& biometricSourceType == BiometricSourceType.FACE) {
	mJustUnlockedWithFace = true;
	}
	}
	};

	FalsingManagerImpl(Context context) {
	mContext = context;
	mSensorManager = Dependency.get(AsyncSensorManager.class);
	mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
	mDataCollector = DataCollector.getInstance(mContext);
	mHumanInteractionClassifier = HumanInteractionClassifier.getInstance(mContext);
	mUiOffloadThread = Dependency.get(UiOffloadThread.class);
	mScreenOn = context.getSystemService(PowerManager.class).isInteractive();
	mMetricsLogger = new MetricsLogger();

	mContext.getContentResolver().registerContentObserver(
	Settings.Secure.getUriFor(ENFORCE_BOUNCER), false,
	mSettingsObserver,
	UserHandle.USER_ALL);

	updateConfiguration();
	Dependency.get(StatusBarStateController.class).addCallback(mStatusBarStateListener);
	KeyguardUpdateMonitor.getInstance(context).registerCallback(mKeyguardUpdateCallback);
	}

	private void updateConfiguration() {
	mEnforceBouncer = 0 != Settings.Secure.getInt(mContext.getContentResolver(),
	ENFORCE_BOUNCER, 0);
	}

	private boolean shouldSessionBeActive() {
	if (FalsingLog.ENABLED && FalsingLog.VERBOSE) {
	FalsingLog.v("shouldBeActive", new StringBuilder()
	.append("enabled=").append(isEnabled() ? 1 : 0)
	.append(" mScreenOn=").append(mScreenOn ? 1 : 0)
	.append(" mState=").append(StatusBarState.toShortString(mState))
	.toString()
	);
	}
	return isEnabled() && mScreenOn && (mState == StatusBarState.KEYGUARD) && !mShowingAod;
	}

	private boolean sessionEntrypoint() {
	if (!mSessionActive && shouldSessionBeActive()) {
	onSessionStart();
	return true;
	}
	return false;
	}

	private void sessionExitpoint(boolean force) {
	if (mSessionActive && (force \|\| !shouldSessionBeActive())) {
	mSessionActive = false;
	if (mIsFalseTouchCalls != 0) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i(
	"isFalseTouchCalls", "Calls before failure: " + mIsFalseTouchCalls);
	}
	mMetricsLogger.histogram(FALSING_REMAIN_LOCKED, mIsFalseTouchCalls);
	mIsFalseTouchCalls = 0;
	}

	// This can be expensive, and doesn't need to happen on the main thread.
	mUiOffloadThread.submit(() -> {
	mSensorManager.unregisterListener(mSensorEventListener);
	});
	}
	}

	public void updateSessionActive() {
	if (shouldSessionBeActive()) {
	sessionEntrypoint();
	} else {
	sessionExitpoint(false /* force */);
	}
	}

	private void onSessionStart() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onSessionStart", "classifierEnabled=" + isClassiferEnabled());
	clearPendingWtf();
	}
	mBouncerOn = false;
	mSessionActive = true;
	mJustUnlockedWithFace = false;
	mIsFalseTouchCalls = 0;

	if (mHumanInteractionClassifier.isEnabled()) {
	registerSensors(CLASSIFIER_SENSORS);
	}
	if (mDataCollector.isEnabledFull()) {
	registerSensors(COLLECTOR_SENSORS);
	}
	if (mDataCollector.isEnabled()) {
	mDataCollector.onFalsingSessionStarted();
	}
	}

	private void registerSensors(int [] sensors) {
	for (int sensorType : sensors) {
	Sensor s = mSensorManager.getDefaultSensor(sensorType);
	if (s != null) {

	// This can be expensive, and doesn't need to happen on the main thread.
	mUiOffloadThread.submit(() -> {
	mSensorManager.registerListener(
	mSensorEventListener, s, SensorManager.SENSOR_DELAY_GAME);
	});
	}
	}
	}

	public boolean isClassiferEnabled() {
	return mHumanInteractionClassifier.isEnabled();
	}

	private boolean isEnabled() {
	return mHumanInteractionClassifier.isEnabled() \|\| mDataCollector.isEnabled();
	}

	public boolean isUnlockingDisabled() {
	return mDataCollector.isUnlockingDisabled();
	}
	/**
	* @return true if the classifier determined that this is not a human interacting with the phone
	*/
	public boolean isFalseTouch() {
	if (FalsingLog.ENABLED) {
	// We're getting some false wtfs from touches that happen after the device went
	// to sleep. Only report missing sessions that happen when the device is interactive.
	if (!mSessionActive && mContext.getSystemService(PowerManager.class).isInteractive()
	&& mPendingWtf == null) {
	int enabled = isEnabled() ? 1 : 0;
	int screenOn = mScreenOn ? 1 : 0;
	String state = StatusBarState.toShortString(mState);
	Throwable here = new Throwable("here");
	FalsingLog.wLogcat("isFalseTouch", new StringBuilder()
	.append("Session is not active, yet there's a query for a false touch.")
	.append(" enabled=").append(enabled)
	.append(" mScreenOn=").append(screenOn)
	.append(" mState=").append(state)
	.append(". Escalating to WTF if screen does not turn on soon.")
	.toString());

	// Unfortunately we're also getting false positives for touches that happen right
	// after the screen turns on, but before that notification has made it to us.
	// Unfortunately there's no good way to catch that, except to wait and see if we get
	// the screen on notification soon.
	mPendingWtf = () -> FalsingLog.wtf("isFalseTouch", new StringBuilder()
	.append("Session did not become active after query for a false touch.")
	.append(" enabled=").append(enabled)
	.append('/').append(isEnabled() ? 1 : 0)
	.append(" mScreenOn=").append(screenOn)
	.append('/').append(mScreenOn ? 1 : 0)
	.append(" mState=").append(state)
	.append('/').append(StatusBarState.toShortString(mState))
	.append(". Look for warnings ~1000ms earlier to see root cause.")
	.toString(), here);
	mHandler.postDelayed(mPendingWtf, 1000);
	}
	}
	if (mAccessibilityManager.isTouchExplorationEnabled()) {
	// Touch exploration triggers false positives in the classifier and
	// already sufficiently prevents false unlocks.
	return false;
	}
	if (!mIsTouchScreen) {
	// Unlocking with input devices besides the touchscreen should already be sufficiently
	// anti-falsed.
	return false;
	}
	if (mJustUnlockedWithFace) {
	// Unlocking with face is a strong user presence signal, we can assume the user
	// is present until the next session starts.
	return false;
	}
	mIsFalseTouchCalls++;
	boolean isFalse = mHumanInteractionClassifier.isFalseTouch();
	if (!isFalse) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("isFalseTouchCalls", "Calls before success: " + mIsFalseTouchCalls);
	}
	mMetricsLogger.histogram(FALSING_SUCCESS, mIsFalseTouchCalls);
	mIsFalseTouchCalls = 0;
	}
	return isFalse;
	}

	private void clearPendingWtf() {
	if (mPendingWtf != null) {
	mHandler.removeCallbacks(mPendingWtf);
	mPendingWtf = null;
	}
	}


	public boolean shouldEnforceBouncer() {
	return mEnforceBouncer;
	}

	public void setShowingAod(boolean showingAod) {
	mShowingAod = showingAod;
	updateSessionActive();
	}

	public void onScreenTurningOn() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onScreenTurningOn", new StringBuilder()
	.append("from=").append(mScreenOn ? 1 : 0)
	.toString());
	clearPendingWtf();
	}
	mScreenOn = true;
	if (sessionEntrypoint()) {
	mDataCollector.onScreenTurningOn();
	}
	}

	public void onScreenOnFromTouch() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onScreenOnFromTouch", new StringBuilder()
	.append("from=").append(mScreenOn ? 1 : 0)
	.toString());
	}
	mScreenOn = true;
	if (sessionEntrypoint()) {
	mDataCollector.onScreenOnFromTouch();
	}
	}

	public void onScreenOff() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onScreenOff", new StringBuilder()
	.append("from=").append(mScreenOn ? 1 : 0)
	.toString());
	}
	mDataCollector.onScreenOff();
	mScreenOn = false;
	sessionExitpoint(false /* force */);
	}

	public void onSucccessfulUnlock() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onSucccessfulUnlock", "");
	}
	mDataCollector.onSucccessfulUnlock();
	}

	public void onBouncerShown() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onBouncerShown", new StringBuilder()
	.append("from=").append(mBouncerOn ? 1 : 0)
	.toString());
	}
	if (!mBouncerOn) {
	mBouncerOn = true;
	mDataCollector.onBouncerShown();
	}
	}

	public void onBouncerHidden() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onBouncerHidden", new StringBuilder()
	.append("from=").append(mBouncerOn ? 1 : 0)
	.toString());
	}
	if (mBouncerOn) {
	mBouncerOn = false;
	mDataCollector.onBouncerHidden();
	}
	}

	public void onQsDown() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onQsDown", "");
	}
	mHumanInteractionClassifier.setType(Classifier.QUICK_SETTINGS);
	mDataCollector.onQsDown();
	}

	public void setQsExpanded(boolean expanded) {
	mDataCollector.setQsExpanded(expanded);
	}

	public void onTrackingStarted(boolean secure) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onTrackingStarted", "");
	}
	mHumanInteractionClassifier.setType(secure
	? Classifier.BOUNCER_UNLOCK : Classifier.UNLOCK);
	mDataCollector.onTrackingStarted();
	}

	public void onTrackingStopped() {
	mDataCollector.onTrackingStopped();
	}

	public void onNotificationActive() {
	mDataCollector.onNotificationActive();
	}

	public void onNotificationDoubleTap(boolean accepted, float dx, float dy) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onNotificationDoubleTap", "accepted=" + accepted
	+ " dx=" + dx + " dy=" + dy + " (px)");
	}
	mDataCollector.onNotificationDoubleTap();
	}

	public void setNotificationExpanded() {
	mDataCollector.setNotificationExpanded();
	}

	public void onNotificatonStartDraggingDown() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onNotificatonStartDraggingDown", "");
	}
	mHumanInteractionClassifier.setType(Classifier.NOTIFICATION_DRAG_DOWN);
	mDataCollector.onNotificatonStartDraggingDown();
	}

	public void onStartExpandingFromPulse() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onStartExpandingFromPulse", "");
	}
	mHumanInteractionClassifier.setType(Classifier.PULSE_EXPAND);
	mDataCollector.onStartExpandingFromPulse();
	}

	public void onNotificatonStopDraggingDown() {
	mDataCollector.onNotificatonStopDraggingDown();
	}

	public void onExpansionFromPulseStopped() {
	mDataCollector.onExpansionFromPulseStopped();
	}

	public void onNotificationDismissed() {
	mDataCollector.onNotificationDismissed();
	}

	public void onNotificatonStartDismissing() {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onNotificatonStartDismissing", "");
	}
	mHumanInteractionClassifier.setType(Classifier.NOTIFICATION_DISMISS);
	mDataCollector.onNotificatonStartDismissing();
	}

	public void onNotificatonStopDismissing() {
	mDataCollector.onNotificatonStopDismissing();
	}

	public void onCameraOn() {
	mDataCollector.onCameraOn();
	}

	public void onLeftAffordanceOn() {
	mDataCollector.onLeftAffordanceOn();
	}

	public void onAffordanceSwipingStarted(boolean rightCorner) {
	if (FalsingLog.ENABLED) {
	FalsingLog.i("onAffordanceSwipingStarted", "");
	}
	if (rightCorner) {
	mHumanInteractionClassifier.setType(Classifier.RIGHT_AFFORDANCE);
	} else {
	mHumanInteractionClassifier.setType(Classifier.LEFT_AFFORDANCE);
	}
	mDataCollector.onAffordanceSwipingStarted(rightCorner);
	}

	public void onAffordanceSwipingAborted() {
	mDataCollector.onAffordanceSwipingAborted();
	}

	public void onUnlockHintStarted() {
	mDataCollector.onUnlockHintStarted();
	}

	public void onCameraHintStarted() {
	mDataCollector.onCameraHintStarted();
	}

	public void onLeftAffordanceHintStarted() {
	mDataCollector.onLeftAffordanceHintStarted();
	}

	public void onTouchEvent(MotionEvent event, int width, int height) {
	if (event.getAction() == MotionEvent.ACTION_DOWN) {
	mIsTouchScreen = event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN);
	// If the bouncer was not shown during the down event,
	// we want the entire gesture going to HumanInteractionClassifier
	mBouncerOffOnDown = !mBouncerOn;
	}
	if (mSessionActive) {
	if (!mBouncerOn) {
	// In case bouncer is "visible", but onFullyShown has not yet been called,
	// avoid adding the event to DataCollector
	mDataCollector.onTouchEvent(event, width, height);
	}
	if (mBouncerOffOnDown) {
	mHumanInteractionClassifier.onTouchEvent(event);
	}
	}
	}

	public void dump(PrintWriter pw) {
	pw.println("FALSING MANAGER");
	pw.print("classifierEnabled="); pw.println(isClassiferEnabled() ? 1 : 0);
	pw.print("mSessionActive="); pw.println(mSessionActive ? 1 : 0);
	pw.print("mBouncerOn="); pw.println(mSessionActive ? 1 : 0);
	pw.print("mState="); pw.println(StatusBarState.toShortString(mState));
	pw.print("mScreenOn="); pw.println(mScreenOn ? 1 : 0);
	pw.println();
	}

	public Uri reportRejectedTouch() {
	if (mDataCollector.isEnabled()) {
	return mDataCollector.reportRejectedTouch();
	}
	return null;
	}

	public boolean isReportingEnabled() {
	return mDataCollector.isReportingEnabled();
	}
	}