1 /*
2 * Copyright (c) 2021 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 "power_mode_module.h"
17
18 #include "hilog_wrapper.h"
19
20 #include "display_power_mgr_client.h"
21 #include "power_common.h"
22 #include "power_mode_policy.h"
23 #include "power_mgr_service.h"
24 #include "power_save_mode.h"
25 #include "power_state_machine.h"
26
27 #include "singleton.h"
28
29 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::AAFwk;
32 using namespace OHOS::EventFwk;
33 using namespace OHOS::DisplayPowerMgr;
34
35 namespace OHOS {
36 namespace PowerMgr {
PowerModeModule()37 PowerModeModule::PowerModeModule()
38 : mode_(NORMAL_MODE), lastMode_(LAST_MODE_FLAG), started_(false)
39 {
40 POWER_HILOGI(MODULE_SERVICE, "PowerModeModule create");
41 callbackMgr_ = new CallbackManager();
42 auto policy = DelayedSingleton<PowerModePolicy>::GetInstance();
43 policy->AddAction(PowerModePolicy::ServiceType::DISPLAY_OFFTIME,
44 std::bind(&PowerModeModule::SetDisplayOffTime, this));
45 policy->AddAction(PowerModePolicy::ServiceType::SLEEPTIME,
46 std::bind(&PowerModeModule::SetSleepTime, this));
47 policy->AddAction(PowerModePolicy::ServiceType::AUTO_ADJUST_BRIGHTNESS,
48 std::bind(&PowerModeModule::SetAutoAdjustBrightness, this));
49 policy->AddAction(PowerModePolicy::ServiceType::SMART_BACKLIGHT,
50 std::bind(&PowerModeModule::SetLcdBrightness, this));
51 policy->AddAction(PowerModePolicy::ServiceType::VIBRATORS_STATE,
52 std::bind(&PowerModeModule::SetVibration, this));
53 policy->AddAction(PowerModePolicy::ServiceType::AUTO_WINDOWN_RORATION,
54 std::bind(&PowerModeModule::OnOffRotation, this));
55 }
56
SetModeItem(uint32_t mode)57 void PowerModeModule::SetModeItem(uint32_t mode)
58 {
59 POWER_HILOGD(MODULE_SERVICE, "Set Mode Item : %{public}u", mode);
60
61 /* Same as the previous mode */
62 if (this->mode_ == mode) {
63 return;
64 }
65
66 /* If it's a valid mode */
67 if (mode < POWER_MODE_MIN || mode > POWER_MODE_MAX) {
68 POWER_HILOGE(MODULE_SERVICE, "Unknow mode %{public}d", mode);
69 return;
70 }
71
72 /* start set mode thread */
73 EnableMode(mode);
74 }
75
GetModeItem()76 uint32_t PowerModeModule::GetModeItem()
77 {
78 POWER_HILOGD(MODULE_SERVICE, "Get Mode Item : %{public}u", mode_);
79 /* get power mode */
80 return mode_;
81 }
82
EnableMode(uint32_t mode)83 void PowerModeModule::EnableMode(uint32_t mode)
84 {
85 if (started_) {
86 POWER_HILOGE(MODULE_SERVICE, "Power Mode is already running.");
87 return;
88 }
89
90 started_ = true;
91 mode_ = mode;
92
93 /* Update power mode policy */
94 UpdateModepolicy();
95
96 /* Send state change */
97 Prepare();
98
99 /* Set action */
100 RunAction();
101
102 this->lastMode_ = mode;
103 started_ = false;
104 }
105
UpdateModepolicy()106 void PowerModeModule::UpdateModepolicy()
107 {
108 /* update policy */
109 DelayedSingleton<PowerModePolicy>::GetInstance()->SetPowerModePolicy(this->mode_, this->lastMode_);
110 }
111
AddPowerModeCallback(const sptr<IPowerModeCallback> & callback)112 void PowerModeModule::AddPowerModeCallback(const sptr<IPowerModeCallback>& callback)
113 {
114 if (callbackMgr_) {
115 callbackMgr_->AddCallback(callback);
116 }
117 }
118
DelPowerModeCallback(const sptr<IPowerModeCallback> & callback)119 void PowerModeModule::DelPowerModeCallback(const sptr<IPowerModeCallback>& callback)
120 {
121 if (callbackMgr_) {
122 callbackMgr_->RemoveCallback(callback);
123 }
124 }
125
Prepare()126 void PowerModeModule::Prepare()
127 {
128 PublishPowerModeEvent();
129 if (callbackMgr_) {
130 callbackMgr_->WaitingCallback();
131 }
132 }
133
AddCallback(const sptr<IPowerModeCallback> & callback)134 void PowerModeModule::CallbackManager::AddCallback(const sptr<IPowerModeCallback>& callback)
135 {
136 unique_lock<mutex> lock(mutex_);
137 RETURN_IF((callback == nullptr) || (callback->AsObject() == nullptr));
138 auto object = callback->AsObject();
139 auto retIt = callbacks_.insert(object);
140 if (retIt.second) {
141 object->AddDeathRecipient(this);
142 }
143 POWER_HILOGI(MODULE_SERVICE, "object = %{public}p, callback = %{public}p, callbacks.size = %{public}zu,"
144 " insertOk = %{public}d", object.GetRefPtr(),
145 callback.GetRefPtr(), callbacks_.size(), retIt.second);
146 }
147
RemoveCallback(const sptr<IPowerModeCallback> & callback)148 void PowerModeModule::CallbackManager::RemoveCallback(const sptr<IPowerModeCallback>& callback)
149 {
150 unique_lock<mutex> lock(mutex_);
151 RETURN_IF((callback == nullptr) || (callback->AsObject() == nullptr));
152 auto object = callback->AsObject();
153 auto it = find(callbacks_.begin(), callbacks_.end(), object);
154 if (it != callbacks_.end()) {
155 callbacks_.erase(it);
156 object->RemoveDeathRecipient(this);
157 }
158 POWER_HILOGI(MODULE_SERVICE, "object = %{public}p, callback = %{public}p, callbacks.size = %{public}zu,",
159 object.GetRefPtr(), callback.GetRefPtr(), callbacks_.size());
160 }
161
OnRemoteDied(const wptr<IRemoteObject> & remote)162 void PowerModeModule::CallbackManager::OnRemoteDied(const wptr<IRemoteObject>& remote)
163 {
164 POWER_HILOGI(MODULE_SERVICE, "OnRemoteDied");
165 RETURN_IF(remote.promote() == nullptr);
166 RemoveCallback(iface_cast<IPowerModeCallback>(remote.promote()));
167 }
168
WaitingCallback()169 void PowerModeModule::CallbackManager::WaitingCallback()
170 {
171 POWER_HILOGD(MODULE_SERVICE, "mode callback started.");
172 unique_lock<mutex> lock(mutex_);
173 for (auto &obj : callbacks_) {
174 sptr<IPowerModeCallback> callback = iface_cast<IPowerModeCallback>(obj);
175 if (callback != nullptr) {
176 POWER_HILOGD(MODULE_SERVICE, "callback->PowerModeCallback()");
177 callback->PowerModeCallback();
178 }
179 }
180 }
181
PublishPowerModeEvent()182 void PowerModeModule::PublishPowerModeEvent()
183 {
184 POWER_HILOGD(MODULE_SERVICE, "Start of publishing mode event");
185 /* send event */
186 CommonEventPublishInfo publishInfo;
187 publishInfo.SetOrdered(false);
188 IntentWant setModeWant;
189 CommonEventData event(setModeWant);
190 switch (mode_) {
191 case PowerModeModule::EXTREME_MODE:
192 setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED);
193 event.SetCode(PowerModeModule::EXTREME_MODE);
194 break;
195 case PowerModeModule::NORMAL_MODE:
196 setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED);
197 event.SetCode(PowerModeModule::NORMAL_MODE);
198 break;
199 case PowerModeModule::SAVE_MODE:
200 setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED);
201 event.SetCode(PowerModeModule::SAVE_MODE);
202 break;
203 case PowerModeModule::LOWPOWER_MODE:
204 setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED);
205 event.SetCode(PowerModeModule::LOWPOWER_MODE);
206 break;
207 default:
208 POWER_HILOGE(MODULE_SERVICE, "Unknow mode");
209 return;
210 }
211 if (!CommonEventManager::PublishCommonEvent(event, publishInfo, nullptr)) {
212 POWER_HILOGE(MODULE_SERVICE, "Failed to publish the mode event!");
213 return;
214 }
215 POWER_HILOGD(MODULE_SERVICE, "End of publishing mode event");
216 }
217
RunAction()218 void PowerModeModule::RunAction()
219 {
220 POWER_HILOGI(MODULE_SERVICE, "PowerModeModule::RunAction");
221 auto policy = DelayedSingleton<PowerModePolicy>::GetInstance();
222 policy->TriggerAllActions();
223 return;
224 }
225
SetDisplayOffTime()226 void PowerModeModule::SetDisplayOffTime()
227 {
228 POWER_HILOGI(MODULE_SERVICE, "PowerModeModule::SetDisplayOffTime");
229 int32_t time = DelayedSingleton<PowerModePolicy>::GetInstance()
230 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::DISPLAY_OFFTIME);
231 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
232 if (pms == nullptr) {
233 POWER_HILOGI(MODULE_SERVICE, "No service instance");
234 return;
235 }
236 pms->GetPowerStateMachine()->SetDisplayOffTime(static_cast<int64_t>(time));
237 }
238
SetSleepTime()239 void PowerModeModule::SetSleepTime()
240 {
241 POWER_HILOGI(MODULE_SERVICE, "PowerModeModule::SetSleepTime");
242 int32_t time = DelayedSingleton<PowerModePolicy>::GetInstance()
243 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::SLEEPTIME);
244 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
245 if (pms == nullptr) {
246 POWER_HILOGI(MODULE_SERVICE, "No service instance");
247 return;
248 }
249 pms->GetPowerStateMachine()->SetSleepTime(static_cast<int64_t>(time));
250 }
251
SetAutoAdjustBrightness()252 void PowerModeModule::SetAutoAdjustBrightness()
253 {
254 POWER_HILOGI(MODULE_SERVICE, "PowerModeModule::SetAutoAdjustBrightness");
255 bool enable = false;
256 int32_t value = DelayedSingleton<PowerModePolicy>::GetInstance()
257 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::AUTO_ADJUST_BRIGHTNESS);
258 if (value != FLAG_FALSE) {
259 enable = true;
260 }
261 bool ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(enable);
262 POWER_HILOGI(MODULE_SERVICE, "SetAutoAdjustBrightness: %{public}d, result=%{public}d", enable, ret);
263 }
264
SetLcdBrightness()265 void PowerModeModule::SetLcdBrightness()
266 {
267 POWER_HILOGD(MODULE_SERVICE, "set lcd brightness");
268 int32_t lcdBrightness = DelayedSingleton<PowerModePolicy>::GetInstance()
269 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::SMART_BACKLIGHT);
270 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy lcdBrightness=%{public}d", lcdBrightness);
271 if (lcdBrightness != FLAG_FALSE) {
272 // set lastmode value to recoverValue
273 if (lastMode_ == LAST_MODE_FLAG) {
274 POWER_HILOGD(MODULE_SERVICE, "first set lcdBrightness=%{public}d", lcdBrightness);
275 recoverValue[PowerModePolicy::ServiceType::SMART_BACKLIGHT] = lcdBrightness;
276 } else {
277 // get value from setting privider value
278 POWER_HILOGD(MODULE_SERVICE, "Setting lcdBrightness=%{public}d", SETTINGS_PRIVIDER_VALUE_LCD_BRIGHTNESS);
279 recoverValue[PowerModePolicy::ServiceType::SMART_BACKLIGHT] = SETTINGS_PRIVIDER_VALUE_LCD_BRIGHTNESS;
280 }
281 // set lcd brightness
282 int32_t dispId = DisplayPowerMgrClient::GetInstance().GetMainDisplayId();
283 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(static_cast<uint32_t>(lcdBrightness), dispId);
284 POWER_HILOGI(MODULE_SERVICE, "SetBrightness: %{public}d, result=%{public}d", lcdBrightness, ret);
285 } else {
286 lcdBrightness = DelayedSingleton<PowerModePolicy>::GetInstance()
287 ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::SMART_BACKLIGHT);
288 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy lcdBrightness=%{public}d", lcdBrightness);
289 if (lcdBrightness != FLAG_FALSE) {
290 // get recoverValue
291 std::lock_guard<std::mutex> lock(mutex_);
292 recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::SMART_BACKLIGHT);
293 if (recoverValueiter != recoverValue.end()) {
294 lcdBrightness = recoverValueiter->second;
295 POWER_HILOGD(MODULE_SERVICE, "Get recovervalue lcdBrightness=%{public}d", lcdBrightness);
296 // delete map
297 recoverValue.erase(recoverValueiter);
298 }
299 POWER_HILOGD(MODULE_SERVICE, "please set lcdBrightness");
300 }
301 }
302 return;
303 }
304
SetVibration()305 void PowerModeModule::SetVibration()
306 {
307 POWER_HILOGD(MODULE_SERVICE, "set vibration");
308 int32_t vibration = DelayedSingleton<PowerModePolicy>::GetInstance()
309 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::VIBRATORS_STATE);
310 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy vibrate=%{public}d", vibration);
311 if (vibration != FLAG_FALSE) {
312 // set lastmode value to recoverValue
313 if (lastMode_ == LAST_MODE_FLAG) {
314 POWER_HILOGD(MODULE_SERVICE, "first set vibration=%{public}d", vibration);
315 recoverValue[PowerModePolicy::ServiceType::VIBRATORS_STATE] = vibration;
316 } else {
317 // get value from setting privider value
318 POWER_HILOGD(MODULE_SERVICE, "Setting vibration=%{public}d", SETTINGS_PRIVIDER_VALUE_VIBRATION);
319 recoverValue[PowerModePolicy::ServiceType::VIBRATORS_STATE] = SETTINGS_PRIVIDER_VALUE_VIBRATION;
320 }
321 // set vibration
322 POWER_HILOGD(MODULE_SERVICE, "please set vibration");
323 } else {
324 vibration = DelayedSingleton<PowerModePolicy>::GetInstance()
325 ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::VIBRATORS_STATE);
326 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy vibration=%{public}d", vibration);
327 if (vibration != FLAG_FALSE) {
328 // get recoverValue
329 std::lock_guard<std::mutex> lock(mutex_);
330 recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::VIBRATORS_STATE);
331 if (recoverValueiter != recoverValue.end()) {
332 vibration = recoverValueiter->second;
333 POWER_HILOGD(MODULE_SERVICE, "Get recovervalue vibration=%{public}d", vibration);
334 // delete map
335 recoverValue.erase(recoverValueiter);
336 }
337 POWER_HILOGD(MODULE_SERVICE, "please set vibration");
338 }
339 }
340 return;
341 }
342
OnOffRotation()343 void PowerModeModule::OnOffRotation()
344 {
345 POWER_HILOGD(MODULE_SERVICE, "on or off rotation");
346 int32_t rotation = DelayedSingleton<PowerModePolicy>::GetInstance()
347 ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::AUTO_WINDOWN_RORATION);
348 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy rotation=%{public}d", rotation);
349 if (rotation != FLAG_FALSE) {
350 // set lastmode value to recoverValue
351 if (lastMode_ == LAST_MODE_FLAG) {
352 POWER_HILOGD(MODULE_SERVICE, "first set rotation=%{public}d", rotation);
353 recoverValue[PowerModePolicy::ServiceType::AUTO_WINDOWN_RORATION] = rotation;
354 } else {
355 // get value from setting privider value
356 POWER_HILOGD(MODULE_SERVICE, "Setting rotation=%{public}d", SETTINGS_PRIVIDER_VALUE_ROTATION);
357 recoverValue[PowerModePolicy::ServiceType::AUTO_WINDOWN_RORATION] = SETTINGS_PRIVIDER_VALUE_ROTATION;
358 }
359 // set lcd vibrate
360 POWER_HILOGD(MODULE_SERVICE, "please on or off rotation");
361 } else {
362 rotation = DelayedSingleton<PowerModePolicy>::GetInstance()
363 ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::AUTO_WINDOWN_RORATION);
364 POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy rotation=%{public}d", rotation);
365 if (rotation != FLAG_FALSE) {
366 // get recoverValue
367 std::lock_guard<std::mutex> lock(mutex_);
368 recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::VIBRATORS_STATE);
369 if (recoverValueiter != recoverValue.end()) {
370 rotation = recoverValueiter->second;
371 POWER_HILOGD(MODULE_SERVICE, "Get recovervalue rotation=%{public}d", rotation);
372 // delete map
373 recoverValue.erase(recoverValueiter);
374 }
375 POWER_HILOGD(MODULE_SERVICE, "please on or off rotation");
376 }
377 }
378 return;
379 }
380 } // namespace PowerMgr
381 } // namespace OHOS
382