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

Commit f668ee13 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Some fixes to power manager lib code"

parents dff91611 b59a9b54

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

               services/vr/

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