Fingerprint virtual HAL checkin (part 3) (52653189) · Commits · e / os / android_hardware_interfaces

biometrics/common/util/include/util/Util.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -40,7 +40,7 @@ namespace aidl::android::hardware::biometrics {
		// by parts of the UI or fail if there is no latency. For example, the
		// Face settings page constantly runs auth and the enrollment UI uses a
		// cancel/restart cycle that requires some latency while the activities change.
		#define DEFAULT_LATENCY 800
		#define DEFAULT_LATENCY 400

		class Util {
		public:

biometrics/fingerprint/aidl/default/Android.bp

+27 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@ cc_binary {
		vintf_fragments: ["fingerprint-example.xml"],
		local_include_dirs: ["include"],
		srcs: [
		"FakeLockoutTracker.cpp",
		"FakeFingerprintEngine.cpp",
		"FakeFingerprintEngineRear.cpp",
		"FakeFingerprintEngineUdfps.cpp",
		@@ -40,6 +41,7 @@ cc_test {
		srcs: [
		"tests/FakeFingerprintEngineTest.cpp",
		"FakeFingerprintEngine.cpp",
		"FakeLockoutTracker.cpp",
		],
		shared_libs: [
		"libbase",
		@@ -65,6 +67,31 @@ cc_test {
		"tests/FakeFingerprintEngineUdfpsTest.cpp",
		"FakeFingerprintEngineUdfps.cpp",
		"FakeFingerprintEngine.cpp",
		"FakeLockoutTracker.cpp",
		],
		shared_libs: [
		"libbase",
		"libbinder_ndk",
		"android.hardware.biometrics.common.thread",
		],
		static_libs: [
		"libandroid.hardware.biometrics.fingerprint.VirtualProps",
		"android.hardware.biometrics.fingerprint-V2-ndk",
		"android.hardware.biometrics.common-V2-ndk",
		"android.hardware.keymaster-V3-ndk",
		"android.hardware.biometrics.common.util",
		],
		vendor: true,
		test_suites: ["general-tests"],
		require_root: true,
		}

		cc_test {
		name: "android.hardware.biometrics.fingerprint.FakeLockoutTrackerTest",
		local_include_dirs: ["include"],
		srcs: [
		"tests/FakeLockoutTrackerTest.cpp",
		"FakeLockoutTracker.cpp",
		],
		shared_libs: [
		"libbase",

biometrics/fingerprint/aidl/default/FakeFingerprintEngine.cpp

+98 −40

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 The Android Open Source Project
		* Copyright (C) 2022 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.
		@@ -15,6 +15,7 @@
		*/

		#include "FakeFingerprintEngine.h"
		#include <regex>
		#include "Fingerprint.h"

		#include <android-base/logging.h>
		@@ -47,7 +48,7 @@ void FakeFingerprintEngine::revokeChallengeImpl(ISessionCallback* cb, int64_t ch
		void FakeFingerprintEngine::enrollImpl(ISessionCallback* cb,
		const keymaster::HardwareAuthToken& hat,
		const std::future<void>& cancel) {
		BEGIN_OP(FingerprintHalProperties::operation_enroll_latency().value_or(DEFAULT_LATENCY));
		BEGIN_OP(getLatency(FingerprintHalProperties::operation_enroll_latency()));

		// Do proper HAT verification in the real implementation.
		if (hat.mac.empty()) {
		@@ -117,7 +118,7 @@ void FakeFingerprintEngine::enrollImpl(ISessionCallback* cb,

		void FakeFingerprintEngine::authenticateImpl(ISessionCallback* cb, int64_t /* operationId */,
		const std::future<void>& cancel) {
		BEGIN_OP(FingerprintHalProperties::operation_authenticate_latency().value_or(DEFAULT_LATENCY));
		BEGIN_OP(getLatency(FingerprintHalProperties::operation_authenticate_latency()));

		int64_t now = Util::getSystemNanoTime();
		int64_t duration = FingerprintHalProperties::operation_authenticate_duration().value_or(10);
		@@ -131,10 +132,23 @@ void FakeFingerprintEngine::authenticateImpl(ISessionCallback* cb, int64_t /* op
		return;
		}

		// got lockout?
		FakeLockoutTracker::LockoutMode lockoutMode = mLockoutTracker.getMode();
		if (lockoutMode == FakeLockoutTracker::LockoutMode::kPermanent) {
		LOG(ERROR) << "Fail: lockout permanent";
		cb->onLockoutPermanent();
		return;
		} else if (lockoutMode == FakeLockoutTracker::LockoutMode::kTimed) {
		int64_t timeLeft = mLockoutTracker.getLockoutTimeLeft();
		LOG(ERROR) << "Fail: lockout timed " << timeLeft;
		cb->onLockoutTimed(timeLeft);
		}

		int i = 0;
		do {
		if (FingerprintHalProperties::operation_authenticate_fails().value_or(false)) {
		LOG(ERROR) << "Fail: operation_authenticate_fails";
		mLockoutTracker.addFailedAttempt();
		cb->onAuthenticationFailed();
		return;
		}
		@@ -174,20 +188,30 @@ void FakeFingerprintEngine::authenticateImpl(ISessionCallback* cb, int64_t /* op
		auto isEnrolled = std::find(enrolls.begin(), enrolls.end(), id) != enrolls.end();
		if (id > 0 && isEnrolled) {
		cb->onAuthenticationSucceeded(id, {} /* hat */);
		mLockoutTracker.reset();
		return;
		} else {
		LOG(ERROR) << "Fail: fingerprint not enrolled";
		cb->onAuthenticationFailed();
		mLockoutTracker.addFailedAttempt();
		}
		}

		void FakeFingerprintEngine::detectInteractionImpl(ISessionCallback* cb,
		const std::future<void>& cancel) {
		BEGIN_OP(FingerprintHalProperties::operation_detect_interaction_latency().value_or(
		DEFAULT_LATENCY));
		BEGIN_OP(getLatency(FingerprintHalProperties::operation_detect_interaction_latency()));

		int64_t duration =
		FingerprintHalProperties::operation_detect_interaction_duration().value_or(10);

		auto detectInteractionSupported =
		FingerprintHalProperties::detect_interaction().value_or(false);
		if (!detectInteractionSupported) {
		LOG(ERROR) << "Detect interaction is not supported";
		cb->onError(Error::UNABLE_TO_PROCESS, 0 /* vendorError */);
		return;
		}

		auto acquired = FingerprintHalProperties::operation_detect_interaction_acquired().value_or("1");
		auto acquiredInfos = parseIntSequence(acquired);
		int N = acquiredInfos.size();
		@@ -308,6 +332,7 @@ void FakeFingerprintEngine::resetLockoutImpl(ISessionCallback* cb,
		}
		FingerprintHalProperties::lockout(false);
		cb->onLockoutCleared();
		mLockoutTracker.reset();
		}

		ndk::ScopedAStatus FakeFingerprintEngine::onPointerDownImpl(int32_t /pointerId/, int32_t /x/,
		@@ -383,49 +408,52 @@ std::vector<int32_t> FakeFingerprintEngine::parseIntSequence(const std::string&
		return res;
		}

		std::vector<std::vector<int32_t>> FakeFingerprintEngine::parseEnrollmentCapture(
		const std::string& str) {
		bool FakeFingerprintEngine::parseEnrollmentCaptureSingle(const std::string& str,
		std::vector<std::vector<int32_t>>& res) {
		std::vector<int32_t> defaultAcquiredInfo = {(int32_t)AcquiredInfo::GOOD};
		std::vector<std::vector<int32_t>> res;
		int i = 0, N = str.length();
		std::size_t found = 0;
		bool aborted = true;

		while (found != std::string::npos) {
		std::string durationStr, acquiredStr;
		found = str.find_first_of("-,", i);
		if (found == std::string::npos) {
		if (N - i < 1) break;
		durationStr = str.substr(i, N - i);
		} else {
		durationStr = str.substr(i, found - i);
		if (str[found] == '-') {
		found = str.find_first_of('[', found + 1);
		if (found == std::string::npos) break;
		i = found + 1;
		found = str.find_first_of(']', found + 1);
		if (found == std::string::npos) break;
		acquiredStr = str.substr(i, found - i);
		found = str.find_first_of(',', found + 1);
		}
		}
		std::vector<int32_t> duration{0};
		if (!ParseInt(durationStr, &duration[0])) break;
		res.push_back(duration);
		if (!acquiredStr.empty()) {
		std::vector<int32_t> acquiredInfo = parseIntSequence(acquiredStr);
		if (acquiredInfo.empty()) break;
		res.push_back(acquiredInfo);
		do {
		std::smatch sms;
		// Parses strings like "1000-[5,1]" or "500"
		std::regex ex("((\\d+)(-\\[([\\d\|,]+)\\])?)");
		if (!regex_match(str.cbegin(), str.cend(), sms, ex)) break;
		int32_t duration;
		if (!ParseInt(sms.str(2), &duration)) break;
		res.push_back({duration});
		if (!sms.str(4).empty()) {
		auto acqv = parseIntSequence(sms.str(4));
		if (acqv.empty()) break;
		res.push_back(acqv);
		} else
		res.push_back(defaultAcquiredInfo);
		aborted = false;
		} while (0);

		i = found + 1;
		if (found == std::string::npos \|\| found == N - 1) aborted = false;
		return !aborted;
		}

		if (aborted) {
		LOG(ERROR) << "Failed to parse enrollment captures:" + str;
		std::vector<std::vector<int32_t>> FakeFingerprintEngine::parseEnrollmentCapture(
		const std::string& str) {
		std::vector<std::vector<int32_t>> res;

		std::string s(str);
		s.erase(std::remove_if(s.begin(), s.end(), ::isspace), s.end());
		bool aborted = false;
		std::smatch sms;
		// Parses strings like "1000-[5,1],500,800-[6,5,1]"
		// ---------- --- -----------
		// into parts: A B C
		while (regex_search(s, sms, std::regex("^(,)?(\\d+(-\\[[\\d\|,]+\\])?)"))) {
		if (!parseEnrollmentCaptureSingle(sms.str(2), res)) {
		aborted = true;
		break;
		}
		s = sms.suffix();
		}
		if (aborted \|\| s.length() != 0) {
		res.clear();
		LOG(ERROR) << "Failed to parse enrollment captures:" + str;
		}

		return res;
		@@ -455,4 +483,34 @@ std::pair<Error, int32_t> FakeFingerprintEngine::convertError(int32_t code) {
		return res;
		}

		int32_t FakeFingerprintEngine::getLatency(
		const std::vector<std::optional<std::int32_t>>& latencyIn) {
		int32_t res = DEFAULT_LATENCY;

		std::vector<int32_t> latency;
		for (auto x : latencyIn)
		if (x.has_value()) latency.push_back(*x);

		switch (latency.size()) {
		case 0:
		break;
		case 1:
		res = latency[0];
		break;
		case 2:
		res = getRandomInRange(latency[0], latency[1]);
		break;
		default:
		LOG(ERROR) << "ERROR: unexpected input of size " << latency.size();
		break;
		}

		return res;
		}

		int32_t FakeFingerprintEngine::getRandomInRange(int32_t bound1, int32_t bound2) {
		std::uniform_int_distribution<int32_t> dist(std::min(bound1, bound2), std::max(bound1, bound2));
		return dist(mRandom);
		}

		} // namespace aidl::android::hardware::biometrics::fingerprint

biometrics/fingerprint/aidl/default/FakeFingerprintEngineUdfps.cpp

+84 −5

Original line number	Diff line number	Diff line
		@@ -23,10 +23,16 @@
		#include "util/CancellationSignal.h"
		#include "util/Util.h"

		#undef LOG_TAG
		#define LOG_TAG "FingerprintVirtualHalUdfps"

		using namespace ::android::fingerprint::virt;

		namespace aidl::android::hardware::biometrics::fingerprint {

		FakeFingerprintEngineUdfps::FakeFingerprintEngineUdfps()
		: FakeFingerprintEngine(), mWorkMode(WorkMode::kIdle), mPointerDownTime(0), mUiReadyTime(0) {}

		SensorLocation FakeFingerprintEngineUdfps::defaultSensorLocation() {
		return {0 /* displayId (not used) /, defaultSensorLocationX / sensorLocationX */,
		defaultSensorLocationY /* sensorLocationY /, defaultSensorRadius / sensorRadius */,
		@@ -37,22 +43,95 @@ ndk::ScopedAStatus FakeFingerprintEngineUdfps::onPointerDownImpl(int32_t /*point
		int32_t /x/, int32_t /y/,
		float /minor/, float /major/) {
		BEGIN_OP(0);

		// TODO(b/230515082): if need to handle display touch events

		// verify whetehr touch coordinates/area matching sensor location ?
		mPointerDownTime = Util::getSystemNanoTime();
		if (FingerprintHalProperties::control_illumination().value_or(false)) {
		fingerDownAction();
		}
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus FakeFingerprintEngineUdfps::onPointerUpImpl(int32_t /pointerId/) {
		BEGIN_OP(0);
		// TODO(b/230515082)
		mUiReadyTime = 0;
		mPointerDownTime = 0;
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus FakeFingerprintEngineUdfps::onUiReadyImpl() {
		BEGIN_OP(0);
		// TODO(b/230515082)

		if (Util::hasElapsed(mPointerDownTime, uiReadyTimeoutInMs * 100)) {
		LOG(ERROR) << "onUiReady() arrives too late after onPointerDown()";
		} else {
		fingerDownAction();
		}
		return ndk::ScopedAStatus::ok();
		}

		void FakeFingerprintEngineUdfps::fingerDownAction() {
		switch (mWorkMode) {
		case WorkMode::kAuthenticate:
		onAuthenticateFingerDown();
		break;
		case WorkMode::kEnroll:
		onEnrollFingerDown();
		break;
		case WorkMode::kDetectInteract:
		onDetectInteractFingerDown();
		break;
		default:
		LOG(WARNING) << "unexpected call: onUiReady()";
		break;
		}

		mUiReadyTime = 0;
		mPointerDownTime = 0;
		}

		void FakeFingerprintEngineUdfps::onAuthenticateFingerDown() {
		FakeFingerprintEngine::authenticateImpl(mCb, mOperationId, mCancelVec[0]);
		}

		void FakeFingerprintEngineUdfps::onEnrollFingerDown() {
		// Any use case to emulate display touch for each capture during enrollment?
		FakeFingerprintEngine::enrollImpl(mCb, mHat, mCancelVec[0]);
		}

		void FakeFingerprintEngineUdfps::onDetectInteractFingerDown() {
		FakeFingerprintEngine::detectInteractionImpl(mCb, mCancelVec[0]);
		}

		void FakeFingerprintEngineUdfps::enrollImpl(ISessionCallback* cb,
		const keymaster::HardwareAuthToken& hat,
		const std::future<void>& cancel) {
		updateContext(WorkMode::kEnroll, cb, const_cast<std::future<void>&>(cancel), 0, hat);
		}

		void FakeFingerprintEngineUdfps::authenticateImpl(ISessionCallback* cb, int64_t operationId,
		const std::future<void>& cancel) {
		updateContext(WorkMode::kAuthenticate, cb, const_cast<std::future<void>&>(cancel), operationId,
		keymaster::HardwareAuthToken());
		}

		void FakeFingerprintEngineUdfps::detectInteractionImpl(ISessionCallback* cb,
		const std::future<void>& cancel) {
		updateContext(WorkMode::kDetectInteract, cb, const_cast<std::future<void>&>(cancel), 0,
		keymaster::HardwareAuthToken());
		}

		void FakeFingerprintEngineUdfps::updateContext(WorkMode mode, ISessionCallback* cb,
		std::future<void>& cancel, int64_t operationId,
		const keymaster::HardwareAuthToken& hat) {
		mPointerDownTime = 0;
		mUiReadyTime = 0;
		mCancelVec.clear();

		mCancelVec.push_back(std::move(cancel));
		mWorkMode = mode;
		mCb = cb;
		mOperationId = operationId;
		mHat = hat;
		}

		} // namespace aidl::android::hardware::biometrics::fingerprint

biometrics/fingerprint/aidl/default/FakeLockoutTracker.cpp

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#include "FakeLockoutTracker.h"
		#include <fingerprint.sysprop.h>
		#include "util/Util.h"

		using namespace ::android::fingerprint::virt;

		namespace aidl::android::hardware::biometrics::fingerprint {

		void FakeLockoutTracker::reset() {
		mFailedCount = 0;
		mLockoutTimedStart = 0;
		mCurrentMode = LockoutMode::kNone;
		}

		void FakeLockoutTracker::addFailedAttempt() {
		bool enabled = FingerprintHalProperties::lockout_enable().value_or(false);
		if (enabled) {
		mFailedCount++;
		int32_t lockoutTimedThreshold =
		FingerprintHalProperties::lockout_timed_threshold().value_or(5);
		int32_t lockoutPermanetThreshold =
		FingerprintHalProperties::lockout_permanent_threshold().value_or(20);
		if (mFailedCount >= lockoutPermanetThreshold) {
		mCurrentMode = LockoutMode::kPermanent;
		FingerprintHalProperties::lockout(true);
		} else if (mFailedCount >= lockoutTimedThreshold) {
		if (mCurrentMode == LockoutMode::kNone) {
		mCurrentMode = LockoutMode::kTimed;
		mLockoutTimedStart = Util::getSystemNanoTime();
		}
		}
		} else {
		reset();
		}
		}

		FakeLockoutTracker::LockoutMode FakeLockoutTracker::getMode() {
		if (mCurrentMode == LockoutMode::kTimed) {
		int32_t lockoutTimedDuration =
		FingerprintHalProperties::lockout_timed_duration().value_or(10 * 100);
		if (Util::hasElapsed(mLockoutTimedStart, lockoutTimedDuration)) {
		mCurrentMode = LockoutMode::kNone;
		mLockoutTimedStart = 0;
		}
		}

		return mCurrentMode;
		}

		int64_t FakeLockoutTracker::getLockoutTimeLeft() {
		int64_t res = 0;

		if (mLockoutTimedStart > 0) {
		auto now = Util::getSystemNanoTime();
		auto left = now - mLockoutTimedStart;
		res = (left > 0) ? (left / 1000000LL) : 0;
		}

		return res;
		}
		} // namespace aidl::android::hardware::biometrics::fingerprint