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/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