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
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
index 0473bb8..436c809 100644
--- a/PREUPLOAD.cfg
+++ b/PREUPLOAD.cfg
@@ -6,6 +6,7 @@
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 @@
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 44b8915..dd34c0a 100644
--- a/include/powermanager/PowerHalController.h
+++ b/include/powermanager/PowerHalController.h
@@ -21,58 +21,59 @@
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
-
#include <powermanager/PowerHalWrapper.h>
-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<PowerHalWrapper> connect();
+ virtual std::unique_ptr<HalWrapper> 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<PowerHalConnector>()) {}
- explicit PowerHalController(std::unique_ptr<PowerHalConnector> connector)
- : mHalConnector(std::move(connector)) {}
+ PowerHalController() : PowerHalController(std::make_unique<HalConnector>()) {}
+ explicit PowerHalController(std::unique_ptr<HalConnector> 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<PowerHalConnector> mHalConnector;
+ std::unique_ptr<HalConnector> mHalConnector;
- // Shared pointers to keep global pointer and allow local copies to be used in different threads
- std::shared_ptr<PowerHalWrapper> mConnectedHal GUARDED_BY(mConnectedHalMutex) = nullptr;
- const std::shared_ptr<PowerHalWrapper> mDefaultHal = std::make_shared<EmptyPowerHalWrapper>();
+ // Shared pointers to keep global pointer and allow local copies to be used in
+ // different threads
+ std::shared_ptr<HalWrapper> mConnectedHal GUARDED_BY(mConnectedHalMutex) = nullptr;
+ const std::shared_ptr<HalWrapper> mDefaultHal = std::make_shared<EmptyHalWrapper>();
- std::shared_ptr<PowerHalWrapper> initHal();
- PowerHalResult processHalResult(PowerHalResult result, const char* functionName);
+ std::shared_ptr<HalWrapper> 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 487b95b..ed6f6f3 100644
--- a/include/powermanager/PowerHalLoader.h
+++ b/include/powermanager/PowerHalLoader.h
@@ -18,35 +18,36 @@
#define ANDROID_POWERHALLOADER_H
#include <android-base/thread_annotations.h>
-
#include <android/hardware/power/1.1/IPower.h>
#include <android/hardware/power/IPower.h>
-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<IPowerAidl> loadAidl();
- static sp<IPowerV1_0> loadHidlV1_0();
- static sp<IPowerV1_1> loadHidlV1_1();
+ static sp<hardware::power::IPower> loadAidl();
+ static sp<hardware::power::V1_0::IPower> loadHidlV1_0();
+ static sp<hardware::power::V1_1::IPower> loadHidlV1_1();
private:
static std::mutex gHalMutex;
- static sp<IPowerAidl> gHalAidl GUARDED_BY(gHalMutex);
- static sp<IPowerV1_0> gHalHidlV1_0 GUARDED_BY(gHalMutex);
- static sp<IPowerV1_1> gHalHidlV1_1 GUARDED_BY(gHalMutex);
+ static sp<hardware::power::IPower> gHalAidl GUARDED_BY(gHalMutex);
+ static sp<hardware::power::V1_0::IPower> gHalHidlV1_0 GUARDED_BY(gHalMutex);
+ static sp<hardware::power::V1_1::IPower> gHalHidlV1_1 GUARDED_BY(gHalMutex);
- static sp<IPowerV1_0> loadHidlV1_0Locked() EXCLUSIVE_LOCKS_REQUIRED(gHalMutex);
+ static sp<hardware::power::V1_0::IPower> 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 6d8a6eb..c3e7601 100644
--- a/include/powermanager/PowerHalWrapper.h
+++ b/include/powermanager/PowerHalWrapper.h
@@ -18,111 +18,111 @@
#define ANDROID_POWERHALWRAPPER_H
#include <android-base/thread_annotations.h>
-
#include <android/hardware/power/1.1/IPower.h>
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
-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<IPowerV1_0> powerHal) : handleV1_0(std::move(powerHal)) {}
- virtual ~HidlPowerHalWrapperV1_0() = default;
+ explicit HidlHalWrapperV1_0(sp<hardware::power::V1_0::IPower> 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<IPowerV1_0> handleV1_0;
- PowerHalResult setInteractive(bool enabled);
- PowerHalResult setFeature(Feature feature, bool enabled);
+ sp<hardware::power::V1_0::IPower> 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<IPowerV1_0> powerHalV1_0, sp<IPowerV1_1> powerHalV1_1)
- : HidlPowerHalWrapperV1_0(powerHalV1_0), handleV1_1(std::move(powerHalV1_1)) {}
- ~HidlPowerHalWrapperV1_1() = default;
+ HidlHalWrapperV1_1(sp<hardware::power::V1_0::IPower> handleV1_0,
+ sp<hardware::power::V1_1::IPower> 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<IPowerV1_1> handleV1_1;
+ sp<hardware::power::V1_1::IPower> mHandleV1_1;
};
// Wrapper for the AIDL Power HAL.
-class AidlPowerHalWrapper : public PowerHalWrapper {
+class AidlHalWrapper : public HalWrapper {
public:
- explicit AidlPowerHalWrapper(sp<IPowerAidl> powerHal) : handle(std::move(powerHal)) {}
- ~AidlPowerHalWrapper() = default;
+ explicit AidlHalWrapper(sp<hardware::power::IPower> 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<IPowerAidl> handle;
+ sp<hardware::power::IPower> mHandle;
// Android framework only sends boost upto DISPLAY_UPDATE_IMMINENT.
// Need to increase the array size if more boost supported.
- std::array<std::atomic<PowerHalSupport>, static_cast<int32_t>(Boost::DISPLAY_UPDATE_IMMINENT)+1>
- boostSupportedArray GUARDED_BY(mBoostMutex) = {PowerHalSupport::UNKNOWN};
+ std::array<std::atomic<HalSupport>,
+ static_cast<int32_t>(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<std::atomic<PowerHalSupport>, static_cast<int32_t>(Mode::DISPLAY_INACTIVE)+1>
- modeSupportedArray GUARDED_BY(mModeMutex) = {PowerHalSupport::UNKNOWN};
+ std::array<std::atomic<HalSupport>,
+ static_cast<int32_t>(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 d26d582..178f545 100644
--- a/services/powermanager/PowerHalController.cpp
+++ b/services/powermanager/PowerHalController.cpp
@@ -15,40 +15,39 @@
*/
#define LOG_TAG "PowerHalController"
-#include <utils/Log.h>
-
#include <android/hardware/power/1.1/IPower.h>
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
-
#include <powermanager/PowerHalController.h>
#include <powermanager/PowerHalLoader.h>
+#include <utils/Log.h>
-using android::hardware::power::Boost;
-using android::hardware::power::Mode;
+using namespace android::hardware::power;
namespace android {
+namespace power {
+
// -------------------------------------------------------------------------------------------------
-std::unique_ptr<PowerHalWrapper> PowerHalConnector::connect() {
- sp<IPowerAidl> halAidl = PowerHalLoader::loadAidl();
+std::unique_ptr<HalWrapper> HalConnector::connect() {
+ sp<IPower> halAidl = PowerHalLoader::loadAidl();
if (halAidl) {
- return std::make_unique<AidlPowerHalWrapper>(halAidl);
+ return std::make_unique<AidlHalWrapper>(halAidl);
}
- sp<IPowerV1_0> halHidlV1_0 = PowerHalLoader::loadHidlV1_0();
- sp<IPowerV1_1> halHidlV1_1 = PowerHalLoader::loadHidlV1_1();
+ sp<V1_0::IPower> halHidlV1_0 = PowerHalLoader::loadHidlV1_0();
+ sp<V1_1::IPower> halHidlV1_1 = PowerHalLoader::loadHidlV1_1();
if (halHidlV1_1) {
- return std::make_unique<HidlPowerHalWrapperV1_1>(halHidlV1_0, halHidlV1_1);
+ return std::make_unique<HidlHalWrapperV1_1>(halHidlV1_0, halHidlV1_1);
}
if (halHidlV1_0) {
- return std::make_unique<HidlPowerHalWrapperV1_0>(halHidlV1_0);
+ return std::make_unique<HidlHalWrapperV1_0>(halHidlV1_0);
}
return nullptr;
}
-void PowerHalConnector::reset() {
+void HalConnector::reset() {
PowerHalLoader::unloadAll();
}
@@ -58,8 +57,9 @@
initHal();
}
-// Check validity of current handle to the power HAL service, and create a new one if necessary.
-std::shared_ptr<PowerHalWrapper> PowerHalController::initHal() {
+// Check validity of current handle to the power HAL service, and create a new
+// one if necessary.
+std::shared_ptr<HalWrapper> PowerHalController::initHal() {
std::lock_guard<std::mutex> lock(mConnectedHalMutex);
if (mConnectedHal == nullptr) {
mConnectedHal = mHalConnector->connect();
@@ -71,10 +71,10 @@
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<std::mutex> lock(mConnectedHalMutex);
// Drop Power HAL handle. This will force future api calls to reconnect.
@@ -84,16 +84,18 @@
return result;
}
-PowerHalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) {
- std::shared_ptr<PowerHalWrapper> handle = initHal();
+HalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) {
+ std::shared_ptr<HalWrapper> handle = initHal();
auto result = handle->setBoost(boost, durationMs);
return processHalResult(result, "setBoost");
}
-PowerHalResult PowerHalController::setMode(Mode mode, bool enabled) {
- std::shared_ptr<PowerHalWrapper> handle = initHal();
+HalResult PowerHalController::setMode(Mode mode, bool enabled) {
+ std::shared_ptr<HalWrapper> 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 3ae5384..1f1b43a 100644
--- a/services/powermanager/PowerHalLoader.cpp
+++ b/services/powermanager/PowerHalLoader.cpp
@@ -21,15 +21,14 @@
#include <binder/IServiceManager.h>
#include <hardware/power.h>
#include <hardware_legacy/power.h>
-
#include <powermanager/PowerHalLoader.h>
-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 <typename T, typename F>
@@ -53,9 +52,9 @@
// -------------------------------------------------------------------------------------------------
std::mutex PowerHalLoader::gHalMutex;
-sp<IPowerAidl> PowerHalLoader::gHalAidl = nullptr;
-sp<IPowerV1_0> PowerHalLoader::gHalHidlV1_0 = nullptr;
-sp<IPowerV1_1> PowerHalLoader::gHalHidlV1_1 = nullptr;
+sp<IPower> PowerHalLoader::gHalAidl = nullptr;
+sp<V1_0::IPower> PowerHalLoader::gHalHidlV1_0 = nullptr;
+sp<V1_1::IPower> PowerHalLoader::gHalHidlV1_1 = nullptr;
void PowerHalLoader::unloadAll() {
std::lock_guard<std::mutex> lock(gHalMutex);
@@ -64,31 +63,33 @@
gHalHidlV1_1 = nullptr;
}
-sp<IPowerAidl> PowerHalLoader::loadAidl() {
+sp<IPower> PowerHalLoader::loadAidl() {
std::lock_guard<std::mutex> lock(gHalMutex);
static bool gHalExists = true;
- static auto loadFn = []() { return waitForVintfService<IPowerAidl>(); };
- return loadHal<IPowerAidl>(gHalExists, gHalAidl, loadFn, "AIDL");
+ static auto loadFn = []() { return waitForVintfService<IPower>(); };
+ return loadHal<IPower>(gHalExists, gHalAidl, loadFn, "AIDL");
}
-sp<IPowerV1_0> PowerHalLoader::loadHidlV1_0() {
+sp<V1_0::IPower> PowerHalLoader::loadHidlV1_0() {
std::lock_guard<std::mutex> lock(gHalMutex);
return loadHidlV1_0Locked();
}
-sp<IPowerV1_1> PowerHalLoader::loadHidlV1_1() {
+sp<V1_1::IPower> PowerHalLoader::loadHidlV1_1() {
std::lock_guard<std::mutex> lock(gHalMutex);
static bool gHalExists = true;
- static auto loadFn = []() { return IPowerV1_1::castFrom(loadHidlV1_0Locked()); };
- return loadHal<IPowerV1_1>(gHalExists, gHalHidlV1_1, loadFn, "HIDL v1.1");
+ static auto loadFn = []() { return V1_1::IPower::castFrom(loadHidlV1_0Locked()); };
+ return loadHal<V1_1::IPower>(gHalExists, gHalHidlV1_1, loadFn, "HIDL v1.1");
}
-sp<IPowerV1_0> PowerHalLoader::loadHidlV1_0Locked() {
+sp<V1_0::IPower> PowerHalLoader::loadHidlV1_0Locked() {
static bool gHalExists = true;
- static auto loadFn = []() { return IPowerV1_0::getService(); };
- return loadHal<IPowerV1_0>(gHalExists, gHalHidlV1_0, loadFn, "HIDL v1.0");
+ static auto loadFn = []() { return V1_0::IPower::getService(); };
+ return loadHal<V1_0::IPower>(gHalExists, gHalHidlV1_0, loadFn, "HIDL v1.0");
}
// -------------------------------------------------------------------------------------------------
+} // namespace power
+
} // namespace android
diff --git a/services/powermanager/PowerHalWrapper.cpp b/services/powermanager/PowerHalWrapper.cpp
index d959a2c..5f4bfed 100644
--- a/services/powermanager/PowerHalWrapper.cpp
+++ b/services/powermanager/PowerHalWrapper.cpp
@@ -14,159 +14,162 @@
* limitations under the License.
*/
-#define LOG_TAG "PowerHalWrapper"
-#include <utils/Log.h>
-
+#define LOG_TAG "HalWrapper"
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/Mode.h>
-
#include <powermanager/PowerHalWrapper.h>
+#include <utils/Log.h>
-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 {
+
// -------------------------------------------------------------------------------------------------
-PowerHalResult EmptyPowerHalWrapper::setBoost(Boost boost, int32_t durationMs) {
+inline HalResult toHalResult(const binder::Status& result) {
+ return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED;
+}
+
+template <typename T>
+inline HalResult toHalResult(const hardware::Return<T>& result) {
+ return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+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<std::mutex> lock(mBoostMutex);
// Quick return if boost is not supported by HAL
if (boost > Boost::DISPLAY_UPDATE_IMMINENT ||
- boostSupportedArray[static_cast<int32_t>(boost)] == PowerHalSupport::OFF) {
- ALOGV("Skipped setBoost %s because Power HAL doesn't support it",
- toString(boost).c_str());
- return PowerHalResult::UNSUPPORTED;
+ mBoostSupportedArray[static_cast<int32_t>(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<int32_t>(boost)] == PowerHalSupport::UNKNOWN) {
+ if (mBoostSupportedArray[static_cast<int32_t>(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<int32_t>(boost)] =
- isSupported ? PowerHalSupport::ON : PowerHalSupport::OFF;
+ mBoostSupportedArray[static_cast<int32_t>(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<std::mutex> lock(mModeMutex);
// Quick return if mode is not supported by HAL
if (mode > Mode::DISPLAY_INACTIVE ||
- modeSupportedArray[static_cast<int32_t>(mode)] == PowerHalSupport::OFF) {
- ALOGV("Skipped setMode %s because Power HAL doesn't support it",
- toString(mode).c_str());
- return PowerHalResult::UNSUPPORTED;
+ mModeSupportedArray[static_cast<int32_t>(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<int32_t>(mode)] == PowerHalSupport::UNKNOWN) {
+ if (mModeSupportedArray[static_cast<int32_t>(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<int32_t>(mode)] =
- isSupported ? PowerHalSupport::ON : PowerHalSupport::OFF;
+ mModeSupportedArray[static_cast<int32_t>(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 9a67901..caaec55 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 70837cf..49abc11 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 @@
"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 ac1e19a..141b244 100644
--- a/services/powermanager/tests/PowerHalControllerTest.cpp
+++ b/services/powermanager/tests/PowerHalControllerTest.cpp
@@ -19,15 +19,12 @@
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
-#include <powermanager/PowerHalWrapper.h>
#include <powermanager/PowerHalController.h>
+#include <utils/Log.h>
#include <thread>
-#include <utils/Log.h>
using android::hardware::power::Boost;
using android::hardware::power::Mode;
@@ -36,6 +33,7 @@
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 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
-class TestPowerHalConnector : public PowerHalConnector {
+class TestPowerHalConnector : public HalConnector {
public:
TestPowerHalConnector(sp<IPower> powerHal) : mHal(std::move(powerHal)) {}
virtual ~TestPowerHalConnector() = default;
- virtual std::unique_ptr<PowerHalWrapper> connect() override {
+ virtual std::unique_ptr<HalWrapper> connect() override {
mCountMutex.lock();
++mConnectedCount;
mCountMutex.unlock();
- return std::make_unique<HidlPowerHalWrapperV1_0>(mHal);
+ return std::make_unique<HidlHalWrapperV1_0>(mHal);
}
void reset() override {
@@ -70,13 +66,9 @@
mCountMutex.unlock();
}
- int getConnectCount() {
- return mConnectedCount;
- }
+ int getConnectCount() { return mConnectedCount; }
- int getResetCount() {
- return mResetCount;
- }
+ int getResetCount() { return mResetCount; }
private:
sp<IPower> mHal = nullptr;
@@ -89,8 +81,8 @@
public:
AlwaysFailingTestPowerHalConnector() : TestPowerHalConnector(nullptr) {}
- std::unique_ptr<PowerHalWrapper> connect() override {
- // Call parent to update counter, but ignore connected PowerHalWrapper.
+ std::unique_ptr<HalWrapper> connect() override {
+ // Call parent to update counter, but ignore connected HalWrapper.
TestPowerHalConnector::connect();
return nullptr;
}
@@ -103,7 +95,7 @@
void SetUp() override {
mMockHal = new StrictMock<MockIPowerV1_0>();
std::unique_ptr<TestPowerHalConnector> halConnector =
- std::make_unique<TestPowerHalConnector>(mMockHal);
+ std::make_unique<TestPowerHalConnector>(mMockHal);
mHalConnector = halConnector.get();
mHalController = std::make_unique<PowerHalController>(std::move(halConnector));
}
@@ -132,20 +124,22 @@
TEST_F(PowerHalControllerTest, TestUnableToConnectToPowerHalIgnoresAllApiCalls) {
std::unique_ptr<AlwaysFailingTestPowerHalConnector> halConnector =
- std::make_unique<AlwaysFailingTestPowerHalConnector>();
+ std::make_unique<AlwaysFailingTestPowerHalConnector>();
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 @@
{
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 @@
EXPECT_EQ(powerHalConnectCount, 0);
ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _))
- .WillByDefault([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .WillByDefault([](PowerHint, int32_t) {
+ return hardware::Return<void>(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 @@
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 @@
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<std::thread> 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 @@
EXPECT_EQ(powerHalConnectCount, 0);
ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _))
- .WillByDefault([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .WillByDefault([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
- EXPECT_CALL(*mMockHal.get(), powerHint(_, _))
- .Times(Exactly(40));
+ EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(40));
std::vector<std::thread> 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 2310a72..058e1b5 100644
--- a/services/powermanager/tests/PowerHalLoaderTest.cpp
+++ b/services/powermanager/tests/PowerHalLoaderTest.cpp
@@ -19,17 +19,18 @@
#include <android-base/logging.h>
#include <android/hardware/power/1.1/IPower.h>
#include <android/hardware/power/IPower.h>
+#include <gtest/gtest.h>
+#include <powermanager/PowerHalLoader.h>
#include <future>
-#include <gtest/gtest.h>
-
-#include <powermanager/PowerHalLoader.h>
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 @@
// -------------------------------------------------------------------------------------------------
template <typename T>
-class PowerHalLoaderTest : public testing::Test {
+class PowerHalLoaderTest : public Test {
public:
- sp<T> load() {
- return ::loadHal<T>();
- }
- void unload() {
- PowerHalLoader::unloadAll();
- }
+ sp<T> load() { return ::loadHal<T>(); }
+ void unload() { PowerHalLoader::unloadAll(); }
};
// -------------------------------------------------------------------------------------------------
@@ -95,7 +92,7 @@
std::vector<std::future<sp<TypeParam>>> futures;
for (int i = 0; i < 10; i++) {
futures.push_back(
- std::async(std::launch::async, &PowerHalLoaderTest<TypeParam>::load, this));
+ std::async(std::launch::async, &PowerHalLoaderTest<TypeParam>::load, this));
}
futures[0].wait();
diff --git a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
index 73b7466..a765659 100644
--- a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
+++ b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
@@ -19,14 +19,12 @@
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
+#include <utils/Log.h>
#include <thread>
-#include <utils/Log.h>
using android::binder::Status;
using android::hardware::power::Boost;
@@ -34,6 +32,7 @@
using android::hardware::power::Mode;
using namespace android;
+using namespace android::power;
using namespace std::chrono_literals;
using namespace testing;
@@ -57,7 +56,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPower>> mMockHal = nullptr;
};
@@ -65,7 +64,7 @@
void PowerHalWrapperAidlTest::SetUp() {
mMockHal = new StrictMock<MockIPower>();
- mWrapper = std::make_unique<AidlPowerHalWrapper>(mMockHal);
+ mWrapper = std::make_unique<AidlHalWrapper>(mMockHal);
ASSERT_NE(mWrapper, nullptr);
}
@@ -75,62 +74,61 @@
{
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<std::thread> 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 @@
{
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<std::thread> 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 5379054..6693d0b 100644
--- a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp
+++ b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp
@@ -20,12 +20,9 @@
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
-
#include <utils/Log.h>
using android::hardware::power::Boost;
@@ -35,6 +32,7 @@
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 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
// -------------------------------------------------------------------------------------------------
@@ -58,7 +54,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPowerV1_0>> mMockHal = nullptr;
};
@@ -66,80 +62,75 @@
void PowerHalWrapperHidlV1_0Test::SetUp() {
mMockHal = new StrictMock<MockIPowerV1_0>();
- mWrapper = std::make_unique<HidlPowerHalWrapperV1_0>(mMockHal);
+ mWrapper = std::make_unique<HidlHalWrapperV1_0>(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<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(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<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(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 931c0d5..55bbd6d 100644
--- a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp
+++ b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp
@@ -21,12 +21,9 @@
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
-
#include <utils/Log.h>
using android::hardware::power::Boost;
@@ -37,6 +34,7 @@
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 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
class MockIPowerV1_1 : public IPowerV1_1 {
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
- MOCK_METHOD(
- hardware::Return<void>, powerHintAsync, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, getSubsystemLowPowerStats,
- (getSubsystemLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, powerHintAsync, (PowerHint hint, int32_t data), (override));
+ MOCK_METHOD(hardware::Return<void>, getSubsystemLowPowerStats,
+ (getSubsystemLowPowerStats_cb _hidl_cb), (override));
};
// -------------------------------------------------------------------------------------------------
@@ -76,7 +68,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPowerV1_0>> mMockHalV1_0 = nullptr;
sp<StrictMock<MockIPowerV1_1>> mMockHalV1_1 = nullptr;
};
@@ -86,7 +78,7 @@
void PowerHalWrapperHidlV1_1Test::SetUp() {
mMockHalV1_0 = new StrictMock<MockIPowerV1_0>();
mMockHalV1_1 = new StrictMock<MockIPowerV1_1>();
- mWrapper = std::make_unique<HidlPowerHalWrapperV1_1>(mMockHalV1_0, mMockHalV1_1);
+ mWrapper = std::make_unique<HidlHalWrapperV1_1>(mMockHalV1_0, mMockHalV1_1);
ASSERT_NE(mWrapper, nullptr);
}
@@ -94,72 +86,72 @@
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<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(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<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(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);
}