services/powermanager/PowerHalWrapper.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *            http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "HalWrapper"
 #include <aidl/android/hardware/power/Boost.h>
 #include <aidl/android/hardware/power/IPowerHintSession.h>
 #include <aidl/android/hardware/power/Mode.h>
 #include <powermanager/PowerHalWrapper.h>
 #include <utils/Log.h>

 #include <cinttypes>

 using namespace android::hardware::power;
 namespace Aidl = aidl::android::hardware::power;

 namespace android {

 namespace power {

 // -------------------------------------------------------------------------------------------------
 inline HalResult<void> toHalResult(const ndk::ScopedAStatus& result) {
     if (result.isOk()) {
         return HalResult<void>::ok();
     }
     ALOGE("Power HAL request failed: %s", result.getDescription().c_str());
     return HalResult<void>::failed(result.getDescription());
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> EmptyHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
     ALOGV("Skipped setBoost %s with duration %dms because %s", toString(boost).c_str(), durationMs,
           getUnsupportedMessage());
     return HalResult<void>::unsupported();
 }

 HalResult<void> EmptyHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
     ALOGV("Skipped setMode %s to %s because %s", toString(mode).c_str(), enabled ? "true" : "false",
           getUnsupportedMessage());
     return HalResult<void>::unsupported();
 }

 HalResult<std::shared_ptr<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSession(
         int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) {
     ALOGV("Skipped createHintSession(task num=%zu) because %s", threadIds.size(),
           getUnsupportedMessage());
     return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::unsupported();
 }

 HalResult<std::shared_ptr<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSessionWithConfig(
         int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t, Aidl::SessionTag,
         Aidl::SessionConfig*) {
     ALOGV("Skipped createHintSessionWithConfig(task num=%zu) because %s", threadIds.size(),
           getUnsupportedMessage());
     return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::unsupported();
 }

 HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() {
     ALOGV("Skipped getHintSessionPreferredRate because %s", getUnsupportedMessage());
     return HalResult<int64_t>::unsupported();
 }

 HalResult<Aidl::ChannelConfig> EmptyHalWrapper::getSessionChannel(int, int) {
     ALOGV("Skipped getSessionChannel because %s", getUnsupportedMessage());
     return HalResult<Aidl::ChannelConfig>::unsupported();
 }

 HalResult<void> EmptyHalWrapper::closeSessionChannel(int, int) {
     ALOGV("Skipped closeSessionChannel because %s", getUnsupportedMessage());
     return HalResult<void>::unsupported();
 }

 const char* EmptyHalWrapper::getUnsupportedMessage() {
     return "Power HAL is not supported";
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> HidlHalWrapperV1_0::setBoost(Aidl::Boost boost, int32_t durationMs) {
     if (boost == Aidl::Boost::INTERACTION) {
         return sendPowerHint(V1_3::PowerHint::INTERACTION, durationMs);
     } else {
         return EmptyHalWrapper::setBoost(boost, durationMs);
     }
 }

 HalResult<void> HidlHalWrapperV1_0::setMode(Aidl::Mode mode, bool enabled) {
     uint32_t data = enabled ? 1 : 0;
     switch (mode) {
         case Aidl::Mode::LAUNCH:
             return sendPowerHint(V1_3::PowerHint::LAUNCH, data);
         case Aidl::Mode::LOW_POWER:
             return sendPowerHint(V1_3::PowerHint::LOW_POWER, data);
         case Aidl::Mode::SUSTAINED_PERFORMANCE:
             return sendPowerHint(V1_3::PowerHint::SUSTAINED_PERFORMANCE, data);
         case Aidl::Mode::VR:
             return sendPowerHint(V1_3::PowerHint::VR_MODE, data);
         case Aidl::Mode::INTERACTIVE:
             return setInteractive(enabled);
         case Aidl::Mode::DOUBLE_TAP_TO_WAKE:
             return setFeature(V1_0::Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled);
         default:
             return EmptyHalWrapper::setMode(mode, enabled);
     }
 }

 HalResult<void> HidlHalWrapperV1_0::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
     auto ret = mHandleV1_0->powerHint(static_cast<V1_0::PowerHint>(hintId), data);
     return HalResult<void>::fromReturn(ret);
 }

 HalResult<void> HidlHalWrapperV1_0::setInteractive(bool enabled) {
     auto ret = mHandleV1_0->setInteractive(enabled);
     return HalResult<void>::fromReturn(ret);
 }

 HalResult<void> HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) {
     auto ret = mHandleV1_0->setFeature(feature, enabled);
     return HalResult<void>::fromReturn(ret);
 }

 const char* HidlHalWrapperV1_0::getUnsupportedMessage() {
     return "Power HAL AIDL is not supported";
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
     auto handle = static_cast<V1_1::IPower*>(mHandleV1_0.get());
     auto ret = handle->powerHintAsync(static_cast<V1_0::PowerHint>(hintId), data);
     return HalResult<void>::fromReturn(ret);
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> HidlHalWrapperV1_2::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
     auto handle = static_cast<V1_2::IPower*>(mHandleV1_0.get());
     auto ret = handle->powerHintAsync_1_2(static_cast<V1_2::PowerHint>(hintId), data);
     return HalResult<void>::fromReturn(ret);
 }

 HalResult<void> HidlHalWrapperV1_2::setBoost(Aidl::Boost boost, int32_t durationMs) {
     switch (boost) {
         case Aidl::Boost::CAMERA_SHOT:
             return sendPowerHint(V1_3::PowerHint::CAMERA_SHOT, durationMs);
         case Aidl::Boost::CAMERA_LAUNCH:
             return sendPowerHint(V1_3::PowerHint::CAMERA_LAUNCH, durationMs);
         default:
             return HidlHalWrapperV1_1::setBoost(boost, durationMs);
     }
 }

 HalResult<void> HidlHalWrapperV1_2::setMode(Aidl::Mode mode, bool enabled) {
     uint32_t data = enabled ? 1 : 0;
     switch (mode) {
         case Aidl::Mode::CAMERA_STREAMING_SECURE:
         case Aidl::Mode::CAMERA_STREAMING_LOW:
         case Aidl::Mode::CAMERA_STREAMING_MID:
         case Aidl::Mode::CAMERA_STREAMING_HIGH:
             return sendPowerHint(V1_3::PowerHint::CAMERA_STREAMING, data);
         case Aidl::Mode::AUDIO_STREAMING_LOW_LATENCY:
             return sendPowerHint(V1_3::PowerHint::AUDIO_LOW_LATENCY, data);
         default:
             return HidlHalWrapperV1_1::setMode(mode, enabled);
     }
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> HidlHalWrapperV1_3::setMode(Aidl::Mode mode, bool enabled) {
     uint32_t data = enabled ? 1 : 0;
     if (mode == Aidl::Mode::EXPENSIVE_RENDERING) {
         return sendPowerHint(V1_3::PowerHint::EXPENSIVE_RENDERING, data);
     }
     return HidlHalWrapperV1_2::setMode(mode, enabled);
 }

 HalResult<void> HidlHalWrapperV1_3::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
     auto handle = static_cast<V1_3::IPower*>(mHandleV1_0.get());
     auto ret = handle->powerHintAsync_1_3(hintId, data);
     return HalResult<void>::fromReturn(ret);
 }

 // -------------------------------------------------------------------------------------------------

 HalResult<void> AidlHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
     std::unique_lock<std::mutex> lock(mBoostMutex);
     size_t idx = static_cast<size_t>(boost);

     // Quick return if boost is not supported by HAL
     if (idx >= mBoostSupportedArray.size() || mBoostSupportedArray[idx] == HalSupport::OFF) {
         ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(), getUnsupportedMessage());
         return HalResult<void>::unsupported();
     }

     if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) {
         bool isSupported = false;
         auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported);
         if (!isSupportedRet.isOk()) {
             ALOGE("Skipped setBoost %s because check support failed with: %s",
                   toString(boost).c_str(), isSupportedRet.getDescription().c_str());
             // return HalResult::FAILED;
             return HalResult<void>::fromStatus(isSupportedRet);
         }

         mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
         if (!isSupported) {
             ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(),
                   getUnsupportedMessage());
             return HalResult<void>::unsupported();
         }
     }
     lock.unlock();

     return toHalResult(mHandle->setBoost(boost, durationMs));
 }

 HalResult<void> AidlHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
     std::unique_lock<std::mutex> lock(mModeMutex);
     size_t idx = static_cast<size_t>(mode);

     // Quick return if mode is not supported by HAL
     if (idx >= mModeSupportedArray.size() || mModeSupportedArray[idx] == HalSupport::OFF) {
         ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
         return HalResult<void>::unsupported();
     }

     if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) {
         bool isSupported = false;
         auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported);
         if (!isSupportedRet.isOk()) {
             return HalResult<void>::failed(isSupportedRet.getDescription());
         }

         mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
         if (!isSupported) {
             ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
             return HalResult<void>::unsupported();
         }
     }
     lock.unlock();

     return toHalResult(mHandle->setMode(mode, enabled));
 }

 HalResult<std::shared_ptr<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSession(
         int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {
     std::shared_ptr<Aidl::IPowerHintSession> appSession;
     return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::
             fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession),
                        std::move(appSession));
 }

 HalResult<std::shared_ptr<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSessionWithConfig(
         int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos,
         Aidl::SessionTag tag, Aidl::SessionConfig* config) {
     std::shared_ptr<Aidl::IPowerHintSession> appSession;
     return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::
             fromStatus(mHandle->createHintSessionWithConfig(tgid, uid, threadIds, durationNanos,
                                                             tag, config, &appSession),
                        std::move(appSession));
 }

 HalResult<int64_t> AidlHalWrapper::getHintSessionPreferredRate() {
     int64_t rate = -1;
     auto result = mHandle->getHintSessionPreferredRate(&rate);
     return HalResult<int64_t>::fromStatus(result, rate);
 }

 HalResult<Aidl::ChannelConfig> AidlHalWrapper::getSessionChannel(int tgid, int uid) {
     Aidl::ChannelConfig config;
     auto result = mHandle->getSessionChannel(tgid, uid, &config);
     return HalResult<Aidl::ChannelConfig>::fromStatus(result, std::move(config));
 }

 HalResult<void> AidlHalWrapper::closeSessionChannel(int tgid, int uid) {
     return toHalResult(mHandle->closeSessionChannel(tgid, uid));
 }

 const char* AidlHalWrapper::getUnsupportedMessage() {
     return "Power HAL doesn't support it";
 }

 // -------------------------------------------------------------------------------------------------

 } // namespace power

 } // namespace android
	/*
	* Copyright (C) 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "HalWrapper"
	#include <aidl/android/hardware/power/Boost.h>
	#include <aidl/android/hardware/power/IPowerHintSession.h>
	#include <aidl/android/hardware/power/Mode.h>
	#include <powermanager/PowerHalWrapper.h>
	#include <utils/Log.h>

	#include <cinttypes>

	using namespace android::hardware::power;
	namespace Aidl = aidl::android::hardware::power;

	namespace android {

	namespace power {

	// -------------------------------------------------------------------------------------------------
	inline HalResult<void> toHalResult(const ndk::ScopedAStatus& result) {
	if (result.isOk()) {
	return HalResult<void>::ok();
	}
	ALOGE("Power HAL request failed: %s", result.getDescription().c_str());
	return HalResult<void>::failed(result.getDescription());
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> EmptyHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
	ALOGV("Skipped setBoost %s with duration %dms because %s", toString(boost).c_str(), durationMs,
	getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}

	HalResult<void> EmptyHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
	ALOGV("Skipped setMode %s to %s because %s", toString(mode).c_str(), enabled ? "true" : "false",
	getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}

	HalResult<std::shared_ptr<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSession(
	int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) {
	ALOGV("Skipped createHintSession(task num=%zu) because %s", threadIds.size(),
	getUnsupportedMessage());
	return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::unsupported();
	}

	HalResult<std::shared_ptr<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSessionWithConfig(
	int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t, Aidl::SessionTag,
	Aidl::SessionConfig*) {
	ALOGV("Skipped createHintSessionWithConfig(task num=%zu) because %s", threadIds.size(),
	getUnsupportedMessage());
	return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::unsupported();
	}

	HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() {
	ALOGV("Skipped getHintSessionPreferredRate because %s", getUnsupportedMessage());
	return HalResult<int64_t>::unsupported();
	}

	HalResult<Aidl::ChannelConfig> EmptyHalWrapper::getSessionChannel(int, int) {
	ALOGV("Skipped getSessionChannel because %s", getUnsupportedMessage());
	return HalResult<Aidl::ChannelConfig>::unsupported();
	}

	HalResult<void> EmptyHalWrapper::closeSessionChannel(int, int) {
	ALOGV("Skipped closeSessionChannel because %s", getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}

	const char* EmptyHalWrapper::getUnsupportedMessage() {
	return "Power HAL is not supported";
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> HidlHalWrapperV1_0::setBoost(Aidl::Boost boost, int32_t durationMs) {
	if (boost == Aidl::Boost::INTERACTION) {
	return sendPowerHint(V1_3::PowerHint::INTERACTION, durationMs);
	} else {
	return EmptyHalWrapper::setBoost(boost, durationMs);
	}
	}

	HalResult<void> HidlHalWrapperV1_0::setMode(Aidl::Mode mode, bool enabled) {
	uint32_t data = enabled ? 1 : 0;
	switch (mode) {
	case Aidl::Mode::LAUNCH:
	return sendPowerHint(V1_3::PowerHint::LAUNCH, data);
	case Aidl::Mode::LOW_POWER:
	return sendPowerHint(V1_3::PowerHint::LOW_POWER, data);
	case Aidl::Mode::SUSTAINED_PERFORMANCE:
	return sendPowerHint(V1_3::PowerHint::SUSTAINED_PERFORMANCE, data);
	case Aidl::Mode::VR:
	return sendPowerHint(V1_3::PowerHint::VR_MODE, data);
	case Aidl::Mode::INTERACTIVE:
	return setInteractive(enabled);
	case Aidl::Mode::DOUBLE_TAP_TO_WAKE:
	return setFeature(V1_0::Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled);
	default:
	return EmptyHalWrapper::setMode(mode, enabled);
	}
	}

	HalResult<void> HidlHalWrapperV1_0::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
	auto ret = mHandleV1_0->powerHint(static_cast<V1_0::PowerHint>(hintId), data);
	return HalResult<void>::fromReturn(ret);
	}

	HalResult<void> HidlHalWrapperV1_0::setInteractive(bool enabled) {
	auto ret = mHandleV1_0->setInteractive(enabled);
	return HalResult<void>::fromReturn(ret);
	}

	HalResult<void> HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) {
	auto ret = mHandleV1_0->setFeature(feature, enabled);
	return HalResult<void>::fromReturn(ret);
	}

	const char* HidlHalWrapperV1_0::getUnsupportedMessage() {
	return "Power HAL AIDL is not supported";
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
	auto handle = static_cast<V1_1::IPower*>(mHandleV1_0.get());
	auto ret = handle->powerHintAsync(static_cast<V1_0::PowerHint>(hintId), data);
	return HalResult<void>::fromReturn(ret);
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> HidlHalWrapperV1_2::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
	auto handle = static_cast<V1_2::IPower*>(mHandleV1_0.get());
	auto ret = handle->powerHintAsync_1_2(static_cast<V1_2::PowerHint>(hintId), data);
	return HalResult<void>::fromReturn(ret);
	}

	HalResult<void> HidlHalWrapperV1_2::setBoost(Aidl::Boost boost, int32_t durationMs) {
	switch (boost) {
	case Aidl::Boost::CAMERA_SHOT:
	return sendPowerHint(V1_3::PowerHint::CAMERA_SHOT, durationMs);
	case Aidl::Boost::CAMERA_LAUNCH:
	return sendPowerHint(V1_3::PowerHint::CAMERA_LAUNCH, durationMs);
	default:
	return HidlHalWrapperV1_1::setBoost(boost, durationMs);
	}
	}

	HalResult<void> HidlHalWrapperV1_2::setMode(Aidl::Mode mode, bool enabled) {
	uint32_t data = enabled ? 1 : 0;
	switch (mode) {
	case Aidl::Mode::CAMERA_STREAMING_SECURE:
	case Aidl::Mode::CAMERA_STREAMING_LOW:
	case Aidl::Mode::CAMERA_STREAMING_MID:
	case Aidl::Mode::CAMERA_STREAMING_HIGH:
	return sendPowerHint(V1_3::PowerHint::CAMERA_STREAMING, data);
	case Aidl::Mode::AUDIO_STREAMING_LOW_LATENCY:
	return sendPowerHint(V1_3::PowerHint::AUDIO_LOW_LATENCY, data);
	default:
	return HidlHalWrapperV1_1::setMode(mode, enabled);
	}
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> HidlHalWrapperV1_3::setMode(Aidl::Mode mode, bool enabled) {
	uint32_t data = enabled ? 1 : 0;
	if (mode == Aidl::Mode::EXPENSIVE_RENDERING) {
	return sendPowerHint(V1_3::PowerHint::EXPENSIVE_RENDERING, data);
	}
	return HidlHalWrapperV1_2::setMode(mode, enabled);
	}

	HalResult<void> HidlHalWrapperV1_3::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
	auto handle = static_cast<V1_3::IPower*>(mHandleV1_0.get());
	auto ret = handle->powerHintAsync_1_3(hintId, data);
	return HalResult<void>::fromReturn(ret);
	}

	// -------------------------------------------------------------------------------------------------

	HalResult<void> AidlHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
	std::unique_lock<std::mutex> lock(mBoostMutex);
	size_t idx = static_cast<size_t>(boost);

	// Quick return if boost is not supported by HAL
	if (idx >= mBoostSupportedArray.size() \|\| mBoostSupportedArray[idx] == HalSupport::OFF) {
	ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(), getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}

	if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) {
	bool isSupported = false;
	auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported);
	if (!isSupportedRet.isOk()) {
	ALOGE("Skipped setBoost %s because check support failed with: %s",
	toString(boost).c_str(), isSupportedRet.getDescription().c_str());
	// return HalResult::FAILED;
	return HalResult<void>::fromStatus(isSupportedRet);
	}

	mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
	if (!isSupported) {
	ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(),
	getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}
	}
	lock.unlock();

	return toHalResult(mHandle->setBoost(boost, durationMs));
	}

	HalResult<void> AidlHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
	std::unique_lock<std::mutex> lock(mModeMutex);
	size_t idx = static_cast<size_t>(mode);

	// Quick return if mode is not supported by HAL
	if (idx >= mModeSupportedArray.size() \|\| mModeSupportedArray[idx] == HalSupport::OFF) {
	ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}

	if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) {
	bool isSupported = false;
	auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported);
	if (!isSupportedRet.isOk()) {
	return HalResult<void>::failed(isSupportedRet.getDescription());
	}

	mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
	if (!isSupported) {
	ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
	return HalResult<void>::unsupported();
	}
	}
	lock.unlock();

	return toHalResult(mHandle->setMode(mode, enabled));
	}

	HalResult<std::shared_ptr<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSession(
	int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {
	std::shared_ptr<Aidl::IPowerHintSession> appSession;
	return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::
	fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession),
	std::move(appSession));
	}

	HalResult<std::shared_ptr<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSessionWithConfig(
	int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos,
	Aidl::SessionTag tag, Aidl::SessionConfig* config) {
	std::shared_ptr<Aidl::IPowerHintSession> appSession;
	return HalResult<std::shared_ptr<Aidl::IPowerHintSession>>::
	fromStatus(mHandle->createHintSessionWithConfig(tgid, uid, threadIds, durationNanos,
	tag, config, &appSession),
	std::move(appSession));
	}

	HalResult<int64_t> AidlHalWrapper::getHintSessionPreferredRate() {
	int64_t rate = -1;
	auto result = mHandle->getHintSessionPreferredRate(&rate);
	return HalResult<int64_t>::fromStatus(result, rate);
	}

	HalResult<Aidl::ChannelConfig> AidlHalWrapper::getSessionChannel(int tgid, int uid) {
	Aidl::ChannelConfig config;
	auto result = mHandle->getSessionChannel(tgid, uid, &config);
	return HalResult<Aidl::ChannelConfig>::fromStatus(result, std::move(config));
	}

	HalResult<void> AidlHalWrapper::closeSessionChannel(int tgid, int uid) {
	return toHalResult(mHandle->closeSessionChannel(tgid, uid));
	}

	const char* AidlHalWrapper::getUnsupportedMessage() {
	return "Power HAL doesn't support it";
	}

	// -------------------------------------------------------------------------------------------------

	} // namespace power

	} // namespace android