native/src/battery_srv_client.cpp

/*
 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
 * 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.
 */

#include "battery_srv_client.h"

#include "new"
#include "refbase.h"
#include "errors.h"
#include "iremote_broker.h"
#include "iservice_registry.h"
#include "if_system_ability_manager.h"
#include "system_ability_definition.h"
#include "battery_info.h"
#include "battery_log.h"
#include "power_mgr_errors.h"
#include "power_common.h"

namespace OHOS {
namespace PowerMgr {
BatterySrvClient::BatterySrvClient() {}
BatterySrvClient::~BatterySrvClient() {}

sptr<IBatterySrv> BatterySrvClient::Connect()
{
    std::lock_guard<std::mutex> lock(mutex_);
    if (proxy_ != nullptr) {
        return proxy_;
    }
    sptr<ISystemAbilityManager> sysMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    if (sysMgr == nullptr) {
        BATTERY_HILOGE(COMP_FWK, "Failed to get Registry");
        return nullptr;
    }
    sptr<IRemoteObject> remoteObject_ = sysMgr->CheckSystemAbility(POWER_MANAGER_BATT_SERVICE_ID);
    if (remoteObject_ == nullptr) {
        BATTERY_HILOGE(COMP_FWK, "GetSystemAbility failed");
        return nullptr;
    }
    sptr<IRemoteObject::DeathRecipient> drt = new(std::nothrow) BatterySrvDeathRecipient(*this);
    if (drt == nullptr) {
        BATTERY_HILOGE(COMP_FWK, "Failed to create BatterySrvDeathRecipient");
        return nullptr;
    }
    if ((remoteObject_->IsProxyObject()) && (!remoteObject_->AddDeathRecipient(drt))) {
        BATTERY_HILOGE(COMP_FWK, "Add death recipient to BatterySrv failed");
        return nullptr;
    }

    proxy_ = iface_cast<IBatterySrv>(remoteObject_);
    deathRecipient_ = drt;
    BATTERY_HILOGI(COMP_FWK, "Connecting PowerMgrService success, pid=%{public}d", getpid());
    return proxy_;
}

void BatterySrvClient::ResetProxy(const wptr<IRemoteObject>& remote)
{
    if (remote == nullptr) {
        BATTERY_HILOGE(COMP_FWK, "OnRemoteDied failed, remote is nullptr");
        return;
    }

    std::lock_guard<std::mutex> lock(mutex_);
    RETURN_IF(proxy_ == nullptr);
    auto serviceRemote = proxy_->AsObject();
    if ((serviceRemote != nullptr) && (serviceRemote == remote.promote())) {
        serviceRemote->RemoveDeathRecipient(deathRecipient_);
        proxy_ = nullptr;
    }
}

void BatterySrvClient::BatterySrvDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
{
    BATTERY_HILOGW(COMP_FWK, "Recv death notice, BateryService Died");
    client_.ResetProxy(remote);
}

int32_t BatterySrvClient::GetCapacity()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
    int32_t capacity = INVALID_BATT_INT_VALUE;
    auto ret = proxy->GetCapacity(capacity);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetCapacity ret = %{public}d", ret);
        return INVALID_BATT_INT_VALUE;
    }
    return capacity;
}

BatteryChargeState BatterySrvClient::GetChargingStatus()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryChargeState::CHARGE_STATE_BUTT);
    uint32_t chargeState = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_BUTT);
    auto ret = proxy->GetChargingStatus(chargeState);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetChargingStatus ret = %{public}d", ret);
        return BatteryChargeState::CHARGE_STATE_BUTT;
    }
    return static_cast<BatteryChargeState>(chargeState);
}

BatteryHealthState BatterySrvClient::GetHealthStatus()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryHealthState::HEALTH_STATE_BUTT);
    uint32_t healthState = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_BUTT);
    auto ret = proxy->GetHealthStatus(healthState);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetHealthStatus ret = %{public}d", ret);
        return BatteryHealthState::HEALTH_STATE_BUTT;
    }
    return static_cast<BatteryHealthState>(healthState);
}

BatteryPluggedType BatterySrvClient::GetPluggedType()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryPluggedType::PLUGGED_TYPE_BUTT);
    uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_BUTT);
    auto ret = proxy->GetPluggedType(pluggedType);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetPluggedType ret = %{public}d", ret);
        return BatteryPluggedType::PLUGGED_TYPE_BUTT;
    }
    return static_cast<BatteryPluggedType>(pluggedType);
}

int32_t BatterySrvClient::GetVoltage()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
    int32_t voltage = INVALID_BATT_INT_VALUE;
    auto ret = proxy->GetVoltage(voltage);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetVoltage ret = %{public}d", ret);
        return INVALID_BATT_INT_VALUE;
    }
    return voltage;
}

bool BatterySrvClient::GetPresent()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_BOOL_VALUE);
    bool present = INVALID_BATT_BOOL_VALUE;
    auto ret = proxy->GetPresent(present);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetPresent ret = %{public}d", ret);
        return INVALID_BATT_BOOL_VALUE;
    }
    return present;
}

std::string BatterySrvClient::GetTechnology()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, "");
    std::string technology = INVALID_STRING_VALUE;
    auto ret = proxy->GetTechnology(technology);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetTechnology ret = %{public}d", ret);
        return INVALID_STRING_VALUE;
    }
    return technology;
}

int32_t BatterySrvClient::GetBatteryTemperature()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_TEMP_VALUE);
    int32_t temperature = INVALID_BATT_TEMP_VALUE;
    auto ret = proxy->GetBatteryTemperature(temperature);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetBatteryTemperature ret = %{public}d", ret);
        return INVALID_BATT_TEMP_VALUE;
    }
    return temperature;
}

int32_t BatterySrvClient::GetNowCurrent()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
    int32_t nowCurr = INVALID_BATT_INT_VALUE;
    auto ret = proxy->GetNowCurrent(nowCurr);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetNowCurrent ret = %{public}d", ret);
        return INVALID_BATT_INT_VALUE;
    }
    return nowCurr;
}

int32_t BatterySrvClient::GetRemainEnergy()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
    int32_t remainEnergy = INVALID_BATT_INT_VALUE;
    auto ret = proxy->GetRemainEnergy(remainEnergy);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetRemainEnergy ret = %{public}d", ret);
        return INVALID_BATT_INT_VALUE;
    }
    return remainEnergy;
}

int32_t BatterySrvClient::GetTotalEnergy()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
    int32_t totalEnergy = INVALID_BATT_INT_VALUE;
    auto ret = proxy->GetTotalEnergy(totalEnergy);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetTotalEnergy ret = %{public}d", ret);
        return INVALID_BATT_INT_VALUE;
    }
    return totalEnergy;
}

BatteryCapacityLevel BatterySrvClient::GetCapacityLevel()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryCapacityLevel::LEVEL_NONE);
    uint32_t batteryCapacityLevel = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
    auto ret = proxy->GetCapacityLevel(batteryCapacityLevel);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetCapacityLevel ret = %{public}d", ret);
        return BatteryCapacityLevel::LEVEL_NONE;
    }
    return static_cast<BatteryCapacityLevel>(batteryCapacityLevel);
}

int64_t BatterySrvClient::GetRemainingChargeTime()
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE);
    int64_t remainTime = INVALID_REMAINING_CHARGE_TIME_VALUE;
    auto ret = proxy->GetRemainingChargeTime(remainTime);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetRemainingChargeTime ret = %{public}d", ret);
        return INVALID_REMAINING_CHARGE_TIME_VALUE;
    }
    return remainTime;
}

BatteryError BatterySrvClient::SetBatteryConfig(const std::string& sceneName, const std::string& value)
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
    int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
    auto ret = proxy->SetBatteryConfig(sceneName, value, batteryErr);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "SetBatteryConfig ret = %{public}d", ret);
        return BatteryError::ERR_CONNECTION_FAIL;
    }
    return static_cast<BatteryError>(batteryErr);
}

BatteryError BatterySrvClient::GetBatteryConfig(const std::string& sceneName, std::string& result)
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
    int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
    auto ret = proxy->GetBatteryConfig(sceneName, result, batteryErr);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "GetBatteryConfig ret = %{public}d", ret);
        return BatteryError::ERR_CONNECTION_FAIL;
    }
    return static_cast<BatteryError>(batteryErr);
}

BatteryError BatterySrvClient::IsBatteryConfigSupported(const std::string& sceneName, bool& result)
{
    auto proxy = Connect();
    RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
    int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
    auto ret = proxy->IsBatteryConfigSupported(sceneName, result, batteryErr);
    if (ret != ERR_OK) {
        BATTERY_HILOGE(COMP_FWK, "IsBatteryConfigSupported ret = %{public}d", ret);
        return BatteryError::ERR_CONNECTION_FAIL;
    }
    return static_cast<BatteryError>(batteryErr);
}
}  // namespace PowerMgr
}  // namespace OHOS