rtwo: wrap 2.1 fingerprint service with 2.3 source built

Android.bp

@@ -1,2 +1,3 @@
 soong_namespace {
+    imports: ["device/motorola/sm8550-common"],
 }

device.mk

@@ -59,6 +59,10 @@ PRODUCT_COPY_FILES += \
     $(LOCAL_PATH)/audio/usecaseKvManager_prc.xml:$(TARGET_COPY_OUT_VENDOR)/etc/usecaseKvManager_prc.xml \
     $(LOCAL_PATH)/audio/usecaseKvManager_tmo.xml:$(TARGET_COPY_OUT_VENDOR)/etc/usecaseKvManager_tmo.xml
 
+# Fingerprint
+PRODUCT_PACKAGES += \
+    android.hardware.biometrics.fingerprint@2.3-service.rtwo
+
 # Init
 $(foreach f,$(wildcard $(LOCAL_PATH)/rootdir/etc/init/hw/*.rc),\
         $(eval PRODUCT_COPY_FILES += $(f):$(TARGET_COPY_OUT_VENDOR)/etc/init/hw/$(notdir $f)))

fingerprint/.clang-format

@@ -0,0 +1,14 @@
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AllowShortFunctionsOnASingleLine: Inline
+ColumnLimit: 99
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+IndentWidth: 4
+PointerAlignment: Right
+TabWidth: 4
+UseTab: Never
+PenaltyExcessCharacter: 32
+AllowShortIfStatementsOnASingleLine: false
+SpacesBeforeTrailingComments: 2
+

fingerprint/Android.bp

@@ -0,0 +1,23 @@
+cc_binary {
+    name: "android.hardware.biometrics.fingerprint@2.3-service.rtwo",
+    defaults: ["hidl_defaults"],
+    init_rc: ["android.hardware.biometrics.fingerprint@2.3-service.rtwo.rc"],
+    vintf_fragments: ["android.hardware.biometrics.fingerprint@2.3-service.rtwo.xml"],
+    relative_install_path: "hw",
+    srcs: [
+        "service.cpp",
+        "BiometricsFingerprint.cpp",
+    ],
+    vendor: true,
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+        "libMotoPanelFeature",
+        "liblog",
+        "libutils",
+        "android.hardware.biometrics.fingerprint@2.1",
+        "android.hardware.biometrics.fingerprint@2.2",
+        "android.hardware.biometrics.fingerprint@2.3",
+        "com.motorola.hardware.biometric.fingerprint@1.0",
+    ],
+}

fingerprint/BiometricsFingerprint.cpp

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2017 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 "fingerprint@2.3-service.rtwo"
+
+#include "BiometricsFingerprint.h"
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+
+#include <chrono>
+#include <cmath>
+#include <fstream>
+#include <thread>
+
+#include <libMotoPanelFeature.h>
+
+#define NOTIFY_FINGER_UP IMotFodEventType::FINGER_UP
+#define NOTIFY_FINGER_DOWN IMotFodEventType::FINGER_DOWN
+
+namespace android {
+namespace hardware {
+namespace biometrics {
+namespace fingerprint {
+namespace V2_3 {
+namespace implementation {
+
+void setFodHbm(bool status) {
+    setFodHbmState(status);
+}
+
+void BiometricsFingerprint::disableHighBrightFod() {
+    std::lock_guard<std::mutex> lock(mSetHbmFodMutex);
+
+    if (!hbmFodEnabled)
+        return;
+
+    mMotoFingerprint->sendFodEvent(NOTIFY_FINGER_UP, {},
+                                   [](IMotFodEventResult, const hidl_vec<signed char> &) {});
+    setFodHbm(false);
+
+    hbmFodEnabled = false;
+}
+
+void BiometricsFingerprint::enableHighBrightFod() {
+    std::lock_guard<std::mutex> lock(mSetHbmFodMutex);
+
+    if (hbmFodEnabled)
+        return;
+
+    setFodHbm(true);
+    mMotoFingerprint->sendFodEvent(NOTIFY_FINGER_DOWN, {},
+                                   [](IMotFodEventResult, const hidl_vec<signed char> &) {});
+
+    hbmFodEnabled = true;
+}
+
+BiometricsFingerprint::BiometricsFingerprint() {
+    biometrics_2_1_service = IBiometricsFingerprint_2_1::getService();
+    mMotoFingerprint = IMotoFingerPrint::getService();
+
+    hbmFodEnabled = false;
+}
+
+Return<uint64_t> BiometricsFingerprint::setNotify(
+    const sp<IBiometricsFingerprintClientCallback> &clientCallback) {
+    return biometrics_2_1_service->setNotify(clientCallback);
+}
+
+Return<uint64_t> BiometricsFingerprint::preEnroll() {
+    return biometrics_2_1_service->preEnroll();
+}
+
+Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69> &hat,
+                                                    uint32_t gid, uint32_t timeoutSec) {
+    return biometrics_2_1_service->enroll(hat, gid, timeoutSec);
+}
+
+Return<RequestStatus> BiometricsFingerprint::postEnroll() {
+    return biometrics_2_1_service->postEnroll();
+}
+
+Return<uint64_t> BiometricsFingerprint::getAuthenticatorId() {
+    return biometrics_2_1_service->getAuthenticatorId();
+}
+
+Return<RequestStatus> BiometricsFingerprint::cancel() {
+    auto ret = biometrics_2_1_service->cancel();
+    BiometricsFingerprint::onFingerUp();
+    return ret;
+}
+
+Return<RequestStatus> BiometricsFingerprint::enumerate() {
+    return biometrics_2_1_service->enumerate();
+}
+
+Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {
+    return biometrics_2_1_service->remove(gid, fid);
+}
+
+Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
+                                                            const hidl_string &storePath) {
+    return biometrics_2_1_service->setActiveGroup(gid, storePath);
+}
+
+Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId, uint32_t gid) {
+    auto ret = biometrics_2_1_service->authenticate(operationId, gid);
+    BiometricsFingerprint::onFingerUp();
+    return ret;
+}
+
+Return<bool> BiometricsFingerprint::isUdfps(uint32_t) {
+    return true;
+}
+
+Return<void> BiometricsFingerprint::onFingerDown(uint32_t, uint32_t, float, float) {
+    BiometricsFingerprint::enableHighBrightFod();
+
+    std::thread([this]() {
+        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        BiometricsFingerprint::onFingerUp();
+    }).detach();
+
+    return Void();
+}
+
+Return<void> BiometricsFingerprint::onFingerUp() {
+    BiometricsFingerprint::disableHighBrightFod();
+
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V2_3
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace hardware
+}  // namespace android

fingerprint/BiometricsFingerprint.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2017 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 ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_3_BIOMETRICSFINGERPRINT_H
+#define ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_3_BIOMETRICSFINGERPRINT_H
+
+#include <android/hardware/biometrics/fingerprint/2.3/IBiometricsFingerprint.h>
+#include <com/motorola/hardware/biometric/fingerprint/1.0/IMotoFingerPrint.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace biometrics {
+namespace fingerprint {
+namespace V2_3 {
+namespace implementation {
+
+using IBiometricsFingerprint_2_1 =
+    ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;
+using ::android::sp;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
+using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
+using ::com::motorola::hardware::biometric::fingerprint::V1_0::IMotFodEventResult;
+using ::com::motorola::hardware::biometric::fingerprint::V1_0::IMotFodEventType;
+using ::com::motorola::hardware::biometric::fingerprint::V1_0::IMotoFingerPrint;
+
+struct BiometricsFingerprint : public IBiometricsFingerprint {
+    BiometricsFingerprint();
+    // Methods from ::V2_1::IBiometricsFingerprint follow.
+    Return<uint64_t> setNotify(
+        const sp<IBiometricsFingerprintClientCallback> &clientCallback) override;
+    Return<uint64_t> preEnroll() override;
+    Return<RequestStatus> enroll(const hidl_array<uint8_t, 69> &hat, uint32_t gid,
+                                 uint32_t timeoutSec) override;
+    Return<RequestStatus> postEnroll() override;
+    Return<uint64_t> getAuthenticatorId() override;
+    Return<RequestStatus> cancel() override;
+    Return<RequestStatus> enumerate() override;
+    Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
+    Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string &storePath) override;
+    Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override;
+
+    // ::V2_3::IBiometricsFingerprint follow.
+    Return<bool> isUdfps(uint32_t sensorId) override;
+    Return<void> onFingerDown(uint32_t x, uint32_t y, float minor, float major) override;
+    Return<void> onFingerUp() override;
+
+  private:
+    void disableHighBrightFod();
+    void enableHighBrightFod();
+
+    bool hbmFodEnabled;
+    std::mutex mSetHbmFodMutex;
+
+    sp<IBiometricsFingerprint_2_1> biometrics_2_1_service;
+    sp<IMotoFingerPrint> mMotoFingerprint;
+};
+
+}  // namespace implementation
+}  // namespace V2_3
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace hardware
+}  // namespace android
+#endif  // ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_3_BIOMETRICSFINGERPRINT_H

fingerprint/android.hardware.biometrics.fingerprint@2.3-service.rtwo.rc

@@ -0,0 +1,11 @@
+#on init
+#    chown system system /sys/devices/platform/soc/soc:qcom,dsi-display-primary/fod_hbm
+
+service fps_hal.rtwo /vendor/bin/hw/android.hardware.biometrics.fingerprint@2.3-service.rtwo
+    # "class hal" causes a race condition on some devices due to files created
+    # in /data. As a workaround, postpone startup until later in boot once
+    # /data is mounted.
+    class late_start
+    user system
+    group system input uhid
+    writepid /dev/cpuset/system-background/tasks

fingerprint/android.hardware.biometrics.fingerprint@2.3-service.rtwo.xml

@@ -0,0 +1,20 @@
+<manifest version="1.0" type="device">
+    <hal format="hidl">
+        <name>android.hardware.biometrics.fingerprint</name>
+        <transport>hwbinder</transport>
+        <version>2.3</version>
+        <interface>
+            <name>IBiometricsFingerprint</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+    <hal format="hidl">
+        <name>vendor.goodix.hardware.biometrics.fingerprint</name>
+        <transport>hwbinder</transport>
+        <version>2.1</version>
+        <interface>
+            <name>IGoodixFingerprintDaemon</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>

fingerprint/service.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 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.3-service.rtwo"
+#include <android-base/logging.h>
+#include <hidl/HidlTransportSupport.h>
+
+#include "BiometricsFingerprint.h"
+
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+
+using android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
+using android::hardware::biometrics::fingerprint::V2_3::implementation::BiometricsFingerprint;
+
+using android::OK;
+using android::status_t;
+
+int main() {
+    android::sp<IBiometricsFingerprint> service = new BiometricsFingerprint();
+
+    configureRpcThreadpool(1, true);
+
+    status_t status = service->registerAsService();
+    if (status != OK) {
+        LOG(ERROR) << "Cannot register Biometrics 2.3 HAL service.";
+        return 1;
+    }
+
+    LOG(INFO) << "Biometrics 2.3 HAL service ready.";
+
+    joinRpcThreadpool();
+
+    LOG(ERROR) << "Biometrics 2.3 HAL service failed to join thread pool.";
+    return 1;
+}