SQUASH: hidl: Import Fingerprint 2.1 HIDL HAL

 * Imported as of HEAD https://github.com/LineageOS/android_hardware_interfaces/commit/1ee53cfa566471153661b2715ade8a9a5d525776

Signed-off-by: Daniel Jacob Chittoor <djchittoor47@gmail.com>
Change-Id: I8b92650d60134e485f22fb7d8051c0ec3b14699e

fingerprint: Rebrand for OnePlus

Change-Id: I0c83fbb23b1d41939623c467c00c80b97cbcf747

fingerprint: Load FP module based on sensor version

* OnePlus loads different modules based on sensor version.

Change-Id: Ia6c6e6f42c002d9964380cb4dccaabff20738757

fingerprint: Revert "fpc: keep fpc in system-background"

While Google found that fingerprint HAL is insensitive to
increased CPU throughput, we have not found that to be the
case. Allowing more CPUs makes fingerprint unlock up to
2x faster in some tests.

SM8250 device with fingerprint on display:
- Before: 3128ms
- After: 944ms

SDM845 device with fingerprint on the power button:
- Before: 1146ms
- After: 688ms

This reverts commit d0fdb4431d26e4f257b8867f67ffd9b4a9818d9e.

Change-Id: I7a28d82caee2b8503b974a8226b29240eb072ceb

fingerprint: Import a skeleton FOD HAL

Change-Id: I76c792dfc77844edb25502a07074a3f4301e8194

inscreen: Set FOD co-ordinates using soong exported variables

 * Based on https://github.com/LineageOS/android_device_oneplus_sm8150-common/commit/f36ea1ade19f5325e22567219fdd15d4973c7cce
   and adapted for newer AOSP soong conditionals.

Change-Id: I256702b70cf5d4c0e901c9fe38b47163b70b978a

inscreen: Handle dimming behaviour on biometric events

 * We make use of wired up OnePlus display and fingerprint HAL hooks to
   handle the dimming logic in correspondance to the biometric events
   such as enrollment, press, release etc.

 * Undeclare "FingerprintInscreen" as an explicitly defaulted function
   since we are not using any special member functions.

Co-authored-by: Peter Cai <peter@typeblog.net>
Co-authored-by: LuK1337 <priv.luk@gmail.com>
Signed-off-by: Daniel Jacob Chittoor <djchittoor47@gmail.com>
Change-Id: I860098feea22e9cd792366488d9eb8f63811415e

inscreen: Ignore vendor error code 6

Change-Id: I7210665da543c3d56335bf280b8a6c16fe107b4e

inscreen: Don't invoke callbacks when FOD circle is not visible

Change-Id: Ib5ca18f6f47642a0d77288694f6e906c2901bceb

inscreen: Switch to libfod extension

 * Decompiled stock libsurfaceflinger.so to get Z values from
   OPFingerprintView and OPFingerprintVDpressed functions.

Change-Id: I23b1af50a37cda342b1b119b792f1216e2ab0a0b

inscreen: Set dim mode instead of HBM for fp enrollment

 * That way we no longer have to turn HBM for the whole enroll process.

Change-Id: Ib0c48b117637381dbd7ab373bedd97dbc70dda28

inscreen: Reset everything when onShowFODView() is called

* Perhaps it'll fix random bright FOD icon?

Change-Id: I08eaf75bfd8a5a6aea1f89ff6810e9c271e1cbe3

inscreen: Remove reduntant template functions

Change-Id: I684bf38439fda78562141547f177b1fe3746dd66

inscreen: Return touched z-order only

OnePlus places FP layer upon the dimlayer, causing the former one
highlighted. Only return the z-order with fingerprint pressed to
target the layer we need.

Signed-off-by: alk3pInjection <webmaster@raspii.tech>
Change-Id: I4666718018aa135a7d6387d957f136f23a5a5670

inscreen: Properly set dim

Matches the behavior of stock rom

Co-authored-by: Hikari-no-Tenshi <kyryljan.serhij@gmail.com>
Signed-off-by: alk3pInjection <webmaster@raspii.tech>
Signed-off-by: Omkar Chandorkar <gotenksIN@aosip.dev>
Change-Id: I76566f0cf427dcf858fae222e71090ed82eeb710

inscreen: Add support for system variants

 * SDM845 family of OnePlus devices on LineageOS use a prebuilt vendor.

Change-Id: Iaad1bb4660655df8be31a503650daab59b381266

16 files changed, 926 insertions, 0 deletions

diff --git a/hidl/fingerprint/Android.bp b/hidl/fingerprint/Android.bp
new file mode 100644
index 0000000..7721df1
--- /dev/null
+++ b/hidl/fingerprint/Android.bp
@@ -0,0 +1,22 @@
+cc_binary {
+    name: "android.hardware.biometrics.fingerprint@2.1-service.oneplus",
+    defaults: ["hidl_defaults"],
+    init_rc: ["android.hardware.biometrics.fingerprint@2.1-service.oneplus.rc"],
+    vintf_fragments: ["android.hardware.biometrics.fingerprint@2.1-service.oneplus.xml"],
+    vendor: true,
+    relative_install_path: "hw",
+    srcs: [
+        "BiometricsFingerprint.cpp",
+        "service.cpp",
+    ],
+
+    shared_libs: [
+        "libcutils",
+        "liblog",
+        "libhidlbase",
+        "libhardware",
+        "libutils",
+        "android.hardware.biometrics.fingerprint@2.1",
+    ],
+
+}
diff --git a/hidl/fingerprint/BiometricsFingerprint.cpp b/hidl/fingerprint/BiometricsFingerprint.cpp
new file mode 100644
index 0000000..7ff7681
--- /dev/null
+++ b/hidl/fingerprint/BiometricsFingerprint.cpp
@@ -0,0 +1,367 @@
+/*
+ * 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.1-service"
+#define LOG_VERBOSE "android.hardware.biometrics.fingerprint@2.1-service"
+
+#include <hardware/hw_auth_token.h>
+
+#include <hardware/hardware.h>
+#include <hardware/fingerprint.h>
+#include "BiometricsFingerprint.h"
+
+#include <fstream>
+#include <inttypes.h>
+#include <unistd.h>
+
+namespace android {
+namespace hardware {
+namespace biometrics {
+namespace fingerprint {
+namespace V2_1 {
+namespace implementation {
+
+// Supported fingerprint HAL version
+static const uint16_t kVersion = HARDWARE_MODULE_API_VERSION(2, 1);
+
+using RequestStatus =
+        android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
+
+BiometricsFingerprint *BiometricsFingerprint::sInstance = nullptr;
+
+BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr), mDevice(nullptr) {
+    sInstance = this; // keep track of the most recent instance
+    mDevice = openHal();
+    if (!mDevice) {
+        ALOGE("Can't open HAL module");
+    }
+}
+
+BiometricsFingerprint::~BiometricsFingerprint() {
+    ALOGV("~BiometricsFingerprint()");
+    if (mDevice == nullptr) {
+        ALOGE("No valid device");
+        return;
+    }
+    int err;
+    if (0 != (err = mDevice->common.close(
+            reinterpret_cast<hw_device_t*>(mDevice)))) {
+        ALOGE("Can't close fingerprint module, error: %d", err);
+        return;
+    }
+    mDevice = nullptr;
+}
+
+Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
+    switch(error) {
+        case 0: return RequestStatus::SYS_OK;
+        case -2: return RequestStatus::SYS_ENOENT;
+        case -4: return RequestStatus::SYS_EINTR;
+        case -5: return RequestStatus::SYS_EIO;
+        case -11: return RequestStatus::SYS_EAGAIN;
+        case -12: return RequestStatus::SYS_ENOMEM;
+        case -13: return RequestStatus::SYS_EACCES;
+        case -14: return RequestStatus::SYS_EFAULT;
+        case -16: return RequestStatus::SYS_EBUSY;
+        case -22: return RequestStatus::SYS_EINVAL;
+        case -28: return RequestStatus::SYS_ENOSPC;
+        case -110: return RequestStatus::SYS_ETIMEDOUT;
+        default:
+            ALOGE("An unknown error returned from fingerprint vendor library: %d", error);
+            return RequestStatus::SYS_UNKNOWN;
+    }
+}
+
+// Translate from errors returned by traditional HAL (see fingerprint.h) to
+// HIDL-compliant FingerprintError.
+FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error,
+            int32_t* vendorCode) {
+    *vendorCode = 0;
+    switch(error) {
+        case FINGERPRINT_ERROR_HW_UNAVAILABLE:
+            return FingerprintError::ERROR_HW_UNAVAILABLE;
+        case FINGERPRINT_ERROR_UNABLE_TO_PROCESS:
+            return FingerprintError::ERROR_UNABLE_TO_PROCESS;
+        case FINGERPRINT_ERROR_TIMEOUT:
+            return FingerprintError::ERROR_TIMEOUT;
+        case FINGERPRINT_ERROR_NO_SPACE:
+            return FingerprintError::ERROR_NO_SPACE;
+        case FINGERPRINT_ERROR_CANCELED:
+            return FingerprintError::ERROR_CANCELED;
+        case FINGERPRINT_ERROR_UNABLE_TO_REMOVE:
+            return FingerprintError::ERROR_UNABLE_TO_REMOVE;
+        case FINGERPRINT_ERROR_LOCKOUT:
+            return FingerprintError::ERROR_LOCKOUT;
+        default:
+            if (error >= FINGERPRINT_ERROR_VENDOR_BASE) {
+                // vendor specific code.
+                *vendorCode = error - FINGERPRINT_ERROR_VENDOR_BASE;
+                return FingerprintError::ERROR_VENDOR;
+            }
+    }
+    ALOGE("Unknown error from fingerprint vendor library: %d", error);
+    return FingerprintError::ERROR_UNABLE_TO_PROCESS;
+}
+
+// Translate acquired messages returned by traditional HAL (see fingerprint.h)
+// to HIDL-compliant FingerprintAcquiredInfo.
+FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(
+        int32_t info, int32_t* vendorCode) {
+    *vendorCode = 0;
+    switch(info) {
+        case FINGERPRINT_ACQUIRED_GOOD:
+            return FingerprintAcquiredInfo::ACQUIRED_GOOD;
+        case FINGERPRINT_ACQUIRED_PARTIAL:
+            return FingerprintAcquiredInfo::ACQUIRED_PARTIAL;
+        case FINGERPRINT_ACQUIRED_INSUFFICIENT:
+            return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
+        case FINGERPRINT_ACQUIRED_IMAGER_DIRTY:
+            return FingerprintAcquiredInfo::ACQUIRED_IMAGER_DIRTY;
+        case FINGERPRINT_ACQUIRED_TOO_SLOW:
+            return FingerprintAcquiredInfo::ACQUIRED_TOO_SLOW;
+        case FINGERPRINT_ACQUIRED_TOO_FAST:
+            return FingerprintAcquiredInfo::ACQUIRED_TOO_FAST;
+        default:
+            if (info >= FINGERPRINT_ACQUIRED_VENDOR_BASE) {
+                // vendor specific code.
+                *vendorCode = info - FINGERPRINT_ACQUIRED_VENDOR_BASE;
+                return FingerprintAcquiredInfo::ACQUIRED_VENDOR;
+            }
+    }
+    ALOGE("Unknown acquiredmsg from fingerprint vendor library: %d", info);
+    return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
+}
+
+Return<uint64_t> BiometricsFingerprint::setNotify(
+        const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
+    std::lock_guard<std::mutex> lock(mClientCallbackMutex);
+    mClientCallback = clientCallback;
+    // This is here because HAL 2.1 doesn't have a way to propagate a
+    // unique token for its driver. Subsequent versions should send a unique
+    // token for each call to setNotify(). This is fine as long as there's only
+    // one fingerprint device on the platform.
+    return reinterpret_cast<uint64_t>(mDevice);
+}
+
+Return<uint64_t> BiometricsFingerprint::preEnroll()  {
+    return mDevice->pre_enroll(mDevice);
+}
+
+Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat,
+        uint32_t gid, uint32_t timeoutSec) {
+    const hw_auth_token_t* authToken =
+        reinterpret_cast<const hw_auth_token_t*>(hat.data());
+    return ErrorFilter(mDevice->enroll(mDevice, authToken, gid, timeoutSec));
+}
+
+Return<RequestStatus> BiometricsFingerprint::postEnroll() {
+    return ErrorFilter(mDevice->post_enroll(mDevice));
+}
+
+Return<uint64_t> BiometricsFingerprint::getAuthenticatorId() {
+    return mDevice->get_authenticator_id(mDevice);
+}
+
+Return<RequestStatus> BiometricsFingerprint::cancel() {
+    return ErrorFilter(mDevice->cancel(mDevice));
+}
+
+Return<RequestStatus> BiometricsFingerprint::enumerate()  {
+    return ErrorFilter(mDevice->enumerate(mDevice));
+}
+
+Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {
+    return ErrorFilter(mDevice->remove(mDevice, gid, fid));
+}
+
+Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
+        const hidl_string& storePath) {
+    if (storePath.size() >= PATH_MAX || storePath.size() <= 0) {
+        ALOGE("Bad path length: %zd", storePath.size());
+        return RequestStatus::SYS_EINVAL;
+    }
+    if (access(storePath.c_str(), W_OK)) {
+        return RequestStatus::SYS_EINVAL;
+    }
+
+    return ErrorFilter(mDevice->set_active_group(mDevice, gid,
+                                                    storePath.c_str()));
+}
+
+Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId,
+        uint32_t gid) {
+    return ErrorFilter(mDevice->authenticate(mDevice, operationId, gid));
+}
+
+IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
+    if (!sInstance) {
+      sInstance = new BiometricsFingerprint();
+    }
+    return sInstance;
+}
+
+const char* BiometricsFingerprint::getModuleId() {
+    int sensor_version = -1;
+    std::ifstream file("/sys/devices/platform/soc/soc:fingerprint_detect/sensor_version");
+    file >> sensor_version;
+    ALOGI("fp sensor version is: 0x%x", sensor_version);
+    return sensor_version == 0x9638 ? "goodix.g6.fod" : "goodix.fod";
+}
+
+fingerprint_device_t* BiometricsFingerprint::openHal() {
+    int err;
+    const hw_module_t *hw_mdl = nullptr;
+    ALOGD("Opening fingerprint hal library...");
+    if (0 != (err = hw_get_module(getModuleId(), &hw_mdl))) {
+        ALOGE("Can't open fingerprint HW Module, error: %d", err);
+        return nullptr;
+    }
+
+    if (hw_mdl == nullptr) {
+        ALOGE("No valid fingerprint module");
+        return nullptr;
+    }
+
+    fingerprint_module_t const *module =
+        reinterpret_cast<const fingerprint_module_t*>(hw_mdl);
+    if (module->common.methods->open == nullptr) {
+        ALOGE("No valid open method");
+        return nullptr;
+    }
+
+    hw_device_t *device = nullptr;
+
+    if (0 != (err = module->common.methods->open(hw_mdl, nullptr, &device))) {
+        ALOGE("Can't open fingerprint methods, error: %d", err);
+        return nullptr;
+    }
+
+    if (kVersion != device->version) {
+        // enforce version on new devices because of HIDL@2.1 translation layer
+        ALOGE("Wrong fp version. Expected %d, got %d", kVersion, device->version);
+        return nullptr;
+    }
+
+    fingerprint_device_t* fp_device =
+        reinterpret_cast<fingerprint_device_t*>(device);
+
+    if (0 != (err =
+            fp_device->set_notify(fp_device, BiometricsFingerprint::notify))) {
+        ALOGE("Can't register fingerprint module callback, error: %d", err);
+        return nullptr;
+    }
+
+    return fp_device;
+}
+
+void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
+    BiometricsFingerprint* thisPtr = static_cast<BiometricsFingerprint*>(
+            BiometricsFingerprint::getInstance());
+    std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex);
+    if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
+        ALOGE("Receiving callbacks before the client callback is registered.");
+        return;
+    }
+    const uint64_t devId = reinterpret_cast<uint64_t>(thisPtr->mDevice);
+    switch (msg->type) {
+        case FINGERPRINT_ERROR: {
+                int32_t vendorCode = 0;
+                FingerprintError result = VendorErrorFilter(msg->data.error, &vendorCode);
+                ALOGD("onError(%d)", result);
+                if (!thisPtr->mClientCallback->onError(devId, result, vendorCode).isOk()) {
+                    ALOGE("failed to invoke fingerprint onError callback");
+                }
+            }
+            break;
+        case FINGERPRINT_ACQUIRED: {
+                int32_t vendorCode = 0;
+                FingerprintAcquiredInfo result =
+                    VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
+                ALOGD("onAcquired(%d)", result);
+                if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode).isOk()) {
+                    ALOGE("failed to invoke fingerprint onAcquired callback");
+                }
+            }
+            break;
+        case FINGERPRINT_TEMPLATE_ENROLLING:
+            ALOGD("onEnrollResult(fid=%d, gid=%d, rem=%d)",
+                msg->data.enroll.finger.fid,
+                msg->data.enroll.finger.gid,
+                msg->data.enroll.samples_remaining);
+            if (!thisPtr->mClientCallback->onEnrollResult(devId,
+                    msg->data.enroll.finger.fid,
+                    msg->data.enroll.finger.gid,
+                    msg->data.enroll.samples_remaining).isOk()) {
+                ALOGE("failed to invoke fingerprint onEnrollResult callback");
+            }
+            break;
+        case FINGERPRINT_TEMPLATE_REMOVED:
+            ALOGD("onRemove(fid=%d, gid=%d, rem=%d)",
+                msg->data.removed.finger.fid,
+                msg->data.removed.finger.gid,
+                msg->data.removed.remaining_templates);
+            if (!thisPtr->mClientCallback->onRemoved(devId,
+                    msg->data.removed.finger.fid,
+                    msg->data.removed.finger.gid,
+                    msg->data.removed.remaining_templates).isOk()) {
+                ALOGE("failed to invoke fingerprint onRemoved callback");
+            }
+            break;
+        case FINGERPRINT_AUTHENTICATED:
+            if (msg->data.authenticated.finger.fid != 0) {
+                ALOGD("onAuthenticated(fid=%d, gid=%d)",
+                    msg->data.authenticated.finger.fid,
+                    msg->data.authenticated.finger.gid);
+                const uint8_t* hat =
+                    reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
+                const hidl_vec<uint8_t> token(
+                    std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
+                if (!thisPtr->mClientCallback->onAuthenticated(devId,
+                        msg->data.authenticated.finger.fid,
+                        msg->data.authenticated.finger.gid,
+                        token).isOk()) {
+                    ALOGE("failed to invoke fingerprint onAuthenticated callback");
+                }
+            } else {
+                // Not a recognized fingerprint
+                if (!thisPtr->mClientCallback->onAuthenticated(devId,
+                        msg->data.authenticated.finger.fid,
+                        msg->data.authenticated.finger.gid,
+                        hidl_vec<uint8_t>()).isOk()) {
+                    ALOGE("failed to invoke fingerprint onAuthenticated callback");
+                }
+            }
+            break;
+        case FINGERPRINT_TEMPLATE_ENUMERATING:
+            ALOGD("onEnumerate(fid=%d, gid=%d, rem=%d)",
+                msg->data.enumerated.finger.fid,
+                msg->data.enumerated.finger.gid,
+                msg->data.enumerated.remaining_templates);
+            if (!thisPtr->mClientCallback->onEnumerate(devId,
+                    msg->data.enumerated.finger.fid,
+                    msg->data.enumerated.finger.gid,
+                    msg->data.enumerated.remaining_templates).isOk()) {
+                ALOGE("failed to invoke fingerprint onEnumerate callback");
+            }
+            break;
+    }
+}
+
+} // namespace implementation
+}  // namespace V2_1
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace hardware
+}  // namespace android
diff --git a/hidl/fingerprint/BiometricsFingerprint.h b/hidl/fingerprint/BiometricsFingerprint.h
new file mode 100644
index 0000000..9ff5089
--- /dev/null
+++ b/hidl/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_1_BIOMETRICSFINGERPRINT_H
+#define ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_1_BIOMETRICSFINGERPRINT_H
+
+#include <log/log.h>
+#include <android/log.h>
+#include <hardware/hardware.h>
+#include <hardware/fingerprint.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
+
+namespace android {
+namespace hardware {
+namespace biometrics {
+namespace fingerprint {
+namespace V2_1 {
+namespace implementation {
+
+using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;
+using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
+using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
+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();
+    ~BiometricsFingerprint();
+
+    // Method to wrap legacy HAL with BiometricsFingerprint class
+    static IBiometricsFingerprint* getInstance();
+
+    // Methods from ::android::hardware::biometrics::fingerprint::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;
+
+private:
+    static const char* getModuleId();
+    static fingerprint_device_t* openHal();
+    static void notify(const fingerprint_msg_t *msg); /* Static callback for legacy HAL implementation */
+    static Return<RequestStatus> ErrorFilter(int32_t error);
+    static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode);
+    static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error, int32_t* vendorCode);
+    static BiometricsFingerprint* sInstance;
+
+    std::mutex mClientCallbackMutex;
+    sp<IBiometricsFingerprintClientCallback> mClientCallback;
+    fingerprint_device_t *mDevice;
+};
+
+}  // namespace implementation
+}  // namespace V2_1
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_1_BIOMETRICSFINGERPRINT_H
diff --git a/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.rc b/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.rc
new file mode 100644
index 0000000..b56b83f
--- /dev/null
+++ b/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.rc
@@ -0,0 +1,7 @@
+service vendor.fps_hal /vendor/bin/hw/android.hardware.biometrics.fingerprint@2.1-service.oneplus
+    # "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
diff --git a/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.xml b/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.xml
new file mode 100644
index 0000000..115dd7b
--- /dev/null
+++ b/hidl/fingerprint/android.hardware.biometrics.fingerprint@2.1-service.oneplus.xml
@@ -0,0 +1,11 @@
+<manifest version="1.0" type="device">
+    <hal format="hidl">
+        <name>android.hardware.biometrics.fingerprint</name>
+        <transport>hwbinder</transport>
+        <version>2.1</version>
+        <interface>
+            <name>IBiometricsFingerprint</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>
diff --git a/hidl/fingerprint/inscreen/.clang-format b/hidl/fingerprint/inscreen/.clang-format
new file mode 100644
index 0000000..55773a2
--- /dev/null
+++ b/hidl/fingerprint/inscreen/.clang-format
@@ -0,0 +1,11 @@
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AllowShortFunctionsOnASingleLine: Inline
+ColumnLimit: 100
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+IndentWidth: 4
+ContinuationIndentWidth: 8
+PointerAlignment: Left
+TabWidth: 4
+UseTab: Never
diff --git a/hidl/fingerprint/inscreen/Android.bp b/hidl/fingerprint/inscreen/Android.bp
new file mode 100644
index 0000000..cbb58ff
--- /dev/null
+++ b/hidl/fingerprint/inscreen/Android.bp
@@ -0,0 +1,66 @@
+soong_config_module_type {
+    name: "oneplus_fod_hal_cc_defaults",
+    module_type: "cc_defaults",
+    config_namespace: "ONEPLUS_FOD",
+    value_variables: [
+        "POS_X",
+        "POS_Y",
+        "SIZE",
+    ],
+    properties: ["cppflags"],
+}
+
+oneplus_fod_hal_cc_defaults {
+    name: "oneplus_fod_hal_defaults",
+    defaults: ["hidl_defaults"],
+    relative_install_path: "hw",
+    soong_config_variables: {
+        POS_X: {
+            cppflags: ["-DFOD_POS_X=%s"],
+        },
+        POS_Y: {
+            cppflags: ["-DFOD_POS_Y=%s"],
+        },
+        SIZE: {
+            cppflags: ["-DFOD_SIZE=%s"],
+        },
+    },
+    srcs: [
+        "service.cpp",
+        "FingerprintInscreen.cpp",
+    ],
+    shared_libs: [
+        "libbase",
+        "libhardware",
+        "libhidlbase",
+        "liblog",
+        "libutils",
+        "vendor.lineage.biometrics.fingerprint.inscreen@1.0",
+        "vendor.oneplus.fingerprint.extension@1.0",
+        "vendor.oneplus.hardware.display@1.0",
+    ],
+}
+
+cc_binary {
+    name: "lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus",
+    defaults: ["oneplus_fod_hal_defaults"],
+    vintf_fragments: ["lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml"],
+    init_rc: ["lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc"],
+    system_ext_specific: true,
+}
+
+cc_binary {
+    name: "vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus",
+    defaults: ["oneplus_fod_hal_defaults"],
+    vintf_fragments: ["vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml"],
+    init_rc: ["vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc"],
+    vendor: true,
+}
+
+cc_library_static {
+    name: "libfod_extension.oneplus",
+    srcs: ["FodExtension.cpp"],
+    include_dirs: [
+        "frameworks/native/services/surfaceflinger/CompositionEngine/include",
+    ],
+}
diff --git a/hidl/fingerprint/inscreen/FingerprintInscreen.cpp b/hidl/fingerprint/inscreen/FingerprintInscreen.cpp
new file mode 100644
index 0000000..e239e02
--- /dev/null
+++ b/hidl/fingerprint/inscreen/FingerprintInscreen.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define LOG_TAG "FingerprintInscreenService"
+
+#include "FingerprintInscreen.h"
+#include <android-base/logging.h>
+#include <hidl/HidlTransportSupport.h>
+#include <fstream>
+
+#define FINGERPRINT_ACQUIRED_VENDOR 6
+#define FINGERPRINT_ERROR_VENDOR 8
+
+#define OP_ENABLE_FP_LONGPRESS 3
+#define OP_DISABLE_FP_LONGPRESS 4
+#define OP_RESUME_FP_ENROLL 8
+#define OP_FINISH_FP_ENROLL 10
+
+#define OP_DISPLAY_AOD_MODE 8
+#define OP_DISPLAY_NOTIFY_PRESS 9
+#define OP_DISPLAY_SET_DIM 10
+
+namespace vendor {
+namespace lineage {
+namespace biometrics {
+namespace fingerprint {
+namespace inscreen {
+namespace V1_0 {
+namespace implementation {
+
+FingerprintInscreen::FingerprintInscreen() {
+    this->mFodCircleVisible = false;
+    this->mVendorFpService = IVendorFingerprintExtensions::getService();
+    this->mVendorDisplayService = IOneplusDisplay::getService();
+}
+
+Return<void> FingerprintInscreen::onStartEnroll() {
+    this->mVendorFpService->updateStatus(OP_DISABLE_FP_LONGPRESS);
+    this->mVendorFpService->updateStatus(OP_RESUME_FP_ENROLL);
+
+    return Void();
+}
+
+Return<void> FingerprintInscreen::onFinishEnroll() {
+    this->mVendorFpService->updateStatus(OP_FINISH_FP_ENROLL);
+
+    return Void();
+}
+
+Return<void> FingerprintInscreen::onPress() {
+    this->mVendorDisplayService->setMode(OP_DISPLAY_NOTIFY_PRESS, 1);
+
+    return Void();
+}
+
+Return<void> FingerprintInscreen::onRelease() {
+    this->mVendorDisplayService->setMode(OP_DISPLAY_NOTIFY_PRESS, 0);
+
+    return Void();
+}
+
+Return<void> FingerprintInscreen::onShowFODView() {
+    this->mFodCircleVisible = true;
+    this->mVendorDisplayService->setMode(OP_DISPLAY_SET_DIM, 1);
+
+    return Void();
+}
+
+Return<void> FingerprintInscreen::onHideFODView() {
+    this->mFodCircleVisible = false;
+    this->mVendorDisplayService->setMode(OP_DISPLAY_AOD_MODE, 0);
+    this->mVendorDisplayService->setMode(OP_DISPLAY_SET_DIM, 0);
+    this->mVendorDisplayService->setMode(OP_DISPLAY_NOTIFY_PRESS, 0);
+
+    return Void();
+}
+
+Return<bool> FingerprintInscreen::handleAcquired(int32_t acquiredInfo, int32_t vendorCode) {
+    std::lock_guard<std::mutex> _lock(mCallbackLock);
+    if (mCallback == nullptr) {
+        return false;
+    }
+
+    if (acquiredInfo == FINGERPRINT_ACQUIRED_VENDOR) {
+        if (mFodCircleVisible && vendorCode == 0) {
+            Return<void> ret = mCallback->onFingerDown();
+            if (!ret.isOk()) {
+                LOG(ERROR) << "FingerDown() error: " << ret.description();
+            }
+            return true;
+        }
+
+        if (mFodCircleVisible && vendorCode == 1) {
+            Return<void> ret = mCallback->onFingerUp();
+            if (!ret.isOk()) {
+                LOG(ERROR) << "FingerUp() error: " << ret.description();
+            }
+            return true;
+        }
+    }
+
+    return false;
+}
+
+Return<bool> FingerprintInscreen::handleError(int32_t error, int32_t vendorCode) {
+    return error == FINGERPRINT_ERROR_VENDOR && vendorCode == 6;
+}
+
+Return<void> FingerprintInscreen::setLongPressEnabled(bool enabled) {
+    this->mVendorFpService->updateStatus(
+            enabled ? OP_ENABLE_FP_LONGPRESS : OP_DISABLE_FP_LONGPRESS);
+
+    return Void();
+}
+
+Return<int32_t> FingerprintInscreen::getDimAmount(int32_t) {
+    return 0;
+}
+
+Return<bool> FingerprintInscreen::shouldBoostBrightness() {
+    return false;
+}
+
+Return<void> FingerprintInscreen::setCallback(const sp<IFingerprintInscreenCallback>& callback) {
+    {
+        std::lock_guard<std::mutex> _lock(mCallbackLock);
+        mCallback = callback;
+    }
+
+    return Void();
+}
+
+Return<int32_t> FingerprintInscreen::getPositionX() {
+    return FOD_POS_X;
+}
+
+Return<int32_t> FingerprintInscreen::getPositionY() {
+    return FOD_POS_Y;
+}
+
+Return<int32_t> FingerprintInscreen::getSize() {
+    return FOD_SIZE;
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace inscreen
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace lineage
+}  // namespace vendor
diff --git a/hidl/fingerprint/inscreen/FingerprintInscreen.h b/hidl/fingerprint/inscreen/FingerprintInscreen.h
new file mode 100644
index 0000000..f8baa54
--- /dev/null
+++ b/hidl/fingerprint/inscreen/FingerprintInscreen.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef VENDOR_LINEAGE_BIOMETRICS_FINGERPRINT_INSCREEN_V1_0_FINGERPRINTINSCREEN_H
+#define VENDOR_LINEAGE_BIOMETRICS_FINGERPRINT_INSCREEN_V1_0_FINGERPRINTINSCREEN_H
+
+#include <vendor/lineage/biometrics/fingerprint/inscreen/1.0/IFingerprintInscreen.h>
+#include <vendor/oneplus/fingerprint/extension/1.0/IVendorFingerprintExtensions.h>
+#include <vendor/oneplus/hardware/display/1.0/IOneplusDisplay.h>
+
+namespace vendor {
+namespace lineage {
+namespace biometrics {
+namespace fingerprint {
+namespace inscreen {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::sp;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::vendor::oneplus::fingerprint::extension::V1_0::IVendorFingerprintExtensions;
+using ::vendor::oneplus::hardware::display::V1_0::IOneplusDisplay;
+
+class FingerprintInscreen : public IFingerprintInscreen {
+  public:
+    FingerprintInscreen();
+
+    Return<void> onStartEnroll() override;
+    Return<void> onFinishEnroll() override;
+    Return<void> onPress() override;
+    Return<void> onRelease() override;
+    Return<void> onShowFODView() override;
+    Return<void> onHideFODView() override;
+    Return<bool> handleAcquired(int32_t acquiredInfo, int32_t vendorCode) override;
+    Return<bool> handleError(int32_t error, int32_t vendorCode) override;
+    Return<void> setLongPressEnabled(bool enabled) override;
+    Return<int32_t> getDimAmount(int32_t cur_brightness) override;
+    Return<bool> shouldBoostBrightness() override;
+    Return<void> setCallback(const sp<IFingerprintInscreenCallback>& callback) override;
+    Return<int32_t> getPositionX() override;
+    Return<int32_t> getPositionY() override;
+    Return<int32_t> getSize() override;
+
+  private:
+    bool mFodCircleVisible;
+
+    sp<IOneplusDisplay> mVendorDisplayService;
+    sp<IVendorFingerprintExtensions> mVendorFpService;
+
+    std::mutex mCallbackLock;
+    sp<IFingerprintInscreenCallback> mCallback;
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace inscreen
+}  // namespace fingerprint
+}  // namespace biometrics
+}  // namespace lineage
+}  // namespace vendor
+
+#endif  // VENDOR_LINEAGE_BIOMETRICS_FINGERPRINT_INSCREEN_V1_0_FINGERPRINTINSCREEN_H
diff --git a/hidl/fingerprint/inscreen/FodExtension.cpp b/hidl/fingerprint/inscreen/FodExtension.cpp
new file mode 100644
index 0000000..26bab43
--- /dev/null
+++ b/hidl/fingerprint/inscreen/FodExtension.cpp
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <compositionengine/FodExtension.h>
+
+uint32_t getFodZOrder(uint32_t z, bool touched) {
+    return touched ? 0xfc8 : z;
+}
+
+uint32_t getFodUsageBits(uint32_t usageBits, bool) {
+    return usageBits;
+}
diff --git a/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc b/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc
new file mode 100644
index 0000000..bff67e8
--- /dev/null
+++ b/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc
@@ -0,0 +1,6 @@
+service fingerprint-inscreen-1-0 /system_ext/bin/hw/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus
+    interface vendor.lineage.biometrics.fingerprint.inscreen@1.0::IFingerprintInscreen default
+    class hal
+    user system
+    group system
+    shutdown critical
diff --git a/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml b/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml
new file mode 100644
index 0000000..0806439
--- /dev/null
+++ b/hidl/fingerprint/inscreen/lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml
@@ -0,0 +1,11 @@
+<manifest version="1.0" type="framework">
+    <hal format="hidl">
+        <name>vendor.lineage.biometrics.fingerprint.inscreen</name>
+        <transport>hwbinder</transport>
+        <version>1.0</version>
+        <interface>
+            <name>IFingerprintInscreen</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>
diff --git a/hidl/fingerprint/inscreen/service.cpp b/hidl/fingerprint/inscreen/service.cpp
new file mode 100644
index 0000000..305f704
--- /dev/null
+++ b/hidl/fingerprint/inscreen/service.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define LOG_TAG "vendor.lineage.biometrics.fingerprint.inscreen@1.0-service"
+
+#include <android-base/logging.h>
+#include <hidl/HidlTransportSupport.h>
+
+#include "FingerprintInscreen.h"
+
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+
+using vendor::lineage::biometrics::fingerprint::inscreen::V1_0::IFingerprintInscreen;
+using vendor::lineage::biometrics::fingerprint::inscreen::V1_0::implementation::FingerprintInscreen;
+
+using android::OK;
+using android::status_t;
+
+int main() {
+    android::sp<IFingerprintInscreen> service = new FingerprintInscreen();
+
+    configureRpcThreadpool(1, true);
+
+    status_t status = service->registerAsService();
+    if (status != OK) {
+        LOG(ERROR) << "Cannot register FOD HAL service.";
+        return 1;
+    }
+
+    LOG(INFO) << "FOD HAL service ready.";
+
+    joinRpcThreadpool();
+
+    LOG(ERROR) << "FOD HAL service failed to join thread pool.";
+    return 1;
+}
diff --git a/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc b/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc
new file mode 100644
index 0000000..4c4e896
--- /dev/null
+++ b/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.rc
@@ -0,0 +1,10 @@
+on init
+    chown system system /sys/class/drm/card0-DSI-1/op_friginer_print_hbm
+    chmod 0660 /sys/class/drm/card0-DSI-1/op_friginer_print_hbm
+
+service vendor.fingerprint-inscreen-1-0 /vendor/bin/hw/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus
+    interface vendor.lineage.biometrics.fingerprint.inscreen@1.0::IFingerprintInscreen default
+    class hal
+    user system
+    group system
+    shutdown critical
diff --git a/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml b/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml
new file mode 100644
index 0000000..e03c70c
--- /dev/null
+++ b/hidl/fingerprint/inscreen/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.oneplus.xml
@@ -0,0 +1,11 @@
+<manifest version="1.0" type="device">
+    <hal format="hidl">
+        <name>vendor.lineage.biometrics.fingerprint.inscreen</name>
+        <transport>hwbinder</transport>
+        <version>1.0</version>
+        <interface>
+            <name>IFingerprintInscreen</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>
diff --git a/hidl/fingerprint/service.cpp b/hidl/fingerprint/service.cpp
new file mode 100644
index 0000000..edfaac4
--- /dev/null
+++ b/hidl/fingerprint/service.cpp
@@ -0,0 +1,48 @@
+/*
+ * 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.1-service"
+
+#include <android/log.h>
+#include <hidl/HidlSupport.h>
+#include <hidl/HidlTransportSupport.h>
+#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
+#include <android/hardware/biometrics/fingerprint/2.1/types.h>
+#include "BiometricsFingerprint.h"
+
+using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;
+using android::hardware::biometrics::fingerprint::V2_1::implementation::BiometricsFingerprint;
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+using android::sp;
+
+int main() {
+    android::sp<IBiometricsFingerprint> bio = BiometricsFingerprint::getInstance();
+
+    configureRpcThreadpool(1, true /*callerWillJoin*/);
+
+    if (bio != nullptr) {
+        if (::android::OK != bio->registerAsService()) {
+            return 1;
+        }
+    } else {
+        ALOGE("Can't create instance of BiometricsFingerprint, nullptr");
+    }
+
+    joinRpcThreadpool();
+
+    return 0; // should never get here
+}