/**
 * 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 <aidl/android/hardware/automotive/vehicle/StatusCode.h>
#include <aidl/android/hardware/automotive/vehicle/SubscribeOptions.h>
#include <aidl/android/hardware/automotive/vehicle/VehicleApPowerStateReport.h>
#include <aidl/android/hardware/automotive/vehicle/VehicleProperty.h>
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <android/binder_ibinder.h>
#include <android/binder_manager.h>
#include <android/binder_status.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 ::aidl::android::frameworks::automotive::powerpolicy::CarPowerPolicy;
using ::aidl::android::frameworks::automotive::powerpolicy::CarPowerPolicyFilter;
using ::aidl::android::frameworks::automotive::powerpolicy::ICarPowerPolicyChangeCallback;
using ::aidl::android::frameworks::automotive::powerpolicy::PowerComponent;
using ::aidl::android::frameworks::automotive::powerpolicy::internal::PolicyState;
using ::aidl::android::hardware::automotive::vehicle::StatusCode;
using ::aidl::android::hardware::automotive::vehicle::SubscribeOptions;
using ::aidl::android::hardware::automotive::vehicle::VehicleApPowerStateReport;
using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;

using ::android::defaultServiceManager;
using ::android::IBinder;
using ::android::Looper;
using ::android::Mutex;
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::frameworks::automotive::vhal::HalPropError;
using ::android::frameworks::automotive::vhal::IHalPropValue;
using ::android::frameworks::automotive::vhal::ISubscriptionClient;
using ::android::frameworks::automotive::vhal::IVhalClient;
using ::android::hardware::hidl_vec;
using ::android::hardware::interfacesEqual;
using ::android::hardware::Return;
using ::android::hardware::automotive::vehicle::VhalResult;

using ::android::hidl::base::V1_0::IBase;
using ::ndk::ScopedAIBinder_DeathRecipient;
using ::ndk::ScopedAStatus;
using ::ndk::SharedRefBase;
using ::ndk::SpAIBinder;

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[] =
        "android.frameworks.automotive.powerpolicy.internal.ICarPowerPolicySystemNotification/"
        "default";

std::vector<CallbackInfo>::const_iterator lookupPowerPolicyChangeCallback(
        const std::vector<CallbackInfo>& callbacks, const AIBinder* binder) {
    for (auto it = callbacks.begin(); it != callbacks.end(); it++) {
        if (it->binder.get() == binder) {
            return it;
        }
    }
    return callbacks.end();
}

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

}  // namespace

std::shared_ptr<CarPowerPolicyServer> CarPowerPolicyServer::sCarPowerPolicyServer = nullptr;

PropertyChangeListener::PropertyChangeListener(CarPowerPolicyServer* service) : mService(service) {}

void PropertyChangeListener::onPropertyEvent(
        const std::vector<std::unique_ptr<IHalPropValue>>& values) {
    for (const auto& value : values) {
        const std::string stringValue = value->getStringValue();
        int32_t propId = value->getPropId();
        if (propId == static_cast<int32_t>(VehicleProperty::POWER_POLICY_GROUP_REQ)) {
            const auto& ret = mService->setPowerPolicyGroup(stringValue);
            if (!ret.ok()) {
                ALOGW("Failed to set power policy group(%s): %s", stringValue.c_str(),
                      ret.error().message().c_str());
            }
        } else if (propId == static_cast<int32_t>(VehicleProperty::POWER_POLICY_REQ)) {
            const auto& ret = mService->applyPowerPolicy(stringValue,
                                                         /*carServiceExpected=*/false,
                                                         /*force=*/false);
            if (!ret.ok()) {
                ALOGW("Failed to apply power policy(%s): %s", stringValue.c_str(),
                      ret.error().message().c_str());
            }
        }
    }
}

void PropertyChangeListener::onPropertySetError(
        [[maybe_unused]] const std::vector<HalPropError>& errors) {
    return;
}

MessageHandlerImpl::MessageHandlerImpl(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(CarPowerPolicyServer* service) :
      mService(service) {}

void CarServiceNotificationHandler::terminate() {
    Mutex::Autolock lock(mMutex);
    mService = nullptr;
}

binder_status_t CarServiceNotificationHandler::dump(int fd, const char** args, uint32_t numArgs) {
    Mutex::Autolock lock(mMutex);
    if (mService == nullptr) {
        ALOGD("Skip dumping, CarPowerPolicyServer is ending");
        return STATUS_OK;
    }
    return mService->dump(fd, args, numArgs);
}

ScopedAStatus CarServiceNotificationHandler::notifyCarServiceReady(PolicyState* policyState) {
    Mutex::Autolock lock(mMutex);
    if (mService == nullptr) {
        ALOGD("Skip notifying CarServiceReady, CarPowerPolicyServer is ending");
        return ScopedAStatus::ok();
    }
    return mService->notifyCarServiceReady(policyState);
}

ScopedAStatus CarServiceNotificationHandler::notifyPowerPolicyChange(const std::string& policyId,
                                                                     bool force) {
    Mutex::Autolock lock(mMutex);
    if (mService == nullptr) {
        ALOGD("Skip notifying PowerPolicyChange, CarPowerPolicyServer is ending");
        return ScopedAStatus::ok();
    }
    return mService->notifyPowerPolicyChange(policyId, force);
}

ScopedAStatus CarServiceNotificationHandler::notifyPowerPolicyDefinition(
        const std::string& policyId, const std::vector<std::string>& enabledComponents,
        const std::vector<std::string>& disabledComponents) {
    Mutex::Autolock lock(mMutex);
    if (mService == nullptr) {
        ALOGD("Skip notifying PowerPolicyDefinition, CarPowerPolicyServer is ending");
        return ScopedAStatus::ok();
    }
    return mService->notifyPowerPolicyDefinition(policyId, enabledComponents, disabledComponents);
}

ISilentModeChangeHandler::~ISilentModeChangeHandler() {}

Result<std::shared_ptr<CarPowerPolicyServer>> CarPowerPolicyServer::startService(
        const sp<Looper>& looper) {
    if (sCarPowerPolicyServer != nullptr) {
        return Error(INVALID_OPERATION) << "Cannot start service more than once";
    }
    std::shared_ptr<CarPowerPolicyServer> server = SharedRefBase::make<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(true) {
    mMessageHandler = new MessageHandlerImpl(this);
    mDeathRecipient = ScopedAIBinder_DeathRecipient(
            AIBinder_DeathRecipient_new(&CarPowerPolicyServer::onBinderDied));
    mPropertyChangeListener = std::make_unique<PropertyChangeListener>(this);
    mLinkUnlinkImpl = std::make_unique<AIBinderLinkUnlinkImpl>();
}

// For test-only.
void CarPowerPolicyServer::setLinkUnlinkImpl(
        std::unique_ptr<CarPowerPolicyServer::LinkUnlinkImpl> impl) {
    mLinkUnlinkImpl = std::move(impl);
}

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

ScopedAStatus 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 ScopedAStatus::fromServiceSpecificErrorWithMessage(EX_ILLEGAL_ARGUMENT,
                                                                  errorMsg.c_str());
    }
    *aidlReturn = *ret;
    return ScopedAStatus::ok();
}

ScopedAStatus CarPowerPolicyServer::registerPowerPolicyChangeCallback(
        const std::shared_ptr<ICarPowerPolicyChangeCallback>& callback,
        const CarPowerPolicyFilter& filter) {
    Mutex::Autolock lock(mMutex);
    pid_t callingPid = IPCThreadState::self()->getCallingPid();
    uid_t callingUid = IPCThreadState::self()->getCallingUid();
    SpAIBinder binder = callback->asBinder();
    AIBinder* clientId = binder.get();
    if (isRegisteredLocked(clientId)) {
        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 ScopedAStatus::fromServiceSpecificErrorWithMessage(EX_ILLEGAL_ARGUMENT, errorCause);
    }

    std::unique_ptr<OnBinderDiedContext> context = std::make_unique<OnBinderDiedContext>(
            OnBinderDiedContext{.server = this, .clientId = clientId});
    binder_status_t status = mLinkUnlinkImpl->linkToDeath(clientId, mDeathRecipient.get(),
                                                          static_cast<void*>(context.get()));
    if (status != 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 ScopedAStatus::fromServiceSpecificErrorWithMessage(EX_ILLEGAL_STATE, errorCause);
    }
    // Insert into a map to keep the context object alive.
    mOnBinderDiedContexts[clientId] = std::move(context);
    mPolicyChangeCallbacks.emplace_back(binder, filter, callingPid);

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

ScopedAStatus CarPowerPolicyServer::unregisterPowerPolicyChangeCallback(
        const std::shared_ptr<ICarPowerPolicyChangeCallback>& callback) {
    Mutex::Autolock lock(mMutex);
    pid_t callingPid = IPCThreadState::self()->getCallingPid();
    uid_t callingUid = IPCThreadState::self()->getCallingUid();
    AIBinder* clientId = callback->asBinder().get();
    auto it = lookupPowerPolicyChangeCallback(mPolicyChangeCallbacks, clientId);
    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 ScopedAStatus::fromServiceSpecificErrorWithMessage(EX_ILLEGAL_ARGUMENT, errorCause);
    }
    if (mOnBinderDiedContexts.find(clientId) != mOnBinderDiedContexts.end()) {
        // We don't set a callback for unlinkToDeath but need to call unlinkToDeath to clean up the
        // registered death recipient.
        mLinkUnlinkImpl->unlinkToDeath(clientId, mDeathRecipient.get(),
                                       static_cast<void*>(mOnBinderDiedContexts[clientId].get()));
        mOnBinderDiedContexts.erase(clientId);
    }
    mPolicyChangeCallbacks.erase(it);
    if (DEBUG) {
        ALOGD("Power policy change callback(pid: %d, uid: %d) is unregistered", callingPid,
              callingUid);
    }
    return ScopedAStatus::ok();
}

ScopedAStatus CarPowerPolicyServer::notifyCarServiceReady(PolicyState* policyState) {
    ScopedAStatus 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 ScopedAStatus::ok();
}

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

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

status_t CarPowerPolicyServer::dump(int fd, const char** args, uint32_t numArgs) {
    Vector<String16> argsV;
    for (size_t i = 0; i < numArgs; i++) {
        argsV.push(String16(args[i]));
    }

    {
        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,
                                         callbackToString(callback).c_str()),
                            fd);
        }
    }
    if (const auto& ret = mPolicyManager.dump(fd, argsV); !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, argsV); !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) {
    AIBinder* binderCarService = AServiceManager_checkService(kCarServiceInterface);

    Mutex::Autolock lock(mMutex);
    // Before initializing power policy daemon, we need to update mIsCarServiceInOperation
    // according to whether CPMS is running.
    mIsCarServiceInOperation = binderCarService != nullptr;

    mHandlerLooper = looper;
    mPolicyManager.init();
    mComponentHandler.init();
    mSilentModeHandler.init();
    mCarServiceNotificationHandler = SharedRefBase::make<CarServiceNotificationHandler>(this);

    binder_exception_t err =
            AServiceManager_addService(this->asBinder().get(), kCarPowerPolicyServerInterface);
    if (err != EX_NONE) {
        return Error(err) << "Failed to add carpowerpolicyd to ServiceManager";
    }
    err = AServiceManager_addService(mCarServiceNotificationHandler->asBinder().get(),
                                     kCarPowerPolicySystemNotificationInterface);
    if (err != EX_NONE) {
        return Error(err) << "Failed to add car power policy system notification to ServiceManager";
    }

    connectToVhal();
    return {};
}

void CarPowerPolicyServer::terminate() {
    Mutex::Autolock lock(mMutex);
    mPolicyChangeCallbacks.clear();
    if (mVhalService != nullptr) {
        mSubscriptionClient->unsubscribe(
                {static_cast<int32_t>(VehicleProperty::POWER_POLICY_REQ),
                 static_cast<int32_t>(VehicleProperty::POWER_POLICY_GROUP_REQ)});
    }

    if (mCarServiceNotificationHandler != nullptr) {
        mCarServiceNotificationHandler->terminate();
        mCarServiceNotificationHandler = nullptr;
    }

    // Delete the deathRecipient so that all binders would be unlinked.
    mDeathRecipient = ScopedAIBinder_DeathRecipient();
    mSilentModeHandler.release();
    // Remove the messages so that mMessageHandler would no longer be used.
    mHandlerLooper->removeMessages(mMessageHandler);
}

void CarPowerPolicyServer::onBinderDied(void* cookie) {
    OnBinderDiedContext* context = reinterpret_cast<OnBinderDiedContext*>(cookie);
    context->server->handleBinderDeath(context->clientId);
}

void CarPowerPolicyServer::handleBinderDeath(const AIBinder* clientId) {
    Mutex::Autolock lock(mMutex);
    auto it = lookupPowerPolicyChangeCallback(mPolicyChangeCallbacks, clientId);
    if (it != mPolicyChangeCallbacks.end()) {
        ALOGW("Power policy callback(pid: %d) died", it->pid);
        mPolicyChangeCallbacks.erase(it);
    }
    mOnBinderDiedContexts.erase(clientId);
}

void CarPowerPolicyServer::handleVhalDeath() {
    {
        Mutex::Autolock lock(mMutex);
        ALOGW("VHAL has died.");
        mVhalService = nullptr;
    }
    connectToVhal();
}

Result<void> CarPowerPolicyServer::applyPowerPolicy(const std::string& policyId,
                                                    const bool carServiceInOperation,
                                                    const bool force) {
    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 (force) {
                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) {
        ICarPowerPolicyChangeCallback::fromBinder(client.binder)->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, /*force=*/false);
    } else {
        ret = applyPowerPolicy(pendingPowerPolicyId,
                               /*carServiceExpected=*/false, /*force=*/true);
    }
    if (!ret.ok()) {
        ALOGW("Failed to apply power policy: %s", ret.error().message().c_str());
    }
}

bool CarPowerPolicyServer::isRegisteredLocked(const AIBinder* binder) {
    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;
        }
    }
    std::shared_ptr<IVhalClient> vhalService = IVhalClient::tryCreate();
    if (vhalService == 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;
    }
    vhalService->addOnBinderDiedCallback(
            std::make_shared<IVhalClient::OnBinderDiedCallbackFunc>([this] { handleVhalDeath(); }));
    std::string currentPolicyId;
    {
        Mutex::Autolock lock(mMutex);
        mVhalService = vhalService;
        mSubscriptionClient = mVhalService->getSubscriptionClient(mPropertyChangeListener);
        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, /*force=*/false);
        !ret.ok()) {
        ALOGW("Cannot apply the initial power policy(%s): %s", policyId.c_str(),
              ret.error().message().c_str());
        return;
    }
    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 IHalPropValue& value) {
                            std::string stringValue = value.getStringValue();
                            if (stringValue.size() > 0) {
                                const auto& ret = applyPowerPolicy(stringValue,
                                                                   /*carServiceExpected=*/false,
                                                                   /*force=*/false);
                                if (!ret.ok()) {
                                    ALOGW("Failed to apply power policy(%s): %s",
                                          stringValue.c_str(), ret.error().message().c_str());
                                }
                            }
                        });
    subscribeToProperty(static_cast<int32_t>(VehicleProperty::POWER_POLICY_GROUP_REQ),
                        [this](const IHalPropValue& value) {
                            std::string stringValue = value.getStringValue();
                            if (stringValue.size() > 0) {
                                const auto& ret = setPowerPolicyGroup(stringValue);
                                if (ret.ok()) {
                                    Mutex::Autolock lock(mMutex);
                                    mLastSetDefaultPowerPolicyGroupUptimeMs = value.getTimestamp();
                                } else {
                                    ALOGW("Failed to set power policy group(%s): %s",
                                          stringValue.c_str(), ret.error().message().c_str());
                                }
                            }
                        });
}

void CarPowerPolicyServer::subscribeToProperty(
        int32_t prop, std::function<void(const IHalPropValue&)> processor) {
    if (!isPropertySupported(prop)) {
        ALOGW("Vehicle property(%d) is not supported by VHAL.", prop);
        return;
    }
    std::shared_ptr<IVhalClient> vhalService;
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService == nullptr) {
            ALOGW("Failed to subscribe to property(%d): VHAL is not ready", prop);
            return;
        }
        vhalService = mVhalService;
    }

    VhalResult<std::unique_ptr<IHalPropValue>> result =
            vhalService->getValueSync(*vhalService->createHalPropValue(prop));

    if (!result.ok()) {
        ALOGW("Failed to get vehicle property(%d) value, error: %s.", prop,
              result.error().message().c_str());
        return;
    }
    processor(*result.value());
    std::vector<SubscribeOptions> options = {
            {.propId = prop, .areaIds = {}},
    };

    if (auto result = mSubscriptionClient->subscribe(options); !result.ok()) {
        ALOGW("Failed to subscribe to vehicle property(%d), error: %s", prop,
              result.error().message().c_str());
    }
}

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);
    }
    std::shared_ptr<IVhalClient> vhalService;
    {
        Mutex::Autolock lock(mMutex);
        if (mVhalService == nullptr) {
            return Error() << "VHAL is not ready";
        }
        vhalService = mVhalService;
    }
    std::unique_ptr<IHalPropValue> propValue = vhalService->createHalPropValue(prop);
    propValue->setStringValue(policyId);

    VhalResult<void> result = vhalService->setValueSync(*propValue);
    if (!result.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};
    std::shared_ptr<IVhalClient> 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;
    }
    auto result = vhalService->getPropConfigs(props);
    mSupportedProperties[prop] = result.ok();
    return mSupportedProperties[prop];
}

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

std::string CarPowerPolicyServer::callbackToString(const CallbackInfo& callback) {
    const std::vector<PowerComponent>& components = callback.filter.components;
    return StringPrintf("callback(pid %d, filter: %s)", callback.pid, toString(components).c_str());
}

std::vector<CallbackInfo> CarPowerPolicyServer::getPolicyChangeCallbacks() {
    Mutex::Autolock lock(mMutex);
    return mPolicyChangeCallbacks;
}

size_t CarPowerPolicyServer::countOnBinderDiedContexts() {
    Mutex::Autolock lock(mMutex);
    return mOnBinderDiedContexts.size();
}

binder_status_t CarPowerPolicyServer::AIBinderLinkUnlinkImpl::linkToDeath(
        AIBinder* binder, AIBinder_DeathRecipient* recipient, void* cookie) {
    return AIBinder_linkToDeath(binder, recipient, cookie);
}

binder_status_t CarPowerPolicyServer::AIBinderLinkUnlinkImpl::unlinkToDeath(
        AIBinder* binder, AIBinder_DeathRecipient* recipient, void* cookie) {
    return AIBinder_unlinkToDeath(binder, recipient, cookie);
}

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