Merge changes from topic "biometric-fingerprint" (940384bf) · Commits · e / os / android_frameworks_base

api/current.txt

+46 −6

Original line number	Diff line number	Diff line
		@@ -16489,8 +16489,37 @@ package android.hardware.display {
		package android.hardware.fingerprint {

		public class FingerprintDialog {
		method public void authenticate(android.hardware.fingerprint.FingerprintManager.CryptoObject, android.os.CancellationSignal, java.util.concurrent.Executor, android.hardware.fingerprint.FingerprintManager.AuthenticationCallback);
		method public void authenticate(android.os.CancellationSignal, java.util.concurrent.Executor, android.hardware.fingerprint.FingerprintManager.AuthenticationCallback);
		method public void authenticate(android.hardware.fingerprint.FingerprintDialog.CryptoObject, android.os.CancellationSignal, java.util.concurrent.Executor, android.hardware.fingerprint.FingerprintDialog.AuthenticationCallback);
		method public void authenticate(android.os.CancellationSignal, java.util.concurrent.Executor, android.hardware.fingerprint.FingerprintDialog.AuthenticationCallback);
		field public static final int FINGERPRINT_ACQUIRED_GOOD = 0; // 0x0
		field public static final int FINGERPRINT_ACQUIRED_IMAGER_DIRTY = 3; // 0x3
		field public static final int FINGERPRINT_ACQUIRED_INSUFFICIENT = 2; // 0x2
		field public static final int FINGERPRINT_ACQUIRED_PARTIAL = 1; // 0x1
		field public static final int FINGERPRINT_ACQUIRED_TOO_FAST = 5; // 0x5
		field public static final int FINGERPRINT_ACQUIRED_TOO_SLOW = 4; // 0x4
		field public static final int FINGERPRINT_ERROR_CANCELED = 5; // 0x5
		field public static final int FINGERPRINT_ERROR_HW_NOT_PRESENT = 12; // 0xc
		field public static final int FINGERPRINT_ERROR_HW_UNAVAILABLE = 1; // 0x1
		field public static final int FINGERPRINT_ERROR_LOCKOUT = 7; // 0x7
		field public static final int FINGERPRINT_ERROR_LOCKOUT_PERMANENT = 9; // 0x9
		field public static final int FINGERPRINT_ERROR_NO_FINGERPRINTS = 11; // 0xb
		field public static final int FINGERPRINT_ERROR_NO_SPACE = 4; // 0x4
		field public static final int FINGERPRINT_ERROR_TIMEOUT = 3; // 0x3
		field public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2; // 0x2
		field public static final int FINGERPRINT_ERROR_USER_CANCELED = 10; // 0xa
		field public static final int FINGERPRINT_ERROR_VENDOR = 8; // 0x8
		}

		public static abstract class FingerprintDialog.AuthenticationCallback {
		ctor public FingerprintDialog.AuthenticationCallback();
		method public void onAuthenticationError(int, java.lang.CharSequence);
		method public void onAuthenticationFailed();
		method public void onAuthenticationHelp(int, java.lang.CharSequence);
		method public void onAuthenticationSucceeded(android.hardware.fingerprint.FingerprintDialog.AuthenticationResult);
		}

		public static class FingerprintDialog.AuthenticationResult {
		method public android.hardware.fingerprint.FingerprintDialog.CryptoObject getCryptoObject();
		}

		public static class FingerprintDialog.Builder {
		@@ -16502,10 +16531,19 @@ package android.hardware.fingerprint {
		method public android.hardware.fingerprint.FingerprintDialog.Builder setTitle(java.lang.CharSequence);
		}

		public class FingerprintManager {
		method public void authenticate(android.hardware.fingerprint.FingerprintManager.CryptoObject, android.os.CancellationSignal, int, android.hardware.fingerprint.FingerprintManager.AuthenticationCallback, android.os.Handler);
		method public boolean hasEnrolledFingerprints();
		method public boolean isHardwareDetected();
		public static final class FingerprintDialog.CryptoObject {
		ctor public FingerprintDialog.CryptoObject(java.security.Signature);
		ctor public FingerprintDialog.CryptoObject(javax.crypto.Cipher);
		ctor public FingerprintDialog.CryptoObject(javax.crypto.Mac);
		method public javax.crypto.Cipher getCipher();
		method public javax.crypto.Mac getMac();
		method public java.security.Signature getSignature();
		}

		public deprecated class FingerprintManager {
		method public deprecated void authenticate(android.hardware.fingerprint.FingerprintManager.CryptoObject, android.os.CancellationSignal, int, android.hardware.fingerprint.FingerprintManager.AuthenticationCallback, android.os.Handler);
		method public deprecated boolean hasEnrolledFingerprints();
		method public deprecated boolean isHardwareDetected();
		field public static final int FINGERPRINT_ACQUIRED_GOOD = 0; // 0x0
		field public static final int FINGERPRINT_ACQUIRED_IMAGER_DIRTY = 3; // 0x3
		field public static final int FINGERPRINT_ACQUIRED_INSUFFICIENT = 2; // 0x2
		@@ -16513,9 +16551,11 @@ package android.hardware.fingerprint {
		field public static final int FINGERPRINT_ACQUIRED_TOO_FAST = 5; // 0x5
		field public static final int FINGERPRINT_ACQUIRED_TOO_SLOW = 4; // 0x4
		field public static final int FINGERPRINT_ERROR_CANCELED = 5; // 0x5
		field public static final int FINGERPRINT_ERROR_HW_NOT_PRESENT = 12; // 0xc
		field public static final int FINGERPRINT_ERROR_HW_UNAVAILABLE = 1; // 0x1
		field public static final int FINGERPRINT_ERROR_LOCKOUT = 7; // 0x7
		field public static final int FINGERPRINT_ERROR_LOCKOUT_PERMANENT = 9; // 0x9
		field public static final int FINGERPRINT_ERROR_NO_FINGERPRINTS = 11; // 0xb
		field public static final int FINGERPRINT_ERROR_NO_SPACE = 4; // 0x4
		field public static final int FINGERPRINT_ERROR_TIMEOUT = 3; // 0x3
		field public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2; // 0x2

core/java/android/hardware/biometrics/BiometricAuthenticator.java

0 → 100644

+184 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 android.hardware.biometrics;

		import android.annotation.CallbackExecutor;
		import android.annotation.NonNull;
		import android.os.CancellationSignal;
		import android.os.Parcelable;

		import java.util.concurrent.Executor;

		/**
		* This is the common interface that all biometric authentication classes should implement.
		* @hide
		*/
		public interface BiometricAuthenticator {

		/**
		* Container for biometric data
		* @hide
		*/
		abstract class BiometricIdentifier implements Parcelable {}

		/**
		* Container for callback data from {@link BiometricAuthenticator#authenticate(
		* CancellationSignal, Executor, AuthenticationCallback)} and
		* {@link BiometricAuthenticator#authenticate(CryptoObject, CancellationSignal, Executor,
		* AuthenticationCallback)}
		*/
		class AuthenticationResult {
		private BiometricIdentifier mIdentifier;
		private CryptoObject mCryptoObject;
		private int mUserId;

		/**
		* @hide
		*/
		public AuthenticationResult() { }

		/**
		* Authentication result
		* @param crypto
		* @param identifier
		* @param userId
		* @hide
		*/
		public AuthenticationResult(CryptoObject crypto, BiometricIdentifier identifier,
		int userId) {
		mCryptoObject = crypto;
		mIdentifier = identifier;
		mUserId = userId;
		}

		/**
		* Obtain the crypto object associated with this transaction
		* @return crypto object provided to {@link BiometricAuthenticator#authenticate(
		* CryptoObject, CancellationSignal, Executor, AuthenticationCallback)}
		*/
		public CryptoObject getCryptoObject() {
		return mCryptoObject;
		}

		/**
		* Obtain the biometric identifier associated with this operation. Applications are strongly
		* discouraged from associating specific identifiers with specific applications or
		* operations.
		* @hide
		*/
		public BiometricIdentifier getId() {
		return mIdentifier;
		}

		/**
		* Obtain the userId for which this biometric was authenticated.
		* @hide
		*/
		public int getUserId() {
		return mUserId;
		}
		};

		/**
		* Callback structure provided to {@link BiometricAuthenticator#authenticate(CancellationSignal,
		* Executor, AuthenticationCallback)} or {@link BiometricAuthenticator#authenticate(
		* CryptoObject, CancellationSignal, Executor, AuthenticationCallback)}. Users must provide
		* an implementation of this for listening to biometric events.
		*/
		abstract class AuthenticationCallback {
		/**
		* Called when an unrecoverable error has been encountered and the operation is complete.
		* No further actions will be made on this object.
		* @param errorCode An integer identifying the error message
		* @param errString A human-readable error string that can be shown on an UI
		*/
		public void onAuthenticationError(int errorCode, CharSequence errString) {}

		/**
		* Called when a recoverable error has been encountered during authentication. The help
		* string is provided to give the user guidance for what went wrong, such as "Sensor dirty,
		* please clean it."
		* @param helpCode An integer identifying the error message
		* @param helpString A human-readable string that can be shown on an UI
		*/
		public void onAuthenticationHelp(int helpCode, CharSequence helpString) {}

		/**
		* Called when a biometric is recognized.
		* @param result An object containing authentication-related data
		*/
		public void onAuthenticationSucceeded(AuthenticationResult result) {}

		/**
		* Called when a biometric is valid but not recognized.
		*/
		public void onAuthenticationFailed() {}

		/**
		* Called when a biometric has been acquired, but hasn't been processed yet.
		* @hide
		*/
		public void onAuthenticationAcquired(int acquireInfo) {}
		};

		/**
		* This call warms up the hardware and starts scanning for valid biometrics. It terminates
		* when {@link AuthenticationCallback#onAuthenticationError(int,
		* CharSequence)} is called or when {@link AuthenticationCallback#onAuthenticationSucceeded(
		* AuthenticationResult)} is called, at which point the crypto object becomes invalid. This
		* operation can be canceled by using the provided cancel object. The application wil receive
		* authentication errors through {@link AuthenticationCallback}. Calling
		* {@link BiometricAuthenticator#authenticate(CryptoObject, CancellationSignal, Executor,
		* AuthenticationCallback)} while an existing authentication attempt is occurring will stop
		* the previous client and start a new authentication. The interrupted client will receive a
		* cancelled notification through {@link AuthenticationCallback#onAuthenticationError(int,
		* CharSequence)}.
		*
		* @throws IllegalArgumentException If any of the arguments are null
		*
		* @param crypto Object associated with the call
		* @param cancel An object that can be used to cancel authentication
		* @param executor An executor to handle callback events
		* @param callback An object to receive authentication events
		*/
		void authenticate(@NonNull CryptoObject crypto,
		@NonNull CancellationSignal cancel,
		@NonNull @CallbackExecutor Executor executor,
		@NonNull AuthenticationCallback callback);

		/**
		* This call warms up the hardware and starts scanning for valid biometrics. It terminates
		* when {@link AuthenticationCallback#onAuthenticationError(int,
		* CharSequence)} is called or when {@link AuthenticationCallback#onAuthenticationSucceeded(
		* AuthenticationResult)} is called. This operation can be canceled by using the provided cancel
		* object. The application wil receive authentication errors through
		* {@link AuthenticationCallback}. Calling {@link BiometricAuthenticator#authenticate(
		* CryptoObject, CancellationSignal, Executor, AuthenticationCallback)} while an existing
		* authentication attempt is occurring will stop the previous client and start a new
		* authentication. The interrupted client will receive a cancelled notification through
		* {@link AuthenticationCallback#onAuthenticationError(int, CharSequence)}.
		*
		* @throws IllegalArgumentException If any of the arguments are null
		*
		* @param cancel An object that can be used to cancel authentication
		* @param executor An executor to handle callback events
		* @param callback An object to receive authentication events
		*/
		void authenticate(@NonNull CancellationSignal cancel,
		@NonNull @CallbackExecutor Executor executor,
		@NonNull AuthenticationCallback callback);
		}

core/java/android/hardware/biometrics/BiometricFingerprintConstants.java

0 → 100644

+168 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 android.hardware.biometrics;

		import android.hardware.fingerprint.FingerprintManager;

		/**
		* Interface containing all of the fingerprint-specific constants.
		* @hide
		*/
		public interface BiometricFingerprintConstants {
		//
		// Error messages from fingerprint hardware during initilization, enrollment, authentication or
		// removal. Must agree with the list in fingerprint.h
		//

		/**
		* The hardware is unavailable. Try again later.
		*/
		public static final int FINGERPRINT_ERROR_HW_UNAVAILABLE = 1;

		/**
		* Error state returned when the sensor was unable to process the current image.
		*/
		public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2;

		/**
		* Error state returned when the current request has been running too long. This is intended to
		* prevent programs from waiting for the fingerprint sensor indefinitely. The timeout is
		* platform and sensor-specific, but is generally on the order of 30 seconds.
		*/
		public static final int FINGERPRINT_ERROR_TIMEOUT = 3;

		/**
		* Error state returned for operations like enrollment; the operation cannot be completed
		* because there's not enough storage remaining to complete the operation.
		*/
		public static final int FINGERPRINT_ERROR_NO_SPACE = 4;

		/**
		* The operation was canceled because the fingerprint sensor is unavailable. For example,
		* this may happen when the user is switched, the device is locked or another pending operation
		* prevents or disables it.
		*/
		public static final int FINGERPRINT_ERROR_CANCELED = 5;

		/**
		* The {@link FingerprintManager#remove} call failed. Typically this will happen when the
		* provided fingerprint id was incorrect.
		*
		* @hide
		*/
		public static final int FINGERPRINT_ERROR_UNABLE_TO_REMOVE = 6;

		/**
		* The operation was canceled because the API is locked out due to too many attempts.
		* This occurs after 5 failed attempts, and lasts for 30 seconds.
		*/
		public static final int FINGERPRINT_ERROR_LOCKOUT = 7;

		/**
		* Hardware vendors may extend this list if there are conditions that do not fall under one of
		* the above categories. Vendors are responsible for providing error strings for these errors.
		* These messages are typically reserved for internal operations such as enrollment, but may be
		* used to express vendor errors not covered by the ones in fingerprint.h. Applications are
		* expected to show the error message string if they happen, but are advised not to rely on the
		* message id since they will be device and vendor-specific
		*/
		public static final int FINGERPRINT_ERROR_VENDOR = 8;

		/**
		* The operation was canceled because FINGERPRINT_ERROR_LOCKOUT occurred too many times.
		* Fingerprint authentication is disabled until the user unlocks with strong authentication
		* (PIN/Pattern/Password)
		*/
		public static final int FINGERPRINT_ERROR_LOCKOUT_PERMANENT = 9;

		/**
		* The user canceled the operation. Upon receiving this, applications should use alternate
		* authentication (e.g. a password). The application should also provide the means to return
		* to fingerprint authentication, such as a "use fingerprint" button.
		*/
		public static final int FINGERPRINT_ERROR_USER_CANCELED = 10;

		/**
		* The user does not have any fingerprints enrolled.
		*/
		public static final int FINGERPRINT_ERROR_NO_FINGERPRINTS = 11;

		/**
		* The device does not have a fingerprint sensor.
		*/
		public static final int FINGERPRINT_ERROR_HW_NOT_PRESENT = 12;

		/**
		* @hide
		*/
		public static final int FINGERPRINT_ERROR_VENDOR_BASE = 1000;

		//
		// Image acquisition messages. Must agree with those in fingerprint.h
		//

		/**
		* The image acquired was good.
		*/
		public static final int FINGERPRINT_ACQUIRED_GOOD = 0;

		/**
		* Only a partial fingerprint image was detected. During enrollment, the user should be
		* informed on what needs to happen to resolve this problem, e.g. "press firmly on sensor."
		*/
		public static final int FINGERPRINT_ACQUIRED_PARTIAL = 1;

		/**
		* The fingerprint image was too noisy to process due to a detected condition (i.e. dry skin) or
		* a possibly dirty sensor (See {@link #FINGERPRINT_ACQUIRED_IMAGER_DIRTY}).
		*/
		public static final int FINGERPRINT_ACQUIRED_INSUFFICIENT = 2;

		/**
		* The fingerprint image was too noisy due to suspected or detected dirt on the sensor.
		* For example, it's reasonable return this after multiple
		* {@link #FINGERPRINT_ACQUIRED_INSUFFICIENT} or actual detection of dirt on the sensor
		* (stuck pixels, swaths, etc.). The user is expected to take action to clean the sensor
		* when this is returned.
		*/
		public static final int FINGERPRINT_ACQUIRED_IMAGER_DIRTY = 3;

		/**
		* The fingerprint image was unreadable due to lack of motion. This is most appropriate for
		* linear array sensors that require a swipe motion.
		*/
		public static final int FINGERPRINT_ACQUIRED_TOO_SLOW = 4;

		/**
		* The fingerprint image was incomplete due to quick motion. While mostly appropriate for
		* linear array sensors, this could also happen if the finger was moved during acquisition.
		* The user should be asked to move the finger slower (linear) or leave the finger on the sensor
		* longer.
		*/
		public static final int FINGERPRINT_ACQUIRED_TOO_FAST = 5;

		/**
		* Hardware vendors may extend this list if there are conditions that do not fall under one of
		* the above categories. Vendors are responsible for providing error strings for these errors.
		* @hide
		*/
		public static final int FINGERPRINT_ACQUIRED_VENDOR = 6;
		/**
		* @hide
		*/
		public static final int FINGERPRINT_ACQUIRED_VENDOR_BASE = 1000;
		}

core/java/android/hardware/biometrics/CryptoObject.java

0 → 100644

+79 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 android.hardware.biometrics;

		import android.annotation.NonNull;
		import android.security.keystore.AndroidKeyStoreProvider;

		import java.security.Signature;

		import javax.crypto.Cipher;
		import javax.crypto.Mac;

		/**
		* A wrapper class for the crypto objects supported by FingerprintManager. Currently the
		* framework supports {@link Signature}, {@link Cipher} and {@link Mac} objects.
		* @hide
		*/
		public class CryptoObject {
		private final Object mCrypto;

		public CryptoObject(@NonNull Signature signature) {
		mCrypto = signature;
		}

		public CryptoObject(@NonNull Cipher cipher) {
		mCrypto = cipher;
		}

		public CryptoObject(@NonNull Mac mac) {
		mCrypto = mac;
		}

		/**
		* Get {@link Signature} object.
		* @return {@link Signature} object or null if this doesn't contain one.
		*/
		public Signature getSignature() {
		return mCrypto instanceof Signature ? (Signature) mCrypto : null;
		}

		/**
		* Get {@link Cipher} object.
		* @return {@link Cipher} object or null if this doesn't contain one.
		*/
		public Cipher getCipher() {
		return mCrypto instanceof Cipher ? (Cipher) mCrypto : null;
		}

		/**
		* Get {@link Mac} object.
		* @return {@link Mac} object or null if this doesn't contain one.
		*/
		public Mac getMac() {
		return mCrypto instanceof Mac ? (Mac) mCrypto : null;
		}

		/**
		* @hide
		* @return the opId associated with this object or 0 if none
		*/
		public final long getOpId() {
		return mCrypto != null
		? AndroidKeyStoreProvider.getKeyStoreOperationHandle(mCrypto) : 0;
		}
		};

core/java/android/hardware/fingerprint/Fingerprint.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@
		*/
		package android.hardware.fingerprint;

		import android.hardware.biometrics.BiometricAuthenticator;
		import android.os.Parcel;
		import android.os.Parcelable;

		@@ -22,7 +23,7 @@ import android.os.Parcelable;
		* Container for fingerprint metadata.
		* @hide
		*/
		public final class Fingerprint implements Parcelable {
		public final class Fingerprint extends BiometricAuthenticator.BiometricIdentifier {
		private CharSequence mName;
		private int mGroupId;
		private int mFingerId;