Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 49120d93 authored by Ilya Matyukhin's avatar Ilya Matyukhin
Browse files

Remove enroll_2_2 and authenticate_2_2 

Bug: 139317981
Bug: 149502271
Test: m vts -j
Test: vts-tradefed run commandAndExit vts -m VtsHalBiometricsFingerprintV2_2Target
Change-Id: I80492f324753291be4118de95e16ec370004afc8
parent 9a471eb8

biometrics/fingerprint/2.2/IBiometricsFingerprint.hal

+6 −36
Original line number Original line Diff line number Diff line
@@ -17,42 +17,12 @@ 
package android.hardware.biometrics.fingerprint@2.2;

package android.hardware.biometrics.fingerprint@2.2;





import @2.1::IBiometricsFingerprint;

import @2.1::IBiometricsFingerprint;

import @2.1::RequestStatus;





interface IBiometricsFingerprint extends @2.1::IBiometricsFingerprint {

/**

/**

     * Fingerprint enroll request:

 * The HAL interface for biometric fingerprint authentication.

     * Switches the HAL state machine to collect and store a new fingerprint

     * template. Switches back as soon as enroll is complete, signalled by

     * (fingerprintMsg.type == FINGERPRINT_TEMPLATE_ENROLLING &&

     *  fingerprintMsg.data.enroll.samplesRemaining == 0)

     * or after timeoutSec seconds.

     * The fingerprint template must be assigned to the group gid.

     *

     * @param hat a valid Hardware Authentication Token (HAT), generated

     * as a result of a preEnroll() call.

     * @param gid a framework defined fingerprint set (group) id.

     * @param timeoutSec a timeout in seconds.

     * @param windowId optional ID of an illumination window for optical under

     * display fingerprint sensors. Must contain a null pointer if not used.

     *

     * @return debugErrno is a value the framework logs in case it is not 0.

 *

 *

     * A notify() function may be called with a more detailed error structure.

 * This interface is required because all top-level interfaces need to be

 * updated in a minor uprev.

 */

 */

    enroll_2_2(vec<uint8_t> hat, uint32_t gid, uint32_t timeoutSec, handle windowId)

interface IBiometricsFingerprint extends @2.1::IBiometricsFingerprint {

        generates (RequestStatus debugErrno);



    /**

     * Authenticates an operation identified by operationId

     *

     * @param operationId operation id.

     * @param gid fingerprint group id.

     * @param windowId optional ID of an illumination window for optical under

     * display fingerprint sensors. Must contain a null pointer if not used.

     *

     * @return debugErrno is a value the framework logs in case it is not 0.

     */

    authenticate_2_2(uint64_t operationId, uint32_t gid, handle windowId)

        generates (RequestStatus debugErrno);

};
 
};

biometrics/fingerprint/2.2/vts/functional/VtsHalBiometricsFingerprintV2_2TargetTest.cpp

+36 −60
Original line number Original line Diff line number Diff line
@@ -18,66 +18,67 @@ 




#include <VtsHalHidlTargetCallbackBase.h>

#include <VtsHalHidlTargetCallbackBase.h>

#include <android-base/properties.h>

#include <android-base/properties.h>

#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>

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

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

#include <android/hardware/biometrics/fingerprint/2.2/IBiometricsFingerprintClientCallback.h>

#include <gtest/gtest.h>

#include <gtest/gtest.h>

#include <hidl/GtestPrinter.h>

#include <hidl/GtestPrinter.h>

#include <hidl/HidlSupport.h>

#include <hidl/HidlSupport.h>

#include <hidl/ServiceManagement.h>

#include <hidl/ServiceManagement.h>





#include <cinttypes>

#include <cinttypes>

#include <random>



namespace {



namespace hidl_interface = android::hardware::biometrics::fingerprint::V2_1;

namespace hidl_interface_2_2 = android::hardware::biometrics::fingerprint::V2_2;



using hidl_interface::FingerprintError;

using hidl_interface::IBiometricsFingerprint;

using hidl_interface::RequestStatus;





using android::sp;

using android::sp;

using android::base::GetUintProperty;

using android::base::GetUintProperty;

using android::hardware::hidl_handle;

using android::hardware::hidl_vec;

using android::hardware::hidl_vec;

using android::hardware::Return;

using android::hardware::Return;

using android::hardware::Void;

using android::hardware::Void;

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

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

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

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

using android::hardware::biometrics::fingerprint::V2_2::IBiometricsFingerprint;



namespace {





constexpr uint32_t kTimeoutSec = 3;

constexpr uint32_t kTimeoutSec = 3;

constexpr auto kTimeout = std::chrono::seconds(kTimeoutSec);

constexpr auto kTimeout = std::chrono::seconds(kTimeoutSec);

constexpr uint32_t kGroupId = 99;

constexpr uint32_t kGroupId = 99;

constexpr char kCallbackNameOnError[] = "onError";

constexpr char kCallbackNameOnAcquired[] = "onAcquired";





// Callback arguments that need to be captured for the tests.

// Callback arguments that need to be captured for the tests.

struct FingerprintCallbackArgs {

struct FingerprintCallbackArgs {

    // The error passed to the last onError() callback.

    // The info passed to the last onAcquired() callback.

    FingerprintError error;

    hidl_interface_2_2::FingerprintAcquiredInfo info;



    // The deviceId passed to the last callback.

    uint64_t deviceId;

};

};





// Test callback class for the BiometricsFingerprint HAL.

// Test callback class for the BiometricsFingerprint HAL.

// The HAL will call these callback methods to notify about completed operations

// The HAL will call these callback methods to notify about completed operations

// or encountered errors.

// or encountered errors.

class FingerprintCallback : public ::testing::VtsHalHidlTargetCallbackBase<FingerprintCallbackArgs>,

class FingerprintCallback : public ::testing::VtsHalHidlTargetCallbackBase<FingerprintCallbackArgs>,

                            public IBiometricsFingerprintClientCallback {

                            public hidl_interface_2_2::IBiometricsFingerprintClientCallback {

  public:

  public:

    Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }

    Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }





    Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo, int32_t) override { return Void(); }

    Return<void> onAcquired(uint64_t, hidl_interface::FingerprintAcquiredInfo, int32_t) override {



    Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t, const hidl_vec<uint8_t>&) override {

        return Void();

        return Void();

    }

    }





    Return<void> onError(uint64_t deviceId, FingerprintError error, int32_t) override {

    Return<void> onAcquired_2_2(uint64_t, hidl_interface_2_2::FingerprintAcquiredInfo info,

                                int32_t) override {

        FingerprintCallbackArgs args = {};

        FingerprintCallbackArgs args = {};

        args.error = error;

        args.info = info;

        args.deviceId = deviceId;

        NotifyFromCallback(kCallbackNameOnAcquired, args);

        NotifyFromCallback(kCallbackNameOnError, args);

        return Void();

        return Void();

    }

    }





    Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t, const hidl_vec<uint8_t>&) override {

        return Void();

    }



    Return<void> onError(uint64_t, FingerprintError, int32_t) override { return Void(); }



    Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }

    Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }





    Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }

    Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t) override { return Void(); }
@@ -121,41 +122,16 @@ class FingerprintHidlTest : public ::testing::TestWithParam<std::string> { 
    sp<FingerprintCallback> mCallback;

    sp<FingerprintCallback> mCallback;

};

};





// Enroll with an invalid (all zeroes) HAT should fail.

// The START message and onAcquired_2_2 method should exist and work together correctly.

TEST_P(FingerprintHidlTest, EnrollZeroHatTest) {

// Note, this test doesn't use the HAL. It just makes sure that the newly added constant and

    // Filling HAT with zeros

// callback compile. Unfortunately, there is no way to test the usage of the constant within the

    hidl_vec<uint8_t> token(69);

// actual HAL.

    for (size_t i = 0; i < 69; i++) {

TEST_P(FingerprintHidlTest, acquiredInfoStartTest) {

        token[i] = 0;

    mCallback->SetWaitTimeoutDefault(kTimeout);

    }

    mCallback->onAcquired_2_2(0 /* deviceId */, hidl_interface_2_2::FingerprintAcquiredInfo::START,



                              0 /* vendorCode */);

    hidl_handle windowId = nullptr;

    auto res = mCallback->WaitForCallback(kCallbackNameOnAcquired);

    Return<RequestStatus> ret = mService->enroll_2_2(token, kGroupId, kTimeoutSec, windowId);

    ASSERT_EQ(hidl_interface_2_2::FingerprintAcquiredInfo::START, res.args->info);

    ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(ret));



    // At least one call to onError should occur

    auto res = mCallback->WaitForCallback(kCallbackNameOnError);

    ASSERT_NE(FingerprintError::ERROR_NO_ERROR, res.args->error);

}



// Enroll with an invalid (null) HAT should fail.

TEST_P(FingerprintHidlTest, EnrollGarbageHatTest) {

    // Filling HAT with pseudorandom invalid data.

    // Using default seed to make the test reproducible.

    std::mt19937 gen(std::mt19937::default_seed);

    std::uniform_int_distribution<uint8_t> dist;

    hidl_vec<uint8_t> token(69);

    for (size_t i = 0; i < 69; ++i) {

        token[i] = dist(gen);

    }



    hidl_handle windowId = nullptr;

    Return<RequestStatus> ret = mService->enroll_2_2(token, kGroupId, kTimeoutSec, windowId);

    ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(ret));



    // At least one call to onError should occur

    auto res = mCallback->WaitForCallback(kCallbackNameOnError);

    ASSERT_NE(FingerprintError::ERROR_NO_ERROR, res.args->error);

}

}





}  // anonymous namespace

}  // anonymous namespace