From 28c81f19489b50a560dd124d74c144475139d15d Mon Sep 17 00:00:00 2001 From: Lais Andrade Date: Mon, 24 Jun 2024 14:32:22 +0100 Subject: [PATCH] Disable cpp backend for android.hardware.vibrator Disable CPP backend for vibrator HAL. Dependencies should use the stable NDK instead. This is also the recommended choice: https://source.android.com/docs/core/architecture/aidl/aidl-hals#choosing-runtime The HAL will be allowed to use ndk-stable types like PersistableBundle after disabling the legacy CPP backend. Fix: 349595412 Test: VtsHalVibratorTargetTest & VtsHalVibratorManagerTargetTest Flag: EXEMPT NDK Change-Id: Id5736e092afd36e786ecf3978ff6ad81c7a4df56 --- tests/extension/vibrator/aidl/Android.bp | 6 + .../extension/vibrator/aidl/client/Android.bp | 8 +- .../vibrator/aidl/client/test-cpp-client.cpp | 52 -- .../vibrator/aidl/client/test-ndk-client.cpp | 4 +- vibrator/aidl/Android.bp | 6 + vibrator/aidl/vts/Android.bp | 8 +- .../vts/VtsHalVibratorManagerTargetTest.cpp | 172 +++---- .../aidl/vts/VtsHalVibratorTargetTest.cpp | 485 +++++++++--------- vibrator/aidl/vts/test_utils.h | 60 +++ vibrator/bench/Android.bp | 4 +- vibrator/bench/benchmark.cpp | 58 ++- 11 files changed, 447 insertions(+), 416 deletions(-) delete mode 100644 tests/extension/vibrator/aidl/client/test-cpp-client.cpp create mode 100644 vibrator/aidl/vts/test_utils.h diff --git a/tests/extension/vibrator/aidl/Android.bp b/tests/extension/vibrator/aidl/Android.bp index 0306dca626..9d6fdbcfba 100644 --- a/tests/extension/vibrator/aidl/Android.bp +++ b/tests/extension/vibrator/aidl/Android.bp @@ -37,6 +37,12 @@ aidl_interface { java: { enabled: false, }, + ndk: { + enabled: true, + }, + cpp: { + enabled: false, + }, }, frozen: true, versions_with_info: [ diff --git a/tests/extension/vibrator/aidl/client/Android.bp b/tests/extension/vibrator/aidl/client/Android.bp index 284ac7459b..00510b7443 100644 --- a/tests/extension/vibrator/aidl/client/Android.bp +++ b/tests/extension/vibrator/aidl/client/Android.bp @@ -16,16 +16,10 @@ cc_test { srcs: [ // system code has the option to use the unstable C++ libbinder API // or the NDK one. For maximum code portability, using the ndk client - // makes the most sense, but both are provided here as an example. - "test-cpp-client.cpp", + // makes the most sense. "test-ndk-client.cpp", ], shared_libs: [ - "libbinder", - "libutils", - "android.hardware.vibrator-V2-cpp", - "android.hardware.tests.extension.vibrator-V1-cpp", - "libbinder_ndk", "android.hardware.vibrator-V2-ndk", "android.hardware.tests.extension.vibrator-V1-ndk", diff --git a/tests/extension/vibrator/aidl/client/test-cpp-client.cpp b/tests/extension/vibrator/aidl/client/test-cpp-client.cpp deleted file mode 100644 index 015a3453cb..0000000000 --- a/tests/extension/vibrator/aidl/client/test-cpp-client.cpp +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (C) 2019 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. - */ - -#include -#include -#include -#include -#include - -using android::checked_interface_cast; -using android::IBinder; -using android::IInterface; -using android::OK; -using android::sp; -using android::waitForVintfService; -using android::hardware::tests::extension::vibrator::Directionality; -using android::hardware::tests::extension::vibrator::ICustomVibrator; -using android::hardware::vibrator::IVibrator; - -TEST(Cpp, CallRootMethod) { - sp vib = waitForVintfService(); - ASSERT_NE(nullptr, vib.get()); - ASSERT_TRUE(vib->off().isOk()); -} - -TEST(Cpp, CallExtMethod) { - // normally you would want to cache this - sp vib = waitForVintfService(); - ASSERT_NE(nullptr, vib.get()); - - // getting the extension - sp ext; - ASSERT_EQ(OK, IInterface::asBinder(vib)->getExtension(&ext)); - sp cvib = checked_interface_cast(ext); - ASSERT_NE(nullptr, cvib.get()); - - // calling extension method - ASSERT_TRUE(cvib->setDirectionality(Directionality::TRANSVERSE).isOk()); -} diff --git a/tests/extension/vibrator/aidl/client/test-ndk-client.cpp b/tests/extension/vibrator/aidl/client/test-ndk-client.cpp index c846495984..4dd86e8c5d 100644 --- a/tests/extension/vibrator/aidl/client/test-ndk-client.cpp +++ b/tests/extension/vibrator/aidl/client/test-ndk-client.cpp @@ -28,7 +28,7 @@ using ndk::SpAIBinder; static const std::string kInstance = std::string() + IVibrator::descriptor + "/default"; TEST(Ndk, CallRootMethod) { - SpAIBinder vibBinder = SpAIBinder(AServiceManager_getService(kInstance.c_str())); + SpAIBinder vibBinder = SpAIBinder(AServiceManager_waitForService(kInstance.c_str())); ASSERT_NE(nullptr, vibBinder.get()); std::shared_ptr vib = IVibrator::fromBinder(vibBinder); ASSERT_NE(nullptr, vib.get()); @@ -38,7 +38,7 @@ TEST(Ndk, CallRootMethod) { TEST(Ndk, CallExtMethod) { // normally you would want to cache this // - SpAIBinder vibBinder = SpAIBinder(AServiceManager_getService(kInstance.c_str())); + SpAIBinder vibBinder = SpAIBinder(AServiceManager_waitForService(kInstance.c_str())); ASSERT_NE(nullptr, vibBinder.get()); std::shared_ptr vib = IVibrator::fromBinder(vibBinder); ASSERT_NE(nullptr, vib.get()); diff --git a/vibrator/aidl/Android.bp b/vibrator/aidl/Android.bp index b5199e248b..fe7645067b 100644 --- a/vibrator/aidl/Android.bp +++ b/vibrator/aidl/Android.bp @@ -20,6 +20,12 @@ aidl_interface { java: { sdk_version: "system_current", }, + ndk: { + enabled: true, + }, + cpp: { + enabled: false, + }, }, versions: [ "1", diff --git a/vibrator/aidl/vts/Android.bp b/vibrator/aidl/vts/Android.bp index b6d2fb27da..166b30ba6a 100644 --- a/vibrator/aidl/vts/Android.bp +++ b/vibrator/aidl/vts/Android.bp @@ -17,10 +17,10 @@ cc_test { tidy_timeout_srcs: ["VtsHalVibratorTargetTest.cpp"], srcs: ["VtsHalVibratorTargetTest.cpp"], shared_libs: [ - "libbinder", + "libbinder_ndk", ], static_libs: [ - "android.hardware.vibrator-V2-cpp", + "android.hardware.vibrator-V2-ndk", ], test_suites: [ "general-tests", @@ -36,10 +36,10 @@ cc_test { ], srcs: ["VtsHalVibratorManagerTargetTest.cpp"], shared_libs: [ - "libbinder", + "libbinder_ndk", ], static_libs: [ - "android.hardware.vibrator-V2-cpp", + "android.hardware.vibrator-V2-ndk", ], test_suites: [ "general-tests", diff --git a/vibrator/aidl/vts/VtsHalVibratorManagerTargetTest.cpp b/vibrator/aidl/vts/VtsHalVibratorManagerTargetTest.cpp index e8ed26ab69..3c2a3607b1 100644 --- a/vibrator/aidl/vts/VtsHalVibratorManagerTargetTest.cpp +++ b/vibrator/aidl/vts/VtsHalVibratorManagerTargetTest.cpp @@ -15,42 +15,40 @@ */ #include #include +#include +#include +#include -#include -#include -#include -#include -#include +#include +#include #include #include -using android::ProcessState; -using android::sp; -using android::String16; -using android::binder::Status; -using android::hardware::vibrator::BnVibratorCallback; -using android::hardware::vibrator::CompositeEffect; -using android::hardware::vibrator::CompositePrimitive; -using android::hardware::vibrator::Effect; -using android::hardware::vibrator::EffectStrength; -using android::hardware::vibrator::IVibrator; -using android::hardware::vibrator::IVibratorManager; +#include "test_utils.h" + +using aidl::android::hardware::vibrator::BnVibratorCallback; +using aidl::android::hardware::vibrator::CompositeEffect; +using aidl::android::hardware::vibrator::CompositePrimitive; +using aidl::android::hardware::vibrator::Effect; +using aidl::android::hardware::vibrator::EffectStrength; +using aidl::android::hardware::vibrator::IVibrator; +using aidl::android::hardware::vibrator::IVibratorManager; using std::chrono::high_resolution_clock; -const std::vector kEffects{android::enum_range().begin(), - android::enum_range().end()}; -const std::vector kEffectStrengths{android::enum_range().begin(), - android::enum_range().end()}; -const std::vector kPrimitives{android::enum_range().begin(), - android::enum_range().end()}; +const std::vector kEffects{ndk::enum_range().begin(), + ndk::enum_range().end()}; +const std::vector kEffectStrengths{ndk::enum_range().begin(), + ndk::enum_range().end()}; +const std::vector kPrimitives{ndk::enum_range().begin(), + ndk::enum_range().end()}; class CompletionCallback : public BnVibratorCallback { public: CompletionCallback(const std::function& callback) : mCallback(callback) {} - Status onComplete() override { + ndk::ScopedAStatus onComplete() override { mCallback(); - return Status::ok(); + return ndk::ScopedAStatus::ok(); } private: @@ -60,55 +58,50 @@ class CompletionCallback : public BnVibratorCallback { class VibratorAidl : public testing::TestWithParam { public: virtual void SetUp() override { - manager = android::waitForDeclaredService(String16(GetParam().c_str())); + auto serviceName = GetParam().c_str(); + manager = IVibratorManager::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(serviceName))); ASSERT_NE(manager, nullptr); - ASSERT_TRUE(manager->getCapabilities(&capabilities).isOk()); - EXPECT_TRUE(manager->getVibratorIds(&vibratorIds).isOk()); + EXPECT_OK(manager->getCapabilities(&capabilities)); + EXPECT_OK(manager->getVibratorIds(&vibratorIds)); } - sp manager; + std::shared_ptr manager; int32_t capabilities; std::vector vibratorIds; }; -inline bool isUnknownOrUnsupported(Status status) { - return status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION || - status.transactionError() == android::UNKNOWN_TRANSACTION; -} - TEST_P(VibratorAidl, ValidateExistingVibrators) { - sp vibrator; - for (auto& id : vibratorIds) { - EXPECT_TRUE(manager->getVibrator(id, &vibrator).isOk()); + std::shared_ptr vibrator; + for (int32_t id : vibratorIds) { + EXPECT_OK(manager->getVibrator(id, &vibrator)); ASSERT_NE(vibrator, nullptr); } } TEST_P(VibratorAidl, GetVibratorWithInvalidId) { int32_t invalidId = *max_element(vibratorIds.begin(), vibratorIds.end()) + 1; - sp vibrator; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - manager->getVibrator(invalidId, &vibrator).exceptionCode()); + std::shared_ptr vibrator; + EXPECT_ILLEGAL_ARGUMENT(manager->getVibrator(invalidId, &vibrator)); ASSERT_EQ(vibrator, nullptr); } TEST_P(VibratorAidl, ValidatePrepareSyncedExistingVibrators) { if (!(capabilities & IVibratorManager::CAP_SYNC)) return; if (vibratorIds.empty()) return; - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - EXPECT_TRUE(manager->cancelSynced().isOk()); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + EXPECT_OK(manager->cancelSynced()); } TEST_P(VibratorAidl, PrepareSyncedEmptySetIsInvalid) { if (!(capabilities & IVibratorManager::CAP_SYNC)) return; std::vector emptyIds; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, manager->prepareSynced(emptyIds).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(manager->prepareSynced(emptyIds)); } TEST_P(VibratorAidl, PrepareSyncedNotSupported) { if (!(capabilities & IVibratorManager::CAP_SYNC)) { - Status status = manager->prepareSynced(vibratorIds); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(manager->prepareSynced(vibratorIds)); } } @@ -117,15 +110,14 @@ TEST_P(VibratorAidl, PrepareOnNotSupported) { if (!(capabilities & IVibratorManager::CAP_SYNC)) return; if (!(capabilities & IVibratorManager::CAP_PREPARE_ON)) { uint32_t durationMs = 250; - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - sp vibrator; - for (auto& id : vibratorIds) { - EXPECT_TRUE(manager->getVibrator(id, &vibrator).isOk()); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + std::shared_ptr vibrator; + for (int32_t id : vibratorIds) { + EXPECT_OK(manager->getVibrator(id, &vibrator)); ASSERT_NE(vibrator, nullptr); - Status status = vibrator->on(durationMs, nullptr); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->on(durationMs, nullptr)); } - EXPECT_TRUE(manager->cancelSynced().isOk()); + EXPECT_OK(manager->cancelSynced()); } } @@ -133,16 +125,16 @@ TEST_P(VibratorAidl, PreparePerformNotSupported) { if (vibratorIds.empty()) return; if (!(capabilities & IVibratorManager::CAP_SYNC)) return; if (!(capabilities & IVibratorManager::CAP_PREPARE_ON)) { - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - sp vibrator; - for (auto& id : vibratorIds) { - EXPECT_TRUE(manager->getVibrator(id, &vibrator).isOk()); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + std::shared_ptr vibrator; + for (int32_t id : vibratorIds) { + EXPECT_OK(manager->getVibrator(id, &vibrator)); ASSERT_NE(vibrator, nullptr); int32_t lengthMs = 0; - Status status = vibrator->perform(kEffects[0], kEffectStrengths[0], nullptr, &lengthMs); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED( + vibrator->perform(kEffects[0], kEffectStrengths[0], nullptr, &lengthMs)); } - EXPECT_TRUE(manager->cancelSynced().isOk()); + EXPECT_OK(manager->cancelSynced()); } } @@ -157,15 +149,14 @@ TEST_P(VibratorAidl, PrepareComposeNotSupported) { effect.scale = 1.0f; composite.emplace_back(effect); - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - sp vibrator; - for (auto& id : vibratorIds) { - EXPECT_TRUE(manager->getVibrator(id, &vibrator).isOk()); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + std::shared_ptr vibrator; + for (int32_t id : vibratorIds) { + EXPECT_OK(manager->getVibrator(id, &vibrator)); ASSERT_NE(vibrator, nullptr); - Status status = vibrator->compose(composite, nullptr); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->compose(composite, nullptr)); } - EXPECT_TRUE(manager->cancelSynced().isOk()); + EXPECT_OK(manager->cancelSynced()); } } @@ -177,51 +168,58 @@ TEST_P(VibratorAidl, TriggerWithCallback) { std::promise completionPromise; std::future completionFuture{completionPromise.get_future()}; - sp callback = - new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + auto callback = ndk::SharedRefBase::make( + [&completionPromise] { completionPromise.set_value(); }); uint32_t durationMs = 250; std::chrono::milliseconds timeout{durationMs * 2}; - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - sp vibrator; - for (auto& id : vibratorIds) { - EXPECT_TRUE(manager->getVibrator(id, &vibrator).isOk()); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + std::shared_ptr vibrator; + for (int32_t id : vibratorIds) { + EXPECT_OK(manager->getVibrator(id, &vibrator)); ASSERT_NE(vibrator, nullptr); - EXPECT_TRUE(vibrator->on(durationMs, nullptr).isOk()); + EXPECT_OK(vibrator->on(durationMs, nullptr)); } - EXPECT_TRUE(manager->triggerSynced(callback).isOk()); + EXPECT_OK(manager->triggerSynced(callback)); EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); - EXPECT_TRUE(manager->cancelSynced().isOk()); + EXPECT_OK(manager->cancelSynced()); } TEST_P(VibratorAidl, TriggerSyncNotSupported) { if (!(capabilities & IVibratorManager::CAP_SYNC)) { - Status status = manager->triggerSynced(nullptr); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(manager->triggerSynced(nullptr)); } } TEST_P(VibratorAidl, TriggerCallbackNotSupported) { if (!(capabilities & IVibratorManager::CAP_SYNC)) return; if (!(capabilities & IVibratorManager::CAP_TRIGGER_CALLBACK)) { - sp callback = new CompletionCallback([] {}); - EXPECT_TRUE(manager->prepareSynced(vibratorIds).isOk()); - Status status = manager->triggerSynced(callback); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; - EXPECT_TRUE(manager->cancelSynced().isOk()); + auto callback = ndk::SharedRefBase::make([] {}); + EXPECT_OK(manager->prepareSynced(vibratorIds)); + EXPECT_UNKNOWN_OR_UNSUPPORTED(manager->triggerSynced(callback)); + EXPECT_OK(manager->cancelSynced()); } } +std::vector FindVibratorManagerNames() { + std::vector names; + constexpr auto callback = [](const char* instance, void* context) { + std::string fullName = std::string(IVibratorManager::descriptor) + "/" + instance; + static_cast*>(context)->emplace_back(fullName); + }; + AServiceManager_forEachDeclaredInstance(IVibratorManager::descriptor, + static_cast(&names), callback); + return names; +} + GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VibratorAidl); -INSTANTIATE_TEST_SUITE_P( - Vibrator, VibratorAidl, - testing::ValuesIn(android::getAidlHalInstanceNames(IVibratorManager::descriptor)), - android::PrintInstanceNameToString); +INSTANTIATE_TEST_SUITE_P(Vibrator, VibratorAidl, testing::ValuesIn(FindVibratorManagerNames()), + android::PrintInstanceNameToString); int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); - ProcessState::self()->setThreadPoolMaxThreadCount(1); - ProcessState::self()->startThreadPool(); + ABinderProcess_setThreadPoolMaxThreadCount(1); + ABinderProcess_startThreadPool(); return RUN_ALL_TESTS(); } diff --git a/vibrator/aidl/vts/VtsHalVibratorTargetTest.cpp b/vibrator/aidl/vts/VtsHalVibratorTargetTest.cpp index db474d6920..65a1e84177 100644 --- a/vibrator/aidl/vts/VtsHalVibratorTargetTest.cpp +++ b/vibrator/aidl/vts/VtsHalVibratorTargetTest.cpp @@ -15,38 +15,37 @@ */ #include #include -#include -#include -#include -#include -#include +#include +#include +#include + +#include +#include #include #include -using android::ProcessState; -using android::sp; -using android::String16; -using android::binder::Status; -using android::hardware::vibrator::ActivePwle; -using android::hardware::vibrator::BnVibratorCallback; -using android::hardware::vibrator::Braking; -using android::hardware::vibrator::BrakingPwle; -using android::hardware::vibrator::CompositeEffect; -using android::hardware::vibrator::CompositePrimitive; -using android::hardware::vibrator::Effect; -using android::hardware::vibrator::EffectStrength; -using android::hardware::vibrator::IVibrator; -using android::hardware::vibrator::IVibratorManager; -using android::hardware::vibrator::PrimitivePwle; +#include "test_utils.h" + +using aidl::android::hardware::vibrator::ActivePwle; +using aidl::android::hardware::vibrator::BnVibratorCallback; +using aidl::android::hardware::vibrator::Braking; +using aidl::android::hardware::vibrator::BrakingPwle; +using aidl::android::hardware::vibrator::CompositeEffect; +using aidl::android::hardware::vibrator::CompositePrimitive; +using aidl::android::hardware::vibrator::Effect; +using aidl::android::hardware::vibrator::EffectStrength; +using aidl::android::hardware::vibrator::IVibrator; +using aidl::android::hardware::vibrator::IVibratorManager; +using aidl::android::hardware::vibrator::PrimitivePwle; using std::chrono::high_resolution_clock; using namespace ::std::chrono_literals; -const std::vector kEffects{android::enum_range().begin(), - android::enum_range().end()}; -const std::vector kEffectStrengths{android::enum_range().begin(), - android::enum_range().end()}; +const std::vector kEffects{ndk::enum_range().begin(), + ndk::enum_range().end()}; +const std::vector kEffectStrengths{ndk::enum_range().begin(), + ndk::enum_range().end()}; const std::vector kInvalidEffects = { static_cast(static_cast(kEffects.front()) - 1), @@ -59,8 +58,7 @@ const std::vector kInvalidEffectStrengths = { }; const std::vector kCompositePrimitives{ - android::enum_range().begin(), - android::enum_range().end()}; + ndk::enum_range().begin(), ndk::enum_range().end()}; const std::vector kRequiredPrimitives = { CompositePrimitive::CLICK, CompositePrimitive::LIGHT_TICK, @@ -74,14 +72,36 @@ const std::vector kInvalidPrimitives = { }; // Timeout to wait for vibration callback completion. -static constexpr auto VIBRATION_CALLBACK_TIMEOUT = 100ms; +static constexpr std::chrono::milliseconds VIBRATION_CALLBACK_TIMEOUT = 100ms; + +static std::vector findVibratorManagerNames() { + std::vector names; + constexpr auto callback = [](const char* instance, void* context) { + auto fullName = std::string(IVibratorManager::descriptor) + "/" + instance; + static_cast*>(context)->emplace_back(fullName); + }; + AServiceManager_forEachDeclaredInstance(IVibratorManager::descriptor, + static_cast(&names), callback); + return names; +} + +static std::vector findUnmanagedVibratorNames() { + std::vector names; + constexpr auto callback = [](const char* instance, void* context) { + auto fullName = std::string(IVibrator::descriptor) + "/" + instance; + static_cast*>(context)->emplace_back(fullName); + }; + AServiceManager_forEachDeclaredInstance(IVibrator::descriptor, static_cast(&names), + callback); + return names; +} class CompletionCallback : public BnVibratorCallback { public: CompletionCallback(const std::function &callback) : mCallback(callback) {} - Status onComplete() override { + ndk::ScopedAStatus onComplete() override { mCallback(); - return Status::ok(); + return ndk::ScopedAStatus::ok(); } private: @@ -93,88 +113,87 @@ class VibratorAidl : public testing::TestWithParam> virtual void SetUp() override { int32_t managerIdx = std::get<0>(GetParam()); int32_t vibratorId = std::get<1>(GetParam()); - auto managerAidlNames = android::getAidlHalInstanceNames(IVibratorManager::descriptor); if (managerIdx < 0) { // Testing a unmanaged vibrator, using vibratorId as index from registered HALs - auto vibratorAidlNames = android::getAidlHalInstanceNames(IVibrator::descriptor); - ASSERT_LT(vibratorId, vibratorAidlNames.size()); - auto vibratorName = String16(vibratorAidlNames[vibratorId].c_str()); - vibrator = android::waitForDeclaredService(vibratorName); + std::vector vibratorNames = findUnmanagedVibratorNames(); + ASSERT_LT(vibratorId, vibratorNames.size()); + vibrator = IVibrator::fromBinder(ndk::SpAIBinder( + AServiceManager_waitForService(vibratorNames[vibratorId].c_str()))); } else { // Testing a managed vibrator, using vibratorId to retrieve it from the manager - ASSERT_LT(managerIdx, managerAidlNames.size()); - auto managerName = String16(managerAidlNames[managerIdx].c_str()); - auto vibratorManager = android::waitForDeclaredService(managerName); - auto vibratorResult = vibratorManager->getVibrator(vibratorId, &vibrator); - ASSERT_TRUE(vibratorResult.isOk()); + std::vector managerNames = findVibratorManagerNames(); + ASSERT_LT(managerIdx, managerNames.size()); + auto vibratorManager = IVibratorManager::fromBinder(ndk::SpAIBinder( + AServiceManager_waitForService(managerNames[managerIdx].c_str()))); + EXPECT_OK(vibratorManager->getVibrator(vibratorId, &vibrator)) + << "\n For vibrator id: " << vibratorId; } ASSERT_NE(vibrator, nullptr); - ASSERT_TRUE(vibrator->getCapabilities(&capabilities).isOk()); + EXPECT_OK(vibrator->getCapabilities(&capabilities)); } virtual void TearDown() override { // Reset vibrator state between tests. - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } - sp vibrator; + std::shared_ptr vibrator; int32_t capabilities; }; -inline bool isUnknownOrUnsupported(Status status) { - return status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION || - status.transactionError() == android::UNKNOWN_TRANSACTION; -} - -static float getResonantFrequencyHz(sp vibrator, int32_t capabilities) { +static float getResonantFrequencyHz(const std::shared_ptr& vibrator, + int32_t capabilities) { float resonantFrequencyHz; - Status status = vibrator->getResonantFrequency(&resonantFrequencyHz); + ndk::ScopedAStatus status = vibrator->getResonantFrequency(&resonantFrequencyHz); if (capabilities & IVibrator::CAP_GET_RESONANT_FREQUENCY) { + EXPECT_OK(std::move(status)); EXPECT_GT(resonantFrequencyHz, 0); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } return resonantFrequencyHz; } -static float getFrequencyResolutionHz(sp vibrator, int32_t capabilities) { +static float getFrequencyResolutionHz(const std::shared_ptr& vibrator, + int32_t capabilities) { float freqResolutionHz; - Status status = vibrator->getFrequencyResolution(&freqResolutionHz); + ndk::ScopedAStatus status = vibrator->getFrequencyResolution(&freqResolutionHz); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { + EXPECT_OK(std::move(status)); EXPECT_GT(freqResolutionHz, 0); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } return freqResolutionHz; } -static float getFrequencyMinimumHz(sp vibrator, int32_t capabilities) { +static float getFrequencyMinimumHz(const std::shared_ptr& vibrator, + int32_t capabilities) { float freqMinimumHz; - Status status = vibrator->getFrequencyMinimum(&freqMinimumHz); + ndk::ScopedAStatus status = vibrator->getFrequencyMinimum(&freqMinimumHz); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); + EXPECT_OK(std::move(status)); float resonantFrequencyHz = getResonantFrequencyHz(vibrator, capabilities); EXPECT_GT(freqMinimumHz, 0); EXPECT_LE(freqMinimumHz, resonantFrequencyHz); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } return freqMinimumHz; } -static float getFrequencyMaximumHz(sp vibrator, int32_t capabilities) { +static float getFrequencyMaximumHz(const std::shared_ptr& vibrator, + int32_t capabilities) { std::vector bandwidthAmplitudeMap; - Status status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); + ndk::ScopedAStatus status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); + EXPECT_OK(std::move(status)); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } float freqMaximumHz = ((bandwidthAmplitudeMap.size() - 1) * @@ -191,7 +210,8 @@ static float getAmplitudeMax() { return 1.0; } -static ActivePwle composeValidActivePwle(sp vibrator, int32_t capabilities) { +static ActivePwle composeValidActivePwle(const std::shared_ptr& vibrator, + int32_t capabilities) { float frequencyHz; if (capabilities & IVibrator::CAP_GET_RESONANT_FREQUENCY) { frequencyHz = getResonantFrequencyHz(vibrator, capabilities); @@ -212,9 +232,9 @@ static ActivePwle composeValidActivePwle(sp vibrator, int32_t capabil } TEST_P(VibratorAidl, OnThenOffBeforeTimeout) { - EXPECT_TRUE(vibrator->on(2000, nullptr /*callback*/).isOk()); + EXPECT_OK(vibrator->on(2000, nullptr /*callback*/)); sleep(1); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } TEST_P(VibratorAidl, OnWithCallback) { @@ -223,26 +243,25 @@ TEST_P(VibratorAidl, OnWithCallback) { std::promise completionPromise; std::future completionFuture{completionPromise.get_future()}; - sp callback = - new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + auto callback = ndk::SharedRefBase::make( + [&completionPromise] { completionPromise.set_value(); }); uint32_t durationMs = 250; auto timeout = std::chrono::milliseconds(durationMs) + VIBRATION_CALLBACK_TIMEOUT; - EXPECT_TRUE(vibrator->on(durationMs, callback).isOk()); + EXPECT_OK(vibrator->on(durationMs, callback)); EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } TEST_P(VibratorAidl, OnCallbackNotSupported) { if (!(capabilities & IVibrator::CAP_ON_CALLBACK)) { - sp callback = new CompletionCallback([] {}); - Status status = vibrator->on(250, callback); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + auto callback = ndk::SharedRefBase::make([] {}); + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->on(250, callback)); } } TEST_P(VibratorAidl, ValidateEffect) { std::vector supported; - ASSERT_TRUE(vibrator->getSupportedEffects(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedEffects(&supported)); for (Effect effect : kEffects) { bool isEffectSupported = @@ -250,15 +269,18 @@ TEST_P(VibratorAidl, ValidateEffect) { for (EffectStrength strength : kEffectStrengths) { int32_t lengthMs = 0; - Status status = vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs); + ndk::ScopedAStatus status = + vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs); if (isEffectSupported) { - EXPECT_TRUE(status.isOk()) << toString(effect) << " " << toString(strength); + EXPECT_OK(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); EXPECT_GT(lengthMs, 0); usleep(lengthMs * 1000); + EXPECT_OK(vibrator->off()); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) - << status << " " << toString(effect) << " " << toString(strength); + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } } } @@ -269,7 +291,7 @@ TEST_P(VibratorAidl, ValidateEffectWithCallback) { return; std::vector supported; - ASSERT_TRUE(vibrator->getSupportedEffects(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedEffects(&supported)); for (Effect effect : kEffects) { bool isEffectSupported = @@ -278,25 +300,26 @@ TEST_P(VibratorAidl, ValidateEffectWithCallback) { for (EffectStrength strength : kEffectStrengths) { std::promise completionPromise; std::future completionFuture{completionPromise.get_future()}; - sp callback = - new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + auto callback = ndk::SharedRefBase::make( + [&completionPromise] { completionPromise.set_value(); }); int lengthMs = 0; - Status status = vibrator->perform(effect, strength, callback, &lengthMs); + ndk::ScopedAStatus status = vibrator->perform(effect, strength, callback, &lengthMs); if (isEffectSupported) { - EXPECT_TRUE(status.isOk()); + EXPECT_OK(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); EXPECT_GT(lengthMs, 0); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } - if (!status.isOk()) - continue; + if (lengthMs <= 0) continue; auto timeout = std::chrono::milliseconds(lengthMs) + VIBRATION_CALLBACK_TIMEOUT; EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } } } @@ -307,10 +330,10 @@ TEST_P(VibratorAidl, ValidateEffectWithCallbackNotSupported) { for (Effect effect : kEffects) { for (EffectStrength strength : kEffectStrengths) { - sp callback = new CompletionCallback([] {}); + auto callback = ndk::SharedRefBase::make([] {}); int lengthMs; - Status status = vibrator->perform(effect, strength, callback, &lengthMs); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->perform(effect, strength, callback, &lengthMs)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } } } @@ -319,53 +342,52 @@ TEST_P(VibratorAidl, InvalidEffectsUnsupported) { for (Effect effect : kInvalidEffects) { for (EffectStrength strength : kEffectStrengths) { int32_t lengthMs; - Status status = vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs); - EXPECT_TRUE(isUnknownOrUnsupported(status)) - << status << toString(effect) << " " << toString(strength); + EXPECT_UNKNOWN_OR_UNSUPPORTED( + vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } } for (Effect effect : kEffects) { for (EffectStrength strength : kInvalidEffectStrengths) { int32_t lengthMs; - Status status = vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs); - EXPECT_TRUE(isUnknownOrUnsupported(status)) - << status << " " << toString(effect) << " " << toString(strength); + EXPECT_UNKNOWN_OR_UNSUPPORTED( + vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } } } TEST_P(VibratorAidl, ChangeVibrationAmplitude) { if (capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) { - EXPECT_EQ(Status::EX_NONE, vibrator->setAmplitude(0.1f).exceptionCode()); - EXPECT_TRUE(vibrator->on(2000, nullptr /*callback*/).isOk()); - EXPECT_EQ(Status::EX_NONE, vibrator->setAmplitude(0.5f).exceptionCode()); + EXPECT_OK(vibrator->setAmplitude(0.1f)); + EXPECT_OK(vibrator->on(2000, nullptr /*callback*/)); + EXPECT_OK(vibrator->setAmplitude(0.5f)); sleep(1); - EXPECT_EQ(Status::EX_NONE, vibrator->setAmplitude(1.0f).exceptionCode()); + EXPECT_OK(vibrator->setAmplitude(1.0f)); sleep(1); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } } TEST_P(VibratorAidl, AmplitudeOutsideRangeFails) { if (capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) { - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->setAmplitude(-1).exceptionCode()); - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->setAmplitude(0).exceptionCode()); - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->setAmplitude(1.1).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(-1)); + EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(0)); + EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(1.1)); } } TEST_P(VibratorAidl, AmplitudeReturnsUnsupportedMatchingCapabilities) { if ((capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) == 0) { - Status status = vibrator->setAmplitude(1); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setAmplitude(1)); } } TEST_P(VibratorAidl, ChangeVibrationExternalControl) { if (capabilities & IVibrator::CAP_EXTERNAL_CONTROL) { - EXPECT_TRUE(vibrator->setExternalControl(true).isOk()); + EXPECT_OK(vibrator->setExternalControl(true)); sleep(1); - EXPECT_TRUE(vibrator->setExternalControl(false).isOk()); + EXPECT_OK(vibrator->setExternalControl(false)); sleep(1); } } @@ -375,15 +397,15 @@ TEST_P(VibratorAidl, ExternalAmplitudeControl) { (capabilities & IVibrator::CAP_EXTERNAL_AMPLITUDE_CONTROL) > 0; if (capabilities & IVibrator::CAP_EXTERNAL_CONTROL) { - EXPECT_TRUE(vibrator->setExternalControl(true).isOk()); + EXPECT_OK(vibrator->setExternalControl(true)); - Status amplitudeStatus = vibrator->setAmplitude(0.5); if (supportsExternalAmplitudeControl) { - EXPECT_TRUE(amplitudeStatus.isOk()); + EXPECT_OK(vibrator->setAmplitude(0.5)); } else { - EXPECT_TRUE(isUnknownOrUnsupported(amplitudeStatus)) << amplitudeStatus; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setAmplitude(0.5)); } - EXPECT_TRUE(vibrator->setExternalControl(false).isOk()); + + EXPECT_OK(vibrator->setExternalControl(false)); } else { EXPECT_FALSE(supportsExternalAmplitudeControl); } @@ -391,18 +413,16 @@ TEST_P(VibratorAidl, ExternalAmplitudeControl) { TEST_P(VibratorAidl, ExternalControlUnsupportedMatchingCapabilities) { if ((capabilities & IVibrator::CAP_EXTERNAL_CONTROL) == 0) { - Status status = vibrator->setExternalControl(true); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setExternalControl(true)); } } TEST_P(VibratorAidl, GetSupportedPrimitives) { if (capabilities & IVibrator::CAP_COMPOSE_EFFECTS) { std::vector supported; + EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); - EXPECT_EQ(Status::EX_NONE, vibrator->getSupportedPrimitives(&supported).exceptionCode()); - - for (auto primitive : kCompositePrimitives) { + for (CompositePrimitive primitive : kCompositePrimitives) { bool isPrimitiveSupported = std::find(supported.begin(), supported.end(), primitive) != supported.end(); bool isPrimitiveRequired = @@ -417,22 +437,23 @@ TEST_P(VibratorAidl, GetSupportedPrimitives) { TEST_P(VibratorAidl, GetPrimitiveDuration) { if (capabilities & IVibrator::CAP_COMPOSE_EFFECTS) { std::vector supported; - ASSERT_TRUE(vibrator->getSupportedPrimitives(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); - for (auto primitive : kCompositePrimitives) { + for (CompositePrimitive primitive : kCompositePrimitives) { bool isPrimitiveSupported = std::find(supported.begin(), supported.end(), primitive) != supported.end(); int32_t duration; - Status status = vibrator->getPrimitiveDuration(primitive, &duration); - if (isPrimitiveSupported) { - EXPECT_EQ(Status::EX_NONE, status.exceptionCode()); + EXPECT_OK(vibrator->getPrimitiveDuration(primitive, &duration)) + << "\n For primitive: " << toString(primitive) << " " << duration; if (primitive != CompositePrimitive::NOOP) { - ASSERT_GT(duration, 0) << toString(primitive) << " " << duration; + ASSERT_GT(duration, 0) + << "\n For primitive: " << toString(primitive) << " " << duration; } } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->getPrimitiveDuration(primitive, &duration)) + << "\n For primitive: " << toString(primitive); } } } @@ -446,14 +467,14 @@ TEST_P(VibratorAidl, ComposeValidPrimitives) { std::vector supported; int32_t maxDelay, maxSize; - ASSERT_TRUE(vibrator->getSupportedPrimitives(&supported).isOk()); - EXPECT_EQ(Status::EX_NONE, vibrator->getCompositionDelayMax(&maxDelay).exceptionCode()); - EXPECT_EQ(Status::EX_NONE, vibrator->getCompositionSizeMax(&maxSize).exceptionCode()); + EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); + EXPECT_OK(vibrator->getCompositionDelayMax(&maxDelay)); + EXPECT_OK(vibrator->getCompositionSizeMax(&maxSize)); std::vector composite; for (int i = 0; i < supported.size(); i++) { - auto primitive = supported[i]; + CompositePrimitive primitive = supported[i]; float t = static_cast(i + 1) / supported.size(); CompositeEffect effect; @@ -467,8 +488,8 @@ TEST_P(VibratorAidl, ComposeValidPrimitives) { } if (composite.size() != 0) { - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); } } @@ -477,12 +498,12 @@ TEST_P(VibratorAidl, ComposeUnsupportedPrimitives) { GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; } - auto unsupported = kInvalidPrimitives; + std::vector unsupported(kInvalidPrimitives); std::vector supported; - ASSERT_TRUE(vibrator->getSupportedPrimitives(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); - for (auto primitive : kCompositePrimitives) { + for (CompositePrimitive primitive : kCompositePrimitives) { bool isPrimitiveSupported = std::find(supported.begin(), supported.end(), primitive) != supported.end(); @@ -491,16 +512,15 @@ TEST_P(VibratorAidl, ComposeUnsupportedPrimitives) { } } - for (auto primitive : unsupported) { + for (CompositePrimitive primitive : unsupported) { std::vector composite(1); - for (auto& effect : composite) { + for (CompositeEffect& effect : composite) { effect.delayMs = 0; effect.primitive = primitive; effect.scale = 1.0f; } - Status status = vibrator->compose(composite, nullptr); - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->compose(composite, nullptr)); } } @@ -516,18 +536,18 @@ TEST_P(VibratorAidl, ComposeScaleBoundary) { effect.primitive = CompositePrimitive::CLICK; effect.scale = std::nextafter(0.0f, -1.0f); - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->compose(composite, nullptr).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); effect.scale = 0.0f; - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); effect.scale = 1.0f; - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); effect.scale = std::nextafter(1.0f, 2.0f); - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->compose(composite, nullptr).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); } TEST_P(VibratorAidl, ComposeDelayBoundary) { @@ -537,7 +557,7 @@ TEST_P(VibratorAidl, ComposeDelayBoundary) { int32_t maxDelay; - EXPECT_EQ(Status::EX_NONE, vibrator->getCompositionDelayMax(&maxDelay).exceptionCode()); + EXPECT_OK(vibrator->getCompositionDelayMax(&maxDelay)); std::vector composite(1); CompositeEffect& effect = composite[0]; @@ -546,19 +566,19 @@ TEST_P(VibratorAidl, ComposeDelayBoundary) { effect.scale = 1.0f; effect.delayMs = 0; - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); effect.delayMs = 1; - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); effect.delayMs = maxDelay; - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); effect.delayMs = maxDelay + 1; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->compose(composite, nullptr).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); } TEST_P(VibratorAidl, ComposeSizeBoundary) { @@ -568,7 +588,7 @@ TEST_P(VibratorAidl, ComposeSizeBoundary) { int32_t maxSize; - EXPECT_EQ(Status::EX_NONE, vibrator->getCompositionSizeMax(&maxSize).exceptionCode()); + EXPECT_OK(vibrator->getCompositionSizeMax(&maxSize)); std::vector composite(maxSize); CompositeEffect effect; @@ -578,11 +598,11 @@ TEST_P(VibratorAidl, ComposeSizeBoundary) { effect.scale = 1.0f; std::fill(composite.begin(), composite.end(), effect); - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->compose(composite, nullptr)); + EXPECT_OK(vibrator->off()); composite.emplace_back(effect); - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, vibrator->compose(composite, nullptr).exceptionCode()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); } TEST_P(VibratorAidl, ComposeCallback) { @@ -591,18 +611,17 @@ TEST_P(VibratorAidl, ComposeCallback) { } std::vector supported; + EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); - ASSERT_TRUE(vibrator->getSupportedPrimitives(&supported).isOk()); - - for (auto primitive : supported) { + for (CompositePrimitive primitive : supported) { if (primitive == CompositePrimitive::NOOP) { continue; } std::promise completionPromise; std::future completionFuture{completionPromise.get_future()}; - sp callback = - new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + auto callback = ndk::SharedRefBase::make( + [&completionPromise] { completionPromise.set_value(); }); CompositeEffect effect; std::vector composite; int32_t durationMs; @@ -615,50 +634,50 @@ TEST_P(VibratorAidl, ComposeCallback) { effect.scale = 1.0f; composite.emplace_back(effect); - EXPECT_EQ(Status::EX_NONE, - vibrator->getPrimitiveDuration(primitive, &durationMs).exceptionCode()) - << toString(primitive); + EXPECT_OK(vibrator->getPrimitiveDuration(primitive, &durationMs)) + << "\n For primitive: " << toString(primitive); duration = std::chrono::milliseconds(durationMs); start = high_resolution_clock::now(); - EXPECT_EQ(Status::EX_NONE, vibrator->compose(composite, callback).exceptionCode()) - << toString(primitive); + EXPECT_OK(vibrator->compose(composite, callback)) + << "\n For primitive: " << toString(primitive); EXPECT_EQ(completionFuture.wait_for(duration + VIBRATION_CALLBACK_TIMEOUT), std::future_status::ready) - << toString(primitive); + << "\n For primitive: " << toString(primitive); end = high_resolution_clock::now(); elapsed = std::chrono::duration_cast(end - start); - EXPECT_GE(elapsed.count(), duration.count()) << toString(primitive); + EXPECT_GE(elapsed.count(), duration.count()) + << "\n For primitive: " << toString(primitive); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()) << "\n For primitive: " << toString(primitive); } } TEST_P(VibratorAidl, AlwaysOn) { if (capabilities & IVibrator::CAP_ALWAYS_ON_CONTROL) { std::vector supported; - ASSERT_TRUE(vibrator->getSupportedAlwaysOnEffects(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedAlwaysOnEffects(&supported)); for (Effect effect : kEffects) { bool isEffectSupported = std::find(supported.begin(), supported.end(), effect) != supported.end(); for (EffectStrength strength : kEffectStrengths) { - Status status = vibrator->alwaysOnEnable(0, effect, strength); + ndk::ScopedAStatus status = vibrator->alwaysOnEnable(0, effect, strength); if (isEffectSupported) { - EXPECT_EQ(Status::EX_NONE, status.exceptionCode()) - << toString(effect) << " " << toString(strength); + EXPECT_OK(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) - << status << " " << toString(effect) << " " << toString(strength); + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) + << "\n For effect: " << toString(effect) << " " << toString(strength); } } } - EXPECT_EQ(Status::EX_NONE, vibrator->alwaysOnDisable(0).exceptionCode()); + EXPECT_OK(vibrator->alwaysOnDisable(0)); } } @@ -668,12 +687,12 @@ TEST_P(VibratorAidl, GetResonantFrequency) { TEST_P(VibratorAidl, GetQFactor) { float qFactor; - Status status = vibrator->getQFactor(&qFactor); + ndk::ScopedAStatus status = vibrator->getQFactor(&qFactor); if (capabilities & IVibrator::CAP_GET_Q_FACTOR) { + EXPECT_OK(std::move(status)); ASSERT_GT(qFactor, 0); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } } @@ -687,9 +706,9 @@ TEST_P(VibratorAidl, GetFrequencyMinimum) { TEST_P(VibratorAidl, GetBandwidthAmplitudeMap) { std::vector bandwidthAmplitudeMap; - Status status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); + ndk::ScopedAStatus status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); + EXPECT_OK(std::move(status)); ASSERT_FALSE(bandwidthAmplitudeMap.empty()); int minMapSize = (getResonantFrequencyHz(vibrator, capabilities) - @@ -702,42 +721,42 @@ TEST_P(VibratorAidl, GetBandwidthAmplitudeMap) { ASSERT_LE(e, 1.0); } } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } } TEST_P(VibratorAidl, GetPwlePrimitiveDurationMax) { int32_t durationMs; - Status status = vibrator->getPwlePrimitiveDurationMax(&durationMs); + ndk::ScopedAStatus status = vibrator->getPwlePrimitiveDurationMax(&durationMs); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { + EXPECT_OK(std::move(status)); ASSERT_NE(durationMs, 0); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } } TEST_P(VibratorAidl, GetPwleCompositionSizeMax) { int32_t maxSize; - Status status = vibrator->getPwleCompositionSizeMax(&maxSize); + ndk::ScopedAStatus status = vibrator->getPwleCompositionSizeMax(&maxSize); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { + EXPECT_OK(std::move(status)); ASSERT_NE(maxSize, 0); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } } TEST_P(VibratorAidl, GetSupportedBraking) { std::vector supported; - Status status = vibrator->getSupportedBraking(&supported); + ndk::ScopedAStatus status = vibrator->getSupportedBraking(&supported); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { bool isDefaultNoneSupported = std::find(supported.begin(), supported.end(), Braking::NONE) != supported.end(); + EXPECT_OK(std::move(status)); ASSERT_TRUE(isDefaultNoneSupported); - EXPECT_EQ(status.exceptionCode(), Status::EX_NONE); } else { - EXPECT_TRUE(isUnknownOrUnsupported(status)) << status; + EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); } } @@ -746,7 +765,7 @@ TEST_P(VibratorAidl, ComposeValidPwle) { ActivePwle firstActive = composeValidActivePwle(vibrator, capabilities); std::vector supported; - ASSERT_TRUE(vibrator->getSupportedBraking(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedBraking(&supported)); bool isClabSupported = std::find(supported.begin(), supported.end(), Braking::CLAB) != supported.end(); BrakingPwle firstBraking; @@ -765,11 +784,11 @@ TEST_P(VibratorAidl, ComposeValidPwle) { secondBraking.braking = Braking::NONE; secondBraking.duration = 10; - auto pwleQueue = - std::vector{firstActive, firstBraking, secondActive, secondBraking}; + std::vector pwleQueue = {firstActive, firstBraking, secondActive, + secondBraking}; - EXPECT_EQ(Status::EX_NONE, vibrator->composePwle(pwleQueue, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->composePwle(pwleQueue, nullptr)); + EXPECT_OK(vibrator->off()); } } @@ -780,8 +799,8 @@ TEST_P(VibratorAidl, ComposeValidPwleWithCallback) { std::promise completionPromise; std::future completionFuture{completionPromise.get_future()}; - sp callback = - new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + auto callback = ndk::SharedRefBase::make( + [&completionPromise] { completionPromise.set_value(); }); int32_t segmentDurationMaxMs; vibrator->getPwlePrimitiveDurationMax(&segmentDurationMaxMs); uint32_t durationMs = segmentDurationMaxMs * 2 + 100; // Sum of 2 active and 1 braking below @@ -790,27 +809,25 @@ TEST_P(VibratorAidl, ComposeValidPwleWithCallback) { ActivePwle active = composeValidActivePwle(vibrator, capabilities); std::vector supported; - ASSERT_TRUE(vibrator->getSupportedBraking(&supported).isOk()); + EXPECT_OK(vibrator->getSupportedBraking(&supported)); bool isClabSupported = std::find(supported.begin(), supported.end(), Braking::CLAB) != supported.end(); BrakingPwle braking; braking.braking = isClabSupported ? Braking::CLAB : Braking::NONE; braking.duration = 100; - auto pwleQueue = std::vector{active, braking, active}; + std::vector pwleQueue = {active, braking, active}; - EXPECT_TRUE(vibrator->composePwle(pwleQueue, callback).isOk()); + EXPECT_OK(vibrator->composePwle(pwleQueue, callback)); EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_OK(vibrator->off()); } TEST_P(VibratorAidl, ComposePwleSegmentBoundary) { if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { std::vector pwleQueue; // test empty queue - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueue, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); ActivePwle active = composeValidActivePwle(vibrator, capabilities); @@ -824,9 +841,7 @@ TEST_P(VibratorAidl, ComposePwleSegmentBoundary) { pwleQueue.emplace_back(std::move(pwle)); } - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueue, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); } } @@ -836,20 +851,16 @@ TEST_P(VibratorAidl, ComposePwleAmplitudeParameterBoundary) { active.startAmplitude = getAmplitudeMax() + 1.0; // Amplitude greater than allowed active.endAmplitude = getAmplitudeMax() + 1.0; // Amplitude greater than allowed - auto pwleQueueGreater = std::vector{active}; + std::vector pwleQueueGreater = {active}; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueueGreater, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueGreater, nullptr)); active.startAmplitude = getAmplitudeMin() - 1.0; // Amplitude less than allowed active.endAmplitude = getAmplitudeMin() - 1.0; // Amplitude less than allowed - auto pwleQueueLess = std::vector{active}; + std::vector pwleQueueLess = {active}; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueueLess, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueLess, nullptr)); } } @@ -865,20 +876,16 @@ TEST_P(VibratorAidl, ComposePwleFrequencyParameterBoundary) { freqMaximumHz + freqResolutionHz; // Frequency greater than allowed active.endFrequency = freqMaximumHz + freqResolutionHz; // Frequency greater than allowed - auto pwleQueueGreater = std::vector{active}; + std::vector pwleQueueGreater = {active}; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueueGreater, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueGreater, nullptr)); active.startFrequency = freqMinimumHz - freqResolutionHz; // Frequency less than allowed active.endFrequency = freqMinimumHz - freqResolutionHz; // Frequency less than allowed - auto pwleQueueLess = std::vector{active}; + std::vector pwleQueueLess = {active}; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueueLess, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueLess, nullptr)); } } @@ -890,32 +897,30 @@ TEST_P(VibratorAidl, ComposePwleSegmentDurationBoundary) { vibrator->getPwlePrimitiveDurationMax(&segmentDurationMaxMs); active.duration = segmentDurationMaxMs + 10; // Segment duration greater than allowed - auto pwleQueue = std::vector{active}; + std::vector pwleQueue = {active}; - EXPECT_EQ(Status::EX_ILLEGAL_ARGUMENT, - vibrator->composePwle(pwleQueue, nullptr).exceptionCode()); - EXPECT_TRUE(vibrator->off().isOk()); + EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); } } std::vector> GenerateVibratorMapping() { std::vector> tuples; - auto managerAidlNames = android::getAidlHalInstanceNames(IVibratorManager::descriptor); - std::vector vibratorIds; - for (int i = 0; i < managerAidlNames.size(); i++) { - auto managerName = String16(managerAidlNames[i].c_str()); - auto vibratorManager = android::waitForDeclaredService(managerName); + std::vector managerNames = findVibratorManagerNames(); + std::vector vibratorIds; + for (int i = 0; i < managerNames.size(); i++) { + auto vibratorManager = IVibratorManager::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(managerNames[i].c_str()))); if (vibratorManager->getVibratorIds(&vibratorIds).isOk()) { - for (auto &vibratorId : vibratorIds) { - tuples.push_back(std::make_tuple(i, vibratorId)); + for (int32_t vibratorId : vibratorIds) { + tuples.emplace_back(i, vibratorId); } } } - auto vibratorAidlNames = android::getAidlHalInstanceNames(IVibrator::descriptor); - for (int i = 0; i < vibratorAidlNames.size(); i++) { - tuples.push_back(std::make_tuple(-1, i)); + std::vector vibratorNames = findUnmanagedVibratorNames(); + for (int i = 0; i < vibratorNames.size(); i++) { + tuples.emplace_back(-1, i); } return tuples; @@ -936,7 +941,7 @@ INSTANTIATE_TEST_SUITE_P(Vibrator, VibratorAidl, testing::ValuesIn(GenerateVibra int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); - ProcessState::self()->setThreadPoolMaxThreadCount(1); - ProcessState::self()->startThreadPool(); + ABinderProcess_setThreadPoolMaxThreadCount(1); + ABinderProcess_startThreadPool(); return RUN_ALL_TESTS(); } diff --git a/vibrator/aidl/vts/test_utils.h b/vibrator/aidl/vts/test_utils.h new file mode 100644 index 0000000000..aaf3211bd4 --- /dev/null +++ b/vibrator/aidl/vts/test_utils.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2024 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 VIBRATOR_HAL_TEST_UTILS_H +#define VIBRATOR_HAL_TEST_UTILS_H + +#include +#include + +#if !defined(EXPECT_OK) +#define EXPECT_OK(expression) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::ndk::ScopedAStatus&& _status = (expression); _status.isOk()) \ + ; \ + else \ + ADD_FAILURE() << "Expected STATUS_OK for: " << #expression << "\n Actual: " << _status +#else +#error Macro EXPECT_OK already defined unexpectedly +#endif + +#if !defined(EXPECT_UNKNOWN_OR_UNSUPPORTED) +#define EXPECT_UNKNOWN_OR_UNSUPPORTED(expression) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::ndk::ScopedAStatus&& _status = (expression); \ + _status.getExceptionCode() == EX_UNSUPPORTED_OPERATION || \ + _status.getStatus() == STATUS_UNKNOWN_TRANSACTION) \ + ; \ + else \ + ADD_FAILURE() << "Expected STATUS_UNKNOWN_TRANSACTION or EX_UNSUPPORTED_OPERATION for: " \ + << #expression << "\n Actual: " << _status +#else +#error Macro EXPECT_UNKNOWN_OR_UNSUPPORTED already defined unexpectedly +#endif + +#if !defined(EXPECT_ILLEGAL_ARGUMENT) +#define EXPECT_ILLEGAL_ARGUMENT(expression) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::ndk::ScopedAStatus&& _status = (expression); \ + _status.getExceptionCode() == EX_ILLEGAL_ARGUMENT) \ + ; \ + else \ + ADD_FAILURE() << "Expected EX_ILLEGAL_ARGUMENT for: " << #expression \ + << "\n Actual: " << _status +#else +#error Macro EXPECT_ILLEGAL_ARGUMENT already defined unexpectedly +#endif + +#endif // VIBRATOR_HAL_TEST_UTILS_H diff --git a/vibrator/bench/Android.bp b/vibrator/bench/Android.bp index 87bdab4215..b31c71955a 100644 --- a/vibrator/bench/Android.bp +++ b/vibrator/bench/Android.bp @@ -30,12 +30,12 @@ cc_benchmark { "benchmark.cpp", ], shared_libs: [ - "android.hardware.vibrator-V2-cpp", + "android.hardware.vibrator-V2-ndk", "android.hardware.vibrator@1.0", "android.hardware.vibrator@1.1", "android.hardware.vibrator@1.2", "android.hardware.vibrator@1.3", - "libbinder", + "libbinder_ndk", "libhardware", "libhidlbase", "libutils", diff --git a/vibrator/bench/benchmark.cpp b/vibrator/bench/benchmark.cpp index 8e8d78f8b9..8fe9cf7a54 100644 --- a/vibrator/bench/benchmark.cpp +++ b/vibrator/bench/benchmark.cpp @@ -16,15 +16,14 @@ #include "benchmark/benchmark.h" +#include +#include + +#include +#include #include -#include -#include -#include -#include #include -using ::android::enum_range; -using ::android::sp; using ::android::hardware::hidl_enum_range; using ::android::hardware::Return; using ::android::hardware::details::hidl_enum_values; @@ -33,10 +32,11 @@ using ::benchmark::Fixture; using ::benchmark::kMicrosecond; using ::benchmark::State; using ::benchmark::internal::Benchmark; +using ::ndk::enum_range; using namespace ::std::chrono_literals; -namespace Aidl = ::android::hardware::vibrator; +namespace Aidl = ::aidl::android::hardware::vibrator; namespace V1_0 = ::android::hardware::vibrator::V1_0; namespace V1_1 = ::android::hardware::vibrator::V1_1; namespace V1_2 = ::android::hardware::vibrator::V1_2; @@ -56,8 +56,8 @@ template class BaseBench : public Fixture { public: void SetUp(State& /*state*/) override { - android::ProcessState::self()->setThreadPoolMaxThreadCount(1); - android::ProcessState::self()->startThreadPool(); + ABinderProcess_setThreadPoolMaxThreadCount(1); + ABinderProcess_startThreadPool(); } void TearDown(State& /*state*/) override { @@ -75,7 +75,7 @@ class BaseBench : public Fixture { auto getOtherArg(const State& state, std::size_t index) const { return state.range(index + 0); } protected: - sp mVibrator; + std::shared_ptr mVibrator; }; template @@ -83,7 +83,12 @@ class VibratorBench : public BaseBench { public: void SetUp(State& state) override { BaseBench::SetUp(state); - this->mVibrator = I::getService(); + auto service = I::getService(); + if (service) { + this->mVibrator = std::shared_ptr(service.release()); + } else { + this->mVibrator = nullptr; + } } protected: @@ -356,7 +361,9 @@ class VibratorBench_Aidl : public BaseBench { public: void SetUp(State& state) override { BaseBench::SetUp(state); - this->mVibrator = android::waitForVintfService(); + auto serviceName = std::string(Aidl::IVibrator::descriptor) + "/default"; + this->mVibrator = Aidl::IVibrator::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(serviceName.c_str()))); } void TearDown(State& state) override { @@ -373,9 +380,9 @@ class VibratorBench_Aidl : public BaseBench { return (deviceCapabilities & capabilities) == capabilities; } - bool shouldSkipWithError(State& state, const android::binder::Status&& status) { + bool shouldSkipWithError(State& state, const ndk::ScopedAStatus&& status) { if (!status.isOk()) { - state.SkipWithError(status.toString8().c_str()); + state.SkipWithError(status.getMessage()); return true; } return false; @@ -407,9 +414,9 @@ class HalCallback : public Aidl::BnVibratorCallback { HalCallback() = default; ~HalCallback() = default; - android::binder::Status onComplete() override { + ndk::ScopedAStatus onComplete() override { mPromise.set_value(); - return android::binder::Status::ok(); + return ndk::ScopedAStatus::ok(); } std::future getFuture() { return mPromise.get_future(); } @@ -422,7 +429,9 @@ BENCHMARK_WRAPPER(SlowVibratorBench_Aidl, on, { auto ms = MAX_ON_DURATION_MS; for (auto _ : state) { - auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) ? new HalCallback() : nullptr; + auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) + ? ndk::SharedRefBase::make() + : nullptr; // Grab the future before callback promise is destroyed by the HAL. auto cbFuture = cb ? cb->getFuture() : std::future(); @@ -445,7 +454,9 @@ BENCHMARK_WRAPPER(SlowVibratorBench_Aidl, off, { auto ms = MAX_ON_DURATION_MS; for (auto _ : state) { - auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) ? new HalCallback() : nullptr; + auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) + ? ndk::SharedRefBase::make() + : nullptr; // Grab the future before callback promise is destroyed by the HAL. auto cbFuture = cb ? cb->getFuture() : std::future(); @@ -487,7 +498,9 @@ BENCHMARK_WRAPPER(VibratorBench_Aidl, setAmplitude, { return; } - auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) ? new HalCallback() : nullptr; + auto cb = hasCapabilities(Aidl::IVibrator::CAP_ON_CALLBACK) + ? ndk::SharedRefBase::make() + : nullptr; if (shouldSkipWithError(state, mVibrator->on(ms, cb))) { return; } @@ -689,8 +702,9 @@ BENCHMARK_WRAPPER(SlowVibratorEffectsBench_Aidl, perform, { int32_t lengthMs = 0; for (auto _ : state) { - auto cb = hasCapabilities(Aidl::IVibrator::CAP_PERFORM_CALLBACK) ? new HalCallback() - : nullptr; + auto cb = hasCapabilities(Aidl::IVibrator::CAP_PERFORM_CALLBACK) + ? ndk::SharedRefBase::make() + : nullptr; // Grab the future before callback promise is destroyed by the HAL. auto cbFuture = cb ? cb->getFuture() : std::future(); @@ -803,7 +817,7 @@ BENCHMARK_WRAPPER(SlowVibratorPrimitivesBench_Aidl, compose, { effects.push_back(effect); for (auto _ : state) { - auto cb = new HalCallback(); + auto cb = ndk::SharedRefBase::make(); // Grab the future before callback promise is moved and destroyed by the HAL. auto cbFuture = cb->getFuture();