1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "charger_state_collection.h"
17
18 #ifdef BATTERY_MANAGER_ENABLE
19 #include "battery_info.h"
20 #include "battery_srv_client.h"
21 #endif
22 #include "common_event_subscriber.h"
23 #include "common_event_data.h"
24 #include "common_event_manager.h"
25 #include "common_event_support.h"
26 #include "file_operation.h"
27 #include "securec.h"
28 #include "string_ex.h"
29 #include "string_operation.h"
30 #include "thermal_service.h"
31 #include "thermal_common.h"
32
33 using namespace OHOS::EventFwk;
34 namespace OHOS {
35 namespace PowerMgr {
36 namespace {
37 IdleState g_idleStateConfig {};
38 IdleState g_cachedIdleState {};
39 bool g_isChargeIdle = true;
40 const std::string CHARGER_ON = "1";
41 const std::string CHARGER_OFF = "0";
42 }
Init()43 bool ChargerStateCollection::Init()
44 {
45 auto tms = ThermalService::GetInstance();
46 g_idleStateConfig = tms->GetStateMachineObj()->GetIdleStateConfig();
47 if (!RegisterEvent()) {
48 return false;
49 }
50 return true;
51 }
52
InitParam(std::string & params)53 bool ChargerStateCollection::InitParam(std::string& params)
54 {
55 THERMAL_HILOGD(COMP_SVC, "Enter");
56 params_ = params;
57 return true;
58 }
59
GetState()60 std::string ChargerStateCollection::GetState()
61 {
62 THERMAL_HILOGD(COMP_SVC, "charger state = %{public}s", mockState_.c_str());
63 auto tms = ThermalService::GetInstance();
64 if (!tms->GetSimulationXml()) {
65 return mockState_;
66 } else {
67 return state_;
68 }
69 }
70
RegisterEvent()71 bool ChargerStateCollection::RegisterEvent()
72 {
73 auto tms = ThermalService::GetInstance();
74 if (tms == nullptr) {
75 return false;
76 }
77 auto receiver = tms->GetStateMachineObj()->GetCommonEventReceiver();
78 if (receiver == nullptr) {
79 return false;
80 }
81
82 #ifdef BATTERY_MANAGER_ENABLE
83 EventHandle batteryChangedHandler =
84 [this](const CommonEventData& data) { this->HandleChangerStatusCompleted(data); };
85 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED, batteryChangedHandler);
86 EventHandle batteryChangedInnerHandler =
87 [this](const CommonEventData& data) { this->HandleChangerInnerStatusCompleted(data); };
88 receiver->AddEvent(BatteryInfo::COMMON_EVENT_BATTERY_CHANGED_INNER, batteryChangedInnerHandler);
89 #endif
90 EventHandle thermalLevelHandler =
91 [this](const CommonEventData& data) { this->HandleThermalLevelCompleted(data); };
92 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_THERMAL_LEVEL_CHANGED, thermalLevelHandler);
93 return true;
94 }
95
96 #ifdef BATTERY_MANAGER_ENABLE
HandleChangerStatusCompleted(const CommonEventData & data)97 void ChargerStateCollection::HandleChangerStatusCompleted(const CommonEventData& data)
98 {
99 std::lock_guard<std::mutex> lock(mutex_);
100 g_cachedIdleState.soc = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_CAPACITY, -1);
101 int32_t chargeState = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE, -1);
102 if (g_cachedIdleState.charging != chargeState) {
103 g_cachedIdleState.charging = chargeState;
104 THERMAL_HILOGI(COMP_SVC, "received charge status event, state: %{public}d", g_cachedIdleState.charging);
105 }
106 HandleChargeIdleState();
107
108 switch (g_cachedIdleState.charging) {
109 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_DISABLE): {
110 state_ = ToString(DISABLE);
111 break;
112 }
113 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_ENABLE): {
114 state_ = ToString(ENABLE);
115 break;
116 }
117 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_FULL): {
118 state_ = ToString(FULL);
119 break;
120 }
121 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_NONE): {
122 state_ = ToString(NONE);
123 break;
124 }
125 case static_cast<int>(BatteryChargeState::CHARGE_STATE_BUTT): {
126 state_ = ToString(BUTT);
127 break;
128 }
129 default:
130 break;
131 }
132 }
133
HandleChangerInnerStatusCompleted(const CommonEventData & data)134 void ChargerStateCollection::HandleChangerInnerStatusCompleted(const CommonEventData& data)
135 {
136 std::lock_guard<std::mutex> lock(mutex_);
137 g_cachedIdleState.current = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_PLUGGED_NOW_CURRENT, -1);
138 HandleChargeIdleState();
139 }
140 #endif
141
SetState(const std::string & stateValue)142 void ChargerStateCollection::SetState(const std::string& stateValue)
143 {
144 }
145
DecideState(const std::string & value)146 bool ChargerStateCollection::DecideState(const std::string& value)
147 {
148 #ifdef BATTERY_MANAGER_ENABLE
149 THERMAL_HILOGD(COMP_SVC, "Enter");
150 auto& batterySrvClient = BatterySrvClient::GetInstance();
151 BatteryChargeState chargeState = batterySrvClient.GetChargingStatus();
152 if ((value == CHARGER_ON && chargeState == BatteryChargeState::CHARGE_STATE_ENABLE) ||
153 (value == CHARGER_OFF && chargeState != BatteryChargeState::CHARGE_STATE_ENABLE)) {
154 return true;
155 }
156 return false;
157 #endif
158 return true;
159 }
160
161 #ifdef BATTERY_MANAGER_ENABLE
HandleChargeIdleState()162 void ChargerStateCollection::HandleChargeIdleState()
163 {
164 bool isIdle = ((g_cachedIdleState.soc >= g_idleStateConfig.soc) &&
165 (g_cachedIdleState.charging == g_idleStateConfig.charging) &&
166 (g_cachedIdleState.current >= g_idleStateConfig.current) &&
167 (g_cachedIdleState.level <= g_idleStateConfig.level));
168 if (isIdle != g_isChargeIdle) {
169 THERMAL_HILOGI(COMP_SVC, "soc=%{public}d, charging==%{public}d, current==%{public}d, level==%{public}d",
170 g_cachedIdleState.soc, g_cachedIdleState.charging, g_cachedIdleState.current,
171 g_cachedIdleState.level);
172 THERMAL_HILOGI(COMP_SVC, "idle state changed, start to broadcast event");
173 PublishIdleEvent(isIdle, CommonEventSupport::COMMON_EVENT_CHARGE_IDLE_MODE_CHANGED);
174 g_isChargeIdle = isIdle;
175 }
176 }
177 #endif
178
PublishIdleEvent(bool isIdle,const std::string commonEventSupport)179 void ChargerStateCollection::PublishIdleEvent(bool isIdle, const std::string commonEventSupport)
180 {
181 Want want;
182 auto code = static_cast<uint32_t>(ChargeIdleEventCode::EVENT_CODE_CHARGE_IDLE_STATE);
183 want.SetParam(ToString(code), isIdle);
184 want.SetAction(commonEventSupport);
185 CommonEventData commonData;
186 commonData.SetWant(want);
187 CommonEventPublishInfo publishInfo;
188 publishInfo.SetOrdered(false);
189 if (!CommonEventManager::PublishCommonEvent(commonData, publishInfo)) {
190 THERMAL_HILOGW(COMP_SVC, "failed to publish charge idle event");
191 }
192 }
193
HandleThermalLevelCompleted(const CommonEventData & data)194 void ChargerStateCollection::HandleThermalLevelCompleted(const CommonEventData& data)
195 {
196 std::lock_guard<std::mutex> lock(mutex_);
197 std::string key = ToString(static_cast<int32_t>(ThermalCommonEventCode::CODE_THERMAL_LEVEL_CHANGED));
198 int32_t level = data.GetWant().GetIntParam(key, -1);
199 g_cachedIdleState.level =level;
200 #ifdef BATTERY_MANAGER_ENABLE
201 HandleChargeIdleState();
202 #endif
203 }
204 } // namespace PowerMgr
205 } // namespace OHOS
206