blob: bdbf72dea281a9e12c0fdec486b946d3859d0181 [file] [log] [blame]
/*
* 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_hidl_hal_test"
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportSupport.h>
#include <hidl/ServiceManagement.h>
#include <utils/Condition.h>
#include <cinttypes>
#include <future>
#include <utility>
using android::base::GetUintProperty;
using android::Condition;
using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;
using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
using android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo;
using android::hardware::biometrics::fingerprint::V2_1::FingerprintError;
using android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
using android::hardware::hidl_vec;
using android::hardware::Return;
using android::Mutex;
using android::sp;
namespace {
static const uint32_t kTimeout = 3;
static const std::chrono::seconds kTimeoutInSeconds = std::chrono::seconds(kTimeout);
static const uint32_t kGroupId = 99;
static std::string kTmpDir = "";
static const uint32_t kIterations = 1000;
// Wait for a callback to occur (signaled by the given future) up to the
// provided timeout. If the future is invalid or the callback does not come
// within the given time, returns false.
template<class ReturnType>
bool waitForCallback(
std::future<ReturnType> future,
std::chrono::milliseconds timeout = kTimeoutInSeconds) {
auto expiration = std::chrono::system_clock::now() + timeout;
EXPECT_TRUE(future.valid());
if (future.valid()) {
std::future_status status = future.wait_until(expiration);
EXPECT_NE(std::future_status::timeout, status)
<< "Timed out waiting for callback";
if (status == std::future_status::ready) {
return true;
}
}
return false;
}
// Base callback implementation that just logs all callbacks by default
class FingerprintCallbackBase : public IBiometricsFingerprintClientCallback {
public:
// implement methods of IBiometricsFingerprintClientCallback
virtual Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t)
override {
ALOGD("Enroll callback called.");
return Return<void>();
}
virtual Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo, int32_t)
override {
ALOGD("Acquired callback called.");
return Return<void>();
}
virtual Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t,
const hidl_vec<uint8_t>&) override {
ALOGD("Authenticated callback called.");
return Return<void>();
}
virtual Return<void> onError(uint64_t, FingerprintError, int32_t)
override {
ALOGD("Error callback called.");
EXPECT_TRUE(false); // fail any test that triggers an error
return Return<void>();
}
virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t)
override {
ALOGD("Removed callback called.");
return Return<void>();
}
virtual Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t)
override {
ALOGD("Enumerate callback called.");
return Return<void>();
}
};
class EnumerateCallback : public FingerprintCallbackBase {
public:
virtual Return<void> onEnumerate(uint64_t deviceId, uint32_t fingerId,
uint32_t groupId, uint32_t remaining) override {
this->deviceId = deviceId;
this->fingerId = fingerId;
this->groupId = groupId;
this->remaining = remaining;
if(remaining == 0UL) {
promise.set_value();
}
return Return<void>();
}
uint64_t deviceId;
uint32_t fingerId;
uint32_t groupId;
uint32_t remaining;
std::promise<void> promise;
};
class ErrorCallback : public FingerprintCallbackBase {
public:
ErrorCallback(
bool filterErrors=false,
FingerprintError errorType=FingerprintError::ERROR_NO_ERROR) {
this->filterErrors = filterErrors;
this->errorType = errorType;
}
virtual Return<void> onError(uint64_t deviceId, FingerprintError error,
int32_t vendorCode) override {
if ((this->filterErrors && this->errorType == error) || !this->filterErrors) {
this->deviceId = deviceId;
this->error = error;
this->vendorCode = vendorCode;
promise.set_value();
}
return Return<void>();
}
bool filterErrors;
FingerprintError errorType;
uint64_t deviceId;
FingerprintError error;
int32_t vendorCode;
std::promise<void> promise;
};
class RemoveCallback : public FingerprintCallbackBase {
public:
RemoveCallback(uint32_t groupId) {
this->removeGroupId = groupId;
}
virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t groupId,
uint32_t remaining) override {
EXPECT_EQ(this->removeGroupId, groupId);
if(remaining == 0UL) {
promise.set_value();
}
return Return<void>();
}
uint32_t removeGroupId;
std::promise<void> promise;
};
class FingerprintHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
mService = IBiometricsFingerprint::getService(GetParam());
ASSERT_FALSE(mService == nullptr);
/*
* Devices shipped from now on will instead store
* fingerprint data under /data/vendor_de/<user-id>/fpdata.
* Support for /data/vendor_de and /data/vendor_ce has been added to vold.
*/
uint64_t api_level = GetUintProperty<uint64_t>("ro.product.first_api_level", 0);
if (api_level == 0) {
api_level = GetUintProperty<uint64_t>("ro.build.version.sdk", 0);
}
ASSERT_TRUE(api_level != 0);
// 27 is the API number for O-MR1
if (api_level <= 27) {
kTmpDir = "/data/system/users/0/fpdata/";
} else {
kTmpDir = "/data/vendor_de/0/fpdata/";
}
Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
}
virtual void TearDown() override {}
sp<IBiometricsFingerprint> mService;
};
// The service should be reachable.
TEST_P(FingerprintHidlTest, ConnectTest) {
sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
}
// Starting the service with null callback should succeed.
TEST_P(FingerprintHidlTest, ConnectNullTest) {
Return<uint64_t> rc = mService->setNotify(NULL);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
}
// Pre-enroll should always return unique, cryptographically secure, non-zero number
TEST_P(FingerprintHidlTest, PreEnrollTest) {
std::map<uint64_t, uint64_t> m;
for (unsigned int i = 0; i < kIterations; ++i) {
uint64_t res = static_cast<uint64_t>(mService->preEnroll());
EXPECT_NE(0UL, res);
m[res]++;
EXPECT_EQ(1UL, m[res]);
}
}
// Enroll with an invalid (all zeroes) HAT should fail.
TEST_P(FingerprintHidlTest, EnrollInvalidHatTest) {
sp<ErrorCallback> cb = new ErrorCallback();
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
uint8_t token[69];
for (int i = 0; i < 69; i++) {
token[i] = 0;
}
Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// At least one call to onError should occur
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
}
// Enroll with an invalid (null) HAT should fail.
TEST_P(FingerprintHidlTest, EnrollNullTest) {
sp<ErrorCallback> cb = new ErrorCallback();
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
uint8_t token[69];
Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// At least one call to onError should occur
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
}
// PostEnroll should always return within 3s
TEST_P(FingerprintHidlTest, PostEnrollTest) {
sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
Return<uint64_t> rc = mService->setNotify(cb);
auto start = std::chrono::system_clock::now();
Return<RequestStatus> res = mService->postEnroll();
auto elapsed = std::chrono::system_clock::now() - start;
ASSERT_GE(kTimeoutInSeconds, elapsed);
}
// getAuthenticatorId should always return non-zero numbers
TEST_P(FingerprintHidlTest, GetAuthenticatorIdTest) {
Return<uint64_t> res = mService->getAuthenticatorId();
EXPECT_NE(0UL, static_cast<uint64_t>(res));
}
// Enumerate should always trigger onEnumerated(fid=0, rem=0) when there are no fingerprints
TEST_P(FingerprintHidlTest, EnumerateTest) {
sp<EnumerateCallback> cb = new EnumerateCallback();
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
// Callback will return when rem=0 is found
Return<RequestStatus> res = mService->enumerate();
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
EXPECT_EQ(0UL, cb->fingerId);
EXPECT_EQ(0UL, cb->remaining);
}
// Remove should succeed on any inputs
// At least one callback with "remaining=0" should occur
TEST_P(FingerprintHidlTest, RemoveFingerprintTest) {
// Register callback
sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
// Remove a fingerprint
Return<RequestStatus> res = mService->remove(kGroupId, 1);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// At least one call to onRemove with remaining=0 should occur
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
}
// Remove should accept 0 to delete all fingerprints
// At least one callback with "remaining=0" should occur.
TEST_P(FingerprintHidlTest, RemoveAllFingerprintsTest) {
// Register callback
sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
// Remove all fingerprints
Return<RequestStatus> res = mService->remove(kGroupId, 0);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
}
// Active group should successfully set to a writable location.
TEST_P(FingerprintHidlTest, SetActiveGroupTest) {
// Create an active group
Return<RequestStatus> res = mService->setActiveGroup(2, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// Reset active group
res = mService->setActiveGroup(kGroupId, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
}
// Active group should fail to set to an unwritable location.
TEST_P(FingerprintHidlTest, SetActiveGroupUnwritableTest) {
// Create an active group to an unwritable location (device root dir)
Return<RequestStatus> res = mService->setActiveGroup(3, "/");
ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// Reset active group
res = mService->setActiveGroup(kGroupId, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
}
// Active group should fail to set to a null location.
TEST_P(FingerprintHidlTest, SetActiveGroupNullTest) {
// Create an active group to a null location.
Return<RequestStatus> res = mService->setActiveGroup(4, nullptr);
ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// Reset active group
res = mService->setActiveGroup(kGroupId, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
}
// Cancel should always return ERROR_CANCELED from any starting state including
// the IDLE state.
TEST_P(FingerprintHidlTest, CancelTest) {
sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0UL, static_cast<uint64_t>(rc));
Return<RequestStatus> res = mService->cancel();
// check that we were able to make an IPC request successfully
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// make sure callback was invoked within kTimeoutInSeconds
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
// check error should be ERROR_CANCELED
ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
}
// A call to cancel should succeed during enroll.
TEST_P(FingerprintHidlTest, CancelEnrollTest) {
Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0U, static_cast<uint64_t>(rc));
uint8_t token[69];
res = mService->enroll(token, kGroupId, kTimeout);
// check that we were able to make an IPC request successfully
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
res = mService->cancel();
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// make sure callback was invoked within kTimeoutInSeconds
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
// check error should be ERROR_CANCELED
ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
}
// A call to cancel should succeed during authentication.
TEST_P(FingerprintHidlTest, CancelAuthTest) {
sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0U, static_cast<uint64_t>(rc));
Return<RequestStatus> res = mService->authenticate(0, kGroupId);
// check that we were able to make an IPC request successfully
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
res = mService->cancel();
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// make sure callback was invoked within kTimeoutInSeconds
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
// check error should be ERROR_CANCELED
ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
}
// A call to cancel should succeed during authentication.
TEST_P(FingerprintHidlTest, CancelRemoveTest) {
sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0U, static_cast<uint64_t>(rc));
// Remove a fingerprint
Return<RequestStatus> res = mService->remove(kGroupId, 1);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
res = mService->cancel();
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// make sure callback was invoked within kTimeoutInSeconds
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
// check error should be ERROR_CANCELED
ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
}
// A call to cancel should succeed during authentication.
TEST_P(FingerprintHidlTest, CancelRemoveAllTest) {
sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
Return<uint64_t> rc = mService->setNotify(cb);
ASSERT_NE(0U, static_cast<uint64_t>(rc));
// Remove a fingerprint
Return<RequestStatus> res = mService->remove(kGroupId, 0);
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
res = mService->cancel();
ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
// make sure callback was invoked within kTimeoutInSeconds
ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
// check error should be ERROR_CANCELED
ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
}
} // anonymous namespace
INSTANTIATE_TEST_SUITE_P(PerInstance, FingerprintHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(
IBiometricsFingerprint::descriptor)),
android::hardware::PrintInstanceNameToString);