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

Commit b59a9b54 authored by Lais Andrade's avatar Lais Andrade
Browse files

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
parent 28f3700d

PREUPLOAD.cfg

+2 −0
Original line number Diff line number Diff line
@@ -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/

include/powermanager/PowerHalController.h

+25 −24
Original line number Diff line number Diff line
@@ -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)

    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

include/powermanager/PowerHalLoader.h

+14 −13
Original line number Diff line number Diff line
@@ -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

include/powermanager/PowerHalWrapper.h

+45 −45
Original line number Diff line number Diff line
@@ -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

services/powermanager/PowerHalController.cpp

+26 −24
Original line number Diff line number Diff line
@@ -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 @@ void PowerHalController::init() { 
    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 @@ std::shared_ptr<PowerHalWrapper> 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<std::mutex> 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<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