3/n: Add CoexCoordinator (89315a95) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/biometrics/sensors/AuthenticationClient.java

+122 −103

Original line number	Diff line number	Diff line
		@@ -138,7 +138,6 @@ public abstract class AuthenticationClient<T> extends AcquisitionClient<T>

		final ClientMonitorCallbackConverter listener = getListener();

		try {
		if (DEBUG) Slog.v(TAG, "onAuthenticated(" + authenticated + ")"
		+ ", ID:" + identifier.getBiometricId()
		+ ", Owner: " + getOwnerString()
		@@ -206,10 +205,6 @@ public abstract class AuthenticationClient<T> extends AcquisitionClient<T>

		mAlreadyDone = true;

		if (listener != null && mShouldVibrate) {
		vibrateSuccess();
		}

		if (mTaskStackListener != null) {
		mActivityTaskManager.unregisterTaskStackListener(mTaskStackListener);
		}
		@@ -225,54 +220,78 @@ public abstract class AuthenticationClient<T> extends AcquisitionClient<T>
		getSensorId(), getTargetUserId(), byteToken);
		}

		if (isBiometricPrompt() && listener != null) {
		// BiometricService will add the token to keystore
		listener.onAuthenticationSucceeded(getSensorId(), identifier, byteToken,
		getTargetUserId(), mIsStrongBiometric);
		} else if (!isBiometricPrompt() && listener != null) {
		if (mIsStrongBiometric) {
		final CoexCoordinator coordinator = CoexCoordinator.getInstance();
		coordinator.onAuthenticationSucceeded(this, new CoexCoordinator.Callback() {
		@Override
		public void sendAuthenticationResult(boolean addAuthTokenIfStrong) {
		if (addAuthTokenIfStrong && mIsStrongBiometric) {
		final int result = KeyStore.getInstance().addAuthToken(byteToken);
		Slog.d(TAG, "addAuthToken: " + result);
		} else {
		Slog.d(TAG, "Skipping addAuthToken");
		}

		// Explicitly have if/else here to make it super obvious in case the code is
		// touched in the future.
		if (listener != null) {
		try {
		// Explicitly have if/else here to make it super obvious in case the
		// code is touched in the future.
		if (!mIsRestricted) {
		listener.onAuthenticationSucceeded(getSensorId(), identifier, byteToken,
		getTargetUserId(), mIsStrongBiometric);
		listener.onAuthenticationSucceeded(getSensorId(),
		identifier,
		byteToken,
		getTargetUserId(),
		mIsStrongBiometric);
		} else {
		listener.onAuthenticationSucceeded(getSensorId(), null /* identifier */,
		byteToken, getTargetUserId(), mIsStrongBiometric);
		listener.onAuthenticationSucceeded(getSensorId(),
		null /* identifier */,
		byteToken,
		getTargetUserId(),
		mIsStrongBiometric);
		}
		} catch (RemoteException e) {
		Slog.e(TAG, "Unable to notify listener", e);
		}

		} else {
		// Client not listening
		Slog.w(TAG, "Client not listening");
		}
		} else {
		if (listener != null && mShouldVibrate) {
		vibrateError();
		}

		@Override
		public void sendHapticFeedback() {
		if (listener != null && mShouldVibrate) {
		vibrateSuccess();
		}
		}
		});
		} else {
		// Allow system-defined limit of number of attempts before giving up
		final @LockoutTracker.LockoutMode int lockoutMode =
		handleFailedAttempt(getTargetUserId());
		if (lockoutMode == LockoutTracker.LOCKOUT_NONE) {
		// Don't send onAuthenticationFailed if we're in lockout, it causes a
		// janky UI on Keyguard/BiometricPrompt since "authentication failed"
		// will show briefly and be replaced by "device locked out" message.
		if (lockoutMode != LockoutTracker.LOCKOUT_NONE) {
		mAlreadyDone = true;
		}

		final CoexCoordinator coordinator = CoexCoordinator.getInstance();
		coordinator.onAuthenticationRejected(this, lockoutMode,
		new CoexCoordinator.Callback() {
		@Override
		public void sendAuthenticationResult(boolean addAuthTokenIfStrong) {
		if (listener != null) {
		try {
		listener.onAuthenticationFailed(getSensorId());
		} catch (RemoteException e) {
		Slog.e(TAG, "Unable to notify listener", e);
		}
		} else {
		mAlreadyDone = true;
		}
		}
		} catch (RemoteException e) {
		Slog.e(TAG, "Unable to notify listener, finishing", e);
		mCallback.onClientFinished(this, false /* success */);

		@Override
		public void sendHapticFeedback() {
		if (listener != null && mShouldVibrate) {
		vibrateError();
		}
		}
		});
		}
		}

services/core/java/com/android/server/biometrics/sensors/CoexCoordinator.java

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.server.biometrics.sensors;

		import android.annotation.NonNull;

		/**
		* Singleton that contains the core logic for determining if haptics and authentication callbacks
		* should be sent to receivers. Note that this class is used even when coex is not required (e.g.
		* single sensor devices, or multi-sensor devices where only a single sensor is authenticating).
		* This allows us to have all business logic in one testable place.
		*/
		public class CoexCoordinator {

		private static final String TAG = "BiometricCoexCoordinator";

		/**
		* Callback interface notifying the owner of "results" from the CoexCoordinator's business
		* logic.
		*/
		interface Callback {
		/**
		* Requests the owner to send the result (success/reject) and any associated info to the
		* receiver (e.g. keyguard, BiometricService, etc).
		*/
		void sendAuthenticationResult(boolean addAuthTokenIfStrong);

		/**
		* Requests the owner to initiate a vibration for this event.
		*/
		void sendHapticFeedback();
		}

		private static CoexCoordinator sInstance;

		private CoexCoordinator() {
		// Singleton
		}

		@NonNull
		static CoexCoordinator getInstance() {
		if (sInstance == null) {
		sInstance = new CoexCoordinator();
		}
		return sInstance;
		}

		public void onAuthenticationSucceeded(@NonNull AuthenticationClient<?> client,
		@NonNull Callback callback) {
		if (client.isBiometricPrompt()) {
		callback.sendHapticFeedback();
		// For BP, BiometricService will add the authToken to Keystore.
		callback.sendAuthenticationResult(false /* addAuthTokenIfStrong */);
		} else {
		// Keyguard, FingerprintManager, FaceManager, etc
		callback.sendHapticFeedback();
		callback.sendAuthenticationResult(true /* addAuthTokenIfStrong */);
		}
		}

		public void onAuthenticationRejected(@NonNull AuthenticationClient<?> client,
		@LockoutTracker.LockoutMode int lockoutMode,
		@NonNull Callback callback) {
		callback.sendHapticFeedback();
		if (lockoutMode == LockoutTracker.LOCKOUT_NONE) {
		// Don't send onAuthenticationFailed if we're in lockout, it causes a
		// janky UI on Keyguard/BiometricPrompt since "authentication failed"
		// will show briefly and be replaced by "device locked out" message.
		callback.sendAuthenticationResult(false /* addAuthTokenIfStrong */);
		}
		}
		}

services/tests/servicestests/src/com/android/server/biometrics/sensors/CoexCoordinatorTest.java

0 → 100644

+79 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.server.biometrics.sensors;

		import static org.mockito.ArgumentMatchers.anyBoolean;
		import static org.mockito.ArgumentMatchers.eq;
		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.platform.test.annotations.Presubmit;

		import androidx.test.filters.SmallTest;

		import org.junit.Before;
		import org.junit.Test;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		@Presubmit
		@SmallTest
		public class CoexCoordinatorTest {

		private CoexCoordinator mCoexCoordinator;

		@Mock
		private CoexCoordinator.Callback mCallback;

		@Before
		public void setUp() {
		MockitoAnnotations.initMocks(this);
		mCoexCoordinator = CoexCoordinator.getInstance();
		}

		@Test
		public void testBiometricPrompt_authSuccess() {
		AuthenticationClient<?> client = mock(AuthenticationClient.class);
		when(client.isBiometricPrompt()).thenReturn(true);

		mCoexCoordinator.onAuthenticationSucceeded(client, mCallback);
		verify(mCallback).sendHapticFeedback();
		verify(mCallback).sendAuthenticationResult(eq(false) /* addAuthTokenIfStrong */);
		}

		@Test
		public void testBiometricPrompt_authReject_whenNotLockedOut() {
		AuthenticationClient<?> client = mock(AuthenticationClient.class);
		when(client.isBiometricPrompt()).thenReturn(true);

		mCoexCoordinator.onAuthenticationRejected(client, LockoutTracker.LOCKOUT_NONE, mCallback);
		verify(mCallback).sendHapticFeedback();
		verify(mCallback).sendAuthenticationResult(eq(false) /* addAuthTokenIfStrong */);
		}

		@Test
		public void testBiometricPrompt_authReject_whenLockedOut() {
		AuthenticationClient<?> client = mock(AuthenticationClient.class);
		when(client.isBiometricPrompt()).thenReturn(true);

		mCoexCoordinator.onAuthenticationRejected(client, LockoutTracker.LOCKOUT_TIMED, mCallback);
		verify(mCallback).sendHapticFeedback();
		verify(mCallback, never()).sendAuthenticationResult(anyBoolean());
		}
		}