1 /*
2 * Copyright (c) 2024 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 "datashare_manager.h"
17
18 #include "distributed_sched_utils.h"
19 #include "dsched_continue_manager.h"
20 #include "dtbschedmgr_log.h"
21 #include "mission/dms_continue_recv_manager.h"
22 #include "mission/dms_continue_send_manager.h"
23 #include "os_account_manager.h"
24 #include "switch_status_dependency.h"
25
26 namespace OHOS {
27 namespace DistributedSchedule {
28 IMPLEMENT_SINGLE_INSTANCE(DataShareManager);
29 namespace {
30 const std::string TAG = "DMSDataShareManager";
31 constexpr static int32_t INVALID_ACCOUNT_ID = -1;
32 }
33 SettingObserver::SettingObserver() = default;
34 SettingObserver::~SettingObserver() = default;
35
OnChange()36 void SettingObserver::OnChange()
37 {
38 HILOGI("DataShareRegisterObserver OnChange start");
39 if (observerCallback_ != nullptr) {
40 observerCallback_();
41 }
42 HILOGI("DataShareRegisterObserver OnChange done");
43 }
44
SetObserverCallback(ObserverCallback & observerCallback)45 void SettingObserver::SetObserverCallback(ObserverCallback &observerCallback)
46 {
47 observerCallback_ = observerCallback;
48 }
49
GetSettingObserver(const std::string & key)50 sptr<SettingObserver> DataShareManager::GetSettingObserver(const std::string &key)
51 {
52 HILOGI("GetSettingObserver with key is %{public}s", key.c_str());
53 std::lock_guard<std::mutex> lockGuard(observerMapMutex_);
54 if (settingObserverMap_.find(key) != settingObserverMap_.end()) {
55 return settingObserverMap_.find(key)->second;
56 }
57 return nullptr;
58 }
59
CreateDataShareHelper()60 std::shared_ptr<DataShare::DataShareHelper> DataShareManager::CreateDataShareHelper()
61 {
62 HILOGI("DataShareManager CreateDataShareHelper start");
63 DataShare::CreateOptions options;
64 options.isProxy_ = true;
65 return DataShare::DataShareHelper::Creator(SwitchStatusDependency::SETTINGS_USER_SECURE_URI, options);
66 }
67
RegisterObserver(const std::string & key,SettingObserver::ObserverCallback & observerCallback)68 void DataShareManager::RegisterObserver(const std::string &key, SettingObserver::ObserverCallback &observerCallback)
69 {
70 HILOGI("DataShareManager RegisterObserver start");
71 sptr<SettingObserver> observer = GetSettingObserver(key);
72 if (observer != nullptr) {
73 HILOGI("Observer is already registered with key is %{public}s", key.c_str());
74 UnregisterObserver(key);
75 }
76 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
77 if (dataShareHelper == nullptr) {
78 HILOGE("Register observer failed, dataShareHelper is null");
79 return;
80 }
81 int32_t userId = GetLocalAccountId();
82 Uri uri(AssembleUserSecureUri(userId, key));
83 sptr<SettingObserver> newObserver(new SettingObserver());
84 observer = newObserver;
85 if (observer == nullptr) {
86 HILOGE("Register observer failed, observer is null");
87 return;
88 }
89 observer->SetObserverCallback(observerCallback);
90 dataShareHelper->RegisterObserver(uri, observer);
91 dataShareHelper->Release();
92
93 std::lock_guard<std::mutex> lockGuard(observerMapMutex_);
94 settingObserverMap_[key] = observer;
95 HILOGI("DataShareManager RegisterObserver success with key is %{public}s", key.c_str());
96 }
97
UnregisterObserver(const std::string & key)98 void DataShareManager::UnregisterObserver(const std::string &key)
99 {
100 HILOGI("DataShareManager UnregisterObserver start");
101 sptr<SettingObserver> observer = GetSettingObserver(key);
102 if (observer == nullptr) {
103 HILOGI("UnregisterObserver, observer is nullptr with key is %{public}s", key.c_str());
104 return;
105 }
106 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
107 if (dataShareHelper == nullptr) {
108 HILOGE("Unregister observer failed with key is %{public}s", key.c_str());
109 return;
110 }
111 int32_t userId = GetLocalAccountId();
112 Uri uri(AssembleUserSecureUri(userId, key));
113 dataShareHelper->UnregisterObserver(uri, observer);
114 dataShareHelper->Release();
115
116 std::lock_guard<std::mutex> lockGuard(observerMapMutex_);
117 settingObserverMap_.erase(key);
118 HILOGI("DataShareManager UnregisterObserver success with key is %{public}s", key.c_str());
119 }
120
AssembleUserSecureUri(int userId,const std::string & key)121 Uri DataShareManager::AssembleUserSecureUri(int userId, const std::string &key)
122 {
123 Uri uri(SwitchStatusDependency::SETTINGS_USER_SECURE_URI + "_" + std::to_string(userId) + "?Proxy=true&key=" + key);
124 return uri;
125 }
126
GetLocalAccountId()127 int32_t DataShareManager::GetLocalAccountId()
128 {
129 int32_t id = INVALID_ACCOUNT_ID;
130 ErrCode err = AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(id);
131 if (err != ERR_OK || id == INVALID_ACCOUNT_ID) {
132 HILOGE("GetLocalAccountId passing param invalid or return error!, err : %{public}d", err);
133 return INVALID_PARAMETERS_ERR;
134 }
135 return id;
136 }
137
UpdateSwitchStatus(const std::string & key,const std::string & value)138 void DataShareManager::UpdateSwitchStatus(const std::string &key, const std::string &value)
139 {
140 HILOGI("Start UpdateSwitchStatus");
141 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
142 if (dataShareHelper == nullptr) {
143 HILOGE("dataShareHelper is null, key is %{public}s", key.c_str());
144 return;
145 }
146
147 HILOGD("UpdateSwitchStatus key = %{public}s", key.c_str());
148 int32_t userId = GetLocalAccountId();
149 Uri uri(AssembleUserSecureUri(userId, key));
150 DataShare::DataSharePredicates predicates;
151 predicates.EqualTo(SwitchStatusDependency::SETTINGS_DATA_FIELD_KEY, key);
152
153 DataShare::DataShareValuesBucket bucket;
154 bucket.Put(SwitchStatusDependency::SETTINGS_DATA_FIELD_KEY, key);
155 bucket.Put(SwitchStatusDependency::SETTINGS_DATA_FIELD_VAL, value);
156
157 auto result = dataShareHelper->UpdateEx(uri, predicates, bucket);
158 dataShareHelper->Release();
159 if (result.first != ERR_OK) {
160 HILOGE("Update status failed: %{public}d", result.first);
161 }
162 HILOGI("Finish UpdateSwitchStatus, Updata status success: %{public}d", result.first);
163 return;
164 }
165
IsCurrentContinueSwitchOn()166 bool DataShareManager::IsCurrentContinueSwitchOn()
167 {
168 HILOGD("IsCurrentContinueSwitchOn start");
169 return isCurrentContinueSwitchOn_.load();
170 }
171
SetCurrentContinueSwitch(bool status)172 void DataShareManager::SetCurrentContinueSwitch(bool status)
173 {
174 HILOGD("SetCurrentContinueSwitch start, status : %{public}d", status);
175 isCurrentContinueSwitchOn_.store(status);
176 }
177 } // namespace DistributedSchedule
178 } // namespace OHOS