android-12.0.0_r34/s

/**
 * 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 "carpowerpolicyd"
#define DEBUG false  // STOPSHIP if true.

#include "CarPowerPolicyServer.h"

#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <android/frameworks/automotive/powerpolicy/BnCarPowerPolicyChangeCallback.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <hidl/HidlTransportSupport.h>
#include <private/android_filesystem_config.h>
#include <utils/String8.h>
#include <utils/SystemClock.h>
#include <utils/Timers.h>

#include <inttypes.h>

namespace android {
namespace frameworks {
namespace automotive {
namespace powerpolicy {

using android::defaultServiceManager;
using android::IBinder;
using android::Looper;
using android::Mutex;
using android::sp;
using android::status_t;
using android::String16;
using android::uptimeMillis;
using android::Vector;
using android::wp;
using android::base::Error;
using android::base::Result;
using android::base::StringAppendF;
using android::base::StringPrintf;
using android::base::WriteStringToFd;
using android::binder::Status;
using android::frameworks::automotive::powerpolicy::internal::PolicyState;
using android::hardware::hidl_vec;
using android::hardware::interfacesEqual;
using android::hardware::Return;
using android::hardware::automotive::vehicle::V2_0::IVehicle;
using android::hardware::automotive::vehicle::V2_0::StatusCode;
using android::hardware::automotive::vehicle::V2_0::SubscribeFlags;
using android::hardware::automotive::vehicle::V2_0::SubscribeOptions;
using android::hardware::automotive::vehicle::V2_0::VehicleApPowerStateReport;
using android::hardware::automotive::vehicle::V2_0::VehiclePropConfig;
using android::hardware::automotive::vehicle::V2_0::VehicleProperty;
using android::hardware::automotive::vehicle::V2_0::VehiclePropValue;
using android::hidl::base::V1_0::IBase;

namespace {

const int32_t MSG_CONNECT_TO_VHAL = 1;  // Message to request of connecting to VHAL.

const nsecs_t kConnectionRetryIntervalNs = 200000000;  // 200 milliseconds.
const int32_t kMaxConnectionRetry = 25;                // Retry up to 5 seconds.

constexpr const char* kCarServiceInterface = "car_service";
constexpr const char* kCarPowerPolicyServerInterface =
        "android.frameworks.automotive.powerpolicy.ICarPowerPolicyServer/default";
constexpr const char* kCarPowerPolicySystemNotificationInterface =
        "carpowerpolicy_system_notification";

std::string toString(const CallbackInfo& callback) {
    return StringPrintf("callback(pid %d, filter: %s)", callback.pid,
                        toString(callback.filter.components).c_str());
}

std::vector<CallbackInfo>::const_iterator lookupPowerPolicyChangeCallback(
        const std::vector<CallbackInfo>& callbacks, const sp<IBinder>& binder) {
    for (auto it = callbacks.begin(); it != callbacks.end(); it++) {
        if (BnCarPowerPolicyChangeCallback::asBinder(it->callback) == binder) {
            return it;
        }
    }
    return callbacks.end();
}

Status checkSystemPermission() {
    if (IPCThreadState::self()->getCallingUid() != AID_SYSTEM) {
        return Status::fromExceptionCode(Status::EX_SECURITY,
                                         "Calling process does not have proper privilege");
    }
    return Status::ok();
}

}  // namespace

sp<CarPowerPolicyServer> CarPowerPolicyServer::sCarPowerPolicyServer = nullptr;

BinderDeathRecipient::BinderDeathRecipient(const sp<CarPowerPolicyServer>& service) :
      mService(service) {}

void BinderDeathRecipient::binderDied(const wp<IBinder>& who) {
    mService->handleBinderDeath(who);
}

HidlDeathRecipient::HidlDeathRecipient(const sp<CarPowerPolicyServer>& service) :
      mService(service) {}

void HidlDeathRecipient::serviceDied(uint64_t /*cookie*/, const wp<IBase>& who) {
    mService->handleHidlDeath(who);
}

PropertyChangeListener::PropertyChangeListener(const sp<CarPowerPolicyServer>& service) :
      mService(service) {}

Return<void> PropertyChangeListener::onPropertyEvent(const hidl_vec<VehiclePropValue>& propValues) {
    for (const auto& value : propValues) {
        if (value.prop == static_cast<int32_t>(VehicleProperty::POWER_POLICY_GROUP_REQ)) {
            const auto& ret = mService->setPowerPolicyGroup(value.value.stringValue);
            if (!ret.ok()) {
                ALOGW("Failed to set power policy group(%s): %s", value.value.stringValue.c_str(),
                      ret.error().message().c_str());
            }
        } else if (value.prop == static_cast<int32_t>(VehicleProperty::POWER_POLICY_REQ)) {
            const auto& ret = mService->applyPowerPolicy(value.value.stringValue,
                                                         /*carServiceExpected=*/false,
                                                         /*overridePreemptive=*/false);
            if (!ret.ok()) {
                ALOGW("Failed to apply power policy(%s): %s", value.value.stringValue.c_str(),
                      ret.error().message().c_str());
            }
        }
    }
    return Return<void>();
}

Return<void> PropertyChangeListener::onPropertySet(const VehiclePropValue& /*propValue*/) {
    return Return<void>();
}

Return<void> PropertyChangeListener::onPropertySetError(StatusCode /*status*/, int32_t /*propId*/,
                                                        int32_t /*areaId*/) {
    return Return<void>();
}

MessageHandlerImpl::MessageHandlerImpl(const sp<CarPowerPolicyServer>& service) :
      mService(service) {}

void MessageHandlerImpl::handleMessage(const Message& message) {
    switch (message.what) {
        case MSG_CONNECT_TO_VHAL:
            mService->connectToVhalHelper();
            break;
        default:
            ALOGW("Unknown message: %d", message.what);
    }
}

CarServiceNotificationHandler::CarServiceNotificationHandler(
        const sp<CarPowerPolicyServer>& service) :
      mService(service) {}

status_t CarServiceNotificationHandler::dump(int fd, const Vector<String16>& args) {
    return mService->dump(fd, args);
}

Status CarServiceNotificationHandler::notifyCarServiceReady(PolicyState* policyState) {
    return mService->notifyCarServiceReady(policyState);
}

Status CarServiceNotificationHandler::notifyPowerPolicyChange(const std::string& policyId) {
    return mService->notifyPowerPolicyChange(policyId);
}

Status CarServiceNotificationHandler::notifyPowerPolicyDefinition(
        const std::string& policyId, const std::vector<std::string>& enabledComponents,
        const std::vector<std::string>& disabledComponents) {
    return mService->notifyPowerPolicyDefinition(policyId, enabledComponents, disabledComponents);
}

ISilentModeChangeHandler::~ISilentModeChangeHandler() {}

Result<sp<CarPowerPolicyServer>> CarPowerPolicyServer::startService(const sp<Looper>& looper) {
    if (sCarPowerPolicyServer != nullptr) {
        return Error(INVALID_OPERATION) << "Cannot start service more than once";
    }
    sp<CarPowerPolicyServer> server = new CarPowerPolicyServer();
    const auto& ret = server->init(looper);
    if (!ret.ok()) {
        return Error(ret.error().code())
                << "Failed to start car power policy server: " << ret.error();
    }
    sCarPowerPolicyServer = server;

    return sCarPowerPolicyServer;
}

void CarPowerPolicyServer::terminateService() {
    if (sCarPowerPolicyServer != nullptr) {
        sCarPowerPolicyServer->terminate();
        sCarPowerPolicyServer = nullptr;
    }
}

CarPowerPolicyServer::CarPowerPolicyServer() :
      mSilentModeHandler(this),
      mIsPowerPolicyLocked(false),
      mIsCarServiceInOperation(false),
      mIsFirstConnectionToVhal(false) {
    mMessageHandler = new MessageHandlerImpl(this);
    mBinderDeathRecipient = new BinderDeathRecipient(this);
    mHidlDeathRecipient = new HidlDeathRecipient(this);
    mPropertyChangeListener = new PropertyChangeListener(this);
    mCarServiceNotificationHandler = new CarServiceNotificationHandler(this);
}

Status CarPowerPolicyServer::getCurrentPowerPolicy(CarPowerPolicy* aidlReturn) {
    Mutex::Autolock lock(mMutex);
    if (!isPowerPolicyAppliedLocked()) {
        return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE,
                                         "The current power policy is not set");
    }
    *aidlReturn = *mCurrentPowerPolicyMeta.powerPolicy;
    return Status::ok();
}

Status CarPowerPolicyServer::getPowerComponentState(PowerComponent componentId, bool* aidlReturn) {
    const auto& ret = mComponentHandler.getPowerComponentState(componentId);
    if (!ret.ok()) {
        std::string errorMsg = ret.error().message();
        ALOGW("getPowerComponentState(%s) failed: %s", toString(componentId).c_str(),
              errorMsg.c_str());
        return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, errorMsg.c_str());
    }
    *aidlReturn = *ret;
    return Status::ok();
}

Status CarPowerPolicyServer::registerPowerPolicyChangeCallback(
        const sp<ICarPowerPolicyChangeCallback>& callback, const CarPowerPolicyFilter& filter) {
    Mutex::Autolock lock(mMutex);
    pid_t callingPid = IPCThreadState::self()->getCallingPid();
    uid_t callingUid = IPCThreadState::self()->getCallingUid();
    if (isRegisteredLocked(callback)) {
        std::string errorStr = StringPrintf("The callback(pid: %d, uid: %d) is already registered.",
                                            callingPid, callingUid);
        const char* errorCause = errorStr.c_str();
        ALOGW("Cannot register a callback: %s", errorCause);
        return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, errorCause);
    }
    sp<IBinder> binder = BnCarPowerPolicyChangeCallback::asBinder(callback);
    status_t status = binder->linkToDeath(mBinderDeathRecipient);
    if (status != OK) {
        std::string errorStr = StringPrintf("The given callback(pid: %d, uid: %d) is dead",
                                            callingPid, callingUid);
        const char* errorCause = errorStr.c_str();
        ALOGW("Cannot register a callback: %s", errorCause);
        return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE, errorCause);
    }
    mPolicyChangeCallbacks.emplace_back(callback, filter, callingPid);

    if (DEBUG) {
        ALOGD("Power policy change callback(pid: %d, filter: %s) is registered", callingPid,
              toString(filter.components).c_str());
    }
    return Status::ok();
}

Status CarPowerPolicyServer::unregisterPowerPolicyChangeCallback(
        const sp<ICarPowerPolicyChangeCallback>& callback) {
    Mutex::Autolock lock(mMutex);
    pid_t callingPid = IPCThreadState::self()->getCallingPid();
    uid_t callingUid = IPCThreadState::self()->getCallingUid();
    sp<IBinder> binder = BnCarPowerPolicyChangeCallback::asBinder(callback);
    auto it = lookupPowerPolicyChangeCallback(mPolicyChangeCallbacks, binder);
    if (it == mPolicyChangeCallbacks.end()) {
        std::string errorStr =
                StringPrintf("The callback(pid: %d, uid: %d) has not been registered", callingPid,
                             callingUid);
        const char* errorCause = errorStr.c_str();
        ALOGW("Cannot unregister a callback: %s", errorCause);
        return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, errorCause);
    }
    binder->unlinkToDeath(mBinderDeathRecipient);
    mPolicyChangeCallbacks.erase(it);
    if (DEBUG) {
        ALOGD("Power policy change callback(pid: %d, uid: %d) is unregistered", callingPid,
              callingUid);
    }
    return Status::ok();
}

Status CarPowerPolicyServer::notifyCarServiceReady(PolicyState* policyState) {
    Status status = checkSystemPermission();
    if (!status.isOk()) {
        return status;
    }
    mSilentModeHandler.stopMonitoringSilentModeHwState(/*shouldWaitThread=*/false);
    Mutex::Autolock lock(mMutex);
    policyState->policyId =
            isPowerPolicyAppliedLocked() ? mCurrentPowerPolicyMeta.powerPolicy->policyId : "";
    policyState->policyGroupId = mCurrentPolicyGroupId;
    mIsCarServiceInOperation = true;
    ALOGI("CarService is now responsible for power policy management");
    return Status::ok();
}

Status CarPowerPolicyServer::notifyPowerPolicyChange(const std::string& policyId) {
    Status status = checkSystemPermission();
    if (!status.isOk()) {
        return status;
    }
    const auto& ret =
            applyPowerPolicy(policyId, /*carServiceExpected=*/true, /*overridePreemptive=*/false);
    if (!ret.ok()) {
        return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE,
                                         StringPrintf("Failed to notify power policy change: %s",
                                                      ret.error().message().c_str())
                                                 .c_str());
    }
    ALOGD("Policy(%s) is applied at CarService", policyId.c_str());
    return Status::ok();
}

Status CarPowerPolicyServer::notifyPowerPolicyDefinition(
        const std::string& policyId, const std::vector<std::string>& enabledComponents,
        const std::vector<std::string>& disabledComponents) {
    Status status = checkSystemPermission();
    if (!status.isOk()) {
        return status;
    }
    const auto& ret =
            mPolicyManager.definePowerPolicy(policyId, enabledComponents, disabledComponents);
    if (!ret.ok()) {
        return Status::
                fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT,
                                  StringPrintf("Failed to notify power policy definition: %s",
                                               ret.error().message().c_str())
                                          .c_str());
    }
    return Status::ok();
}

status_t CarPowerPolicyServer::dump(int fd, const Vector<String16>& args) {
    {
        Mutex::Autolock lock(mMutex);
        const char* indent = "  ";
        const char* doubleIndent = "    ";
        WriteStringToFd("CAR POWER POLICY DAEMON\n", fd);
        WriteStringToFd(StringPrintf("%sCarService is in operation: %s\n", indent,
                                     mIsCarServiceInOperation ? "true" : "false"),
                        fd);
        WriteStringToFd(StringPrintf("%sConnection to VHAL: %s\n", indent,
                                     mVhalService.get() ? "connected" : "disconnected"),
                        fd);
        WriteStringToFd(StringPrintf("%sCurrent power policy: %s\n", indent,
                                     isPowerPolicyAppliedLocked()
                                             ? mCurrentPowerPolicyMeta.powerPolicy->policyId.c_str()
                                             : "not set"),
                        fd);
        WriteStringToFd(StringPrintf("%sLast uptime of applying power policy: %" PRId64 "ms\n",
                                     indent, mLastApplyPowerPolicyUptimeMs.value_or(-1)),
                        fd);
        WriteStringToFd(StringPrintf("%sPending power policy ID: %s\n", indent,
                                     mPendingPowerPolicyId.c_str()),
                        fd);
        WriteStringToFd(StringPrintf("%sCurrent power policy group ID: %s\n", indent,
                                     mCurrentPolicyGroupId.empty() ? "not set"
                                                                   : mCurrentPolicyGroupId.c_str()),
                        fd);
        WriteStringToFd(StringPrintf("%sLast uptime of setting default power policy group: "
                                     "%" PRId64 "ms\n",
                                     indent, mLastSetDefaultPowerPolicyGroupUptimeMs.value_or(-1)),
                        fd);
        WriteStringToFd(StringPrintf("%sPolicy change callbacks:%s\n", indent,
                                     mPolicyChangeCallbacks.size() ? "" : " none"),
                        fd);
        for (auto& callback : mPolicyChangeCallbacks) {
            WriteStringToFd(StringPrintf("%s- %s\n", doubleIndent, toString(callback).c_str()), fd);
        }
    }
    if (const auto& ret = mPolicyManager.dump(fd, args); !ret.ok()) {
        ALOGW("Failed to dump power policy handler: %s", ret.error().message().c_str());
        return ret.error().code();
    }
    if (const auto& ret = mComponentHandler.dump(fd); !ret.ok()) {
        ALOGW("Failed to dump power component handler: %s", ret.error().message().c_str());
        return ret.error().code();
    }
    if (const auto& ret = mSilentModeHandler.dump(fd, args); !ret.ok()) {
        ALOGW("Failed to dump Silent Mode handler: %s", ret.error().message().c_str());
        return ret.error().code();
    }
    return OK;
}

Result<void> CarPowerPolicyServer::init(const sp<Looper>& looper) {
    sp<IBinder> binderCarService =
            defaultServiceManager()->checkService(String16(kCarServiceInterface));
    {
        // Before initializing power policy daemon, we need to update mIsCarServiceInOperation
        // according to whether CPMS is running.
        Mutex::Autolock lock(mMutex);
        mIsCarServiceInOperation = binderCarService != nullptr;
    }

    mHandlerLooper = looper;
    mPolicyManager.init();
    mComponentHandler.init();
    mSilentModeHandler.init();

    status_t status =
            defaultServiceManager()->addService(String16(kCarPowerPolicyServerInterface), this);
    if (status != OK) {
        return Error(status) << "Failed to add carpowerpolicyd to ServiceManager";
    }
    status =
            defaultServiceManager()->addService(String16(
                                                        kCarPowerPolicySystemNotificationInterface),
                                                mCarServiceNotificationHandler);
    if (status != OK) {
        return Error(status)
                << "Failed to add car power policy system notification to ServiceManager";
    }

    connectToVhal();
    return {};
}

void CarPowerPolicyServer::terminate() {
    {
        Mutex::Autolock lock(mMutex);
        for (auto it = mPolicyChangeCallbacks.begin(); it != mPolicyChangeCallbacks.end(); it++) {
            sp<IBinder> binder = BnCarPowerPolicyChangeCallback::asBinder(it->callback);
            binder->unlinkToDeath(mBinderDeathRecipient);
        }
        mPolicyChangeCallbacks.clear();
    }
    mSilentModeHandler.release();
}

void CarPowerPolicyServer::handleBinderDeath(const wp<IBinder>& who) {
    Mutex::Autolock lock(mMutex);
    IBinder* binder = who.unsafe_get();
    auto it = lookupPowerPolicyChangeCallback(mPolicyChangeCallbacks, binder);
    if (it != mPolicyChangeCallbacks.end()) {
        ALOGW("Power policy callback(pid: %d) died", it->pid);
        binder->unlinkToDeath(mBinderDeathRecipient);
        mPolicyChangeCallbacks.erase(it);
    }
}

void CarPowerPolicyServer::handleHidlDeath(const wp<IBase>& who) {
    {
        Mutex::Autolock lock(mMutex);
        if (!interfacesEqual(mVhalService, who.promote())) {
            return;
        }
        ALOGW("VHAL has died.");
        mVhalService->unlinkToDeath(mHidlDeathRecipient);
        mVhalService = nullptr;
    }
    connectToVhal();
}

Result<void> CarPowerPolicyServer::applyPowerPolicy(const std::string& policyId,
                                                    const bool carServiceInOperation,
                                                    const bool overridePreemptive) {
    auto policyMeta = mPolicyManager.getPowerPolicy(policyId);
    if (!policyMeta.ok()) {
        return Error() << "Failed to apply power policy: " << policyMeta.error().message();
    }

    std::vector<CallbackInfo> clients;
    if (Mutex::Autolock lock(mMutex); mIsCarServiceInOperation != carServiceInOperation) {
        return Error() << (mIsCarServiceInOperation
                                   ? "After CarService starts serving, power policy cannot be "
                                     "managed in car power policy daemon"
                                   : "Before CarService starts serving, power policy cannot be "
                                     "applied from CarService");
    } else {
        if (mVhalService == nullptr) {
            ALOGI("%s is queued and will be applied after VHAL gets ready", policyId.c_str());
            mPendingPowerPolicyId = policyId;
            return {};
        }
        bool isPolicyApplied = isPowerPolicyAppliedLocked();
        if (isPolicyApplied && mCurrentPowerPolicyMeta.powerPolicy->policyId == policyId) {
            ALOGI("Applying policy skipped: the given policy(ID: %s) is the current policy",
                  policyId.c_str());
            return {};
        }
        if (policyMeta->isPreemptive) {
            if (isPolicyApplied && !mCurrentPowerPolicyMeta.isPreemptive) {
                mPendingPowerPolicyId = mCurrentPowerPolicyMeta.powerPolicy->policyId;
            }
            mIsPowerPolicyLocked = true;
        } else {
            if (overridePreemptive) {
                mPendingPowerPolicyId.clear();
                mIsPowerPolicyLocked = false;
            } else if (mIsPowerPolicyLocked) {
                ALOGI("%s is queued and will be applied after power policy get unlocked",
                      policyId.c_str());
                mPendingPowerPolicyId = policyId;
                return {};
            }
        }
        mCurrentPowerPolicyMeta = *policyMeta;
        clients = mPolicyChangeCallbacks;
        mLastApplyPowerPolicyUptimeMs = uptimeMillis();
    }
    CarPowerPolicyPtr policy = policyMeta->powerPolicy;
    mComponentHandler.applyPowerPolicy(policy);
    if (const auto& ret = notifyVhalNewPowerPolicy(policyId); !ret.ok()) {
        ALOGW("Failed to tell VHAL the new power policy(%s): %s", policyId.c_str(),
              ret.error().message().c_str());
    }
    for (auto client : clients) {
        client.callback->onPolicyChanged(*policy);
    }
    ALOGI("The current power policy is %s", policyId.c_str());
    return {};
}

Result<void> CarPowerPolicyServer::setPowerPolicyGroup(const std::string& groupId) {
    if (!mPolicyManager.isPowerPolicyGroupAvailable(groupId)) {
        return Error() << StringPrintf("Power policy group(%s) is not available", groupId.c_str());
    }
    Mutex::Autolock lock(mMutex);
    if (mIsCarServiceInOperation) {
        return Error() << "After CarService starts serving, power policy group cannot be set in "
                          "car power policy daemon";
    }
    mCurrentPolicyGroupId = groupId;
    ALOGI("The current power policy group is |%s|", groupId.c_str());
    return {};
}

void CarPowerPolicyServer::notifySilentModeChange(const bool isSilent) {
    std::string pendingPowerPolicyId;
    if (Mutex::Autolock lock(mMutex); mIsCarServiceInOperation) {
        return;
    } else {
        pendingPowerPolicyId = mPendingPowerPolicyId;
    }
    ALOGI("Silent Mode is set to %s", isSilent ? "silent" : "non-silent");
    Result<void> ret;
    if (isSilent) {
        ret = applyPowerPolicy(kSystemPolicyIdNoUserInteraction,
                               /*carServiceExpected=*/false, /*overridePreemptive=*/false);
    } else {
        ret = applyPowerPolicy(pendingPowerPolicyId,
                               /*carServiceExpected=*/false, /*overridePreemptive=*/true);
    }
    if (!ret.ok()) {
        ALOGW("Failed to apply power policy: %s", ret.error().message().c_str());
    }
}

bool CarPowerPolicyServer::isRegisteredLocked(const sp<ICarPowerPolicyChangeCallback>& callback) {
    sp<IBinder> binder = BnCarPowerPolicyChangeCallback::asBinder(callback);
    return lookupPowerPolicyChangeCallback(mPolicyChangeCallbacks, binder) !=
            mPolicyChangeCallbacks.end();
}

// This method ensures that the attempt to connect to VHAL occurs in the main thread.
void CarPowerPolicyServer::connectToVhal() {
    mRemainingConnectionRetryCount = kMaxConnectionRetry;
    mHandlerLooper->sendMessage(mMessageHandler, MSG_CONNECT_TO_VHAL);
}

// connectToVhalHelper is always executed in the main thread.
void CarPowerPolicyServer::connectToVhalHelper() {
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService != nullptr) {
            return;
        }
    }
    sp<IVehicle> vhalService = IVehicle::tryGetService();
    if (vhalService.get() == nullptr) {
        ALOGW("Failed to connect to VHAL. Retrying in %" PRId64 " ms.",
              nanoseconds_to_milliseconds(kConnectionRetryIntervalNs));
        mRemainingConnectionRetryCount--;
        if (mRemainingConnectionRetryCount <= 0) {
            ALOGE("Failed to connect to VHAL after %d attempt%s. Gave up.", kMaxConnectionRetry,
                  kMaxConnectionRetry > 1 ? "s" : "");
            return;
        }
        mHandlerLooper->sendMessageDelayed(kConnectionRetryIntervalNs, mMessageHandler,
                                           MSG_CONNECT_TO_VHAL);
        return;
    }
    auto ret = vhalService->linkToDeath(mHidlDeathRecipient, /*cookie=*/0);
    if (!ret.isOk() || ret == false) {
        connectToVhal();
        ALOGW("Failed to connect to VHAL. VHAL is dead. Retrying...");
        return;
    }
    std::string currentPolicyId;
    {
        Mutex::Autolock lock(mMutex);
        mVhalService = vhalService;
        if (isPowerPolicyAppliedLocked()) {
            currentPolicyId = mCurrentPowerPolicyMeta.powerPolicy->policyId;
        }
    }
    /*
     * When VHAL is first executed, a normal power management goes on. When VHAL is restarted due to
     * some reasons, the current policy is notified to VHAL.
     */
    if (mIsFirstConnectionToVhal) {
        applyInitialPowerPolicy();
        mIsFirstConnectionToVhal = false;
    } else if (!currentPolicyId.empty()) {
        notifyVhalNewPowerPolicy(currentPolicyId);
    }
    subscribeToVhal();
    ALOGI("Connected to VHAL");
    return;
}

void CarPowerPolicyServer::applyInitialPowerPolicy() {
    std::string policyId;
    std::string currentPolicyGroupId;
    CarPowerPolicyPtr powerPolicy;
    {
        Mutex::Autolock lock(mMutex);
        if (mIsCarServiceInOperation) {
            ALOGI("Skipping initial power policy application because CarService is running");
            return;
        }
        policyId = mPendingPowerPolicyId;
        currentPolicyGroupId = mCurrentPolicyGroupId;
    }
    if (policyId.empty()) {
        if (auto policy = mPolicyManager.getDefaultPowerPolicyForState(currentPolicyGroupId,
                                                                       VehicleApPowerStateReport::
                                                                               WAIT_FOR_VHAL);
            policy.ok()) {
            policyId = (*policy)->policyId;
        } else {
            policyId = kSystemPolicyIdInitialOn;
        }
    }
    if (const auto& ret = applyPowerPolicy(policyId, /*carServiceExpected=*/false,
                                           /*overridePreemptive=*/false);
        !ret.ok()) {
        ALOGW("Cannot apply the initial power policy(%s): %s", policyId.c_str(),
              ret.error().message().c_str());
    }
    ALOGD("Policy(%s) is applied as the initial one", policyId.c_str());
}

void CarPowerPolicyServer::subscribeToVhal() {
    subscribeToProperty(static_cast<int32_t>(VehicleProperty::POWER_POLICY_REQ),
                        [this](const VehiclePropValue& value) {
                            if (value.value.stringValue.size() > 0) {
                                const auto& ret = applyPowerPolicy(value.value.stringValue,
                                                                   /*carServiceExpected=*/false,
                                                                   /*overridePreemptive=*/false);
                                if (!ret.ok()) {
                                    ALOGW("Failed to apply power policy(%s): %s",
                                          value.value.stringValue.c_str(),
                                          ret.error().message().c_str());
                                }
                            }
                        });
    subscribeToProperty(static_cast<int32_t>(VehicleProperty::POWER_POLICY_GROUP_REQ),
                        [this](const VehiclePropValue& value) {
                            if (value.value.stringValue.size() > 0) {
                                const auto& ret = setPowerPolicyGroup(value.value.stringValue);
                                if (ret.ok()) {
                                    Mutex::Autolock lock(mMutex);
                                    mLastSetDefaultPowerPolicyGroupUptimeMs = value.timestamp;
                                } else {
                                    ALOGW("Failed to set power policy group(%s): %s",
                                          value.value.stringValue.c_str(),
                                          ret.error().message().c_str());
                                }
                            }
                        });
}

void CarPowerPolicyServer::subscribeToProperty(
        int32_t prop, std::function<void(const VehiclePropValue&)> processor) {
    if (!isPropertySupported(prop)) {
        ALOGW("Vehicle property(%d) is not supported by VHAL.", prop);
        return;
    }
    VehiclePropValue propValue{
            .prop = prop,
    };
    sp<IVehicle> vhalService;
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService == nullptr) {
            ALOGW("Failed to subscribe to property(%d): VHAL is not ready", prop);
            return;
        }
        vhalService = mVhalService;
    }
    StatusCode status;
    vhalService->get(propValue, [&status, &propValue](StatusCode s, const VehiclePropValue& value) {
        status = s;
        propValue = value;
    });
    if (status != StatusCode::OK) {
        ALOGW("Failed to get vehicle property(%d) value.", prop);
        return;
    }
    processor(propValue);
    SubscribeOptions reqVhalProperties[] = {
            {.propId = prop, .flags = SubscribeFlags::EVENTS_FROM_CAR},
    };
    hidl_vec<SubscribeOptions> options;
    options.setToExternal(reqVhalProperties, arraysize(reqVhalProperties));
    status = vhalService->subscribe(mPropertyChangeListener, options);
    if (status != StatusCode::OK) {
        ALOGW("Failed to subscribe to vehicle property(%d).", prop);
    }
}

Result<void> CarPowerPolicyServer::notifyVhalNewPowerPolicy(const std::string& policyId) {
    int32_t prop = static_cast<int32_t>(VehicleProperty::CURRENT_POWER_POLICY);
    if (!isPropertySupported(prop)) {
        return Error() << StringPrintf("Vehicle property(%d) is not supported by VHAL.", prop);
    }
    VehiclePropValue propValue{
            .prop = prop,
            .value = {
                    .stringValue = policyId,
            },
    };
    sp<IVehicle> vhalService;
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService == nullptr) {
            return Error() << "VHAL is not ready";
        }
        vhalService = mVhalService;
    }
    auto ret = vhalService->set(propValue);
    if (!ret.isOk() || ret != StatusCode::OK) {
        return Error() << "Failed to set CURRENT_POWER_POLICY property";
    }
    ALOGD("Policy(%s) is notified to VHAL", policyId.c_str());
    return {};
}

bool CarPowerPolicyServer::isPropertySupported(const int32_t prop) {
    if (mSupportedProperties.count(prop) > 0) {
        return mSupportedProperties[prop];
    }
    StatusCode status;
    hidl_vec<int32_t> props = {prop};
    sp<IVehicle> vhalService;
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService == nullptr) {
            ALOGW("Failed to check if property(%d) is supported: VHAL is not ready", prop);
            return false;
        }
        vhalService = mVhalService;
    }
    vhalService->getPropConfigs(props,
                                [&status](StatusCode s,
                                          hidl_vec<VehiclePropConfig> /*propConfigs*/) {
                                    status = s;
                                });
    mSupportedProperties[prop] = status == StatusCode::OK;
    return mSupportedProperties[prop];
}

bool CarPowerPolicyServer::isPowerPolicyAppliedLocked() const {
    return mCurrentPowerPolicyMeta.powerPolicy != nullptr;
}

}  // namespace powerpolicy
}  // namespace automotive
}  // namespace frameworks
}  // namespace android