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