1 /*
2 * Copyright (C) 2021-2023 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 <vector>
17 #include "iremote_stub.h"
18 #include "wifi_datashare_utils.h"
19 #ifdef HAS_ACCOUNT_PART
20 #include "os_account_manager.h"
21 #endif
22 #include "wifi_log.h"
23 #include "wifi_logger.h"
24 #include "system_ability_definition.h"
25
26 DEFINE_WIFILOG_LABEL("WifiDataShareHelperUtils");
27
28 namespace OHOS {
29 namespace Wifi {
30 namespace {
31 constexpr const char *SETTINGS_DATASHARE_URI =
32 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
33 constexpr const char *SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
34 constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
35 constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
36 constexpr const char *DEFAULT_USERID = "100";
37
38 // E_OK and E_DATA_SHARE_NOT_READY used to check datashare ready
39 constexpr const int32_t E_OK = 0;
40 constexpr const int32_t E_DATA_SHARE_NOT_READY = 1055;
41 }
42
GetInstance()43 WifiDataShareHelperUtils& WifiDataShareHelperUtils::GetInstance()
44 {
45 static WifiDataShareHelperUtils instance;
46 return instance;
47 }
48
IsDataMgrServiceActive()49 bool WifiDataShareHelperUtils::IsDataMgrServiceActive()
50 {
51 sptr<ISystemAbilityManager> saMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
52 if (saMgr == nullptr) {
53 WIFI_LOGE("Failed to get SystemAbilityManager!");
54 return false;
55 }
56 sptr<IRemoteObject> object = saMgr->CheckSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
57 if (object == nullptr) {
58 WIFI_LOGE("Failed to get DataMgrService!");
59 return false;
60 }
61 return true;
62 }
63
CheckIfSettingsDataReady()64 bool WifiDataShareHelperUtils::CheckIfSettingsDataReady()
65 {
66 if (isDataShareReady_) {
67 return true;
68 }
69
70 if (!IsDataMgrServiceActive()) {
71 return false;
72 }
73
74 auto remote = sptr<IWifiDataShareRemoteBroker>(new (std::nothrow) IRemoteStub<IWifiDataShareRemoteBroker>());
75 if (remote == nullptr) {
76 WIFI_LOGE("%{public}s remote is nullptr", __func__);
77 return false;
78 }
79 auto remoteObj = remote->AsObject();
80 if (remoteObj == nullptr) {
81 WIFI_LOGE("%{public}s remoteObj_ is nullptr", __func__);
82 return false;
83 }
84
85 std::pair<int, std::shared_ptr<DataShare::DataShareHelper>> ret =
86 DataShare::DataShareHelper::Create(remoteObj, SETTINGS_DATASHARE_URI, SETTINGS_DATA_EXT_URI);
87 WIFI_LOGI("%{public}s create datashare helper, ret = %{public}d", __func__, ret.first);
88
89 if (ret.first == E_DATA_SHARE_NOT_READY) {
90 return false;
91 }
92
93 if (ret.first == E_OK) {
94 if (ret.second) {
95 ret.second->Release();
96 }
97 isDataShareReady_ = true;
98 }
99 return true;
100 }
101
WifiCreateDataShareHelper(bool onlySettingsData)102 std::shared_ptr<DataShare::DataShareHelper> WifiDataShareHelperUtils::WifiCreateDataShareHelper(bool onlySettingsData)
103 {
104 if (!CheckIfSettingsDataReady()) {
105 WIFI_LOGE("%{public}s datashare not ready.", __func__);
106 return nullptr;
107 }
108
109 auto remote = sptr<IWifiDataShareRemoteBroker>(new (std::nothrow) IRemoteStub<IWifiDataShareRemoteBroker>());
110 if (remote == nullptr) {
111 WIFI_LOGE("%{public}s remote is nullptr", __func__);
112 return nullptr;
113 }
114 auto remoteObj = remote->AsObject();
115 if (remoteObj == nullptr) {
116 WIFI_LOGE("%{public}s remoteObj_ is nullptr", __func__);
117 return nullptr;
118 }
119 if (onlySettingsData) {
120 return DataShare::DataShareHelper::Creator(remoteObj, SETTINGS_DATA_EXT_URI);
121 }
122 return DataShare::DataShareHelper::Creator(remoteObj, SETTINGS_DATASHARE_URI, SETTINGS_DATA_EXT_URI);
123 }
124
Query(Uri & uri,const std::string & key,std::string & value,bool onlySettingsData)125 ErrCode WifiDataShareHelperUtils::Query(Uri &uri, const std::string &key, std::string &value, bool onlySettingsData)
126 {
127 std::shared_ptr<DataShare::DataShareHelper> queryHelper = WifiCreateDataShareHelper(onlySettingsData);
128 CHECK_NULL_AND_RETURN(queryHelper, WIFI_OPT_FAILED);
129
130 DataShare::DataSharePredicates predicates;
131 std::vector<std::string> columns;
132 predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
133 auto result = queryHelper->Query(uri, predicates, columns);
134 if (result == nullptr) {
135 WIFI_LOGE("WifiDataShareHelper query error, result is null");
136 ClearResources(queryHelper, result);
137 return WIFI_OPT_FAILED;
138 }
139
140 int rowCount = 0;
141 if (result->GetRowCount(rowCount) != DataShare::E_OK) {
142 WIFI_LOGE("WifiDataShareHelper query failed, get row count fail");
143 ClearResources(queryHelper, result);
144 return WIFI_OPT_FAILED;
145 }
146 if (rowCount == 0) {
147 WIFI_LOGI("WifiDataShareHelper query success, but rowCount is 0");
148 ClearResources(queryHelper, result);
149 return WIFI_OPT_SUCCESS;
150 }
151
152 if (result->GoToFirstRow() != DataShare::E_OK) {
153 WIFI_LOGE("WifiDataShareHelper query failed,go to first row error");
154 ClearResources(queryHelper, result);
155 return WIFI_OPT_FAILED;
156 }
157
158 int columnIndex;
159 result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
160 result->GetString(columnIndex, value);
161 ClearResources(queryHelper, result);
162 WIFI_LOGI("WifiDataShareHelper query success,value[%{public}s]", value.c_str());
163 return WIFI_OPT_SUCCESS;
164 }
165
Insert(Uri & uri,const std::string & key,const std::string & value)166 ErrCode WifiDataShareHelperUtils::Insert(Uri &uri, const std::string &key, const std::string &value)
167 {
168 std::shared_ptr<DataShare::DataShareHelper> insertHelper = WifiCreateDataShareHelper();
169 CHECK_NULL_AND_RETURN(insertHelper, WIFI_OPT_FAILED);
170
171 DataShare::DataShareValuesBucket valuesBucket;
172 DataShare::DataShareValueObject keyObj(key);
173 DataShare::DataShareValueObject valueObj(value);
174 valuesBucket.Put(SETTINGS_DATA_COLUMN_KEYWORD, keyObj);
175 valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
176 int result = insertHelper->Insert(uri, valuesBucket);
177 if (result <= 0) {
178 WIFI_LOGE("WifiDataShareHelper insert failed, resultCode=%{public}d", result);
179 ClearResources(insertHelper, nullptr);
180 return WIFI_OPT_FAILED;
181 }
182 insertHelper->NotifyChange(uri);
183 ClearResources(insertHelper, nullptr);
184 WIFI_LOGE("DataShareHelper insert success");
185 return WIFI_OPT_SUCCESS;
186 }
187
Update(Uri & uri,const std::string & key,const std::string & value)188 ErrCode WifiDataShareHelperUtils::Update(Uri &uri, const std::string &key, const std::string &value)
189 {
190 std::shared_ptr<DataShare::DataShareHelper> updateHelper = WifiCreateDataShareHelper();
191 CHECK_NULL_AND_RETURN(updateHelper, WIFI_OPT_FAILED);
192
193 DataShare::DataShareValuesBucket valuesBucket;
194 DataShare::DataShareValueObject valueObj(value);
195 valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
196 DataShare::DataSharePredicates predicates;
197 predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
198 int result = updateHelper->Update(uri, predicates, valuesBucket);
199 if (result <= 0) {
200 WIFI_LOGE("WifiDataShareHelper update failed, resultCode=%{public}d", result);
201 ClearResources(updateHelper, nullptr);
202 return WIFI_OPT_FAILED;
203 }
204 updateHelper->NotifyChange(uri);
205 ClearResources(updateHelper, nullptr);
206 WIFI_LOGE("DataShareHelper update success");
207 return WIFI_OPT_SUCCESS;
208 }
209
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & observer)210 ErrCode WifiDataShareHelperUtils::RegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &observer)
211 {
212 std::shared_ptr<DataShare::DataShareHelper> registerHelper = WifiCreateDataShareHelper();
213 CHECK_NULL_AND_RETURN(registerHelper, WIFI_OPT_FAILED);
214 CHECK_NULL_AND_RETURN(observer, WIFI_OPT_FAILED);
215 registerHelper->RegisterObserver(uri, observer);
216 ClearResources(registerHelper, nullptr);
217 return WIFI_OPT_SUCCESS;
218 }
219
UnRegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & observer)220 ErrCode WifiDataShareHelperUtils::UnRegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &observer)
221 {
222 std::shared_ptr<DataShare::DataShareHelper> unregisterHelper = WifiCreateDataShareHelper();
223 CHECK_NULL_AND_RETURN(unregisterHelper, WIFI_OPT_FAILED);
224 CHECK_NULL_AND_RETURN(observer, WIFI_OPT_FAILED);
225 unregisterHelper->UnregisterObserver(uri, observer);
226 ClearResources(unregisterHelper, nullptr);
227 return WIFI_OPT_SUCCESS;
228 }
229
GetLoactionDataShareUri()230 std::string WifiDataShareHelperUtils::GetLoactionDataShareUri()
231 {
232 std::vector<int> accountIds;
233 #ifdef HAS_ACCOUNT_PART
234 OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds);
235 #endif
236 std::string userId = "100";
237 if (!accountIds.empty()) {
238 userId = std::to_string(accountIds[0]);
239 }
240
241 std::string uri = "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_"
242 + userId + "?Proxy=true&key=location_enable";
243 return uri;
244 }
245
ClearResources(std::shared_ptr<DataShare::DataShareHelper> operatrPtr,std::shared_ptr<DataShare::DataShareResultSet> result)246 void WifiDataShareHelperUtils::ClearResources(std::shared_ptr<DataShare::DataShareHelper> operatrPtr,
247 std::shared_ptr<DataShare::DataShareResultSet> result)
248 {
249 if (result != nullptr) {
250 result->Close();
251 result = nullptr;
252 }
253 if (operatrPtr != nullptr) {
254 operatrPtr->Release();
255 operatrPtr = nullptr;
256 }
257 }
258
GetScanMacInfoWhiteListDataShareUri()259 std::string WifiDataShareHelperUtils::GetScanMacInfoWhiteListDataShareUri()
260 {
261 std::vector<int> accountIds;
262 #ifdef HAS_ACCOUNT_PART
263 OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds);
264 #endif
265 std::string userId = DEFAULT_USERID;
266 if (!accountIds.empty()) {
267 userId = std::to_string(accountIds[0]);
268 }
269
270 std::string uri = "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_" + userId +
271 "?Proxy=true&key=" + SETTINGS_DATASHARE_KEY_SCANMACINFO_WHITELIST;
272 return uri;
273 }
274 } // namespace Wifi
275 } // namespace OHOS