From 3f7ecc5bad8005fb680909bd67ed06458ff58f14 Mon Sep 17 00:00:00 2001 From: Lais Andrade Date: Wed, 25 Mar 2020 23:57:08 +0000 Subject: Create controller for Power HAL handles. This controller is also a PowerHalWrapper and delegates each api call to the Power HAL currently connected. It is also responsible for reconnecting with it after any api call fails. This cl also introduces PowerHalConnector, to abstract away the logic to connect to a Power HAL. Bug: 150878220 Test: atest powermanager_test Change-Id: I24cd262ce40429cc1107a1f0184ed2719a7492d9 --- include/powermanager/PowerHalController.h | 78 +++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 include/powermanager/PowerHalController.h (limited to 'include/powermanager/PowerHalController.h') diff --git a/include/powermanager/PowerHalController.h b/include/powermanager/PowerHalController.h new file mode 100644 index 0000000000..44b8915875 --- /dev/null +++ b/include/powermanager/PowerHalController.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2020 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 ANDROID_POWERHALCONTROLLER_H +#define ANDROID_POWERHALCONTROLLER_H + +#include +#include +#include +#include + +#include + +using android::hardware::power::Boost; +using android::hardware::power::Mode; +using android::hardware::power::V1_0::Feature; +using android::hardware::power::V1_0::PowerHint; + +namespace android { + +// ------------------------------------------------------------------------------------------------- + +// Connects to underlying Power HAL handles. +class PowerHalConnector { +public: + PowerHalConnector() = default; + virtual ~PowerHalConnector() = default; + + virtual std::unique_ptr connect(); + virtual void reset(); +}; + +// ------------------------------------------------------------------------------------------------- + +// Controller for Power HAL handle. +// This relies on PowerHalConnector to connect to the underlying Power HAL service and reconnects to +// it after each failed api call. This also ensures connecting to the service is thread-safe. +class PowerHalController : public PowerHalWrapper { +public: + PowerHalController() : PowerHalController(std::make_unique()) {} + explicit PowerHalController(std::unique_ptr connector) + : mHalConnector(std::move(connector)) {} + + void init(); + + PowerHalResult setBoost(Boost boost, int32_t durationMs) override; + PowerHalResult setMode(Mode mode, bool enabled) override; + +private: + std::mutex mConnectedHalMutex; + std::unique_ptr mHalConnector; + + // Shared pointers to keep global pointer and allow local copies to be used in different threads + std::shared_ptr mConnectedHal GUARDED_BY(mConnectedHalMutex) = nullptr; + const std::shared_ptr mDefaultHal = std::make_shared(); + + std::shared_ptr initHal(); + PowerHalResult processHalResult(PowerHalResult result, const char* functionName); +}; + +// ------------------------------------------------------------------------------------------------- + +}; // namespace android + +#endif // ANDROID_POWERHALCONTROLLER_H -- cgit v1.2.3-59-g8ed1b From b59a9b54112ab674c3dfe00bb851316dd88afed8 Mon Sep 17 00:00:00 2001 From: Lais Andrade Date: Thu, 7 May 2020 17:23:42 +0100 Subject: Some fixes to power manager lib code - Run clang-format on all recently added files; - Move all new classes to android::power namespace and remove Power prefix from all classes and enums; - Add virtual function specifier to overrides of virtual members; - Add missing virtual destructors; - Remove namespaces and aliases from public api of header files; - Delete constructor and destructor of PowerHalLoader; - Add helper functions to convert hal results in wrapper implementations; - Merge test targets to single libpowermanager_test target; Bug: 150878220 Test: atest libpowermanager_test Change-Id: Ie2b5ad69f3b05d5f6b576671bc98e0f83b274152 --- PREUPLOAD.cfg | 2 + include/powermanager/PowerHalController.h | 49 +++---- include/powermanager/PowerHalLoader.h | 27 ++-- include/powermanager/PowerHalWrapper.h | 90 ++++++------ services/powermanager/PowerHalController.cpp | 50 +++---- services/powermanager/PowerHalLoader.cpp | 35 ++--- services/powermanager/PowerHalWrapper.cpp | 151 +++++++++++---------- services/powermanager/TEST_MAPPING | 5 +- services/powermanager/tests/Android.bp | 22 +-- .../powermanager/tests/PowerHalControllerTest.cpp | 107 +++++++-------- services/powermanager/tests/PowerHalLoaderTest.cpp | 19 ++- .../powermanager/tests/PowerHalWrapperAidlTest.cpp | 91 ++++++------- .../tests/PowerHalWrapperHidlV1_0Test.cpp | 73 +++++----- .../tests/PowerHalWrapperHidlV1_1Test.cpp | 88 ++++++------ 14 files changed, 384 insertions(+), 425 deletions(-) (limited to 'include/powermanager/PowerHalController.h') diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg index 0473bb833e..436c80948d 100644 --- a/PREUPLOAD.cfg +++ b/PREUPLOAD.cfg @@ -6,6 +6,7 @@ clang_format = true clang_format = --commit ${PREUPLOAD_COMMIT} --style file --extensions c,h,cc,cpp cmds/idlcli/ include/input/ + include/powermanager/ libs/binder/fuzzer/ libs/binder/ndk/ libs/binderthreadstate/ @@ -18,6 +19,7 @@ clang_format = --commit ${PREUPLOAD_COMMIT} --style file --extensions c,h,cc,cpp opengl/libs/ services/bufferhub/ services/inputflinger/ + services/powermanager/ services/surfaceflinger/ services/vr/ vulkan/ diff --git a/include/powermanager/PowerHalController.h b/include/powermanager/PowerHalController.h index 44b8915875..dd34c0a6c2 100644 --- a/include/powermanager/PowerHalController.h +++ b/include/powermanager/PowerHalController.h @@ -21,58 +21,59 @@ #include #include #include - #include -using android::hardware::power::Boost; -using android::hardware::power::Mode; -using android::hardware::power::V1_0::Feature; -using android::hardware::power::V1_0::PowerHint; - namespace android { +namespace power { + // ------------------------------------------------------------------------------------------------- // Connects to underlying Power HAL handles. -class PowerHalConnector { +class HalConnector { public: - PowerHalConnector() = default; - virtual ~PowerHalConnector() = default; + HalConnector() = default; + virtual ~HalConnector() = default; - virtual std::unique_ptr connect(); + virtual std::unique_ptr connect(); virtual void reset(); }; // ------------------------------------------------------------------------------------------------- // Controller for Power HAL handle. -// This relies on PowerHalConnector to connect to the underlying Power HAL service and reconnects to -// it after each failed api call. This also ensures connecting to the service is thread-safe. -class PowerHalController : public PowerHalWrapper { +// This relies on HalConnector to connect to the underlying Power HAL +// service and reconnects to it after each failed api call. This also ensures +// connecting to the service is thread-safe. +class PowerHalController : public HalWrapper { public: - PowerHalController() : PowerHalController(std::make_unique()) {} - explicit PowerHalController(std::unique_ptr connector) - : mHalConnector(std::move(connector)) {} + PowerHalController() : PowerHalController(std::make_unique()) {} + explicit PowerHalController(std::unique_ptr connector) + : mHalConnector(std::move(connector)) {} + virtual ~PowerHalController() = default; void init(); - PowerHalResult setBoost(Boost boost, int32_t durationMs) override; - PowerHalResult setMode(Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; private: std::mutex mConnectedHalMutex; - std::unique_ptr mHalConnector; + std::unique_ptr mHalConnector; - // Shared pointers to keep global pointer and allow local copies to be used in different threads - std::shared_ptr mConnectedHal GUARDED_BY(mConnectedHalMutex) = nullptr; - const std::shared_ptr mDefaultHal = std::make_shared(); + // Shared pointers to keep global pointer and allow local copies to be used in + // different threads + std::shared_ptr mConnectedHal GUARDED_BY(mConnectedHalMutex) = nullptr; + const std::shared_ptr mDefaultHal = std::make_shared(); - std::shared_ptr initHal(); - PowerHalResult processHalResult(PowerHalResult result, const char* functionName); + std::shared_ptr initHal(); + HalResult processHalResult(HalResult result, const char* functionName); }; // ------------------------------------------------------------------------------------------------- +}; // namespace power + }; // namespace android #endif // ANDROID_POWERHALCONTROLLER_H diff --git a/include/powermanager/PowerHalLoader.h b/include/powermanager/PowerHalLoader.h index 487b95b298..ed6f6f35f5 100644 --- a/include/powermanager/PowerHalLoader.h +++ b/include/powermanager/PowerHalLoader.h @@ -18,35 +18,36 @@ #define ANDROID_POWERHALLOADER_H #include - #include #include -using IPowerV1_0 = android::hardware::power::V1_0::IPower; -using IPowerV1_1 = android::hardware::power::V1_1::IPower; -using IPowerAidl = android::hardware::power::IPower; - namespace android { +namespace power { + // Loads available Power HAL services. class PowerHalLoader { public: static void unloadAll(); - static sp loadAidl(); - static sp loadHidlV1_0(); - static sp loadHidlV1_1(); + static sp loadAidl(); + static sp loadHidlV1_0(); + static sp loadHidlV1_1(); private: static std::mutex gHalMutex; - static sp gHalAidl GUARDED_BY(gHalMutex); - static sp gHalHidlV1_0 GUARDED_BY(gHalMutex); - static sp gHalHidlV1_1 GUARDED_BY(gHalMutex); + static sp gHalAidl GUARDED_BY(gHalMutex); + static sp gHalHidlV1_0 GUARDED_BY(gHalMutex); + static sp gHalHidlV1_1 GUARDED_BY(gHalMutex); - static sp loadHidlV1_0Locked() EXCLUSIVE_LOCKS_REQUIRED(gHalMutex); + static sp loadHidlV1_0Locked() + EXCLUSIVE_LOCKS_REQUIRED(gHalMutex); - PowerHalLoader() = default; + PowerHalLoader() = delete; + ~PowerHalLoader() = delete; }; +}; // namespace power + } // namespace android #endif // ANDROID_POWERHALLOADER_H diff --git a/include/powermanager/PowerHalWrapper.h b/include/powermanager/PowerHalWrapper.h index 6d8a6eb0f6..c3e7601c29 100644 --- a/include/powermanager/PowerHalWrapper.h +++ b/include/powermanager/PowerHalWrapper.h @@ -18,111 +18,111 @@ #define ANDROID_POWERHALWRAPPER_H #include - #include #include #include #include -using android::hardware::power::Boost; -using android::hardware::power::Mode; -using android::hardware::power::V1_0::Feature; -using android::hardware::power::V1_0::PowerHint; -using IPowerV1_1 = android::hardware::power::V1_1::IPower; -using IPowerV1_0 = android::hardware::power::V1_0::IPower; -using IPowerAidl = android::hardware::power::IPower; - namespace android { +namespace power { + // State of Power HAL support for individual apis. -enum class PowerHalSupport { +enum class HalSupport { UNKNOWN = 0, ON = 1, OFF = 2, }; // State of the Power HAL api call result. -enum class PowerHalResult { +enum class HalResult { SUCCESSFUL = 0, FAILED = 1, UNSUPPORTED = 2, }; // Wrapper for Power HAL handlers. -class PowerHalWrapper { +class HalWrapper { public: - virtual ~PowerHalWrapper() = default; + virtual ~HalWrapper() = default; - virtual PowerHalResult setBoost(Boost boost, int32_t durationMs) = 0; - virtual PowerHalResult setMode(Mode mode, bool enabled) = 0; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) = 0; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) = 0; }; // Empty Power HAL wrapper that ignores all api calls. -class EmptyPowerHalWrapper : public PowerHalWrapper { +class EmptyHalWrapper : public HalWrapper { public: - EmptyPowerHalWrapper() = default; - ~EmptyPowerHalWrapper() = default; + EmptyHalWrapper() = default; + ~EmptyHalWrapper() = default; - PowerHalResult setBoost(Boost boost, int32_t durationMs) override; - PowerHalResult setMode(Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; }; // Wrapper for the HIDL Power HAL v1.0. -class HidlPowerHalWrapperV1_0 : public PowerHalWrapper { +class HidlHalWrapperV1_0 : public HalWrapper { public: - explicit HidlPowerHalWrapperV1_0(sp powerHal) : handleV1_0(std::move(powerHal)) {} - virtual ~HidlPowerHalWrapperV1_0() = default; + explicit HidlHalWrapperV1_0(sp Hal) + : mHandleV1_0(std::move(Hal)) {} + virtual ~HidlHalWrapperV1_0() = default; - PowerHalResult setBoost(Boost boost, int32_t durationMs) override; - PowerHalResult setMode(Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; protected: - virtual PowerHalResult sendPowerHint(PowerHint hintId, uint32_t data); + virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, uint32_t data); private: - sp handleV1_0; - PowerHalResult setInteractive(bool enabled); - PowerHalResult setFeature(Feature feature, bool enabled); + sp mHandleV1_0; + HalResult setInteractive(bool enabled); + HalResult setFeature(hardware::power::V1_0::Feature feature, bool enabled); }; // Wrapper for the HIDL Power HAL v1.1. -class HidlPowerHalWrapperV1_1 : public HidlPowerHalWrapperV1_0 { +class HidlHalWrapperV1_1 : public HidlHalWrapperV1_0 { public: - HidlPowerHalWrapperV1_1(sp powerHalV1_0, sp powerHalV1_1) - : HidlPowerHalWrapperV1_0(powerHalV1_0), handleV1_1(std::move(powerHalV1_1)) {} - ~HidlPowerHalWrapperV1_1() = default; + HidlHalWrapperV1_1(sp handleV1_0, + sp handleV1_1) + : HidlHalWrapperV1_0(std::move(handleV1_0)), mHandleV1_1(std::move(handleV1_1)) {} + virtual ~HidlHalWrapperV1_1() = default; protected: - virtual PowerHalResult sendPowerHint(PowerHint hintId, uint32_t data) override; + virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, + uint32_t data) override; private: - sp handleV1_1; + sp mHandleV1_1; }; // Wrapper for the AIDL Power HAL. -class AidlPowerHalWrapper : public PowerHalWrapper { +class AidlHalWrapper : public HalWrapper { public: - explicit AidlPowerHalWrapper(sp powerHal) : handle(std::move(powerHal)) {} - ~AidlPowerHalWrapper() = default; + explicit AidlHalWrapper(sp handle) : mHandle(std::move(handle)) {} + virtual ~AidlHalWrapper() = default; - PowerHalResult setBoost(Boost boost, int32_t durationMs) override; - PowerHalResult setMode(Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; private: // Control access to the boost and mode supported arrays. std::mutex mBoostMutex; std::mutex mModeMutex; - sp handle; + sp mHandle; // Android framework only sends boost upto DISPLAY_UPDATE_IMMINENT. // Need to increase the array size if more boost supported. - std::array, static_cast(Boost::DISPLAY_UPDATE_IMMINENT)+1> - boostSupportedArray GUARDED_BY(mBoostMutex) = {PowerHalSupport::UNKNOWN}; + std::array, + static_cast(hardware::power::Boost::DISPLAY_UPDATE_IMMINENT) + 1> + mBoostSupportedArray GUARDED_BY(mBoostMutex) = {HalSupport::UNKNOWN}; // Android framework only sends mode upto DISPLAY_INACTIVE. // Need to increase the array if more mode supported. - std::array, static_cast(Mode::DISPLAY_INACTIVE)+1> - modeSupportedArray GUARDED_BY(mModeMutex) = {PowerHalSupport::UNKNOWN}; + std::array, + static_cast(hardware::power::Mode::DISPLAY_INACTIVE) + 1> + mModeSupportedArray GUARDED_BY(mModeMutex) = {HalSupport::UNKNOWN}; }; +}; // namespace power + }; // namespace android #endif // ANDROID_POWERHALWRAPPER_H diff --git a/services/powermanager/PowerHalController.cpp b/services/powermanager/PowerHalController.cpp index d26d582c43..178f545b2e 100644 --- a/services/powermanager/PowerHalController.cpp +++ b/services/powermanager/PowerHalController.cpp @@ -15,40 +15,39 @@ */ #define LOG_TAG "PowerHalController" -#include - #include #include #include #include - #include #include +#include -using android::hardware::power::Boost; -using android::hardware::power::Mode; +using namespace android::hardware::power; namespace android { +namespace power { + // ------------------------------------------------------------------------------------------------- -std::unique_ptr PowerHalConnector::connect() { - sp halAidl = PowerHalLoader::loadAidl(); +std::unique_ptr HalConnector::connect() { + sp halAidl = PowerHalLoader::loadAidl(); if (halAidl) { - return std::make_unique(halAidl); + return std::make_unique(halAidl); } - sp halHidlV1_0 = PowerHalLoader::loadHidlV1_0(); - sp halHidlV1_1 = PowerHalLoader::loadHidlV1_1(); + sp halHidlV1_0 = PowerHalLoader::loadHidlV1_0(); + sp halHidlV1_1 = PowerHalLoader::loadHidlV1_1(); if (halHidlV1_1) { - return std::make_unique(halHidlV1_0, halHidlV1_1); + return std::make_unique(halHidlV1_0, halHidlV1_1); } if (halHidlV1_0) { - return std::make_unique(halHidlV1_0); + return std::make_unique(halHidlV1_0); } return nullptr; } -void PowerHalConnector::reset() { +void HalConnector::reset() { PowerHalLoader::unloadAll(); } @@ -58,8 +57,9 @@ void PowerHalController::init() { initHal(); } -// Check validity of current handle to the power HAL service, and create a new one if necessary. -std::shared_ptr PowerHalController::initHal() { +// Check validity of current handle to the power HAL service, and create a new +// one if necessary. +std::shared_ptr PowerHalController::initHal() { std::lock_guard lock(mConnectedHalMutex); if (mConnectedHal == nullptr) { mConnectedHal = mHalConnector->connect(); @@ -71,10 +71,10 @@ std::shared_ptr PowerHalController::initHal() { return mConnectedHal; } -// Check if a call to Power HAL function failed; if so, log the failure and invalidate the -// current Power HAL handle. -PowerHalResult PowerHalController::processHalResult(PowerHalResult result, const char* fnName) { - if (result == PowerHalResult::FAILED) { +// Check if a call to Power HAL function failed; if so, log the failure and +// invalidate the current Power HAL handle. +HalResult PowerHalController::processHalResult(HalResult result, const char* fnName) { + if (result == HalResult::FAILED) { ALOGE("%s() failed: power HAL service not available.", fnName); std::lock_guard lock(mConnectedHalMutex); // Drop Power HAL handle. This will force future api calls to reconnect. @@ -84,16 +84,18 @@ PowerHalResult PowerHalController::processHalResult(PowerHalResult result, const return result; } -PowerHalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) { - std::shared_ptr handle = initHal(); +HalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) { + std::shared_ptr handle = initHal(); auto result = handle->setBoost(boost, durationMs); return processHalResult(result, "setBoost"); } -PowerHalResult PowerHalController::setMode(Mode mode, bool enabled) { - std::shared_ptr handle = initHal(); +HalResult PowerHalController::setMode(Mode mode, bool enabled) { + std::shared_ptr handle = initHal(); auto result = handle->setMode(mode, enabled); return processHalResult(result, "setMode"); } -}; // namespace android +} // namespace power + +} // namespace android diff --git a/services/powermanager/PowerHalLoader.cpp b/services/powermanager/PowerHalLoader.cpp index 3ae538447b..1f1b43a607 100644 --- a/services/powermanager/PowerHalLoader.cpp +++ b/services/powermanager/PowerHalLoader.cpp @@ -21,15 +21,14 @@ #include #include #include - #include -using IPowerV1_1 = android::hardware::power::V1_1::IPower; -using IPowerV1_0 = android::hardware::power::V1_0::IPower; -using IPowerAidl = android::hardware::power::IPower; +using namespace android::hardware::power; namespace android { +namespace power { + // ------------------------------------------------------------------------------------------------- template @@ -53,9 +52,9 @@ sp loadHal(bool& exists, sp& hal, F& loadFn, const char* halName) { // ------------------------------------------------------------------------------------------------- std::mutex PowerHalLoader::gHalMutex; -sp PowerHalLoader::gHalAidl = nullptr; -sp PowerHalLoader::gHalHidlV1_0 = nullptr; -sp PowerHalLoader::gHalHidlV1_1 = nullptr; +sp PowerHalLoader::gHalAidl = nullptr; +sp PowerHalLoader::gHalHidlV1_0 = nullptr; +sp PowerHalLoader::gHalHidlV1_1 = nullptr; void PowerHalLoader::unloadAll() { std::lock_guard lock(gHalMutex); @@ -64,31 +63,33 @@ void PowerHalLoader::unloadAll() { gHalHidlV1_1 = nullptr; } -sp PowerHalLoader::loadAidl() { +sp PowerHalLoader::loadAidl() { std::lock_guard lock(gHalMutex); static bool gHalExists = true; - static auto loadFn = []() { return waitForVintfService(); }; - return loadHal(gHalExists, gHalAidl, loadFn, "AIDL"); + static auto loadFn = []() { return waitForVintfService(); }; + return loadHal(gHalExists, gHalAidl, loadFn, "AIDL"); } -sp PowerHalLoader::loadHidlV1_0() { +sp PowerHalLoader::loadHidlV1_0() { std::lock_guard lock(gHalMutex); return loadHidlV1_0Locked(); } -sp PowerHalLoader::loadHidlV1_1() { +sp PowerHalLoader::loadHidlV1_1() { std::lock_guard lock(gHalMutex); static bool gHalExists = true; - static auto loadFn = []() { return IPowerV1_1::castFrom(loadHidlV1_0Locked()); }; - return loadHal(gHalExists, gHalHidlV1_1, loadFn, "HIDL v1.1"); + static auto loadFn = []() { return V1_1::IPower::castFrom(loadHidlV1_0Locked()); }; + return loadHal(gHalExists, gHalHidlV1_1, loadFn, "HIDL v1.1"); } -sp PowerHalLoader::loadHidlV1_0Locked() { +sp PowerHalLoader::loadHidlV1_0Locked() { static bool gHalExists = true; - static auto loadFn = []() { return IPowerV1_0::getService(); }; - return loadHal(gHalExists, gHalHidlV1_0, loadFn, "HIDL v1.0"); + static auto loadFn = []() { return V1_0::IPower::getService(); }; + return loadHal(gHalExists, gHalHidlV1_0, loadFn, "HIDL v1.0"); } // ------------------------------------------------------------------------------------------------- +} // namespace power + } // namespace android diff --git a/services/powermanager/PowerHalWrapper.cpp b/services/powermanager/PowerHalWrapper.cpp index d959a2cc96..5f4bfed595 100644 --- a/services/powermanager/PowerHalWrapper.cpp +++ b/services/powermanager/PowerHalWrapper.cpp @@ -14,159 +14,162 @@ * limitations under the License. */ -#define LOG_TAG "PowerHalWrapper" -#include - +#define LOG_TAG "HalWrapper" #include #include - #include +#include -using android::hardware::power::Boost; -using android::hardware::power::Mode; -using android::hardware::power::V1_0::Feature; -using android::hardware::power::V1_0::PowerHint; +using namespace android::hardware::power; namespace android { +namespace power { + +// ------------------------------------------------------------------------------------------------- + +inline HalResult toHalResult(const binder::Status& result) { + return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED; +} + +template +inline HalResult toHalResult(const hardware::Return& result) { + return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED; +} + // ------------------------------------------------------------------------------------------------- -PowerHalResult EmptyPowerHalWrapper::setBoost(Boost boost, int32_t durationMs) { +HalResult EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) { ALOGV("Skipped setBoost %s with duration %dms because Power HAL not available", - toString(boost).c_str(), durationMs); - return PowerHalResult::UNSUPPORTED; + toString(boost).c_str(), durationMs); + return HalResult::UNSUPPORTED; } -PowerHalResult EmptyPowerHalWrapper::setMode(Mode mode, bool enabled) { - ALOGV("Skipped setMode %s to %s because Power HAL not available", - toString(mode).c_str(), enabled ? "true" : "false"); - return PowerHalResult::UNSUPPORTED; +HalResult EmptyHalWrapper::setMode(Mode mode, bool enabled) { + ALOGV("Skipped setMode %s to %s because Power HAL not available", toString(mode).c_str(), + enabled ? "true" : "false"); + return HalResult::UNSUPPORTED; } // ------------------------------------------------------------------------------------------------- -PowerHalResult HidlPowerHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) { +HalResult HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) { if (boost == Boost::INTERACTION) { - return sendPowerHint(PowerHint::INTERACTION, durationMs); + return sendPowerHint(V1_0::PowerHint::INTERACTION, durationMs); } else { - ALOGV("Skipped setBoost %s because Power HAL AIDL not available", - toString(boost).c_str()); - return PowerHalResult::UNSUPPORTED; + ALOGV("Skipped setBoost %s because Power HAL AIDL not available", toString(boost).c_str()); + return HalResult::UNSUPPORTED; } } -PowerHalResult HidlPowerHalWrapperV1_0::setMode(Mode mode, bool enabled) { +HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) { uint32_t data = enabled ? 1 : 0; switch (mode) { case Mode::LAUNCH: - return sendPowerHint(PowerHint::LAUNCH, data); + return sendPowerHint(V1_0::PowerHint::LAUNCH, data); case Mode::LOW_POWER: - return sendPowerHint(PowerHint::LOW_POWER, data); + return sendPowerHint(V1_0::PowerHint::LOW_POWER, data); case Mode::SUSTAINED_PERFORMANCE: - return sendPowerHint(PowerHint::SUSTAINED_PERFORMANCE, data); + return sendPowerHint(V1_0::PowerHint::SUSTAINED_PERFORMANCE, data); case Mode::VR: - return sendPowerHint(PowerHint::VR_MODE, data); + return sendPowerHint(V1_0::PowerHint::VR_MODE, data); case Mode::INTERACTIVE: return setInteractive(enabled); case Mode::DOUBLE_TAP_TO_WAKE: - return setFeature(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled); + return setFeature(V1_0::Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled); default: ALOGV("Skipped setMode %s because Power HAL AIDL not available", - toString(mode).c_str()); - return PowerHalResult::UNSUPPORTED; + toString(mode).c_str()); + return HalResult::UNSUPPORTED; } } -PowerHalResult HidlPowerHalWrapperV1_0::sendPowerHint(PowerHint hintId, uint32_t data) { - auto ret = handleV1_0->powerHint(hintId, data); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; +HalResult HidlHalWrapperV1_0::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { + return toHalResult(mHandleV1_0->powerHint(hintId, data)); } -PowerHalResult HidlPowerHalWrapperV1_0::setInteractive(bool enabled) { - auto ret = handleV1_0->setInteractive(enabled); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; +HalResult HidlHalWrapperV1_0::setInteractive(bool enabled) { + return toHalResult(mHandleV1_0->setInteractive(enabled)); } -PowerHalResult HidlPowerHalWrapperV1_0::setFeature(Feature feature, bool enabled) { - auto ret = handleV1_0->setFeature(feature, enabled); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; +HalResult HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) { + return toHalResult(mHandleV1_0->setFeature(feature, enabled)); } // ------------------------------------------------------------------------------------------------- -PowerHalResult HidlPowerHalWrapperV1_1::sendPowerHint(PowerHint hintId, uint32_t data) { - auto ret = handleV1_1->powerHintAsync(hintId, data); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; +HalResult HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { + return toHalResult(mHandleV1_1->powerHintAsync(hintId, data)); } // ------------------------------------------------------------------------------------------------- -PowerHalResult AidlPowerHalWrapper::setBoost(Boost boost, int32_t durationMs) { +HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { std::unique_lock lock(mBoostMutex); // Quick return if boost is not supported by HAL if (boost > Boost::DISPLAY_UPDATE_IMMINENT || - boostSupportedArray[static_cast(boost)] == PowerHalSupport::OFF) { - ALOGV("Skipped setBoost %s because Power HAL doesn't support it", - toString(boost).c_str()); - return PowerHalResult::UNSUPPORTED; + mBoostSupportedArray[static_cast(boost)] == HalSupport::OFF) { + ALOGV("Skipped setBoost %s because Power HAL doesn't support it", toString(boost).c_str()); + return HalResult::UNSUPPORTED; } - if (boostSupportedArray[static_cast(boost)] == PowerHalSupport::UNKNOWN) { + if (mBoostSupportedArray[static_cast(boost)] == HalSupport::UNKNOWN) { bool isSupported = false; - auto isSupportedRet = handle->isBoostSupported(boost, &isSupported); + auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported); if (!isSupportedRet.isOk()) { - ALOGV("Skipped setBoost %s because Power HAL is not available to check support", - toString(boost).c_str()); - return PowerHalResult::FAILED; + ALOGV("Skipped setBoost %s because Power HAL is not available to check " + "support", + toString(boost).c_str()); + return HalResult::FAILED; } - boostSupportedArray[static_cast(boost)] = - isSupported ? PowerHalSupport::ON : PowerHalSupport::OFF; + mBoostSupportedArray[static_cast(boost)] = + isSupported ? HalSupport::ON : HalSupport::OFF; if (!isSupported) { ALOGV("Skipped setBoost %s because Power HAL doesn't support it", - toString(boost).c_str()); - return PowerHalResult::UNSUPPORTED; + toString(boost).c_str()); + return HalResult::UNSUPPORTED; } } lock.unlock(); - auto ret = handle->setBoost(boost, durationMs); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; + return toHalResult(mHandle->setBoost(boost, durationMs)); } -PowerHalResult AidlPowerHalWrapper::setMode(Mode mode, bool enabled) { +HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) { std::unique_lock lock(mModeMutex); // Quick return if mode is not supported by HAL if (mode > Mode::DISPLAY_INACTIVE || - modeSupportedArray[static_cast(mode)] == PowerHalSupport::OFF) { - ALOGV("Skipped setMode %s because Power HAL doesn't support it", - toString(mode).c_str()); - return PowerHalResult::UNSUPPORTED; + mModeSupportedArray[static_cast(mode)] == HalSupport::OFF) { + ALOGV("Skipped setMode %s because Power HAL doesn't support it", toString(mode).c_str()); + return HalResult::UNSUPPORTED; } - if (modeSupportedArray[static_cast(mode)] == PowerHalSupport::UNKNOWN) { + if (mModeSupportedArray[static_cast(mode)] == HalSupport::UNKNOWN) { bool isSupported = false; - auto isSupportedRet = handle->isModeSupported(mode, &isSupported); + auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported); if (!isSupportedRet.isOk()) { - ALOGV("Skipped setMode %s because Power HAL is not available to check support", - toString(mode).c_str()); - return PowerHalResult::FAILED; + ALOGV("Skipped setMode %s because Power HAL is not available to check " + "support", + toString(mode).c_str()); + return HalResult::FAILED; } - modeSupportedArray[static_cast(mode)] = - isSupported ? PowerHalSupport::ON : PowerHalSupport::OFF; + mModeSupportedArray[static_cast(mode)] = + isSupported ? HalSupport::ON : HalSupport::OFF; if (!isSupported) { - ALOGV("Skipped setMode %s because Power HAL doesn't support it", - toString(mode).c_str()); - return PowerHalResult::UNSUPPORTED; + ALOGV("Skipped setMode %s because Power HAL doesn't support it", + toString(mode).c_str()); + return HalResult::UNSUPPORTED; } } lock.unlock(); - auto ret = handle->setMode(mode, enabled); - return ret.isOk() ? PowerHalResult::SUCCESSFUL : PowerHalResult::FAILED; + return toHalResult(mHandle->setMode(mode, enabled)); } // ------------------------------------------------------------------------------------------------- -}; // namespace android +} // namespace power + +} // namespace android diff --git a/services/powermanager/TEST_MAPPING b/services/powermanager/TEST_MAPPING index 9a67901c5f..caaec556e9 100644 --- a/services/powermanager/TEST_MAPPING +++ b/services/powermanager/TEST_MAPPING @@ -1,10 +1,7 @@ { "presubmit": [ { - "name": "powermanager_test" - }, - { - "name": "thermalmanager_test" + "name": "libpowermanager_test" } ] } diff --git a/services/powermanager/tests/Android.bp b/services/powermanager/tests/Android.bp index 70837cfda5..49abc1152b 100644 --- a/services/powermanager/tests/Android.bp +++ b/services/powermanager/tests/Android.bp @@ -13,9 +13,10 @@ // limitations under the License. cc_test { - name: "powermanager_test", + name: "libpowermanager_test", test_suites: ["device-tests"], srcs: [ + "IThermalManagerTest.cpp", "PowerHalControllerTest.cpp", "PowerHalLoaderTest.cpp", "PowerHalWrapperAidlTest.cpp", @@ -42,22 +43,3 @@ cc_test { "libgmock", ], } - -cc_test { - name: "thermalmanager_test", - test_suites: ["device-tests"], - srcs: ["IThermalManagerTest.cpp",], - cflags: [ - "-Wall", - "-Werror", - "-Wextra", - ], - shared_libs: [ - "libbase", - "libhidlbase", - "liblog", - "libpowermanager", - "libbinder", - "libutils", - ], -} diff --git a/services/powermanager/tests/PowerHalControllerTest.cpp b/services/powermanager/tests/PowerHalControllerTest.cpp index ac1e19a242..141b2440b8 100644 --- a/services/powermanager/tests/PowerHalControllerTest.cpp +++ b/services/powermanager/tests/PowerHalControllerTest.cpp @@ -19,15 +19,12 @@ #include #include #include - #include #include - -#include #include +#include #include -#include using android::hardware::power::Boost; using android::hardware::power::Mode; @@ -36,6 +33,7 @@ using android::hardware::power::V1_0::IPower; using android::hardware::power::V1_0::PowerHint; using namespace android; +using namespace android::power; using namespace std::chrono_literals; using namespace testing; @@ -45,23 +43,21 @@ class MockIPowerV1_0 : public IPower { public: MOCK_METHOD(hardware::Return, setInteractive, (bool interactive), (override)); MOCK_METHOD(hardware::Return, powerHint, (PowerHint hint, int32_t data), (override)); - MOCK_METHOD( - hardware::Return, setFeature, (Feature feature, bool activate), (override)); - MOCK_METHOD( - hardware::Return, getPlatformLowPowerStats, - (getPlatformLowPowerStats_cb _hidl_cb), (override)); + MOCK_METHOD(hardware::Return, setFeature, (Feature feature, bool activate), (override)); + MOCK_METHOD(hardware::Return, getPlatformLowPowerStats, + (getPlatformLowPowerStats_cb _hidl_cb), (override)); }; -class TestPowerHalConnector : public PowerHalConnector { +class TestPowerHalConnector : public HalConnector { public: TestPowerHalConnector(sp powerHal) : mHal(std::move(powerHal)) {} virtual ~TestPowerHalConnector() = default; - virtual std::unique_ptr connect() override { + virtual std::unique_ptr connect() override { mCountMutex.lock(); ++mConnectedCount; mCountMutex.unlock(); - return std::make_unique(mHal); + return std::make_unique(mHal); } void reset() override { @@ -70,13 +66,9 @@ public: mCountMutex.unlock(); } - int getConnectCount() { - return mConnectedCount; - } + int getConnectCount() { return mConnectedCount; } - int getResetCount() { - return mResetCount; - } + int getResetCount() { return mResetCount; } private: sp mHal = nullptr; @@ -89,8 +81,8 @@ class AlwaysFailingTestPowerHalConnector : public TestPowerHalConnector { public: AlwaysFailingTestPowerHalConnector() : TestPowerHalConnector(nullptr) {} - std::unique_ptr connect() override { - // Call parent to update counter, but ignore connected PowerHalWrapper. + std::unique_ptr connect() override { + // Call parent to update counter, but ignore connected HalWrapper. TestPowerHalConnector::connect(); return nullptr; } @@ -103,7 +95,7 @@ public: void SetUp() override { mMockHal = new StrictMock(); std::unique_ptr halConnector = - std::make_unique(mMockHal); + std::make_unique(mMockHal); mHalConnector = halConnector.get(); mHalController = std::make_unique(std::move(halConnector)); } @@ -132,20 +124,22 @@ TEST_F(PowerHalControllerTest, TestInitConnectsToPowerHalOnlyOnce) { TEST_F(PowerHalControllerTest, TestUnableToConnectToPowerHalIgnoresAllApiCalls) { std::unique_ptr halConnector = - std::make_unique(); + std::make_unique(); AlwaysFailingTestPowerHalConnector* failingHalConnector = halConnector.get(); PowerHalController halController(std::move(halConnector)); int powerHalConnectCount = failingHalConnector->getConnectCount(); EXPECT_EQ(powerHalConnectCount, 0); - // Still works with EmptyPowerHalWrapper as fallback ignoring every api call and logging. + // Still works with EmptyPowerHalWrapper as fallback ignoring every api call + // and logging. auto result = halController.setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); result = halController.setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); - // PowerHalConnector was called every time to attempt to reconnect with underlying service. + // PowerHalConnector was called every time to attempt to reconnect with + // underlying service. powerHalConnectCount = failingHalConnector->getConnectCount(); EXPECT_EQ(powerHalConnectCount, 2); // PowerHalConnector was never reset. @@ -160,15 +154,14 @@ TEST_F(PowerHalControllerTest, TestAllApiCallsDelegatedToConnectedPowerHal) { { InSequence seg; EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(100))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))) - .Times(Exactly(1)); + .Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))).Times(Exactly(1)); } auto result = mHalController->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); // PowerHalConnector was called only once and never reset. powerHalConnectCount = mHalConnector->getConnectCount(); @@ -182,23 +175,23 @@ TEST_F(PowerHalControllerTest, TestPowerHalRecoversFromFailureByRecreatingPowerH EXPECT_EQ(powerHalConnectCount, 0); ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _)) - .WillByDefault([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .WillByDefault([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); - EXPECT_CALL(*mMockHal.get(), powerHint(_, _)) - .Times(Exactly(4)); + EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(4)); auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); result = mHalController->setMode(Mode::VR, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mHalController->setMode(Mode::LOW_POWER, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); - // PowerHalConnector was called only twice: on first api call and after failed call. + // PowerHalConnector was called only twice: on first api call and after failed + // call. powerHalConnectCount = mHalConnector->getConnectCount(); EXPECT_EQ(powerHalConnectCount, 2); // PowerHalConnector was reset once after failed call. @@ -211,9 +204,9 @@ TEST_F(PowerHalControllerTest, TestPowerHalDoesNotTryToRecoverFromFailureOnUnsup EXPECT_EQ(powerHalConnectCount, 0); auto result = mHalController->setBoost(Boost::CAMERA_LAUNCH, 1000); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); result = mHalController->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); // PowerHalConnector was called only once and never reset. powerHalConnectCount = mHalConnector->getConnectCount(); @@ -226,19 +219,19 @@ TEST_F(PowerHalControllerTest, TestMultiThreadConnectsOnlyOnce) { int powerHalConnectCount = mHalConnector->getConnectCount(); EXPECT_EQ(powerHalConnectCount, 0); - EXPECT_CALL(*mMockHal.get(), powerHint(_, _)) - .Times(Exactly(10)); + EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(10)); std::vector threads; for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); - // PowerHalConnector was called only by the first thread to use the api and never reset. + // PowerHalConnector was called only by the first thread to use the api and + // never reset. powerHalConnectCount = mHalConnector->getConnectCount(); EXPECT_EQ(powerHalConnectCount, 1); int powerHalResetCount = mHalConnector->getResetCount(); @@ -250,36 +243,36 @@ TEST_F(PowerHalControllerTest, TestMultiThreadWithFailureReconnectIsThreadSafe) EXPECT_EQ(powerHalConnectCount, 0); ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _)) - .WillByDefault([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .WillByDefault([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); - EXPECT_CALL(*mMockHal.get(), powerHint(_, _)) - .Times(Exactly(40)); + EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(40)); std::vector threads; for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::VR, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); // PowerHalConnector was called at least once by the first thread. - // Reset and reconnect calls were made at most 10 times, once after each failure. + // Reset and reconnect calls were made at most 10 times, once after each + // failure. powerHalConnectCount = mHalConnector->getConnectCount(); EXPECT_THAT(powerHalConnectCount, AllOf(Ge(1), Le(11))); int powerHalResetCount = mHalConnector->getResetCount(); diff --git a/services/powermanager/tests/PowerHalLoaderTest.cpp b/services/powermanager/tests/PowerHalLoaderTest.cpp index 2310a72318..058e1b5ca8 100644 --- a/services/powermanager/tests/PowerHalLoaderTest.cpp +++ b/services/powermanager/tests/PowerHalLoaderTest.cpp @@ -19,17 +19,18 @@ #include #include #include - -#include #include - #include +#include + using IPowerV1_0 = android::hardware::power::V1_0::IPower; using IPowerV1_1 = android::hardware::power::V1_1::IPower; using IPowerAidl = android::hardware::power::IPower; using namespace android; +using namespace android::power; +using namespace testing; // ------------------------------------------------------------------------------------------------- @@ -54,14 +55,10 @@ sp loadHal() { // ------------------------------------------------------------------------------------------------- template -class PowerHalLoaderTest : public testing::Test { +class PowerHalLoaderTest : public Test { public: - sp load() { - return ::loadHal(); - } - void unload() { - PowerHalLoader::unloadAll(); - } + sp load() { return ::loadHal(); } + void unload() { PowerHalLoader::unloadAll(); } }; // ------------------------------------------------------------------------------------------------- @@ -95,7 +92,7 @@ TYPED_TEST(PowerHalLoaderTest, TestLoadMultiThreadLoadsOnlyOnce) { std::vector>> futures; for (int i = 0; i < 10; i++) { futures.push_back( - std::async(std::launch::async, &PowerHalLoaderTest::load, this)); + std::async(std::launch::async, &PowerHalLoaderTest::load, this)); } futures[0].wait(); diff --git a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp index 73b7466670..a7656598f0 100644 --- a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp +++ b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp @@ -19,14 +19,12 @@ #include #include #include - #include #include - #include +#include #include -#include using android::binder::Status; using android::hardware::power::Boost; @@ -34,6 +32,7 @@ using android::hardware::power::IPower; using android::hardware::power::Mode; using namespace android; +using namespace android::power; using namespace std::chrono_literals; using namespace testing; @@ -57,7 +56,7 @@ public: void SetUp() override; protected: - std::unique_ptr mWrapper = nullptr; + std::unique_ptr mWrapper = nullptr; sp> mMockHal = nullptr; }; @@ -65,7 +64,7 @@ protected: void PowerHalWrapperAidlTest::SetUp() { mMockHal = new StrictMock(); - mWrapper = std::make_unique(mMockHal); + mWrapper = std::make_unique(mMockHal); ASSERT_NE(mWrapper, nullptr); } @@ -75,62 +74,61 @@ TEST_F(PowerHalWrapperAidlTest, TestSetBoostSuccessful) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::DISPLAY_UPDATE_IMMINENT), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::DISPLAY_UPDATE_IMMINENT), Eq(100))) - .Times(Exactly(1)); + .Times(Exactly(1)); } auto result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 100); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostFailed) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100))) - .Times(Exactly(1)) - .WillRepeatedly(Return(Status::fromExceptionCode(-1))); + .Times(Exactly(1)) + .WillRepeatedly(Return(Status::fromExceptionCode(-1))); EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::DISPLAY_UPDATE_IMMINENT), _)) - .Times(Exactly(1)) - .WillRepeatedly(Return(Status::fromExceptionCode(-1))); + .Times(Exactly(1)) + .WillRepeatedly(Return(Status::fromExceptionCode(-1))); } auto result = mWrapper->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 1000); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostUnsupported) { EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); result = mWrapper->setBoost(Boost::CAMERA_SHOT, 10); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostMultiThreadCheckSupportedOnlyOnce) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); - EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100))) - .Times(Exactly(10)); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100))).Times(Exactly(10)); } std::vector threads; for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mWrapper->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); @@ -140,62 +138,61 @@ TEST_F(PowerHalWrapperAidlTest, TestSetModeSuccessful) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::DISPLAY_INACTIVE), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::DISPLAY_INACTIVE), Eq(false))) - .Times(Exactly(1)); + .Times(Exactly(1)); } auto result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperAidlTest, TestSetModeFailed) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(true))) - .Times(Exactly(1)) - .WillRepeatedly(Return(Status::fromExceptionCode(-1))); + .Times(Exactly(1)) + .WillRepeatedly(Return(Status::fromExceptionCode(-1))); EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::DISPLAY_INACTIVE), _)) - .Times(Exactly(1)) - .WillRepeatedly(Return(Status::fromExceptionCode(-1))); + .Times(Exactly(1)) + .WillRepeatedly(Return(Status::fromExceptionCode(-1))); } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperAidlTest, TestSetModeUnsupported) { EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } TEST_F(PowerHalWrapperAidlTest, TestSetModeMultiThreadCheckSupportedOnlyOnce) { { InSequence seq; EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _)) - .Times(Exactly(1)) - .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); - EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(false))) - .Times(Exactly(10)); + .Times(Exactly(1)) + .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status()))); + EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(false))).Times(Exactly(10)); } std::vector threads; for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mWrapper->setMode(Mode::LAUNCH, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp index 5379054493..6693d0b070 100644 --- a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp +++ b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp @@ -20,12 +20,9 @@ #include #include #include - #include #include - #include - #include using android::hardware::power::Boost; @@ -35,6 +32,7 @@ using android::hardware::power::V1_0::IPower; using android::hardware::power::V1_0::PowerHint; using namespace android; +using namespace android::power; using namespace std::chrono_literals; using namespace testing; @@ -44,11 +42,9 @@ class MockIPowerV1_0 : public IPower { public: MOCK_METHOD(hardware::Return, setInteractive, (bool interactive), (override)); MOCK_METHOD(hardware::Return, powerHint, (PowerHint hint, int32_t data), (override)); - MOCK_METHOD( - hardware::Return, setFeature, (Feature feature, bool activate), (override)); - MOCK_METHOD( - hardware::Return, getPlatformLowPowerStats, - (getPlatformLowPowerStats_cb _hidl_cb), (override)); + MOCK_METHOD(hardware::Return, setFeature, (Feature feature, bool activate), (override)); + MOCK_METHOD(hardware::Return, getPlatformLowPowerStats, + (getPlatformLowPowerStats_cb _hidl_cb), (override)); }; // ------------------------------------------------------------------------------------------------- @@ -58,7 +54,7 @@ public: void SetUp() override; protected: - std::unique_ptr mWrapper = nullptr; + std::unique_ptr mWrapper = nullptr; sp> mMockHal = nullptr; }; @@ -66,80 +62,75 @@ protected: void PowerHalWrapperHidlV1_0Test::SetUp() { mMockHal = new StrictMock(); - mWrapper = std::make_unique(mMockHal); + mWrapper = std::make_unique(mMockHal); ASSERT_NE(mWrapper, nullptr); } // ------------------------------------------------------------------------------------------------- TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostSuccessful) { - EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))) - .Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))).Times(Exactly(1)); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostFailed) { EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))) - .Times(Exactly(1)) - .WillRepeatedly([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .Times(Exactly(1)) + .WillRepeatedly([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostUnsupported) { auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeSuccessful) { { InSequence seq; - EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LOW_POWER), Eq(0))) - .Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))).Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LOW_POWER), Eq(0))).Times(Exactly(1)); EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::VR_MODE), Eq(0))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHal.get(), setInteractive(Eq(true))) - .Times(Exactly(1)); + .Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::VR_MODE), Eq(0))).Times(Exactly(1)); + EXPECT_CALL(*mMockHal.get(), setInteractive(Eq(true))).Times(Exactly(1)); EXPECT_CALL(*mMockHal.get(), setFeature(Eq(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE), Eq(false))) - .Times(Exactly(1)); + .Times(Exactly(1)); } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::VR, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::INTERACTIVE, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeFailed) { EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))) - .Times(Exactly(1)) - .WillRepeatedly([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .Times(Exactly(1)) + .WillRepeatedly([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); auto result = mWrapper->setMode(Mode::LAUNCH, 1); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeIgnored) { auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp index 931c0d5011..55bbd6df79 100644 --- a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp +++ b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp @@ -21,12 +21,9 @@ #include #include #include - #include #include - #include - #include using android::hardware::power::Boost; @@ -37,6 +34,7 @@ using IPowerV1_1 = android::hardware::power::V1_1::IPower; using IPowerV1_0 = android::hardware::power::V1_0::IPower; using namespace android; +using namespace android::power; using namespace std::chrono_literals; using namespace testing; @@ -46,27 +44,21 @@ class MockIPowerV1_0 : public IPowerV1_0 { public: MOCK_METHOD(hardware::Return, setInteractive, (bool interactive), (override)); MOCK_METHOD(hardware::Return, powerHint, (PowerHint hint, int32_t data), (override)); - MOCK_METHOD( - hardware::Return, setFeature, (Feature feature, bool activate), (override)); - MOCK_METHOD( - hardware::Return, getPlatformLowPowerStats, - (getPlatformLowPowerStats_cb _hidl_cb), (override)); + MOCK_METHOD(hardware::Return, setFeature, (Feature feature, bool activate), (override)); + MOCK_METHOD(hardware::Return, getPlatformLowPowerStats, + (getPlatformLowPowerStats_cb _hidl_cb), (override)); }; class MockIPowerV1_1 : public IPowerV1_1 { public: MOCK_METHOD(hardware::Return, setInteractive, (bool interactive), (override)); MOCK_METHOD(hardware::Return, powerHint, (PowerHint hint, int32_t data), (override)); - MOCK_METHOD( - hardware::Return, setFeature, (Feature feature, bool activate), (override)); - MOCK_METHOD( - hardware::Return, getPlatformLowPowerStats, - (getPlatformLowPowerStats_cb _hidl_cb), (override)); - MOCK_METHOD( - hardware::Return, powerHintAsync, (PowerHint hint, int32_t data), (override)); - MOCK_METHOD( - hardware::Return, getSubsystemLowPowerStats, - (getSubsystemLowPowerStats_cb _hidl_cb), (override)); + MOCK_METHOD(hardware::Return, setFeature, (Feature feature, bool activate), (override)); + MOCK_METHOD(hardware::Return, getPlatformLowPowerStats, + (getPlatformLowPowerStats_cb _hidl_cb), (override)); + MOCK_METHOD(hardware::Return, powerHintAsync, (PowerHint hint, int32_t data), (override)); + MOCK_METHOD(hardware::Return, getSubsystemLowPowerStats, + (getSubsystemLowPowerStats_cb _hidl_cb), (override)); }; // ------------------------------------------------------------------------------------------------- @@ -76,7 +68,7 @@ public: void SetUp() override; protected: - std::unique_ptr mWrapper = nullptr; + std::unique_ptr mWrapper = nullptr; sp> mMockHalV1_0 = nullptr; sp> mMockHalV1_1 = nullptr; }; @@ -86,7 +78,7 @@ protected: void PowerHalWrapperHidlV1_1Test::SetUp() { mMockHalV1_0 = new StrictMock(); mMockHalV1_1 = new StrictMock(); - mWrapper = std::make_unique(mMockHalV1_0, mMockHalV1_1); + mWrapper = std::make_unique(mMockHalV1_0, mMockHalV1_1); ASSERT_NE(mWrapper, nullptr); } @@ -94,72 +86,72 @@ void PowerHalWrapperHidlV1_1Test::SetUp() { TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostSuccessful) { EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::INTERACTION), Eq(1000))) - .Times(Exactly(1)); + .Times(Exactly(1)); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostFailed) { EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::INTERACTION), Eq(1000))) - .Times(Exactly(1)) - .WillRepeatedly([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .Times(Exactly(1)) + .WillRepeatedly([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostUnsupported) { auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetMode) { { InSequence seq; EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LAUNCH), Eq(1))) - .Times(Exactly(1)); + .Times(Exactly(1)); EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LOW_POWER), Eq(0))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1))) - .Times(Exactly(1)); + .Times(Exactly(1)); + EXPECT_CALL(*mMockHalV1_1.get(), + powerHintAsync(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1))) + .Times(Exactly(1)); EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::VR_MODE), Eq(0))) - .Times(Exactly(1)); - EXPECT_CALL(*mMockHalV1_0.get(), setInteractive(Eq(true))) - .Times(Exactly(1)); + .Times(Exactly(1)); + EXPECT_CALL(*mMockHalV1_0.get(), setInteractive(Eq(true))).Times(Exactly(1)); EXPECT_CALL(*mMockHalV1_0.get(), setFeature(Eq(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE), Eq(false))) - .Times(Exactly(1)); + .Times(Exactly(1)); } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::VR, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::INTERACTIVE, true); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false); - ASSERT_EQ(PowerHalResult::SUCCESSFUL, result); + ASSERT_EQ(HalResult::SUCCESSFUL, result); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeFailed) { EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LAUNCH), Eq(1))) - .Times(Exactly(1)) - .WillRepeatedly([](PowerHint, int32_t) { - return hardware::Return(hardware::Status::fromExceptionCode(-1)); - }); + .Times(Exactly(1)) + .WillRepeatedly([](PowerHint, int32_t) { + return hardware::Return(hardware::Status::fromExceptionCode(-1)); + }); auto result = mWrapper->setMode(Mode::LAUNCH, 1); - ASSERT_EQ(PowerHalResult::FAILED, result); + ASSERT_EQ(HalResult::FAILED, result); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeIgnored) { auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(PowerHalResult::UNSUPPORTED, result); + ASSERT_EQ(HalResult::UNSUPPORTED, result); } -- cgit v1.2.3-59-g8ed1b From 0b264bb47731c140741e2e98927e41a512b5cc25 Mon Sep 17 00:00:00 2001 From: Jimmy Shiu Date: Wed, 3 Mar 2021 00:30:50 +0800 Subject: ADPF: Plumb getAppSession throughout PowerHal wrapping Test: Manual test, run bouncy ball Test: atest libpowermanager_test:PowerHalWrapperAidlTest Test: atest libpowermanager_benchmarks Bug: 158791282 Change-Id: I0cf3420f3cf79f107347a640e6f14c1eeac60f23 Signed-off-by: Wei Wang --- include/powermanager/PowerHalController.h | 12 +- include/powermanager/PowerHalWrapper.h | 123 +++++++++++++++--- services/powermanager/Android.bp | 2 +- services/powermanager/PowerHalController.cpp | 25 +++- services/powermanager/PowerHalWrapper.cpp | 142 ++++++++++++++++----- services/powermanager/benchmarks/Android.bp | 2 +- .../benchmarks/PowerHalAidlBenchmarks.cpp | 106 +++++++++++++++ .../benchmarks/PowerHalControllerBenchmarks.cpp | 16 +-- services/powermanager/tests/Android.bp | 2 +- .../powermanager/tests/PowerHalControllerTest.cpp | 30 ++--- .../powermanager/tests/PowerHalWrapperAidlTest.cpp | 67 ++++++++-- .../tests/PowerHalWrapperHidlV1_0Test.cpp | 22 ++-- .../tests/PowerHalWrapperHidlV1_1Test.cpp | 22 ++-- 13 files changed, 450 insertions(+), 121 deletions(-) (limited to 'include/powermanager/PowerHalController.h') diff --git a/include/powermanager/PowerHalController.h b/include/powermanager/PowerHalController.h index dd34c0a6c2..71a36d09e5 100644 --- a/include/powermanager/PowerHalController.h +++ b/include/powermanager/PowerHalController.h @@ -20,6 +20,7 @@ #include #include #include +#include #include #include @@ -54,8 +55,12 @@ public: void init(); - virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; - virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult> createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos) override; + virtual HalResult getHintSessionPreferredRate() override; private: std::mutex mConnectedHalMutex; @@ -67,7 +72,8 @@ private: const std::shared_ptr mDefaultHal = std::make_shared(); std::shared_ptr initHal(); - HalResult processHalResult(HalResult result, const char* functionName); + template + HalResult processHalResult(HalResult result, const char* functionName); }; // ------------------------------------------------------------------------------------------------- diff --git a/include/powermanager/PowerHalWrapper.h b/include/powermanager/PowerHalWrapper.h index c3e7601c29..2c6eacbfaa 100644 --- a/include/powermanager/PowerHalWrapper.h +++ b/include/powermanager/PowerHalWrapper.h @@ -21,6 +21,7 @@ #include #include #include +#include #include namespace android { @@ -34,11 +35,81 @@ enum class HalSupport { OFF = 2, }; -// State of the Power HAL api call result. -enum class HalResult { - SUCCESSFUL = 0, - FAILED = 1, - UNSUPPORTED = 2, +// Result of a call to the Power HAL wrapper, holding data if successful. +template +class HalResult { +public: + static HalResult ok(T value) { return HalResult(value); } + static HalResult failed(std::string msg) { + return HalResult(std::move(msg), /* unsupported= */ false); + } + static HalResult unsupported() { return HalResult("", /* unsupported= */ true); } + + static HalResult fromStatus(binder::Status status, T data) { + if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) { + return HalResult::unsupported(); + } + if (status.isOk()) { + return HalResult::ok(data); + } + return HalResult::failed(std::string(status.toString8().c_str())); + } + static HalResult fromStatus(hardware::power::V1_0::Status status, T data); + + template + static HalResult fromReturn(hardware::Return& ret, T data); + + template + static HalResult fromReturn(hardware::Return& ret, hardware::power::V1_0::Status status, + T data); + + // This will throw std::bad_optional_access if this result is not ok. + const T& value() const { return mValue.value(); } + bool isOk() const { return !mUnsupported && mValue.has_value(); } + bool isFailed() const { return !mUnsupported && !mValue.has_value(); } + bool isUnsupported() const { return mUnsupported; } + const char* errorMessage() const { return mErrorMessage.c_str(); } + +private: + std::optional mValue; + std::string mErrorMessage; + bool mUnsupported; + + explicit HalResult(T value) + : mValue(std::make_optional(value)), mErrorMessage(), mUnsupported(false) {} + explicit HalResult(std::string errorMessage, bool unsupported) + : mValue(), mErrorMessage(std::move(errorMessage)), mUnsupported(unsupported) {} +}; + +// Empty result of a call to the Power HAL wrapper. +template <> +class HalResult { +public: + static HalResult ok() { return HalResult(); } + static HalResult failed(std::string msg) { return HalResult(std::move(msg)); } + static HalResult unsupported() { return HalResult(/* unsupported= */ true); } + + static HalResult fromStatus(status_t status); + static HalResult fromStatus(binder::Status status); + static HalResult fromStatus(hardware::power::V1_0::Status status); + + template + static HalResult fromReturn(hardware::Return& ret); + + bool isOk() const { return !mUnsupported && !mFailed; } + bool isFailed() const { return !mUnsupported && mFailed; } + bool isUnsupported() const { return mUnsupported; } + const char* errorMessage() const { return mErrorMessage.c_str(); } + +private: + std::string mErrorMessage; + bool mFailed; + bool mUnsupported; + + explicit HalResult(bool unsupported = false) + : mErrorMessage(), mFailed(false), mUnsupported(unsupported) {} + explicit HalResult(std::string errorMessage) + : mErrorMessage(std::move(errorMessage)), mFailed(true), mUnsupported(false) {} }; // Wrapper for Power HAL handlers. @@ -46,8 +117,12 @@ class HalWrapper { public: virtual ~HalWrapper() = default; - virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) = 0; - virtual HalResult setMode(hardware::power::Mode mode, bool enabled) = 0; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) = 0; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) = 0; + virtual HalResult> createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos) = 0; + virtual HalResult getHintSessionPreferredRate() = 0; }; // Empty Power HAL wrapper that ignores all api calls. @@ -56,8 +131,12 @@ public: EmptyHalWrapper() = default; ~EmptyHalWrapper() = default; - virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; - virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult> createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos) override; + virtual HalResult getHintSessionPreferredRate() override; }; // Wrapper for the HIDL Power HAL v1.0. @@ -67,16 +146,20 @@ public: : mHandleV1_0(std::move(Hal)) {} virtual ~HidlHalWrapperV1_0() = default; - virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; - virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult> createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos) override; + virtual HalResult getHintSessionPreferredRate() override; protected: - virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, uint32_t data); + virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, uint32_t data); private: sp mHandleV1_0; - HalResult setInteractive(bool enabled); - HalResult setFeature(hardware::power::V1_0::Feature feature, bool enabled); + HalResult setInteractive(bool enabled); + HalResult setFeature(hardware::power::V1_0::Feature feature, bool enabled); }; // Wrapper for the HIDL Power HAL v1.1. @@ -88,8 +171,8 @@ public: virtual ~HidlHalWrapperV1_1() = default; protected: - virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, - uint32_t data) override; + virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, + uint32_t data) override; private: sp mHandleV1_1; @@ -101,8 +184,12 @@ public: explicit AidlHalWrapper(sp handle) : mHandle(std::move(handle)) {} virtual ~AidlHalWrapper() = default; - virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; - virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override; + virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override; + virtual HalResult> createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos) override; + virtual HalResult getHintSessionPreferredRate() override; private: // Control access to the boost and mode supported arrays. diff --git a/services/powermanager/Android.bp b/services/powermanager/Android.bp index 1d3e5b53fa..d828aa97a0 100644 --- a/services/powermanager/Android.bp +++ b/services/powermanager/Android.bp @@ -38,7 +38,7 @@ cc_library_shared { "libutils", "android.hardware.power@1.0", "android.hardware.power@1.1", - "android.hardware.power-V1-cpp", + "android.hardware.power-V2-cpp", ], cflags: [ diff --git a/services/powermanager/PowerHalController.cpp b/services/powermanager/PowerHalController.cpp index 178f545b2e..8c225d5d02 100644 --- a/services/powermanager/PowerHalController.cpp +++ b/services/powermanager/PowerHalController.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -73,9 +74,10 @@ std::shared_ptr PowerHalController::initHal() { // Check if a call to Power HAL function failed; if so, log the failure and // invalidate the current Power HAL handle. -HalResult PowerHalController::processHalResult(HalResult result, const char* fnName) { - if (result == HalResult::FAILED) { - ALOGE("%s() failed: power HAL service not available.", fnName); +template +HalResult PowerHalController::processHalResult(HalResult result, const char* fnName) { + if (result.isFailed()) { + ALOGE("%s failed: %s", fnName, result.errorMessage()); std::lock_guard lock(mConnectedHalMutex); // Drop Power HAL handle. This will force future api calls to reconnect. mConnectedHal = nullptr; @@ -84,18 +86,31 @@ HalResult PowerHalController::processHalResult(HalResult result, const char* fnN return result; } -HalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) { +HalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) { std::shared_ptr handle = initHal(); auto result = handle->setBoost(boost, durationMs); return processHalResult(result, "setBoost"); } -HalResult PowerHalController::setMode(Mode mode, bool enabled) { +HalResult PowerHalController::setMode(Mode mode, bool enabled) { std::shared_ptr handle = initHal(); auto result = handle->setMode(mode, enabled); return processHalResult(result, "setMode"); } +HalResult> PowerHalController::createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, int64_t durationNanos) { + std::shared_ptr handle = initHal(); + auto result = handle->createHintSession(tgid, uid, threadIds, durationNanos); + return processHalResult(result, "createHintSession"); +} + +HalResult PowerHalController::getHintSessionPreferredRate() { + std::shared_ptr handle = initHal(); + auto result = handle->getHintSessionPreferredRate(); + return processHalResult(result, "getHintSessionPreferredRate"); +} + } // namespace power } // namespace android diff --git a/services/powermanager/PowerHalWrapper.cpp b/services/powermanager/PowerHalWrapper.cpp index 2f32827367..d74bd23a8d 100644 --- a/services/powermanager/PowerHalWrapper.cpp +++ b/services/powermanager/PowerHalWrapper.cpp @@ -16,11 +16,17 @@ #define LOG_TAG "HalWrapper" #include +#include #include #include #include +#include + using namespace android::hardware::power; +namespace V1_0 = android::hardware::power::V1_0; +namespace V1_1 = android::hardware::power::V1_1; +namespace Aidl = android::hardware::power; namespace android { @@ -28,49 +34,88 @@ namespace power { // ------------------------------------------------------------------------------------------------- -inline HalResult toHalResult(const binder::Status& result) { +inline HalResult toHalResult(const binder::Status& result) { if (result.isOk()) { - return HalResult::SUCCESSFUL; + return HalResult::ok(); } ALOGE("Power HAL request failed: %s", result.toString8().c_str()); - return HalResult::FAILED; + return HalResult::fromStatus(result); } template -inline HalResult toHalResult(const hardware::Return& result) { - if (result.isOk()) { - return HalResult::SUCCESSFUL; +template +HalResult HalResult::fromReturn(hardware::Return& ret, T data) { + return ret.isOk() ? HalResult::ok(data) : HalResult::failed(ret.description()); +} + +template +template +HalResult HalResult::fromReturn(hardware::Return& ret, V1_0::Status status, T data) { + return ret.isOk() ? HalResult::fromStatus(status, data) + : HalResult::failed(ret.description()); +} + +// ------------------------------------------------------------------------------------------------- + +HalResult HalResult::fromStatus(status_t status) { + if (status == android::OK) { + return HalResult::ok(); + } + return HalResult::failed(statusToString(status)); +} + +HalResult HalResult::fromStatus(binder::Status status) { + if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) { + return HalResult::unsupported(); + } + if (status.isOk()) { + return HalResult::ok(); } - ALOGE("Power HAL request failed: %s", result.description().c_str()); - return HalResult::FAILED; + return HalResult::failed(std::string(status.toString8().c_str())); } +template +HalResult HalResult::fromReturn(hardware::Return& ret) { + return ret.isOk() ? HalResult::ok() : HalResult::failed(ret.description()); +} // ------------------------------------------------------------------------------------------------- -HalResult EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) { +HalResult EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) { ALOGV("Skipped setBoost %s with duration %dms because Power HAL not available", toString(boost).c_str(), durationMs); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } -HalResult EmptyHalWrapper::setMode(Mode mode, bool enabled) { +HalResult EmptyHalWrapper::setMode(Mode mode, bool enabled) { ALOGV("Skipped setMode %s to %s because Power HAL not available", toString(mode).c_str(), enabled ? "true" : "false"); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); +} + +HalResult> EmptyHalWrapper::createHintSession( + int32_t, int32_t, const std::vector& threadIds, int64_t) { + ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available", + threadIds.size()); + return HalResult>::unsupported(); +} + +HalResult EmptyHalWrapper::getHintSessionPreferredRate() { + ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available"); + return HalResult::unsupported(); } // ------------------------------------------------------------------------------------------------- -HalResult HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) { +HalResult HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) { if (boost == Boost::INTERACTION) { return sendPowerHint(V1_0::PowerHint::INTERACTION, durationMs); } else { ALOGV("Skipped setBoost %s because Power HAL AIDL not available", toString(boost).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } } -HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) { +HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) { uint32_t data = enabled ? 1 : 0; switch (mode) { case Mode::LAUNCH: @@ -88,38 +133,54 @@ HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) { default: ALOGV("Skipped setMode %s because Power HAL AIDL not available", toString(mode).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } } -HalResult HidlHalWrapperV1_0::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { - return toHalResult(mHandleV1_0->powerHint(hintId, data)); +HalResult HidlHalWrapperV1_0::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { + auto ret = mHandleV1_0->powerHint(hintId, data); + return HalResult::fromReturn(ret); +} + +HalResult HidlHalWrapperV1_0::setInteractive(bool enabled) { + auto ret = mHandleV1_0->setInteractive(enabled); + return HalResult::fromReturn(ret); } -HalResult HidlHalWrapperV1_0::setInteractive(bool enabled) { - return toHalResult(mHandleV1_0->setInteractive(enabled)); +HalResult HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) { + auto ret = mHandleV1_0->setFeature(feature, enabled); + return HalResult::fromReturn(ret); } -HalResult HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) { - return toHalResult(mHandleV1_0->setFeature(feature, enabled)); +HalResult> HidlHalWrapperV1_0::createHintSession( + int32_t, int32_t, const std::vector& threadIds, int64_t) { + ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available", + threadIds.size()); + return HalResult>::unsupported(); +} + +HalResult HidlHalWrapperV1_0::getHintSessionPreferredRate() { + ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available"); + return HalResult::unsupported(); } // ------------------------------------------------------------------------------------------------- -HalResult HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { - return toHalResult(mHandleV1_1->powerHintAsync(hintId, data)); +HalResult HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) { + auto ret = mHandleV1_1->powerHintAsync(hintId, data); + return HalResult::fromReturn(ret); } // ------------------------------------------------------------------------------------------------- -HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { +HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { std::unique_lock lock(mBoostMutex); size_t idx = static_cast(boost); // Quick return if boost is not supported by HAL if (idx >= mBoostSupportedArray.size() || mBoostSupportedArray[idx] == HalSupport::OFF) { ALOGV("Skipped setBoost %s because Power HAL doesn't support it", toString(boost).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) { @@ -128,14 +189,15 @@ HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { if (!isSupportedRet.isOk()) { ALOGE("Skipped setBoost %s because check support failed with: %s", toString(boost).c_str(), isSupportedRet.toString8().c_str()); - return HalResult::FAILED; + // return HalResult::FAILED; + return HalResult::fromStatus(isSupportedRet); } mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF; if (!isSupported) { ALOGV("Skipped setBoost %s because Power HAL doesn't support it", toString(boost).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } } lock.unlock(); @@ -143,30 +205,28 @@ HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { return toHalResult(mHandle->setBoost(boost, durationMs)); } -HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) { +HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) { std::unique_lock lock(mModeMutex); size_t idx = static_cast(mode); // Quick return if mode is not supported by HAL if (idx >= mModeSupportedArray.size() || mModeSupportedArray[idx] == HalSupport::OFF) { ALOGV("Skipped setMode %s because Power HAL doesn't support it", toString(mode).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) { bool isSupported = false; auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported); if (!isSupportedRet.isOk()) { - ALOGE("Skipped setMode %s because check support failed with: %s", - toString(mode).c_str(), isSupportedRet.toString8().c_str()); - return HalResult::FAILED; + return HalResult::failed(isSupportedRet.toString8().c_str()); } mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF; if (!isSupported) { ALOGV("Skipped setMode %s because Power HAL doesn't support it", toString(mode).c_str()); - return HalResult::UNSUPPORTED; + return HalResult::unsupported(); } } lock.unlock(); @@ -174,6 +234,20 @@ HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) { return toHalResult(mHandle->setMode(mode, enabled)); } +HalResult> AidlHalWrapper::createHintSession( + int32_t tgid, int32_t uid, const std::vector& threadIds, int64_t durationNanos) { + sp appSession; + return HalResult>:: + fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession), + appSession); +} + +HalResult AidlHalWrapper::getHintSessionPreferredRate() { + int64_t rate = -1; + auto result = mHandle->getHintSessionPreferredRate(&rate); + return HalResult::fromStatus(result, rate); +} + // ------------------------------------------------------------------------------------------------- } // namespace power diff --git a/services/powermanager/benchmarks/Android.bp b/services/powermanager/benchmarks/Android.bp index a489253207..3997929053 100644 --- a/services/powermanager/benchmarks/Android.bp +++ b/services/powermanager/benchmarks/Android.bp @@ -38,7 +38,7 @@ cc_benchmark { "libutils", "android.hardware.power@1.0", "android.hardware.power@1.1", - "android.hardware.power-V1-cpp", + "android.hardware.power-V2-cpp", ], static_libs: [ "libtestUtil", diff --git a/services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp b/services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp index 10048286b9..1100cad361 100644 --- a/services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp +++ b/services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp @@ -18,7 +18,9 @@ #include #include +#include #include +#include #include #include #include @@ -26,7 +28,9 @@ using android::hardware::power::Boost; using android::hardware::power::IPower; +using android::hardware::power::IPowerHintSession; using android::hardware::power::Mode; +using android::hardware::power::WorkDuration; using std::chrono::microseconds; using namespace android; @@ -38,6 +42,21 @@ static constexpr int64_t LAST_BOOST = static_cast(Boost::CAMERA_SHOT); static constexpr int64_t FIRST_MODE = static_cast(Mode::DOUBLE_TAP_TO_WAKE); static constexpr int64_t LAST_MODE = static_cast(Mode::CAMERA_STREAMING_HIGH); +class DurationWrapper : public WorkDuration { +public: + DurationWrapper(int64_t dur, int64_t time) { + durationNanos = dur; + timeStampNanos = time; + } +}; + +static const std::vector DURATIONS = { + DurationWrapper(1L, 1L), + DurationWrapper(1000L, 2L), + DurationWrapper(1000000L, 3L), + DurationWrapper(1000000000L, 4L), +}; + // Delay between oneway method calls to avoid overflowing the binder buffers. static constexpr microseconds ONEWAY_API_DELAY = 100us; @@ -68,6 +87,47 @@ static void runBenchmark(benchmark::State& state, microseconds delay, R (IPower: } } +template +static void runSessionBenchmark(benchmark::State& state, R (IPowerHintSession::*fn)(Args0...), + Args1&&... args1) { + sp pwHal = waitForVintfService(); + + if (pwHal == nullptr) { + ALOGI("Power HAL not available, skipping test..."); + return; + } + + // do not use tid from the benchmark process, use 1 for init + std::vector threadIds{1}; + int64_t durationNanos = 16666666L; + sp hal; + + auto status = pwHal->createHintSession(1, 0, threadIds, durationNanos, &hal); + + if (hal == nullptr) { + ALOGI("Power HAL doesn't support session, skipping test..."); + return; + } + + binder::Status ret = (*hal.*fn)(std::forward(args1)...); + if (ret.exceptionCode() == binder::Status::Exception::EX_UNSUPPORTED_OPERATION) { + ALOGI("Power HAL does not support this operation, skipping test..."); + return; + } + + while (state.KeepRunning()) { + ret = (*hal.*fn)(std::forward(args1)...); + state.PauseTiming(); + if (!ret.isOk()) state.SkipWithError(ret.toString8().c_str()); + if (ONEWAY_API_DELAY > 0us) { + testDelaySpin(std::chrono::duration_cast>(ONEWAY_API_DELAY) + .count()); + } + state.ResumeTiming(); + } + hal->close(); +} + static void BM_PowerHalAidlBenchmarks_isBoostSupported(benchmark::State& state) { bool isSupported; Boost boost = static_cast(state.range(0)); @@ -90,7 +150,53 @@ static void BM_PowerHalAidlBenchmarks_setMode(benchmark::State& state) { runBenchmark(state, ONEWAY_API_DELAY, &IPower::setMode, mode, false); } +static void BM_PowerHalAidlBenchmarks_createHintSession(benchmark::State& state) { + std::vector threadIds{static_cast(state.range(0))}; + int64_t durationNanos = 16666666L; + int32_t tgid = 999; + int32_t uid = 1001; + sp appSession; + sp hal = waitForVintfService(); + + if (hal == nullptr) { + ALOGI("Power HAL not available, skipping test..."); + return; + } + + binder::Status ret = hal->createHintSession(tgid, uid, threadIds, durationNanos, &appSession); + if (ret.exceptionCode() == binder::Status::Exception::EX_UNSUPPORTED_OPERATION) { + ALOGI("Power HAL does not support this operation, skipping test..."); + return; + } + + while (state.KeepRunning()) { + ret = hal->createHintSession(tgid, uid, threadIds, durationNanos, &appSession); + state.PauseTiming(); + if (!ret.isOk()) state.SkipWithError(ret.toString8().c_str()); + appSession->close(); + state.ResumeTiming(); + } +} + +static void BM_PowerHalAidlBenchmarks_getHintSessionPreferredRate(benchmark::State& state) { + int64_t rate; + runBenchmark(state, 0us, &IPower::getHintSessionPreferredRate, &rate); +} + +static void BM_PowerHalAidlBenchmarks_updateTargetWorkDuration(benchmark::State& state) { + int64_t duration = 1000; + runSessionBenchmark(state, &IPowerHintSession::updateTargetWorkDuration, duration); +} + +static void BM_PowerHalAidlBenchmarks_reportActualWorkDuration(benchmark::State& state) { + runSessionBenchmark(state, &IPowerHintSession::reportActualWorkDuration, DURATIONS); +} + BENCHMARK(BM_PowerHalAidlBenchmarks_isBoostSupported)->DenseRange(FIRST_BOOST, LAST_BOOST, 1); BENCHMARK(BM_PowerHalAidlBenchmarks_isModeSupported)->DenseRange(FIRST_MODE, LAST_MODE, 1); BENCHMARK(BM_PowerHalAidlBenchmarks_setBoost)->DenseRange(FIRST_BOOST, LAST_BOOST, 1); BENCHMARK(BM_PowerHalAidlBenchmarks_setMode)->DenseRange(FIRST_MODE, LAST_MODE, 1); +BENCHMARK(BM_PowerHalAidlBenchmarks_createHintSession)->Arg(1); +BENCHMARK(BM_PowerHalAidlBenchmarks_getHintSessionPreferredRate); +BENCHMARK(BM_PowerHalAidlBenchmarks_updateTargetWorkDuration); +BENCHMARK(BM_PowerHalAidlBenchmarks_reportActualWorkDuration); diff --git a/services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp b/services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp index 598080b5bc..f8abc7aba6 100644 --- a/services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp +++ b/services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp @@ -40,29 +40,29 @@ static constexpr int64_t LAST_MODE = static_cast(Mode::CAMERA_STREAMING // Delay between oneway method calls to avoid overflowing the binder buffers. static constexpr std::chrono::microseconds ONEWAY_API_DELAY = 100us; -template -static void runBenchmark(benchmark::State& state, HalResult (PowerHalController::*fn)(Args0...), +template +static void runBenchmark(benchmark::State& state, HalResult (PowerHalController::*fn)(Args0...), Args1&&... args1) { while (state.KeepRunning()) { PowerHalController controller; - HalResult ret = (controller.*fn)(std::forward(args1)...); + HalResult ret = (controller.*fn)(std::forward(args1)...); state.PauseTiming(); - if (ret == HalResult::FAILED) state.SkipWithError("Power HAL request failed"); + if (ret.isFailed()) state.SkipWithError("Power HAL request failed"); state.ResumeTiming(); } } -template +template static void runCachedBenchmark(benchmark::State& state, - HalResult (PowerHalController::*fn)(Args0...), Args1&&... args1) { + HalResult (PowerHalController::*fn)(Args0...), Args1&&... args1) { PowerHalController controller; // First call out of test, to cache HAL service and isSupported result. (controller.*fn)(std::forward(args1)...); while (state.KeepRunning()) { - HalResult ret = (controller.*fn)(std::forward(args1)...); + HalResult ret = (controller.*fn)(std::forward(args1)...); state.PauseTiming(); - if (ret == HalResult::FAILED) { + if (ret.isFailed()) { state.SkipWithError("Power HAL request failed"); } testDelaySpin( diff --git a/services/powermanager/tests/Android.bp b/services/powermanager/tests/Android.bp index 69e4041aaa..659b2d273a 100644 --- a/services/powermanager/tests/Android.bp +++ b/services/powermanager/tests/Android.bp @@ -46,7 +46,7 @@ cc_test { "libutils", "android.hardware.power@1.0", "android.hardware.power@1.1", - "android.hardware.power-V1-cpp", + "android.hardware.power-V2-cpp", ], static_libs: [ "libgmock", diff --git a/services/powermanager/tests/PowerHalControllerTest.cpp b/services/powermanager/tests/PowerHalControllerTest.cpp index 141b2440b8..6cc7a6f3da 100644 --- a/services/powermanager/tests/PowerHalControllerTest.cpp +++ b/services/powermanager/tests/PowerHalControllerTest.cpp @@ -134,9 +134,9 @@ TEST_F(PowerHalControllerTest, TestUnableToConnectToPowerHalIgnoresAllApiCalls) // Still works with EmptyPowerHalWrapper as fallback ignoring every api call // and logging. auto result = halController.setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); result = halController.setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); // PowerHalConnector was called every time to attempt to reconnect with // underlying service. @@ -159,9 +159,9 @@ TEST_F(PowerHalControllerTest, TestAllApiCallsDelegatedToConnectedPowerHal) { } auto result = mHalController->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); // PowerHalConnector was called only once and never reset. powerHalConnectCount = mHalConnector->getConnectCount(); @@ -182,13 +182,13 @@ TEST_F(PowerHalControllerTest, TestPowerHalRecoversFromFailureByRecreatingPowerH EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(4)); auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); result = mHalController->setMode(Mode::VR, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mHalController->setMode(Mode::LOW_POWER, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); // PowerHalConnector was called only twice: on first api call and after failed // call. @@ -204,9 +204,9 @@ TEST_F(PowerHalControllerTest, TestPowerHalDoesNotTryToRecoverFromFailureOnUnsup EXPECT_EQ(powerHalConnectCount, 0); auto result = mHalController->setBoost(Boost::CAMERA_LAUNCH, 1000); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); result = mHalController->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); // PowerHalConnector was called only once and never reset. powerHalConnectCount = mHalConnector->getConnectCount(); @@ -225,7 +225,7 @@ TEST_F(PowerHalControllerTest, TestMultiThreadConnectsOnlyOnce) { for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); @@ -253,19 +253,19 @@ TEST_F(PowerHalControllerTest, TestMultiThreadWithFailureReconnectIsThreadSafe) for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mHalController->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); threads.push_back(std::thread([&]() { auto result = mHalController->setMode(Mode::VR, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); diff --git a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp index a7656598f0..d890f5c332 100644 --- a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp +++ b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "PowerHalWrapperAidlTest" #include +#include #include #include #include @@ -24,11 +25,13 @@ #include #include +#include #include using android::binder::Status; using android::hardware::power::Boost; using android::hardware::power::IPower; +using android::hardware::power::IPowerHintSession; using android::hardware::power::Mode; using namespace android; @@ -44,6 +47,11 @@ public: MOCK_METHOD(Status, setBoost, (Boost boost, int32_t durationMs), (override)); MOCK_METHOD(Status, isModeSupported, (Mode mode, bool* ret), (override)); MOCK_METHOD(Status, setMode, (Mode mode, bool enabled), (override)); + MOCK_METHOD(Status, createHintSession, + (int32_t tgid, int32_t uid, const std::vector& threadIds, + int64_t durationNanos, sp* session), + (override)); + MOCK_METHOD(Status, getHintSessionPreferredRate, (int64_t * rate), (override)); MOCK_METHOD(int32_t, getInterfaceVersion, (), (override)); MOCK_METHOD(std::string, getInterfaceHash, (), (override)); MOCK_METHOD(IBinder*, onAsBinder, (), (override)); @@ -65,7 +73,7 @@ protected: void PowerHalWrapperAidlTest::SetUp() { mMockHal = new StrictMock(); mWrapper = std::make_unique(mMockHal); - ASSERT_NE(mWrapper, nullptr); + ASSERT_NE(nullptr, mWrapper); } // ------------------------------------------------------------------------------------------------- @@ -81,7 +89,7 @@ TEST_F(PowerHalWrapperAidlTest, TestSetBoostSuccessful) { } auto result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 100); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostFailed) { @@ -99,9 +107,9 @@ TEST_F(PowerHalWrapperAidlTest, TestSetBoostFailed) { } auto result = mWrapper->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 1000); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostUnsupported) { @@ -110,9 +118,9 @@ TEST_F(PowerHalWrapperAidlTest, TestSetBoostUnsupported) { .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); result = mWrapper->setBoost(Boost::CAMERA_SHOT, 10); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } TEST_F(PowerHalWrapperAidlTest, TestSetBoostMultiThreadCheckSupportedOnlyOnce) { @@ -128,7 +136,7 @@ TEST_F(PowerHalWrapperAidlTest, TestSetBoostMultiThreadCheckSupportedOnlyOnce) { for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mWrapper->setBoost(Boost::INTERACTION, 100); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); @@ -145,7 +153,7 @@ TEST_F(PowerHalWrapperAidlTest, TestSetModeSuccessful) { } auto result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperAidlTest, TestSetModeFailed) { @@ -163,9 +171,9 @@ TEST_F(PowerHalWrapperAidlTest, TestSetModeFailed) { } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperAidlTest, TestSetModeUnsupported) { @@ -174,9 +182,9 @@ TEST_F(PowerHalWrapperAidlTest, TestSetModeUnsupported) { .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status()))); auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } TEST_F(PowerHalWrapperAidlTest, TestSetModeMultiThreadCheckSupportedOnlyOnce) { @@ -192,8 +200,41 @@ TEST_F(PowerHalWrapperAidlTest, TestSetModeMultiThreadCheckSupportedOnlyOnce) { for (int i = 0; i < 10; i++) { threads.push_back(std::thread([&]() { auto result = mWrapper->setMode(Mode::LAUNCH, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); })); } std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); }); } + +TEST_F(PowerHalWrapperAidlTest, TestCreateHintSessionSuccessful) { + std::vector threadIds{gettid()}; + int32_t tgid = 999; + int32_t uid = 1001; + int64_t durationNanos = 16666666L; + EXPECT_CALL(*mMockHal.get(), + createHintSession(Eq(tgid), Eq(uid), Eq(threadIds), Eq(durationNanos), _)) + .Times(Exactly(1)); + auto result = mWrapper->createHintSession(tgid, uid, threadIds, durationNanos); + ASSERT_TRUE(result.isOk()); +} + +TEST_F(PowerHalWrapperAidlTest, TestCreateHintSessionFailed) { + int32_t tgid = 999; + int32_t uid = 1001; + std::vector threadIds{}; + int64_t durationNanos = 16666666L; + EXPECT_CALL(*mMockHal.get(), + createHintSession(Eq(tgid), Eq(uid), Eq(threadIds), Eq(durationNanos), _)) + .Times(Exactly(1)) + .WillRepeatedly(Return(Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT))); + auto result = mWrapper->createHintSession(tgid, uid, threadIds, durationNanos); + ASSERT_TRUE(result.isFailed()); +} + +TEST_F(PowerHalWrapperAidlTest, TestGetHintSessionPreferredRate) { + EXPECT_CALL(*mMockHal.get(), getHintSessionPreferredRate(_)).Times(Exactly(1)); + auto result = mWrapper->getHintSessionPreferredRate(); + ASSERT_TRUE(result.isOk()); + int64_t rate = result.value(); + ASSERT_GE(0, rate); +} diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp index 6693d0b070..b54762cf6d 100644 --- a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp +++ b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp @@ -72,7 +72,7 @@ TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostSuccessful) { EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))).Times(Exactly(1)); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostFailed) { @@ -83,12 +83,12 @@ TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostFailed) { }); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostUnsupported) { auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeSuccessful) { @@ -106,17 +106,17 @@ TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeSuccessful) { } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::VR, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::INTERACTIVE, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeFailed) { @@ -127,10 +127,10 @@ TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeFailed) { }); auto result = mWrapper->setMode(Mode::LAUNCH, 1); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeIgnored) { auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp index 55bbd6df79..d30e8d2c49 100644 --- a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp +++ b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp @@ -89,7 +89,7 @@ TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostSuccessful) { .Times(Exactly(1)); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostFailed) { @@ -100,12 +100,12 @@ TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostFailed) { }); auto result = mWrapper->setBoost(Boost::INTERACTION, 1000); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostUnsupported) { auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetMode) { @@ -127,17 +127,17 @@ TEST_F(PowerHalWrapperHidlV1_1Test, TestSetMode) { } auto result = mWrapper->setMode(Mode::LAUNCH, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::LOW_POWER, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::VR, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::INTERACTIVE, true); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false); - ASSERT_EQ(HalResult::SUCCESSFUL, result); + ASSERT_TRUE(result.isOk()); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeFailed) { @@ -148,10 +148,10 @@ TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeFailed) { }); auto result = mWrapper->setMode(Mode::LAUNCH, 1); - ASSERT_EQ(HalResult::FAILED, result); + ASSERT_TRUE(result.isFailed()); } TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeIgnored) { auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true); - ASSERT_EQ(HalResult::UNSUPPORTED, result); + ASSERT_TRUE(result.isUnsupported()); } -- cgit v1.2.3-59-g8ed1b