1 /*
2 * Copyright (c) 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 "setting_helper.h"
17
18 #include "power_log.h"
19 #include "power_utils.h"
20 #include <cinttypes>
21 #include <system_ability_definition.h>
22
23 namespace OHOS {
24 namespace PowerMgr {
25 namespace {
26 constexpr int32_t WAKEUP_SOURCE_OPEN = 1;
27 constexpr int32_t WAKEUP_SOURCE_CLOSE = 0;
28 }
29 sptr<SettingObserver> SettingHelper::doubleClickObserver_ = nullptr;
30 sptr<SettingObserver> SettingHelper::pickUpObserver_ = nullptr;
31 sptr<SettingObserver> SettingHelper::powerModeObserver_ = nullptr;
32 sptr<SettingObserver> SettingHelper::lidObserver_ = nullptr;
33
UpdateCurrentUserId()34 void SettingHelper::UpdateCurrentUserId()
35 {
36 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
37 settingProvider.UpdateCurrentUserId();
38 }
39 #ifdef POWER_WAKEUPDOUBLE_OR_PICKUP_ENABLE
CopyDataForUpdateScene()40 void SettingHelper::CopyDataForUpdateScene()
41 {
42 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
43 settingProvider.CopyDataForUpdateScene();
44 }
45 #endif
46
IsSettingKeyValid(const std::string & key)47 bool SettingHelper::IsSettingKeyValid(const std::string& key)
48 {
49 return SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID).IsValidKey(key);
50 }
51
GetSettingIntValue(const std::string & key,int32_t defaultVal)52 int32_t SettingHelper::GetSettingIntValue(const std::string& key, int32_t defaultVal)
53 {
54 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
55 int32_t value = defaultVal;
56 ErrCode ret = settingProvider.GetIntValue(key, value);
57 if (ret != ERR_OK) {
58 POWER_HILOGW(COMP_UTILS, "get setting key=%{public}s failed, ret=%{public}d", key.c_str(), ret);
59 }
60 return value;
61 }
62
SetSettingIntValue(const std::string & key,int32_t value)63 void SettingHelper::SetSettingIntValue(const std::string& key, int32_t value)
64 {
65 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
66 ErrCode ret = settingProvider.PutIntValue(key, value);
67 if (ret != ERR_OK) {
68 POWER_HILOGW(COMP_UTILS,
69 "set setting key=%{public}s value=%{public}d failed, ret=%{public}d",
70 key.c_str(), value, ret);
71 }
72 }
73
GetSettingLongValue(const std::string & key,int64_t defaultVal)74 int64_t SettingHelper::GetSettingLongValue(const std::string& key, int64_t defaultVal)
75 {
76 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
77 int64_t value = defaultVal;
78 ErrCode ret = settingProvider.GetLongValue(key, value);
79 if (ret != ERR_OK) {
80 POWER_HILOGW(COMP_UTILS, "get setting key=%{public}s failed, ret=%{public}d", key.c_str(), ret);
81 }
82 return value;
83 }
84
SetSettingLongValue(const std::string & key,int64_t value)85 void SettingHelper::SetSettingLongValue(const std::string& key, int64_t value)
86 {
87 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
88 ErrCode ret = settingProvider.PutLongValue(key, value);
89 if (ret != ERR_OK) {
90 POWER_HILOGW(COMP_UTILS,
91 "set setting key=%{public}s value=%{public}" PRId64 " failed, ret=%{public}d",
92 key.c_str(), value, ret);
93 }
94 }
95
GetSettingStringValue(const std::string & key)96 const std::string SettingHelper::GetSettingStringValue(const std::string& key)
97 {
98 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
99 std::string value;
100 ErrCode ret = settingProvider.GetStringValue(key, value);
101 if (ret != ERR_OK) {
102 POWER_HILOGW(COMP_UTILS, "get setting key=%{public}s failed, ret=%{public}d", key.c_str(), ret);
103 }
104 return value;
105 }
106
SetSettingJsonStringValue(const std::string & key,const std::string & jsonConfig)107 void SettingHelper::SetSettingJsonStringValue(const std::string& key, const std::string& jsonConfig)
108 {
109 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
110 ErrCode ret = settingProvider.PutStringValue(key, jsonConfig);
111 if (ret != ERR_OK) {
112 POWER_HILOGW(COMP_UTILS,
113 "set setting key=%{public}s failed, jsonConfig=%{public}s, ret=%{public}d",
114 key.c_str(), PowerUtils::JsonToSimpleStr(jsonConfig).c_str(), ret);
115 }
116 }
117
RegisterSettingKeyObserver(const std::string & key,SettingObserver::UpdateFunc & func)118 sptr<SettingObserver> SettingHelper::RegisterSettingKeyObserver(
119 const std::string& key, SettingObserver::UpdateFunc& func)
120 {
121 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
122 auto settingObserver = settingProvider.CreateObserver(key, func);
123 ErrCode ret = settingProvider.RegisterObserver(settingObserver);
124 if (ret != ERR_OK) {
125 POWER_HILOGW(COMP_UTILS, "register setting key=%{public}s observer failed, ret=%{public}d",
126 key.c_str(), ret);
127 return nullptr;
128 }
129 return settingObserver;
130 }
131
UnregisterSettingObserver(sptr<SettingObserver> & observer)132 void SettingHelper::UnregisterSettingObserver(sptr<SettingObserver>& observer)
133 {
134 if (observer == nullptr) {
135 return;
136 }
137 SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID).UnregisterObserver(observer);
138 }
139
IsWakeupPickupSettingValid()140 bool SettingHelper::IsWakeupPickupSettingValid()
141 {
142 return IsSettingKeyValid(SETTING_POWER_WAKEUP_PICKUP_KEY);
143 }
144
GetSettingWakeupPickup(const std::string & key)145 bool SettingHelper::GetSettingWakeupPickup(const std::string& key)
146 {
147 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
148 int32_t value = 0;
149 ErrCode ret = settingProvider.GetIntValue(key, value);
150 if (ret != ERR_OK) {
151 POWER_HILOGE(COMP_UTILS, "get setting power wakeup pickup key failed, ret=%{public}d", ret);
152 }
153 return (value == WAKEUP_SOURCE_OPEN);
154 }
155
SetSettingWakeupPickup(bool enable)156 void SettingHelper::SetSettingWakeupPickup(bool enable)
157 {
158 POWER_HILOGI(COMP_UTILS, "SetSettingWakeupPickup switch, enable=%{public}d", enable);
159 int32_t value = enable ? WAKEUP_SOURCE_OPEN : WAKEUP_SOURCE_CLOSE;
160 SetSettingIntValue(SETTING_POWER_WAKEUP_PICKUP_KEY, value);
161 }
162
RegisterSettingWakeupPickupObserver(SettingObserver::UpdateFunc & func)163 void SettingHelper::RegisterSettingWakeupPickupObserver(SettingObserver::UpdateFunc& func)
164 {
165 if (pickUpObserver_) {
166 POWER_HILOGI(COMP_UTILS, "setting wakeup pickup observer is already registered");
167 return;
168 }
169 pickUpObserver_ = RegisterSettingKeyObserver(SETTING_POWER_WAKEUP_PICKUP_KEY, func);
170 }
171
UnregisterSettingWakeupPickupObserver()172 void SettingHelper::UnregisterSettingWakeupPickupObserver()
173 {
174 if (!pickUpObserver_) {
175 POWER_HILOGI(COMP_UTILS, "pickUpObserver_ is nullptr, no need to unregister");
176 return;
177 }
178 UnregisterSettingObserver(pickUpObserver_);
179 pickUpObserver_ = nullptr;
180 }
181
182 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
IsDisplayOffTimeSettingValid()183 bool SettingHelper::IsDisplayOffTimeSettingValid()
184 {
185 return IsSettingKeyValid(SETTING_DISPLAY_AC_OFF_TIME_KEY) &&
186 IsSettingKeyValid(SETTING_DISPLAY_DC_OFF_TIME_KEY);
187 }
188
IsSettingDisplayAcScreenOffTimeValid()189 bool SettingHelper::IsSettingDisplayAcScreenOffTimeValid()
190 {
191 return IsSettingKeyValid(SETTING_DISPLAY_AC_OFF_TIME_KEY);
192 }
193
GetSettingDisplayAcScreenOffTime(int64_t defaultVal)194 int64_t SettingHelper::GetSettingDisplayAcScreenOffTime(int64_t defaultVal)
195 {
196 return GetSettingLongValue(SETTING_DISPLAY_AC_OFF_TIME_KEY, defaultVal);
197 }
198
SetSettingDisplayAcScreenOffTime(int64_t time)199 void SettingHelper::SetSettingDisplayAcScreenOffTime(int64_t time)
200 {
201 SetSettingLongValue(SETTING_DISPLAY_AC_OFF_TIME_KEY, time);
202 }
203
RegisterSettingDisplayAcScreenOffTimeObserver(SettingObserver::UpdateFunc & func)204 sptr<SettingObserver> SettingHelper::RegisterSettingDisplayAcScreenOffTimeObserver(SettingObserver::UpdateFunc& func)
205 {
206 return RegisterSettingKeyObserver(SETTING_DISPLAY_AC_OFF_TIME_KEY, func);
207 }
208
IsSettingDisplayDcScreenOffTimeValid()209 bool SettingHelper::IsSettingDisplayDcScreenOffTimeValid()
210 {
211 return IsSettingKeyValid(SETTING_DISPLAY_DC_OFF_TIME_KEY);
212 }
213
GetSettingDisplayDcScreenOffTime(int64_t defaultVal)214 int64_t SettingHelper::GetSettingDisplayDcScreenOffTime(int64_t defaultVal)
215 {
216 return GetSettingLongValue(SETTING_DISPLAY_DC_OFF_TIME_KEY, defaultVal);
217 }
218
SetSettingDisplayDcScreenOffTime(int64_t time)219 void SettingHelper::SetSettingDisplayDcScreenOffTime(int64_t time)
220 {
221 SetSettingLongValue(SETTING_DISPLAY_DC_OFF_TIME_KEY, time);
222 }
223
RegisterSettingDisplayDcScreenOffTimeObserver(SettingObserver::UpdateFunc & func)224 sptr<SettingObserver> SettingHelper::RegisterSettingDisplayDcScreenOffTimeObserver(SettingObserver::UpdateFunc& func)
225 {
226 return RegisterSettingKeyObserver(SETTING_DISPLAY_DC_OFF_TIME_KEY, func);
227 }
228 #else
IsDisplayOffTimeSettingValid()229 bool SettingHelper::IsDisplayOffTimeSettingValid()
230 {
231 return IsSettingKeyValid(SETTING_DISPLAY_OFF_TIME_KEY);
232 }
233
GetSettingDisplayOffTime(int64_t defaultVal)234 int64_t SettingHelper::GetSettingDisplayOffTime(int64_t defaultVal)
235 {
236 return GetSettingLongValue(SETTING_DISPLAY_OFF_TIME_KEY, defaultVal);
237 }
238
SetSettingDisplayOffTime(int64_t time)239 void SettingHelper::SetSettingDisplayOffTime(int64_t time)
240 {
241 SetSettingLongValue(SETTING_DISPLAY_OFF_TIME_KEY, time);
242 }
243
RegisterSettingDisplayOffTimeObserver(SettingObserver::UpdateFunc & func)244 sptr<SettingObserver> SettingHelper::RegisterSettingDisplayOffTimeObserver(SettingObserver::UpdateFunc& func)
245 {
246 return RegisterSettingKeyObserver(SETTING_DISPLAY_OFF_TIME_KEY, func);
247 }
248 #endif
249
IsAutoAdjustBrightnessSettingValid()250 bool SettingHelper::IsAutoAdjustBrightnessSettingValid()
251 {
252 return IsSettingKeyValid(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY);
253 }
254
GetSettingAutoAdjustBrightness(int32_t defaultVal)255 int32_t SettingHelper::GetSettingAutoAdjustBrightness(int32_t defaultVal)
256 {
257 return GetSettingIntValue(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY, defaultVal);
258 }
259
SetSettingAutoAdjustBrightness(SwitchStatus status)260 void SettingHelper::SetSettingAutoAdjustBrightness(SwitchStatus status)
261 {
262 SetSettingIntValue(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY, static_cast<int32_t>(status));
263 }
264
RegisterSettingAutoAdjustBrightnessObserver(SettingObserver::UpdateFunc & func)265 sptr<SettingObserver> SettingHelper::RegisterSettingAutoAdjustBrightnessObserver(SettingObserver::UpdateFunc& func)
266 {
267 return RegisterSettingKeyObserver(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY, func);
268 }
269
IsBrightnessSettingValid()270 bool SettingHelper::IsBrightnessSettingValid()
271 {
272 return IsSettingKeyValid(SETTING_BRIGHTNESS_KEY);
273 }
274
SetSettingBrightness(int32_t brightness)275 void SettingHelper::SetSettingBrightness(int32_t brightness)
276 {
277 SetSettingIntValue(SETTING_BRIGHTNESS_KEY, brightness);
278 }
279
IsVibrationSettingValid()280 bool SettingHelper::IsVibrationSettingValid()
281 {
282 return IsSettingKeyValid(SETTING_VIBRATION_KEY);
283 }
284
GetSettingVibration(int32_t defaultVal)285 int32_t SettingHelper::GetSettingVibration(int32_t defaultVal)
286 {
287 return GetSettingIntValue(SETTING_VIBRATION_KEY, defaultVal);
288 }
289
SetSettingVibration(SwitchStatus status)290 void SettingHelper::SetSettingVibration(SwitchStatus status)
291 {
292 SetSettingIntValue(SETTING_VIBRATION_KEY, static_cast<int32_t>(status));
293 }
294
RegisterSettingVibrationObserver(SettingObserver::UpdateFunc & func)295 sptr<SettingObserver> SettingHelper::RegisterSettingVibrationObserver(SettingObserver::UpdateFunc& func)
296 {
297 return RegisterSettingKeyObserver(SETTING_VIBRATION_KEY, func);
298 }
299
IsWindowRotationSettingValid()300 bool SettingHelper::IsWindowRotationSettingValid()
301 {
302 return IsSettingKeyValid(SETTING_WINDOW_ROTATION_KEY);
303 }
304
GetSettingWindowRotation(int32_t defaultVal)305 int32_t SettingHelper::GetSettingWindowRotation(int32_t defaultVal)
306 {
307 return GetSettingIntValue(SETTING_WINDOW_ROTATION_KEY, defaultVal);
308 }
309
SetSettingWindowRotation(SwitchStatus status)310 void SettingHelper::SetSettingWindowRotation(SwitchStatus status)
311 {
312 SetSettingIntValue(SETTING_WINDOW_ROTATION_KEY, static_cast<int32_t>(status));
313 }
314
RegisterSettingWindowRotationObserver(SettingObserver::UpdateFunc & func)315 sptr<SettingObserver> SettingHelper::RegisterSettingWindowRotationObserver(SettingObserver::UpdateFunc& func)
316 {
317 return RegisterSettingKeyObserver(SETTING_WINDOW_ROTATION_KEY, func);
318 }
319
IsIntellVoiceSettingValid()320 bool SettingHelper::IsIntellVoiceSettingValid()
321 {
322 return IsSettingKeyValid(SETTING_INTELL_VOICE_KEY);
323 }
324
GetSettingIntellVoice(int32_t defaultVal)325 int32_t SettingHelper::GetSettingIntellVoice(int32_t defaultVal)
326 {
327 return GetSettingIntValue(SETTING_INTELL_VOICE_KEY, defaultVal);
328 }
329
SetSettingIntellVoice(SwitchStatus status)330 void SettingHelper::SetSettingIntellVoice(SwitchStatus status)
331 {
332 SetSettingIntValue(SETTING_INTELL_VOICE_KEY, static_cast<int32_t>(status));
333 }
334
RegisterSettingIntellVoiceObserver(SettingObserver::UpdateFunc & func)335 sptr<SettingObserver> SettingHelper::RegisterSettingIntellVoiceObserver(SettingObserver::UpdateFunc& func)
336 {
337 return RegisterSettingKeyObserver(SETTING_INTELL_VOICE_KEY, func);
338 }
339
340 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
RegisterSettingAcSuspendSourcesObserver(SettingObserver::UpdateFunc & func)341 sptr<SettingObserver> SettingHelper::RegisterSettingAcSuspendSourcesObserver(SettingObserver::UpdateFunc& func)
342 {
343 return RegisterSettingKeyObserver(SETTING_POWER_AC_SUSPEND_SOURCES_KEY, func);
344 }
345
IsSuspendSourcesSettingValid()346 bool SettingHelper::IsSuspendSourcesSettingValid()
347 {
348 return IsSettingKeyValid(SETTING_POWER_AC_SUSPEND_SOURCES_KEY) &&
349 IsSettingKeyValid(SETTING_POWER_DC_SUSPEND_SOURCES_KEY);
350 }
351
IsSettingAcSuspendSourcesValid()352 bool SettingHelper::IsSettingAcSuspendSourcesValid()
353 {
354 return IsSettingKeyValid(SETTING_POWER_AC_SUSPEND_SOURCES_KEY);
355 }
356
GetSettingAcSuspendSources()357 const std::string SettingHelper::GetSettingAcSuspendSources()
358 {
359 return GetSettingStringValue(SETTING_POWER_AC_SUSPEND_SOURCES_KEY);
360 }
361
SetSettingAcSuspendSources(const std::string & jsonConfig)362 void SettingHelper::SetSettingAcSuspendSources(const std::string& jsonConfig)
363 {
364 SetSettingJsonStringValue(SETTING_POWER_AC_SUSPEND_SOURCES_KEY, jsonConfig);
365 }
366
RegisterSettingDcSuspendSourcesObserver(SettingObserver::UpdateFunc & func)367 sptr<SettingObserver> SettingHelper::RegisterSettingDcSuspendSourcesObserver(SettingObserver::UpdateFunc& func)
368 {
369 return RegisterSettingKeyObserver(SETTING_POWER_DC_SUSPEND_SOURCES_KEY, func);
370 }
371
IsSettingDcSuspendSourcesValid()372 bool SettingHelper::IsSettingDcSuspendSourcesValid()
373 {
374 return IsSettingKeyValid(SETTING_POWER_DC_SUSPEND_SOURCES_KEY);
375 }
376
GetSettingDcSuspendSources()377 const std::string SettingHelper::GetSettingDcSuspendSources()
378 {
379 return GetSettingStringValue(SETTING_POWER_DC_SUSPEND_SOURCES_KEY);
380 }
381
SetSettingDcSuspendSources(const std::string & jsonConfig)382 void SettingHelper::SetSettingDcSuspendSources(const std::string& jsonConfig)
383 {
384 SetSettingJsonStringValue(SETTING_POWER_DC_SUSPEND_SOURCES_KEY, jsonConfig);
385 }
386 #else
RegisterSettingSuspendSourcesObserver(SettingObserver::UpdateFunc & func)387 sptr<SettingObserver> SettingHelper::RegisterSettingSuspendSourcesObserver(SettingObserver::UpdateFunc& func)
388 {
389 return RegisterSettingKeyObserver(SETTING_POWER_SUSPEND_SOURCES_KEY, func);
390 }
391
IsSuspendSourcesSettingValid()392 bool SettingHelper::IsSuspendSourcesSettingValid()
393 {
394 return IsSettingKeyValid(SETTING_POWER_SUSPEND_SOURCES_KEY);
395 }
396
GetSettingSuspendSources()397 const std::string SettingHelper::GetSettingSuspendSources()
398 {
399 return GetSettingStringValue(SETTING_POWER_SUSPEND_SOURCES_KEY);
400 }
401
SetSettingSuspendSources(const std::string & jsonConfig)402 void SettingHelper::SetSettingSuspendSources(const std::string& jsonConfig)
403 {
404 SetSettingJsonStringValue(SETTING_POWER_SUSPEND_SOURCES_KEY, jsonConfig);
405 }
406 #endif
407
RegisterSettingWakeupSourcesObserver(SettingObserver::UpdateFunc & func)408 sptr<SettingObserver> SettingHelper::RegisterSettingWakeupSourcesObserver(SettingObserver::UpdateFunc& func)
409 {
410 return RegisterSettingKeyObserver(SETTING_POWER_WAKEUP_SOURCES_KEY, func);
411 }
412
IsWakeupSourcesSettingValid()413 bool SettingHelper::IsWakeupSourcesSettingValid()
414 {
415 return IsSettingKeyValid(SETTING_POWER_WAKEUP_SOURCES_KEY);
416 }
417
GetSettingWakeupSources()418 const std::string SettingHelper::GetSettingWakeupSources()
419 {
420 return GetSettingStringValue(SETTING_POWER_WAKEUP_SOURCES_KEY);
421 }
422
SetSettingWakeupSources(const std::string & jsonConfig)423 void SettingHelper::SetSettingWakeupSources(const std::string& jsonConfig)
424 {
425 SetSettingJsonStringValue(SETTING_POWER_WAKEUP_SOURCES_KEY, jsonConfig);
426 }
427
IsWakeupDoubleSettingValid()428 bool SettingHelper::IsWakeupDoubleSettingValid()
429 {
430 return IsSettingKeyValid(SETTING_POWER_WAKEUP_DOUBLE_KEY);
431 }
432
GetSettingWakeupDouble(const std::string & key)433 bool SettingHelper::GetSettingWakeupDouble(const std::string& key)
434 {
435 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
436 int32_t value;
437 ErrCode ret = settingProvider.GetIntValue(key, value);
438 if (ret != ERR_OK) {
439 POWER_HILOGE(COMP_UTILS, "get setting power Wakeup double key failed, ret=%{public}d", ret);
440 }
441 return (value == WAKEUP_SOURCE_OPEN);
442 }
443
SetSettingWakeupDouble(bool enable)444 void SettingHelper::SetSettingWakeupDouble(bool enable)
445 {
446 POWER_HILOGI(COMP_UTILS, "SetSettingWakeupDouble switch, enable=%{public}d", enable);
447 int32_t value = enable ? WAKEUP_SOURCE_OPEN : WAKEUP_SOURCE_CLOSE;
448 SetSettingIntValue(SETTING_POWER_WAKEUP_DOUBLE_KEY, value);
449 }
450
RegisterSettingWakeupDoubleObserver(SettingObserver::UpdateFunc & func)451 void SettingHelper::RegisterSettingWakeupDoubleObserver(SettingObserver::UpdateFunc& func)
452 {
453 if (doubleClickObserver_) {
454 POWER_HILOGI(COMP_UTILS, "setting wakeup double click observer is already registered");
455 return;
456 }
457 doubleClickObserver_ = RegisterSettingKeyObserver(SETTING_POWER_WAKEUP_DOUBLE_KEY, func);
458 }
459
UnregisterSettingWakeupDoubleObserver()460 void SettingHelper::UnregisterSettingWakeupDoubleObserver()
461 {
462 if (!doubleClickObserver_) {
463 POWER_HILOGI(COMP_UTILS, "doubleClickObserver_ is nullptr, no need to unregister");
464 return;
465 }
466 UnregisterSettingObserver(doubleClickObserver_);
467 doubleClickObserver_ = nullptr;
468 }
469
SaveCurrentMode(int32_t mode)470 void SettingHelper::SaveCurrentMode(int32_t mode)
471 {
472 SetSettingIntValue(SETTING_POWER_MODE_KEY, mode);
473 }
474
ReadCurrentMode(int32_t defaultMode)475 int32_t SettingHelper::ReadCurrentMode(int32_t defaultMode)
476 {
477 return GetSettingIntValue(SETTING_POWER_MODE_KEY, defaultMode);
478 }
479
RegisterSettingPowerModeObserver(SettingObserver::UpdateFunc & func)480 void SettingHelper::RegisterSettingPowerModeObserver(SettingObserver::UpdateFunc& func)
481 {
482 if (powerModeObserver_) {
483 POWER_HILOGI(COMP_UTILS, "setting power mode observer is already registered");
484 return;
485 }
486 powerModeObserver_ = RegisterSettingKeyObserver(SETTING_POWER_MODE_KEY, func);
487 }
488
UnRegisterSettingPowerModeObserver()489 void SettingHelper::UnRegisterSettingPowerModeObserver()
490 {
491 if (!powerModeObserver_) {
492 POWER_HILOGI(COMP_UTILS, "powerModeObserver_ is nullptr, no need to unregister");
493 return;
494 }
495 auto ret = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID).UnregisterObserver(powerModeObserver_);
496 if (ret != ERR_OK) {
497 POWER_HILOGE(COMP_UTILS, "unregister setting power mode observer failed, ret=%{public}d", ret);
498 }
499 powerModeObserver_ = nullptr;
500 }
501
ReadPowerModeRecoverMap()502 const std::string SettingHelper::ReadPowerModeRecoverMap()
503 {
504 return GetSettingStringValue(SETTING_POWER_MODE_BACKUP_KEY);
505 }
506
SavePowerModeRecoverMap(const std::string & jsonConfig)507 void SettingHelper::SavePowerModeRecoverMap(const std::string& jsonConfig)
508 {
509 SetSettingJsonStringValue(SETTING_POWER_MODE_BACKUP_KEY, jsonConfig);
510 }
511
IsWakeupLidSettingValid()512 bool SettingHelper::IsWakeupLidSettingValid()
513 {
514 return IsSettingKeyValid(SETTING_POWER_WAKEUP_LID_KEY);
515 }
516
RegisterSettingWakeupLidObserver(SettingObserver::UpdateFunc & func)517 void SettingHelper::RegisterSettingWakeupLidObserver(SettingObserver::UpdateFunc& func)
518 {
519 if (!IsWakeupLidSettingValid()) {
520 POWER_HILOGE(COMP_UTILS, "settings.power.wakeup_lid is valid.");
521 return;
522 }
523 lidObserver_ = RegisterSettingKeyObserver(SETTING_POWER_WAKEUP_LID_KEY, func);
524 }
525
UnRegisterSettingWakeupLidObserver()526 void SettingHelper::UnRegisterSettingWakeupLidObserver()
527 {
528 if (!lidObserver_) {
529 POWER_HILOGI(COMP_UTILS, "lidObserver_ is nullptr, no need to unregister");
530 return;
531 }
532 if (!IsWakeupLidSettingValid()) {
533 POWER_HILOGE(COMP_UTILS, "settings.power.wakeup_lid is valid.");
534 return;
535 }
536 auto ret = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID).UnregisterObserver(lidObserver_);
537 if (ret != ERR_OK) {
538 POWER_HILOGE(COMP_UTILS, "unregister setting wakeup lid observer failed, ret=%{public}d", ret);
539 }
540 lidObserver_ = nullptr;
541 }
542
GetSettingWakeupLid(const std::string & key)543 bool SettingHelper::GetSettingWakeupLid(const std::string& key)
544 {
545 if (!IsWakeupLidSettingValid()) {
546 POWER_HILOGE(COMP_UTILS, "settings.power.wakeup_lid is valid.");
547 return false;
548 }
549 SettingProvider& settingProvider = SettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
550 int32_t value = 0;
551 ErrCode ret = settingProvider.GetIntValue(SETTING_POWER_WAKEUP_LID_KEY, value);
552 if (ret != ERR_OK) {
553 POWER_HILOGE(COMP_UTILS, "get setting power wakeup lid key failed, ret=%{public}d", ret);
554 }
555 return (value == WAKEUP_SOURCE_OPEN);
556 }
557
SetSettingWakeupLid(bool enable)558 void SettingHelper::SetSettingWakeupLid(bool enable)
559 {
560 POWER_HILOGI(COMP_UTILS, "SetSettingWakeupLid, enable=%{public}d", enable);
561 int32_t value = enable ? WAKEUP_SOURCE_OPEN : WAKEUP_SOURCE_CLOSE;
562 SetSettingIntValue(SETTING_POWER_WAKEUP_LID_KEY, value);
563 }
564 } // namespace PowerMgr
565 } // namespace OHOS
566