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

Commit 1d5e03f4 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 7529640 from 4f53440f to sc-release 

Change-Id: I6eceaa81856d8802d0285827ba50a023e90a97af
parents f2a9ca80 4f53440f

audio/common/7.0/enums/include/android_audio_policy_configuration_V7_0-enums.h

+0 −8
Original line number Diff line number Diff line
@@ -225,14 +225,6 @@ static inline bool isTelephonyDevice(const std::string& device) { 
    return isTelephonyDevice(stringToAudioDevice(device));

}



static inline bool isEchoReferenceDevice(AudioDevice device) {

    return device == AudioDevice::AUDIO_DEVICE_IN_ECHO_REFERENCE;

}



static inline bool isEchoReferenceDevice(const std::string& device) {

    return isEchoReferenceDevice(stringToAudioDevice(device));

}



static inline bool maybeVendorExtension(const std::string& s) {

    // Only checks whether the string starts with the "vendor prefix".

    static const std::string vendorPrefix = "VX_";

audio/core/all-versions/vts/functional/7.0/AudioPrimaryHidlHalTest.cpp

+1 −2
Original line number Diff line number Diff line
@@ -710,8 +710,7 @@ class PcmOnlyConfigInputStreamTest : public InputStreamTest { 
        // Returning 'true' when no source is found so the test can fail later with a more clear

        // problem description.

        return !maybeSourceAddress.has_value() ||

               !(xsd::isTelephonyDevice(maybeSourceAddress.value().deviceType) ||

                 xsd::isEchoReferenceDevice(maybeSourceAddress.value().deviceType));

               !xsd::isTelephonyDevice(maybeSourceAddress.value().deviceType);

    }



    void createPatchIfNeeded() {

biometrics/face/aidl/default/Session.cpp

+14 −2
Original line number Diff line number Diff line
@@ -34,12 +34,15 @@ class CancellationSignal : public common::BnCancellationSignal { 
    }

};



Session::Session(std::shared_ptr<ISessionCallback> cb) : cb_(std::move(cb)) {}

Session::Session(std::shared_ptr<ISessionCallback> cb)

    : cb_(std::move(cb)), mRandom(std::mt19937::default_seed) {}



ndk::ScopedAStatus Session::generateChallenge() {

    LOG(INFO) << "generateChallenge";

    if (cb_) {

        cb_->onChallengeGenerated(0);

        std::uniform_int_distribution<int64_t> dist;

        auto challenge = dist(mRandom);

        cb_->onChallengeGenerated(challenge);

    }

    return ndk::ScopedAStatus::ok();

}
@@ -63,6 +66,9 @@ ndk::ScopedAStatus Session::enroll( 
        const std::vector<Feature>& /*features*/, const NativeHandle& /*previewSurface*/,

        std::shared_ptr<biometrics::common::ICancellationSignal>* /*return_val*/) {

    LOG(INFO) << "enroll";

    if (cb_) {

        cb_->onError(Error::UNABLE_TO_PROCESS, 0 /* vendorError */);

    }

    return ndk::ScopedAStatus::ok();

}
@@ -100,6 +106,9 @@ ndk::ScopedAStatus Session::removeEnrollments(const std::vector<int32_t>& /*enro 


ndk::ScopedAStatus Session::getFeatures() {

    LOG(INFO) << "getFeatures";

    if (cb_) {

        cb_->onFeaturesRetrieved({});

    }

    return ndk::ScopedAStatus::ok();

}
@@ -119,6 +128,9 @@ ndk::ScopedAStatus Session::getAuthenticatorId() { 


ndk::ScopedAStatus Session::invalidateAuthenticatorId() {

    LOG(INFO) << "invalidateAuthenticatorId";

    if (cb_) {

        cb_->onAuthenticatorIdInvalidated(0);

    }

    return ndk::ScopedAStatus::ok();

}

biometrics/face/aidl/default/Session.h

+3 −0
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 


#pragma once



#include <random>



#include <aidl/android/hardware/biometrics/face/BnSession.h>

#include <aidl/android/hardware/biometrics/face/ISessionCallback.h>
@@ -68,6 +70,7 @@ class Session : public BnSession { 


  private:

    std::shared_ptr<ISessionCallback> cb_;

    std::mt19937 mRandom;

};



}  // namespace aidl::android::hardware::biometrics::face

biometrics/face/aidl/vts/VtsHalBiometricsFaceTargetTest.cpp

+179 −24
Original line number Diff line number Diff line
@@ -29,16 +29,26 @@ namespace { 


using namespace std::literals::chrono_literals;



using aidl::android::hardware::common::NativeHandle;



constexpr int kSensorId = 0;

constexpr int kUserId = 0;



class SessionCallback : public BnSessionCallback {

  public:

    ndk::ScopedAStatus onChallengeGenerated(int64_t /*challenge*/) override {

    ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override {

        auto lock = std::lock_guard{mMutex};

        mOnChallengeGeneratedInvoked = true;

        mGeneratedChallenge = challenge;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }



    ndk::ScopedAStatus onChallengeRevoked(int64_t /*challenge*/) override {

    ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override {

        auto lock = std::lock_guard{mMutex};

        mOnChallengeRevokedInvoked = true;

        mRevokedChallenge = challenge;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }
@@ -50,10 +60,9 @@ class SessionCallback : public BnSessionCallback { 
        return ndk::ScopedAStatus::ok();

    }



    ndk::ScopedAStatus onError(Error error, int32_t vendorCode) override {

    ndk::ScopedAStatus onError(Error error, int32_t /*vendorCode*/) override {

        auto lock = std::lock_guard<std::mutex>{mMutex};

        mError = error;

        mVendorCode = vendorCode;

        mOnErrorInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();
@@ -83,15 +92,24 @@ class SessionCallback : public BnSessionCallback { 


    ndk::ScopedAStatus onEnrollmentsEnumerated(

            const std::vector<int32_t>& /*enrollmentIds*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnEnrollmentsEnumeratedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }



    ndk::ScopedAStatus onEnrollmentsRemoved(

            const std::vector<int32_t>& /*enrollmentIds*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnEnrollmentsRemovedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }



    ndk::ScopedAStatus onFeaturesRetrieved(const std::vector<Feature>& /*features*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnFeaturesRetrievedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }
@@ -100,10 +118,16 @@ class SessionCallback : public BnSessionCallback { 
    }



    ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t /*authenticatorId*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnAuthenticatorIdRetrievedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }



    ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t /*newAuthenticatorId*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnAuthenticatorIdInvalidatedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }
@@ -117,46 +141,177 @@ class SessionCallback : public BnSessionCallback { 
    std::mutex mMutex;

    std::condition_variable mCv;

    Error mError = Error::UNKNOWN;

    int32_t mVendorCode = 0;

    int64_t mGeneratedChallenge = 0;

    int64_t mRevokedChallenge = 0;

    bool mOnChallengeGeneratedInvoked = false;

    bool mOnChallengeRevokedInvoked = false;

    bool mOnErrorInvoked = false;

    bool mOnEnrollmentsEnumeratedInvoked = false;

    bool mOnEnrollmentsRemovedInvoked = false;

    bool mOnFeaturesRetrievedInvoked = false;

    bool mOnAuthenticatorIdRetrievedInvoked = false;

    bool mOnAuthenticatorIdInvalidatedInvoked = false;

    bool mOnSessionClosedInvoked = false;

};



class Face : public testing::TestWithParam<std::string> {

  protected:

    void SetUp() override {

        // Prepare the callback.

        mCb = ndk::SharedRefBase::make<SessionCallback>();



        int retries = 0;

        bool isOk = false;

        // If the first attempt to create a session fails, we try to create a session again. The

        // first attempt might fail if the framework already has an active session. The AIDL

        // contract doesn't allow to create a new session without closing the old one. However, we

        // can't close the framework's session from VTS. The expectation here is that the HAL will

        // crash after the first illegal attempt to create a session, then it will restart, and then

        // we'll be able to create a session.

        do {

            // Get an instance of the HAL.

            AIBinder* binder = AServiceManager_waitForService(GetParam().c_str());

            ASSERT_NE(binder, nullptr);

            mHal = IFace::fromBinder(ndk::SpAIBinder(binder));



            // Create a session.

            isOk = mHal->createSession(kSensorId, kUserId, mCb, &mSession).isOk();

            ++retries;

        } while (!isOk && retries < 2);



        ASSERT_TRUE(isOk);

    }



    void TearDown() override {

        // Close the mSession.

        ASSERT_TRUE(mSession->close().isOk());



        // Make sure the mSession is closed.

        auto lock = std::unique_lock<std::mutex>(mCb->mMutex);

        mCb->mCv.wait(lock, [this] { return mCb->mOnSessionClosedInvoked; });

    }



    std::shared_ptr<IFace> mHal;

    std::shared_ptr<SessionCallback> mCb;

    std::shared_ptr<ISession> mSession;

};



TEST_P(Face, AuthenticateTest) {

    // Prepare the callback.

    auto cb = ndk::SharedRefBase::make<SessionCallback>();

TEST_P(Face, GetSensorPropsWorksTest) {

    std::vector<SensorProps> sensorProps;



    // Create a session

    std::shared_ptr<ISession> session;

    ASSERT_TRUE(mHal->createSession(kSensorId, kUserId, cb, &session).isOk());

    // Call the method.

    ASSERT_TRUE(mHal->getSensorProps(&sensorProps).isOk());



    // Call authenticate

    // Make sure the sensorProps aren't empty.

    ASSERT_FALSE(sensorProps.empty());

    ASSERT_FALSE(sensorProps[0].commonProps.componentInfo.empty());

}



TEST_P(Face, EnrollWithBadHatResultsInErrorTest) {

    // Call the method.

    auto hat = keymaster::HardwareAuthToken{};

    std::shared_ptr<common::ICancellationSignal> cancellationSignal;

    ASSERT_TRUE(session->authenticate(0 /* operationId */, &cancellationSignal).isOk());

    ASSERT_TRUE(

            mSession->enroll(hat, EnrollmentType::DEFAULT, {}, NativeHandle{}, &cancellationSignal)

                    .isOk());



    auto lock = std::unique_lock<std::mutex>(cb->mMutex);

    cb->mCv.wait(lock, [&cb] { return cb->mOnErrorInvoked; });

    // Get the results

    EXPECT_EQ(cb->mError, Error::UNABLE_TO_PROCESS);

    EXPECT_EQ(cb->mVendorCode, 0);

    // Make sure an error is returned.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnErrorInvoked; });

}



TEST_P(Face, GenerateChallengeProducesUniqueChallengesTest) {

    static constexpr int kIterations = 100;



    auto challenges = std::set<int>{};

    for (unsigned int i = 0; i < kIterations; ++i) {

        // Call the method.

        ASSERT_TRUE(mSession->generateChallenge().isOk());



        // Check that the generated challenge is unique and not 0.

        auto lock = std::unique_lock{mCb->mMutex};

        mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeGeneratedInvoked; });

        ASSERT_NE(mCb->mGeneratedChallenge, 0);

        ASSERT_EQ(challenges.find(mCb->mGeneratedChallenge), challenges.end());



        challenges.insert(mCb->mGeneratedChallenge);

        mCb->mOnChallengeGeneratedInvoked = false;

    }

}



TEST_P(Face, RevokeChallengeWorksForNonexistentChallengeTest) {

    const int64_t nonexistentChallenge = 123;



    // Call the method.

    ASSERT_TRUE(mSession->revokeChallenge(nonexistentChallenge).isOk());



    // Check that the challenge is revoked and matches the requested challenge.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeRevokedInvoked; });

    ASSERT_EQ(mCb->mRevokedChallenge, nonexistentChallenge);

}



TEST_P(Face, RevokeChallengeWorksForExistentChallengeTest) {

    // Generate a challenge.

    ASSERT_TRUE(mSession->generateChallenge().isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeGeneratedInvoked; });

    lock.unlock();



    // Close the session

    ASSERT_TRUE(session->close().isOk());

    // Revoke the challenge.

    ASSERT_TRUE(mSession->revokeChallenge(mCb->mGeneratedChallenge).isOk());



    // Check that the challenge is revoked and matches the requested challenge.

    lock.lock();

    cb->mCv.wait(lock, [&cb] { return cb->mOnSessionClosedInvoked; });

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeRevokedInvoked; });

    ASSERT_EQ(mCb->mRevokedChallenge, mCb->mGeneratedChallenge);

}



TEST_P(Face, EnumerateEnrollmentsWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->enumerateEnrollments().isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnEnrollmentsEnumeratedInvoked; });

}



TEST_P(Face, RemoveEnrollmentsWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->removeEnrollments({}).isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnEnrollmentsRemovedInvoked; });

}



TEST_P(Face, GetFeaturesWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->getFeatures().isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnFeaturesRetrievedInvoked; });

}



TEST_P(Face, GetAuthenticatorIdWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->getAuthenticatorId().isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnAuthenticatorIdRetrievedInvoked; });

}



TEST_P(Face, InvalidateAuthenticatorIdWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->invalidateAuthenticatorId().isOk());



    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnAuthenticatorIdInvalidatedInvoked; });

}



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Face);