From 965bd32a70f17836796124dd7e3dc8c44a1449c5 Mon Sep 17 00:00:00 2001 From: Sasha Levitskiy Date: Fri, 21 Oct 2016 10:55:25 -0700 Subject: [PATCH] Fingerprint: HIDL: add default HAL 2.1 implementation Test: Manual fingerprint functionality verification. Bug: 31973669 Change-Id: Ib8bcf602ba0c8884b13d31eb23baa88a912ace20 Signed-off-by: Sasha Levitskiy --- .../2.1/IBiometricsFingerprint.hal | 17 +- biometrics/fingerprint/2.1/default/Android.mk | 17 ++ .../2.1/default/BiometricsFingerprint.cpp | 153 ++++++++++++++++++ .../2.1/default/BiometricsFingerprint.h | 79 +++++++++ ...ware.biometrics.fingerprint@2.1-service.rc | 4 + .../fingerprint/2.1/default/service.cpp | 28 ++++ 6 files changed, 297 insertions(+), 1 deletion(-) create mode 100644 biometrics/fingerprint/2.1/default/Android.mk create mode 100644 biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp create mode 100644 biometrics/fingerprint/2.1/default/BiometricsFingerprint.h create mode 100644 biometrics/fingerprint/2.1/default/android.hardware.biometrics.fingerprint@2.1-service.rc create mode 100644 biometrics/fingerprint/2.1/default/service.cpp diff --git a/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal b/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal index 7494c5888e..b7f8d8837d 100644 --- a/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal +++ b/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal @@ -16,7 +16,23 @@ package android.hardware.biometrics.fingerprint@2.1; +import IBiometricsFingerprintClientCallback; + interface IBiometricsFingerprint { + /* + * Set notification callback: + * Registers a user function that must receive notifications from the HAL + * This call must block if the HAL state machine is in busy state until HAL + * leaves the busy state. + * + * @return isOk indicates if the request is accepted. + * @return debugErrno is a value the framework logs in case isOk == false. + */ + @callflow(next={"setActiveGroup"}) + @entry + setNotify(IBiometricsFingerprintClientCallback clientCallback) + generates (bool isOk, int32_t debugErrno); + /* * Fingerprint pre-enroll enroll request: * Generates a unique token to upper layers to indicate the start of @@ -138,7 +154,6 @@ interface IBiometricsFingerprint { * @return debugErrno is a value the framework logs in case isOk == false. */ @callflow(next={"authenticate", "preEnroll", "enumerate", "remove"}) - @entry setActiveGroup(uint32_t gid, string storePath) generates (bool isOk, int32_t debugErrno); diff --git a/biometrics/fingerprint/2.1/default/Android.mk b/biometrics/fingerprint/2.1/default/Android.mk new file mode 100644 index 0000000000..be8bae61eb --- /dev/null +++ b/biometrics/fingerprint/2.1/default/Android.mk @@ -0,0 +1,17 @@ +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := android.hardware.biometrics.fingerprint@2.1-impl +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := \ + BiometricsFingerprint.cpp \ + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libhidl \ + libhardware \ + libhwbinder \ + libutils \ + android.hardware.biometrics.fingerprint@2.1 \ + +include $(BUILD_SHARED_LIBRARY) diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp new file mode 100644 index 0000000000..3ee7836ee1 --- /dev/null +++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2016 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 +#include +#include "BiometricsFingerprint.h" + +namespace android { +namespace hardware { +namespace biometrics { +namespace fingerprint { +namespace V2_1 { +namespace implementation { + +sp + BiometricsFingerprint::mClientCallback = nullptr; + +BiometricsFingerprint::BiometricsFingerprint(fingerprint_device_t *device) + : mDevice(device) {} + +BiometricsFingerprint::~BiometricsFingerprint() { + ALOG(LOG_VERBOSE, LOG_TAG, "nativeCloseHal()\n"); + if (mDevice == NULL) { + ALOGE("No valid device"); + return; + } + int err; + if (0 != (err = mDevice->common.close( + reinterpret_cast(mDevice)))) { + ALOGE("Can't close fingerprint module, error: %d", err); + return; + } + mDevice = NULL; +} + +Return BiometricsFingerprint::setNotify( + const sp& clientCallback, + setNotify_cb cb) { + mClientCallback = clientCallback; + int32_t debugErrno = mDevice->set_notify(mDevice, notify); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::preEnroll() { + return mDevice->pre_enroll(mDevice); +} + +Return BiometricsFingerprint::enroll(const HwAuthToken& hat, uint32_t gid, + uint32_t timeoutSec, enroll_cb cb) { + const hw_auth_token_t* authToken = + reinterpret_cast(&hat); + int32_t debugErrno = mDevice->enroll(mDevice, authToken, gid, timeoutSec); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::postEnroll(postEnroll_cb cb) { + int32_t debugErrno = mDevice->post_enroll(mDevice); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::getAuthenticatorId() { + return mDevice->get_authenticator_id(mDevice); +} + +Return BiometricsFingerprint::cancel(cancel_cb cb) { + int32_t debugErrno = mDevice->cancel(mDevice); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::enumerate(enumerate_cb cb) { + int32_t debugErrno = mDevice->enumerate(mDevice); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::remove(uint32_t gid, uint32_t fid, + remove_cb cb) { + int32_t debugErrno = mDevice->remove(mDevice, gid, fid); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::setActiveGroup(uint32_t gid, + const hidl_string& storePath, setActiveGroup_cb cb) { + if (storePath.size() >= PATH_MAX || storePath.size() <= 0) { + ALOGE("Bad path length: %zd", storePath.size()); + } + int32_t debugErrno = mDevice->set_active_group(mDevice, gid, + storePath.c_str()); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +Return BiometricsFingerprint::authenticate(uint64_t operationId, + uint32_t gid, authenticate_cb cb) { + int32_t debugErrno = mDevice->authenticate(mDevice, operationId, gid); + cb(debugErrno == 0, debugErrno); + return Void(); +} + +IBiometricsFingerprint* HIDL_FETCH_IBiometricsFingerprint(const char*) { + int err; + const hw_module_t *hw_mdl = NULL; + if (0 != (err = hw_get_module(FINGERPRINT_HARDWARE_MODULE_ID, &hw_mdl))) { + ALOGE("Can't open fingerprint HW Module, error: %d", err); + return nullptr; + } + if (hw_mdl == NULL) { + ALOGE("No valid fingerprint module"); + return nullptr; + } + + fingerprint_module_t const *module = + reinterpret_cast(hw_mdl); + if (module->common.methods->open == NULL) { + ALOGE("No valid open method"); + return nullptr; + } + + hw_device_t *device = NULL; + + if (0 != (err = module->common.methods->open(hw_mdl, NULL, &device))) { + ALOGE("Can't open fingerprint methods, error: %d", err); + return nullptr; + } + + return new BiometricsFingerprint( + reinterpret_cast(device)); +} + +} // namespace implementation +} // namespace V2_1 +} // namespace fingerprint +} // namespace biometrics +} // namespace hardware +} // namespace android diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h new file mode 100644 index 0000000000..4fdc328285 --- /dev/null +++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2016 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. + */ + +#ifndef HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_ +#define HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_ + +#include +#include +#include + +#include +namespace android { +namespace hardware { +namespace biometrics { +namespace fingerprint { +namespace V2_1 { +namespace implementation { + +using ::android::hardware::biometrics::fingerprint::V2_1::HwAuthToken; +using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint; +using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct BiometricsFingerprint : public IBiometricsFingerprint { +public: + BiometricsFingerprint(fingerprint_device_t *device); + ~BiometricsFingerprint(); + // Methods from ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint follow. + Return setNotify(const sp& clientCallback, setNotify_cb _hidl_cb) override; + Return preEnroll() override; + Return enroll(const HwAuthToken& hat, uint32_t gid, uint32_t timeoutSec, enroll_cb _hidl_cb) override; + Return postEnroll(postEnroll_cb _hidl_cb) override; + Return getAuthenticatorId() override; + Return cancel(cancel_cb _hidl_cb) override; + Return enumerate(enumerate_cb _hidl_cb) override; + Return remove(uint32_t gid, uint32_t fid, remove_cb _hidl_cb) override; + Return setActiveGroup(uint32_t gid, const hidl_string& storePath, setActiveGroup_cb _hidl_cb) override; + Return authenticate(uint64_t operationId, uint32_t gid, authenticate_cb _hidl_cb) override; + static void notify(const fingerprint_msg_t *notify_msg) { + if (mClientCallback == nullptr) { + ALOGE("Receiving callbacks before the client callback is registered."); + return; + } + FingerprintMsg msg = {}; + memcpy(&msg, notify_msg, sizeof(msg)); + mClientCallback->notify(msg); + } +private: + static sp mClientCallback; + fingerprint_device_t *mDevice; +}; + +extern "C" IBiometricsFingerprint* HIDL_FETCH_IBiometricsFingerprint(const char* name); + +} // namespace implementation +} // namespace V2_1 +} // namespace fingerprint +} // namespace biometrics +} // namespace hardware +} // namespace android + +#endif // HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_ diff --git a/biometrics/fingerprint/2.1/default/android.hardware.biometrics.fingerprint@2.1-service.rc b/biometrics/fingerprint/2.1/default/android.hardware.biometrics.fingerprint@2.1-service.rc new file mode 100644 index 0000000000..741024dd48 --- /dev/null +++ b/biometrics/fingerprint/2.1/default/android.hardware.biometrics.fingerprint@2.1-service.rc @@ -0,0 +1,4 @@ +service fingerprint@2.1 /system/bin/hw/android.hardware.biometrics.fingerprint@2.1-service + class hal + user system + group system \ No newline at end of file diff --git a/biometrics/fingerprint/2.1/default/service.cpp b/biometrics/fingerprint/2.1/default/service.cpp new file mode 100644 index 0000000000..98670398c3 --- /dev/null +++ b/biometrics/fingerprint/2.1/default/service.cpp @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2016 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. + */ + +#define LOG_TAG "android.hardware.biometrics.fingerprint@2.1-service" + +#include + +#include + +using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint; +using android::hardware::defaultPassthroughServiceImplementation; + +int main() { + return defaultPassthroughServiceImplementation("fingerprint"); +}