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

Commit 4b32a978 authored by Xiang Wang's avatar Xiang Wang Committed by Android (Google) Code Review
Browse files

Merge changes from topic "replace-power-cpp" 

* changes:
  Update power manager to use power ndk
  Update power manager benchmark to use power ndk
parents 5e303534 99f6f3cf

include/powermanager/PowerHalController.h

+11 −9
Original line number Diff line number Diff line
@@ -17,11 +17,11 @@ 
#ifndef ANDROID_POWERHALCONTROLLER_H

#define ANDROID_POWERHALCONTROLLER_H



#include <aidl/android/hardware/power/Boost.h>

#include <aidl/android/hardware/power/IPower.h>

#include <aidl/android/hardware/power/IPowerHintSession.h>

#include <aidl/android/hardware/power/Mode.h>

#include <android-base/thread_annotations.h>

#include <android/hardware/power/Boost.h>

#include <android/hardware/power/IPower.h>

#include <android/hardware/power/IPowerHintSession.h>

#include <android/hardware/power/Mode.h>

#include <powermanager/PowerHalWrapper.h>



namespace android {
@@ -55,10 +55,12 @@ public: 


    void init();



    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(

            int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

    virtual HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                                     int32_t durationMs) override;

    virtual HalResult<void> setMode(aidl::android::hardware::power::Mode mode,

                                    bool enabled) override;

    virtual HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>>

    createHintSession(int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

                      int64_t durationNanos) override;

    virtual HalResult<int64_t> getHintSessionPreferredRate() override;

include/powermanager/PowerHalLoader.h

+3 −3
Original line number Diff line number Diff line
@@ -17,11 +17,11 @@ 
#ifndef ANDROID_POWERHALLOADER_H

#define ANDROID_POWERHALLOADER_H



#include <aidl/android/hardware/power/IPower.h>

#include <android-base/thread_annotations.h>

#include <android/hardware/power/1.1/IPower.h>

#include <android/hardware/power/1.2/IPower.h>

#include <android/hardware/power/1.3/IPower.h>

#include <android/hardware/power/IPower.h>



namespace android {
@@ -31,7 +31,7 @@ namespace power { 
class PowerHalLoader {

public:

    static void unloadAll();

    static sp<hardware::power::IPower> loadAidl();

    static std::shared_ptr<aidl::android::hardware::power::IPower> loadAidl();

    static sp<hardware::power::V1_0::IPower> loadHidlV1_0();

    static sp<hardware::power::V1_1::IPower> loadHidlV1_1();

    static sp<hardware::power::V1_2::IPower> loadHidlV1_2();
@@ -39,7 +39,7 @@ public: 


private:

    static std::mutex gHalMutex;

    static sp<hardware::power::IPower> gHalAidl GUARDED_BY(gHalMutex);

    static std::shared_ptr<aidl::android::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<hardware::power::V1_2::IPower> gHalHidlV1_2 GUARDED_BY(gHalMutex);

include/powermanager/PowerHalWrapper.h

+93 −53
Original line number Diff line number Diff line
@@ -17,14 +17,15 @@ 
#ifndef ANDROID_POWERHALWRAPPER_H

#define ANDROID_POWERHALWRAPPER_H



#include <aidl/android/hardware/power/Boost.h>

#include <aidl/android/hardware/power/IPower.h>

#include <aidl/android/hardware/power/IPowerHintSession.h>

#include <aidl/android/hardware/power/Mode.h>

#include <android-base/thread_annotations.h>

#include <android/hardware/power/1.1/IPower.h>

#include <android/hardware/power/1.2/IPower.h>

#include <android/hardware/power/1.3/IPower.h>

#include <android/hardware/power/Boost.h>

#include <android/hardware/power/IPower.h>

#include <android/hardware/power/IPowerHintSession.h>

#include <android/hardware/power/Mode.h>

#include <binder/Status.h>



namespace android {
@@ -47,7 +48,7 @@ public: 
    }

    static HalResult<T> unsupported() { return HalResult("", /* unsupported= */ true); }



    static HalResult<T> fromStatus(binder::Status status, T data) {

    static HalResult<T> fromStatus(const binder::Status& status, T data) {

        if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {

            return HalResult<T>::unsupported();

        }
@@ -56,14 +57,28 @@ public: 
        }

        return HalResult<T>::failed(std::string(status.toString8().c_str()));

    }

    static HalResult<T> fromStatus(hardware::power::V1_0::Status status, T data);



    static HalResult<T> fromStatus(const ndk::ScopedAStatus& status, T data) {

        if (status.getExceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {

            return HalResult<T>::unsupported();

        }

        if (status.isOk()) {

            return HalResult<T>::ok(data);

        }

        return HalResult<T>::failed(std::string(status.getDescription()));

    }



    template <typename R>

    static HalResult<T> fromReturn(hardware::Return<R>& ret, T data);

    static HalResult<T> fromReturn(hardware::Return<R>& ret, T data) {

        return ret.isOk() ? HalResult<T>::ok(data) : HalResult<T>::failed(ret.description());

    }



    template <typename R>

    static HalResult<T> fromReturn(hardware::Return<R>& ret, hardware::power::V1_0::Status status,

                                   T data);

                                   T data) {

        return ret.isOk() ? HalResult<T>::fromStatus(status, data)

                          : HalResult<T>::failed(ret.description());

    }



    // This will throw std::bad_optional_access if this result is not ok.

    const T& value() const { return mValue.value(); }
@@ -91,12 +106,30 @@ public: 
    static HalResult<void> failed(std::string msg) { return HalResult(std::move(msg)); }

    static HalResult<void> unsupported() { return HalResult(/* unsupported= */ true); }



    static HalResult<void> fromStatus(status_t status);

    static HalResult<void> fromStatus(binder::Status status);

    static HalResult<void> fromStatus(hardware::power::V1_0::Status status);

    static HalResult<void> fromStatus(const binder::Status& status) {

        if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {

            return HalResult<void>::unsupported();

        }

        if (status.isOk()) {

            return HalResult<void>::ok();

        }

        return HalResult<void>::failed(std::string(status.toString8().c_str()));

    }



    static HalResult<void> fromStatus(const ndk::ScopedAStatus& status) {

        if (status.getExceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {

            return HalResult<void>::unsupported();

        }

        if (status.isOk()) {

            return HalResult<void>::ok();

        }

        return HalResult<void>::failed(std::string(status.getDescription()));

    }



    template <typename R>

    static HalResult<void> fromReturn(hardware::Return<R>& ret);

    static HalResult<void> fromReturn(hardware::Return<R>& ret) {

        return ret.isOk() ? HalResult<void>::ok() : HalResult<void>::failed(ret.description());

    }



    bool isOk() const { return !mUnsupported && !mFailed; }

    bool isFailed() const { return !mUnsupported && mFailed; }
@@ -119,10 +152,11 @@ class HalWrapper { 
public:

    virtual ~HalWrapper() = default;



    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) = 0;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) = 0;

    virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(

            int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

    virtual HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                                     int32_t durationMs) = 0;

    virtual HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) = 0;

    virtual HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>>

    createHintSession(int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

                      int64_t durationNanos) = 0;

    virtual HalResult<int64_t> getHintSessionPreferredRate() = 0;

};
@@ -131,14 +165,15 @@ public: 
class EmptyHalWrapper : public HalWrapper {

public:

    EmptyHalWrapper() = default;

    ~EmptyHalWrapper() = default;

    ~EmptyHalWrapper() override = default;



    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(

    HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                             int32_t durationMs) override;

    HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) override;

    HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>> createHintSession(

            int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

            int64_t durationNanos) override;

    virtual HalResult<int64_t> getHintSessionPreferredRate() override;

    HalResult<int64_t> getHintSessionPreferredRate() override;

};



// Wrapper for the HIDL Power HAL v1.0.
@@ -146,14 +181,15 @@ class HidlHalWrapperV1_0 : public HalWrapper { 
public:

    explicit HidlHalWrapperV1_0(sp<hardware::power::V1_0::IPower> handleV1_0)

          : mHandleV1_0(std::move(handleV1_0)) {}

    virtual ~HidlHalWrapperV1_0() = default;

    ~HidlHalWrapperV1_0() override = default;



    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(

    HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                             int32_t durationMs) override;

    HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) override;

    HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>> createHintSession(

            int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

            int64_t durationNanos) override;

    virtual HalResult<int64_t> getHintSessionPreferredRate() override;

    HalResult<int64_t> getHintSessionPreferredRate() override;



protected:

    const sp<hardware::power::V1_0::IPower> mHandleV1_0;
@@ -167,67 +203,71 @@ private: 
// Wrapper for the HIDL Power HAL v1.1.

class HidlHalWrapperV1_1 : public HidlHalWrapperV1_0 {

public:

    HidlHalWrapperV1_1(sp<hardware::power::V1_1::IPower> handleV1_1)

    explicit HidlHalWrapperV1_1(sp<hardware::power::V1_1::IPower> handleV1_1)

          : HidlHalWrapperV1_0(std::move(handleV1_1)) {}

    virtual ~HidlHalWrapperV1_1() = default;

    ~HidlHalWrapperV1_1() override = default;



protected:

    virtual HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId,

                                          uint32_t data) override;

    HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId, uint32_t data) override;

};



// Wrapper for the HIDL Power HAL v1.2.

class HidlHalWrapperV1_2 : public HidlHalWrapperV1_1 {

public:

    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    HidlHalWrapperV1_2(sp<hardware::power::V1_2::IPower> handleV1_2)

    HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                             int32_t durationMs) override;

    HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) override;

    explicit HidlHalWrapperV1_2(sp<hardware::power::V1_2::IPower> handleV1_2)

          : HidlHalWrapperV1_1(std::move(handleV1_2)) {}

    virtual ~HidlHalWrapperV1_2() = default;

    ~HidlHalWrapperV1_2() override = default;



protected:

    virtual HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId,

                                          uint32_t data) override;

    HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId, uint32_t data) override;

};



// Wrapper for the HIDL Power HAL v1.3.

class HidlHalWrapperV1_3 : public HidlHalWrapperV1_2 {

public:

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    HidlHalWrapperV1_3(sp<hardware::power::V1_3::IPower> handleV1_3)

    HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) override;

    explicit HidlHalWrapperV1_3(sp<hardware::power::V1_3::IPower> handleV1_3)

          : HidlHalWrapperV1_2(std::move(handleV1_3)) {}

    virtual ~HidlHalWrapperV1_3() = default;

    ~HidlHalWrapperV1_3() override = default;



protected:

    virtual HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId,

                                          uint32_t data) override;

    HalResult<void> sendPowerHint(hardware::power::V1_3::PowerHint hintId, uint32_t data) override;

};



// Wrapper for the AIDL Power HAL.

class AidlHalWrapper : public HalWrapper {

public:

    explicit AidlHalWrapper(sp<hardware::power::IPower> handle) : mHandle(std::move(handle)) {}

    virtual ~AidlHalWrapper() = default;



    virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;

    virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;

    virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(

    explicit AidlHalWrapper(std::shared_ptr<aidl::android::hardware::power::IPower> handle)

          : mHandle(std::move(handle)) {}

    ~AidlHalWrapper() override = default;



    HalResult<void> setBoost(aidl::android::hardware::power::Boost boost,

                             int32_t durationMs) override;

    HalResult<void> setMode(aidl::android::hardware::power::Mode mode, bool enabled) override;

    HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>> createHintSession(

            int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,

            int64_t durationNanos) override;

    virtual HalResult<int64_t> getHintSessionPreferredRate() override;

    HalResult<int64_t> getHintSessionPreferredRate() override;



private:

    // Control access to the boost and mode supported arrays.

    std::mutex mBoostMutex;

    std::mutex mModeMutex;

    sp<hardware::power::IPower> mHandle;

    std::shared_ptr<aidl::android::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<HalSupport>,

               static_cast<int32_t>(hardware::power::Boost::DISPLAY_UPDATE_IMMINENT) + 1>

    std::array<

            std::atomic<HalSupport>,

            static_cast<int32_t>(aidl::android::hardware::power::Boost::DISPLAY_UPDATE_IMMINENT) +

                    1>

            mBoostSupportedArray GUARDED_BY(mBoostMutex) = {HalSupport::UNKNOWN};

    std::array<std::atomic<HalSupport>,

               static_cast<int32_t>(*(android::enum_range<hardware::power::Mode>().end() - 1)) + 1>

               static_cast<int32_t>(

                       *(ndk::enum_range<aidl::android::hardware::power::Mode>().end() - 1)) +

                       1>

            mModeSupportedArray GUARDED_BY(mModeMutex) = {HalSupport::UNKNOWN};

};

services/powermanager/Android.bp

+3 −2
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ cc_library_shared { 


    shared_libs: [

        "libbinder",

        "libbinder_ndk",

        "libhidlbase",

        "liblog",

        "libutils",
@@ -40,7 +41,7 @@ cc_library_shared { 
        "android.hardware.power@1.1",

        "android.hardware.power@1.2",

        "android.hardware.power@1.3",

        "android.hardware.power-V4-cpp",

        "android.hardware.power-V4-ndk",

    ],



    export_shared_lib_headers: [
@@ -48,7 +49,7 @@ cc_library_shared { 
        "android.hardware.power@1.1",

        "android.hardware.power@1.2",

        "android.hardware.power@1.3",

        "android.hardware.power-V4-cpp",

        "android.hardware.power-V4-ndk",

    ],



    cflags: [

services/powermanager/PowerHalController.cpp

+14 −9
Original line number Diff line number Diff line
@@ -15,11 +15,11 @@ 
 */



#define LOG_TAG "PowerHalController"

#include <aidl/android/hardware/power/Boost.h>

#include <aidl/android/hardware/power/IPower.h>

#include <aidl/android/hardware/power/IPowerHintSession.h>

#include <aidl/android/hardware/power/Mode.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/IPowerHintSession.h>

#include <android/hardware/power/Mode.h>

#include <powermanager/PowerHalController.h>

#include <powermanager/PowerHalLoader.h>

#include <utils/Log.h>
@@ -33,7 +33,8 @@ namespace power { 
// -------------------------------------------------------------------------------------------------



std::unique_ptr<HalWrapper> HalConnector::connect() {

    if (sp<IPower> halAidl = PowerHalLoader::loadAidl()) {

    if (std::shared_ptr<aidl::android::hardware::power::IPower> halAidl =

                PowerHalLoader::loadAidl()) {

        return std::make_unique<AidlHalWrapper>(halAidl);

    }

    // If V1_0 isn't defined, none of them are
@@ -90,20 +91,24 @@ HalResult<T> PowerHalController::processHalResult(HalResult<T> result, const cha 
    return result;

}



HalResult<void> PowerHalController::setBoost(Boost boost, int32_t durationMs) {

HalResult<void> PowerHalController::setBoost(aidl::android::hardware::power::Boost boost,

                                             int32_t durationMs) {

    std::shared_ptr<HalWrapper> handle = initHal();

    auto result = handle->setBoost(boost, durationMs);

    return processHalResult(result, "setBoost");

}



HalResult<void> PowerHalController::setMode(Mode mode, bool enabled) {

HalResult<void> PowerHalController::setMode(aidl::android::hardware::power::Mode mode,

                                            bool enabled) {

    std::shared_ptr<HalWrapper> handle = initHal();

    auto result = handle->setMode(mode, enabled);

    return processHalResult(result, "setMode");

}



HalResult<sp<IPowerHintSession>> PowerHalController::createHintSession(

        int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {

HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>>

PowerHalController::createHintSession(int32_t tgid, int32_t uid,

                                      const std::vector<int32_t>& threadIds,

                                      int64_t durationNanos) {

    std::shared_ptr<HalWrapper> handle = initHal();

    auto result = handle->createHintSession(tgid, uid, threadIds, durationNanos);

    return processHalResult(result, "createHintSession");