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 std::shared_ptr<ChargerStateCollection> ChargerStateCollection::instance_ = nullptr;
37 std::mutex ChargerStateCollection::mutex_;
38 namespace {
39 IdleState g_idleStateConfig {};
40 IdleState g_cachedIdleState {};
41 bool g_isChargeIdle = true;
42 const std::string CHARGER_ON = "1";
43 const std::string CHARGER_OFF = "0";
44 }
Init()45 bool ChargerStateCollection::Init()
46 {
47 auto tms = ThermalService::GetInstance();
48 g_idleStateConfig = tms->GetStateMachineObj()->GetIdleStateConfig();
49 if (!RegisterEvent()) {
50 return false;
51 }
52 #ifdef BATTERY_MANAGER_ENABLE
53 InitChargeState();
54 #endif
55 return true;
56 }
57
InitParam(std::string & params)58 bool ChargerStateCollection::InitParam(std::string& params)
59 {
60 THERMAL_HILOGD(COMP_SVC, "Enter");
61 params_ = params;
62 return true;
63 }
64
GetInstance()65 std::shared_ptr<ChargerStateCollection> ChargerStateCollection::GetInstance()
66 {
67 if (instance_ == nullptr) {
68 std::lock_guard<std::mutex> lock(mutex_);
69 if (instance_ == nullptr) {
70 instance_ = std::make_shared<ChargerStateCollection>();
71 }
72 }
73 return instance_;
74 }
75
GetCharge()76 bool ChargerStateCollection::GetCharge()
77 {
78 return isCharge_;
79 }
80
SetCharge(bool charge)81 void ChargerStateCollection::SetCharge(bool charge)
82 {
83 isCharge_ = charge;
84 }
85
86 #ifdef BATTERY_MANAGER_ENABLE
InitChargeState()87 void ChargerStateCollection::InitChargeState()
88 {
89 auto& batterySrvClient = BatterySrvClient::GetInstance();
90 BatteryChargeState chargeState = batterySrvClient.GetChargingStatus();
91 isCharge_ = (chargeState == BatteryChargeState::CHARGE_STATE_ENABLE);
92 THERMAL_HILOGI(COMP_SVC, "ChargerStateCollection init charging state = %{public}d", isCharge_);
93 }
94 #endif
95
GetState()96 std::string ChargerStateCollection::GetState()
97 {
98 THERMAL_HILOGD(COMP_SVC, "charger state = %{public}s", mockState_.c_str());
99 auto tms = ThermalService::GetInstance();
100 if (!tms->GetSimulationXml()) {
101 return mockState_;
102 } else {
103 return state_;
104 }
105 }
106
RegisterEvent()107 bool ChargerStateCollection::RegisterEvent()
108 {
109 auto tms = ThermalService::GetInstance();
110 if (tms == nullptr) {
111 return false;
112 }
113 auto receiver = tms->GetStateMachineObj()->GetCommonEventReceiver();
114 if (receiver == nullptr) {
115 return false;
116 }
117
118 #ifdef BATTERY_MANAGER_ENABLE
119 EventHandle batteryChangedHandler =
120 [this](const CommonEventData& data) { this->HandleChangerStatusCompleted(data); };
121 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED, batteryChangedHandler);
122 EventHandle batteryChangedInnerHandler =
123 [this](const CommonEventData& data) { this->HandleChangerInnerStatusCompleted(data); };
124 receiver->AddEvent(BatteryInfo::COMMON_EVENT_BATTERY_CHANGED_INNER, batteryChangedInnerHandler);
125 #endif
126 EventHandle thermalLevelHandler =
127 [this](const CommonEventData& data) { this->HandleThermalLevelCompleted(data); };
128 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_THERMAL_LEVEL_CHANGED, thermalLevelHandler);
129 return true;
130 }
131
132 #ifdef BATTERY_MANAGER_ENABLE
HandleChangerStatusCompleted(const CommonEventData & data)133 void ChargerStateCollection::HandleChangerStatusCompleted(const CommonEventData& data)
134 {
135 std::lock_guard<std::mutex> lock(mutex_);
136 g_cachedIdleState.soc = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_CAPACITY, -1);
137 int32_t chargeState = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE, -1);
138 if (g_cachedIdleState.charging != chargeState) {
139 g_cachedIdleState.charging = chargeState;
140 THERMAL_HILOGI(COMP_SVC, "received charge status event, state: %{public}d", g_cachedIdleState.charging);
141 }
142 HandleChargeIdleState();
143
144 switch (g_cachedIdleState.charging) {
145 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_DISABLE): {
146 state_ = ToString(DISABLE);
147 break;
148 }
149 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_ENABLE): {
150 state_ = ToString(ENABLE);
151 break;
152 }
153 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_FULL): {
154 state_ = ToString(FULL);
155 break;
156 }
157 case static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_NONE): {
158 state_ = ToString(NONE);
159 break;
160 }
161 case static_cast<int>(BatteryChargeState::CHARGE_STATE_BUTT): {
162 state_ = ToString(BUTT);
163 break;
164 }
165 default:
166 break;
167 }
168 }
169
HandleChangerInnerStatusCompleted(const CommonEventData & data)170 void ChargerStateCollection::HandleChangerInnerStatusCompleted(const CommonEventData& data)
171 {
172 std::lock_guard<std::mutex> lock(mutex_);
173 g_cachedIdleState.current = data.GetWant().GetIntParam(BatteryInfo::COMMON_EVENT_KEY_PLUGGED_NOW_CURRENT, -1);
174 HandleChargeIdleState();
175 }
176 #endif
177
SetState(const std::string & stateValue)178 void ChargerStateCollection::SetState(const std::string& stateValue)
179 {
180 }
181
DecideState(const std::string & value)182 bool ChargerStateCollection::DecideState(const std::string& value)
183 {
184 #ifdef BATTERY_MANAGER_ENABLE
185 THERMAL_HILOGD(COMP_SVC, "ChargerStateCollection Enter %{public}d", isCharge_);
186 if ((!isCharge_ && value == CHARGER_OFF)||(isCharge_ && value == CHARGER_ON)) {
187 return true;
188 }
189 return false;
190 #endif
191 return true;
192 }
193
194 #ifdef BATTERY_MANAGER_ENABLE
HandleChargeIdleState()195 void ChargerStateCollection::HandleChargeIdleState()
196 {
197 bool isIdle = ((g_cachedIdleState.soc >= g_idleStateConfig.soc) &&
198 (g_cachedIdleState.charging == g_idleStateConfig.charging) &&
199 (g_cachedIdleState.current >= g_idleStateConfig.current) &&
200 (g_cachedIdleState.level <= g_idleStateConfig.level));
201 if (isIdle != g_isChargeIdle) {
202 THERMAL_HILOGI(COMP_SVC, "soc=%{public}d, charging==%{public}d, current==%{public}d, level==%{public}d",
203 g_cachedIdleState.soc, g_cachedIdleState.charging, g_cachedIdleState.current,
204 g_cachedIdleState.level);
205 THERMAL_HILOGI(COMP_SVC, "idle state changed, start to broadcast event");
206 PublishIdleEvent(isIdle, CommonEventSupport::COMMON_EVENT_CHARGE_IDLE_MODE_CHANGED);
207 g_isChargeIdle = isIdle;
208 }
209 }
210 #endif
211
PublishIdleEvent(bool isIdle,const std::string commonEventSupport)212 void ChargerStateCollection::PublishIdleEvent(bool isIdle, const std::string commonEventSupport)
213 {
214 Want want;
215 auto code = static_cast<uint32_t>(ChargeIdleEventCode::EVENT_CODE_CHARGE_IDLE_STATE);
216 want.SetParam(ToString(code), isIdle);
217 want.SetAction(commonEventSupport);
218 CommonEventData commonData;
219 commonData.SetWant(want);
220 CommonEventPublishInfo publishInfo;
221 publishInfo.SetOrdered(false);
222 if (!CommonEventManager::PublishCommonEvent(commonData, publishInfo)) {
223 THERMAL_HILOGW(COMP_SVC, "failed to publish charge idle event");
224 }
225 }
226
HandleThermalLevelCompleted(const CommonEventData & data)227 void ChargerStateCollection::HandleThermalLevelCompleted(const CommonEventData& data)
228 {
229 std::lock_guard<std::mutex> lock(mutex_);
230 std::string key = ToString(static_cast<int32_t>(ThermalCommonEventCode::CODE_THERMAL_LEVEL_CHANGED));
231 int32_t level = data.GetWant().GetIntParam(key, -1);
232 g_cachedIdleState.level =level;
233 #ifdef BATTERY_MANAGER_ENABLE
234 HandleChargeIdleState();
235 #endif
236 }
237 } // namespace PowerMgr
238 } // namespace OHOS
239