Unverified Commit d5a31f1c authored by dev-harsh1998's avatar dev-harsh1998 Committed by pjgowtham
Browse files

nicky: Import udfps_wrapper from realme x2

parent 3a25a335

BoardConfig.mk

+1 −1
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ TARGET_USES_ION := true 
TARGET_FS_CONFIG_GEN := $(DEVICE_PATH)/config.fs



# Fingerprint

TARGET_SURFACEFLINGER_UDFPS_LIB := //hardware/oplus:libudfps_extension.oplus

TARGET_SURFACEFLINGER_UDFPS_LIB := //$(DEVICE_PATH):libudfps_extension.nicky



# Init

TARGET_INIT_VENDOR_LIB := //$(DEVICE_PATH):libinit_oplus

device.mk

+1 −1
Original line number Diff line number Diff line
@@ -186,7 +186,7 @@ PRODUCT_PACKAGES += \ 


# Fingerprint

PRODUCT_PACKAGES += \

    android.hardware.biometrics.fingerprint@2.3-service.oplus

    android.hardware.biometrics.fingerprint@2.3-service.nicky



# Gatekeeper

PRODUCT_PACKAGES += \

udfps_wrapper/Android.bp

0 → 100644
+48 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2021 The LineageOS 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.



cc_binary {

    name: "android.hardware.biometrics.fingerprint@2.3-service.nicky",

    defaults: ["hidl_defaults"],

    init_rc: ["android.hardware.biometrics.fingerprint@2.3-service.nicky.rc"],

    vintf_fragments: ["android.hardware.biometrics.fingerprint@2.3-service.nicky.xml"],

    relative_install_path: "hw",

    proprietary: true,

    srcs: [

        "service.cpp",

        "BiometricsFingerprint.cpp",

    ],

    cflags: [

        "-Wno-unused-parameter",

    ],

    shared_libs: [

        "libbase",

        "libhidlbase",

        "liblog",

        "libutils",

        "android.hardware.biometrics.fingerprint@2.1",

        "android.hardware.biometrics.fingerprint@2.2",

        "android.hardware.biometrics.fingerprint@2.3",

        "vendor.oplus.hardware.biometrics.fingerprint@2.1",

    ],

}



cc_library_static {

    name: "libudfps_extension.nicky",

    srcs: ["UdfpsExtension.cpp"],

    include_dirs: [

        "frameworks/native/services/surfaceflinger/CompositionEngine/include"

    ],

}

udfps_wrapper/BiometricsFingerprint.cpp

0 → 100644
+254 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The LineageOS 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.nicky"



#include "BiometricsFingerprint.h"



#include <android-base/logging.h>

#include <inttypes.h>

#include <unistd.h>

#include <functional>

#include <fstream>

#include <thread>



#define FOD_STATUS_PATH "/sys/kernel/oppo_display/notify_fppress"

#define DIMLAYER_PATH "/sys/kernel/oppo_display/dimlayer_hbm"

#define STATUS_ON 1

#define STATUS_OFF 0

#define BIND(fn) [this](auto&&... args) -> decltype(auto) { return this->fn(std::forward<decltype(args)>(args)...); }



namespace android {

namespace hardware {

namespace biometrics {

namespace fingerprint {

namespace V2_3 {

namespace implementation {



template <typename T>

static inline void set(const std::string& path, const T& value) {

    std::ofstream file(path);

    file << value;

}



BiometricsFingerprint::BiometricsFingerprint() : isEnrolling(false) {

    mOplusBiometricsFingerprint = vendor::oplus::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint::getService();

    if (mOplusBiometricsFingerprint == nullptr) {

        LOG (ERROR) << "BiometricsFingerprint(): Oplus Biometrics hal didn't init trying again, Attempting rescue.";

        for (int i = 0; i < 10; i++) {

            mOplusBiometricsFingerprint = vendor::oplus::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint::getService();

            if (mOplusBiometricsFingerprint != nullptr) {

                LOG (INFO) << "BiometricsFingerprint(): rescue(): Got service for oplus biometrics hal exiting loop.";

                break;

            }

            LOG (INFO) << "BiometricsFingerprint(): rescue(): Unable to get service in witin: " << i+1 << " attempts.";

            sleep(15);

        }

        if (mOplusBiometricsFingerprint == nullptr) {

            LOG(ERROR) << "BiometricsFingerprint(): oplus biometrics service didn't start fingerprint hardware won't be available.";

            exit(0);

        }

    }

}



class OplusClientCallback : public vendor::oplus::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback {

public:

    OplusClientCallback(sp<android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback> clientCallback) : mClientCallback(clientCallback), onAuthenticationSuccess(nullptr) {}

    Return<void> onEnrollResult(uint64_t deviceId, uint32_t fingerId,

        uint32_t groupId, uint32_t remaining) {

        return mClientCallback->onEnrollResult(deviceId, fingerId, groupId, remaining);

    }



    Return<void> onAcquired(uint64_t deviceId, vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo acquiredInfo,

        int32_t vendorCode) {

        return mClientCallback->onAcquired(deviceId, OplusToAOSPFingerprintAcquiredInfo(acquiredInfo), vendorCode);

    }



    Return<void> onAuthenticated(uint64_t deviceId, uint32_t fingerId, uint32_t groupId,

        const hidl_vec<uint8_t>& token) {

        // FingerID = 0 means authentication failure.

        if (fingerId != 0) {

            if (onAuthenticationSuccess != nullptr) {

                onAuthenticationSuccess();

            }

        }

        return mClientCallback->onAuthenticated(deviceId, fingerId, groupId, token);

    }



    Return<void> onError(uint64_t deviceId, vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError error, int32_t vendorCode) {

        return mClientCallback->onError(deviceId, OplusToAOSPFingerprintError(error), vendorCode);

    }



    Return<void> onRemoved(uint64_t deviceId, uint32_t fingerId, uint32_t groupId,

        uint32_t remaining) {

        return mClientCallback->onRemoved(deviceId, fingerId, groupId, remaining);

    }



    Return<void> onEnumerate(uint64_t deviceId, uint32_t fingerId, uint32_t groupId,

        uint32_t remaining) {

        return mClientCallback->onEnumerate(deviceId, fingerId, groupId, remaining);

    }



    Return<void> onTouchUp(uint64_t deviceId) {

        set(FOD_STATUS_PATH, STATUS_ON);

        return Void();

    }



    Return<void> onTouchDown(uint64_t deviceId) {

        set(FOD_STATUS_PATH, STATUS_OFF);

        return Void();

    }



    Return<void> onSyncTemplates(uint64_t deviceId, const hidl_vec<uint32_t>& fingerId, uint32_t remaining) { return Void(); }

    Return<void> onFingerprintCmd(int32_t deviceId, const hidl_vec<uint32_t>& groupId, uint32_t remaining) { return Void(); }

    Return<void> onImageInfoAcquired(uint32_t type, uint32_t quality, uint32_t match_score) { return Void(); }

    Return<void> onMonitorEventTriggered(uint32_t type, const hidl_string& data) { return Void(); }

    Return<void> onEngineeringInfoUpdated(uint32_t length, const hidl_vec<uint32_t>& keys, const hidl_vec<hidl_string>& values) { return Void(); }

    void setOnAuthenticationSuccess(const std::function<void()>& callback) { onAuthenticationSuccess = callback; }



private:

    sp<android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback> mClientCallback;

    std::function<void()> onAuthenticationSuccess;



    Return<android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo> OplusToAOSPFingerprintAcquiredInfo(vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo info) {

        switch(info) {

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_GOOD: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_GOOD;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_PARTIAL: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_PARTIAL;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_IMAGER_DIRTY: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_IMAGER_DIRTY;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_TOO_SLOW: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_TOO_SLOW;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_TOO_FAST: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_TOO_FAST;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_VENDOR: return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_VENDOR;

            default:

                return android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo::ACQUIRED_GOOD;

        }

    }



    Return<android::hardware::biometrics::fingerprint::V2_1::FingerprintError> OplusToAOSPFingerprintError(vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError error) {

        switch(error) {

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_NO_ERROR: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_NO_ERROR;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_HW_UNAVAILABLE: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_HW_UNAVAILABLE;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_UNABLE_TO_PROCESS: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_UNABLE_TO_PROCESS;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_TIMEOUT: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_TIMEOUT;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_NO_SPACE: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_NO_SPACE;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_CANCELED: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_CANCELED;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_UNABLE_TO_REMOVE: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_UNABLE_TO_REMOVE;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_LOCKOUT: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_LOCKOUT;

            case vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_VENDOR: return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_VENDOR;

            default:

                return android::hardware::biometrics::fingerprint::V2_1::FingerprintError::ERROR_NO_ERROR;

        }

    }

};



Return<uint64_t> BiometricsFingerprint::setNotify(const sp<IBiometricsFingerprintClientCallback>& clientCallback) {

    OplusClientCallback* oplusClientCallback = new OplusClientCallback(clientCallback);

    oplusClientCallback->setOnAuthenticationSuccess(BIND(setFingerprintScreenStateOff));

    mOplusClientCallback = oplusClientCallback;

    return mOplusBiometricsFingerprint->setNotify(mOplusClientCallback);

}



Return<RequestStatus> BiometricsFingerprint::OplusToAOSPRequestStatus(vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus req) {

    switch(req) {

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_UNKNOWN: return RequestStatus::SYS_UNKNOWN;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_OK: return RequestStatus::SYS_OK;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_ENOENT: return RequestStatus::SYS_ENOENT;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EINTR: return RequestStatus::SYS_EINTR;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EIO: return RequestStatus::SYS_EIO;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EAGAIN: return RequestStatus::SYS_EAGAIN;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_ENOMEM: return RequestStatus::SYS_ENOMEM;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EACCES: return RequestStatus::SYS_EACCES;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EFAULT: return RequestStatus::SYS_EFAULT;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EBUSY: return RequestStatus::SYS_EBUSY;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_EINVAL: return RequestStatus::SYS_EINVAL;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_ENOSPC: return RequestStatus::SYS_ENOSPC;

        case vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus::SYS_ETIMEDOUT: return RequestStatus::SYS_ETIMEDOUT;

        default:

            return RequestStatus::SYS_UNKNOWN;

    }

}



void BiometricsFingerprint::setFingerprintScreenState(const bool on) {

    mOplusBiometricsFingerprint->setScreenState(

        on ? vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintScreenState::FINGERPRINT_SCREEN_ON :

            vendor::oplus::hardware::biometrics::fingerprint::V2_1::FingerprintScreenState::FINGERPRINT_SCREEN_OFF

        );

    set(DIMLAYER_PATH, on ? STATUS_ON: STATUS_OFF);

}



void BiometricsFingerprint::setFingerprintScreenStateOff() {

    setFingerprintScreenState(false);

}



Return<uint64_t> BiometricsFingerprint::preEnroll() {

    setFingerprintScreenState(true);

    return mOplusBiometricsFingerprint->preEnroll();

}



Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat, uint32_t gid, uint32_t timeoutSec) {

    isEnrolling = true;

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->enroll(hat, gid, timeoutSec));

}



Return<RequestStatus> BiometricsFingerprint::postEnroll() {

    isEnrolling = false;

    setFingerprintScreenState(isEnrolling);

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->postEnroll());

}



Return<uint64_t> BiometricsFingerprint::getAuthenticatorId() {

    return mOplusBiometricsFingerprint->getAuthenticatorId();

}



Return<RequestStatus> BiometricsFingerprint::cancel() {

    if (isEnrolling)

        isEnrolling = false;

    else 

        setFingerprintScreenState(false);

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->cancel());

}



Return<RequestStatus> BiometricsFingerprint::enumerate() {

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->enumerate());

}



Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->remove(gid, fid));

}



Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid, const hidl_string& storePath) {

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->setActiveGroup(gid, storePath));

}



Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId, uint32_t gid) {

    RequestStatus status = OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->authenticate(operationId, gid));

    if (status == RequestStatus::SYS_OK) {

        setFingerprintScreenState(true);

    }

    return OplusToAOSPRequestStatus(mOplusBiometricsFingerprint->authenticate(operationId, gid));

}



Return<bool> BiometricsFingerprint::isUdfps(uint32_t) { return true; }



Return<void> BiometricsFingerprint::onFingerDown(uint32_t, uint32_t, float, float) { return Void(); }



Return<void> BiometricsFingerprint::onFingerUp() { return Void(); }



}  // namespace implementation

}  // namespace V2_3

}  // namespace fingerprint

}  // namespace biometrics

}  // namespace hardware

}  // namespace android

udfps_wrapper/BiometricsFingerprint.h

0 → 100644
+77 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The LineageOS 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.

 */



#pragma once



#include <android/hardware/biometrics/fingerprint/2.3/IBiometricsFingerprint.h>

#include <vendor/oplus/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.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::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;

using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;

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::sp;



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;



    // our own functions

    void setFingerprintScreenState(const bool on);

    void setFingerprintScreenStateOff();



private:

    bool isEnrolling;

    sp<vendor::oplus::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint> mOplusBiometricsFingerprint;

    sp<vendor::oplus::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback> mOplusClientCallback;

    static Return<RequestStatus> OplusToAOSPRequestStatus(vendor::oplus::hardware::biometrics::fingerprint::V2_1::RequestStatus req);

};



}  // namespace implementation

}  // namespace V2_2

}  // namespace fingerprint

}  // namespace biometrics

}  // namespace hardware

}  // namespace android