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