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 "dataobs_mgr_client.h"
17 #include "datashare_ext_ability_context.h"
18 #include "data_storage_errors.h"
19 #include "data_storage_log_wrapper.h"
20 #include "opkey_ability.h"
21 #include "pdp_profile_ability.h"
22 #include "sim_ability.h"
23 #include "sms_mms_ability.h"
24 #include "global_params_ability.h"
25 #include "opkey_version_ability.h"
26 #include "telephony_datashare_stub_impl.h"
27
28
29 namespace OHOS {
30 namespace DataShare {
31 using DataObsMgrClient = OHOS::AAFwk::DataObsMgrClient;
32 using namespace OHOS::Telephony;
33
SetOpKeyAbility(std::shared_ptr<DataShareExtAbility> extension)34 void TelephonyDataShareStubImpl::SetOpKeyAbility(std::shared_ptr<DataShareExtAbility> extension)
35 {
36 std::lock_guard<std::mutex> lock(opKeyMutex_);
37 opKeyAbility_ = extension;
38 }
39
SetPdpProfileAbility(std::shared_ptr<DataShareExtAbility> extension)40 void TelephonyDataShareStubImpl::SetPdpProfileAbility(std::shared_ptr<DataShareExtAbility> extension)
41 {
42 std::lock_guard<std::mutex> lock(pdpProfileMutex_);
43 pdpProfileAbility_ = extension;
44 }
45
SetSimAbility(std::shared_ptr<DataShareExtAbility> extension)46 void TelephonyDataShareStubImpl::SetSimAbility(std::shared_ptr<DataShareExtAbility> extension)
47 {
48 std::lock_guard<std::mutex> lock(simMutex_);
49 simAbility_ = extension;
50 }
51
SetSmsMmsAbility(std::shared_ptr<DataShareExtAbility> extension)52 void TelephonyDataShareStubImpl::SetSmsMmsAbility(std::shared_ptr<DataShareExtAbility> extension)
53 {
54 std::lock_guard<std::mutex> lock(smsMmsMutex_);
55 smsMmsAbility_ = extension;
56 }
57
SetGlobalParamsAbility(std::shared_ptr<DataShareExtAbility> extension)58 void TelephonyDataShareStubImpl::SetGlobalParamsAbility(std::shared_ptr<DataShareExtAbility> extension)
59 {
60 std::lock_guard<std::mutex> lock(globalParamsMutex_);
61 globalParamsAbility_ = extension;
62 }
63
GetTelephonyDataAbility()64 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetTelephonyDataAbility()
65 {
66 return telephonyDataAbility_;
67 }
68
GetOpKeyAbility()69 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetOpKeyAbility()
70 {
71 std::lock_guard<std::mutex> lock(opKeyMutex_);
72 if (opKeyAbility_ == nullptr) {
73 opKeyAbility_.reset(OpKeyAbility::Create());
74 }
75 return opKeyAbility_;
76 }
77
GetPdpProfileAbility()78 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetPdpProfileAbility()
79 {
80 std::lock_guard<std::mutex> lock(pdpProfileMutex_);
81 if (pdpProfileAbility_ == nullptr) {
82 pdpProfileAbility_.reset(PdpProfileAbility::Create());
83 }
84 return pdpProfileAbility_;
85 }
86
GetSimAbility()87 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetSimAbility()
88 {
89 std::lock_guard<std::mutex> lock(simMutex_);
90 if (simAbility_ == nullptr) {
91 simAbility_.reset(SimAbility::Create());
92 }
93 return simAbility_;
94 }
95
GetSmsMmsAbility()96 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetSmsMmsAbility()
97 {
98 std::lock_guard<std::mutex> lock(smsMmsMutex_);
99 if (smsMmsAbility_ == nullptr) {
100 smsMmsAbility_.reset(SmsMmsAbility::Create());
101 }
102 return smsMmsAbility_;
103 }
104
GetGlobalParamsAbility()105 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetGlobalParamsAbility()
106 {
107 std::lock_guard<std::mutex> lock(globalParamsMutex_);
108 if (globalParamsAbility_ == nullptr) {
109 globalParamsAbility_.reset(GlobalParamsAbility::Create());
110 }
111 return globalParamsAbility_;
112 }
113
GetOpkeyVersionAbility()114 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetOpkeyVersionAbility()
115 {
116 if (opkeyVersionAbility_ == nullptr) {
117 std::lock_guard<std::mutex> lock(opkeyVersionMutex_);
118 if (opkeyVersionAbility_ == nullptr) {
119 opkeyVersionAbility_.reset(OpkeyVersionAbility::Create());
120 }
121 }
122 return opkeyVersionAbility_;
123 }
124
GetOwner(const Uri & uri)125 std::shared_ptr<DataShareExtAbility> TelephonyDataShareStubImpl::GetOwner(const Uri &uri)
126 {
127 OHOS::Uri uriTemp = uri;
128 std::string path = uriTemp.GetPath();
129 DATA_STORAGE_LOGD("GetOwner uri: %{public}s", path.c_str());
130 if (path.find("com.ohos.telephonydataability") != std::string::npos) {
131 return GetTelephonyDataAbility();
132 }
133 if (path.find("com.ohos.opkeyability") != std::string::npos) {
134 return GetOpKeyAbility();
135 }
136 if (path.find("com.ohos.pdpprofileability") != std::string::npos) {
137 return GetPdpProfileAbility();
138 }
139 if (path.find("com.ohos.simability") != std::string::npos) {
140 return GetSimAbility();
141 }
142 if (path.find("com.ohos.smsmmsability") != std::string::npos) {
143 return GetSmsMmsAbility();
144 }
145 if (path.find("com.ohos.globalparamsability") != std::string::npos) {
146 return GetGlobalParamsAbility();
147 }
148 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
149 if (path.find("com.ohos.opkeyversionability") != std::string::npos) {
150 return GetOpkeyVersionAbility();
151 }
152 #endif
153 return nullptr;
154 }
155
Insert(const Uri & uri,const DataShareValuesBucket & value)156 int TelephonyDataShareStubImpl::Insert(const Uri &uri, const DataShareValuesBucket &value)
157 {
158 DATA_STORAGE_LOGD("Insert begin.");
159 int ret = 0;
160 auto extension = GetOwner(uri);
161 if (extension == nullptr) {
162 DATA_STORAGE_LOGE("Insert failed, extension is null.");
163 return ret;
164 }
165 ret = extension->Insert(uri, value);
166 DATA_STORAGE_LOGI("Insert end successfully. ret: %{public}d", ret);
167 if (ret != Telephony::OPERATION_ERROR) {
168 NotifyChange(uri);
169 }
170 return ret;
171 }
172
Update(const Uri & uri,const DataSharePredicates & predicates,const DataShareValuesBucket & value)173 int TelephonyDataShareStubImpl::Update(const Uri &uri, const DataSharePredicates &predicates,
174 const DataShareValuesBucket &value)
175 {
176 DATA_STORAGE_LOGD("Update begin.");
177 int ret = 0;
178 auto extension = GetOwner(uri);
179 if (extension == nullptr) {
180 DATA_STORAGE_LOGE("Update failed, extension is null.");
181 return ret;
182 }
183 ret = extension->Update(uri, predicates, value);
184 if (ret != Telephony::OPERATION_OK) {
185 DATA_STORAGE_LOGE("Update end failed. ret: %{public}d", ret);
186 }
187 if (ret != Telephony::OPERATION_ERROR) {
188 NotifyChange(uri);
189 }
190 return ret;
191 }
192
Delete(const Uri & uri,const DataSharePredicates & predicates)193 int TelephonyDataShareStubImpl::Delete(const Uri &uri, const DataSharePredicates &predicates)
194 {
195 DATA_STORAGE_LOGI("Delete begin.");
196 int ret = 0;
197 auto extension = GetOwner(uri);
198 if (extension == nullptr) {
199 DATA_STORAGE_LOGE("Delete failed, extension is null.");
200 return ret;
201 }
202 ret = extension->Delete(uri, predicates);
203 DATA_STORAGE_LOGI("Delete end successfully. ret: %{public}d", ret);
204 if (ret != Telephony::OPERATION_ERROR) {
205 NotifyChange(uri);
206 }
207 return ret;
208 }
209
Query(const Uri & uri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)210 std::shared_ptr<DataShareResultSet> TelephonyDataShareStubImpl::Query(const Uri &uri,
211 const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
212 {
213 DATA_STORAGE_LOGD("Query begin.");
214 auto extension = GetOwner(uri);
215 if (extension == nullptr) {
216 DATA_STORAGE_LOGE("Query failed, extension is null.");
217 return nullptr;
218 }
219 auto resultSet = extension->Query(uri, predicates, columns, businessError);
220 DATA_STORAGE_LOGD("Query end successfully.");
221 return resultSet;
222 }
223
BatchInsert(const Uri & uri,const std::vector<DataShareValuesBucket> & values)224 int TelephonyDataShareStubImpl::BatchInsert(const Uri &uri, const std::vector<DataShareValuesBucket> &values)
225 {
226 DATA_STORAGE_LOGI("BatchInsert begin.");
227 int ret = 0;
228 auto extension = GetOwner(uri);
229 if (extension == nullptr) {
230 DATA_STORAGE_LOGE("BatchInsert failed, extension is null.");
231 return ret;
232 }
233 ret = extension->BatchInsert(uri, values);
234 DATA_STORAGE_LOGI("BatchInsert end successfully. ret: %{public}d", ret);
235 if (ret != Telephony::OPERATION_ERROR) {
236 NotifyChange(uri);
237 }
238 return ret;
239 }
240
GetFileTypes(const Uri & uri,const std::string & mimeTypeFilter)241 std::vector<std::string> TelephonyDataShareStubImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
242 {
243 DATA_STORAGE_LOGI("GetFileTypes not supported.");
244 std::vector<std::string> result;
245 return result;
246 }
247
OpenFile(const Uri & uri,const std::string & mode)248 int TelephonyDataShareStubImpl::OpenFile(const Uri &uri, const std::string &mode)
249 {
250 DATA_STORAGE_LOGI("OpenFile not supported.");
251 return -1;
252 }
253
OpenRawFile(const Uri & uri,const std::string & mode)254 int TelephonyDataShareStubImpl::OpenRawFile(const Uri &uri, const std::string &mode)
255 {
256 DATA_STORAGE_LOGI("OpenRawFile not supported.");
257 return -1;
258 }
259
GetType(const Uri & uri)260 std::string TelephonyDataShareStubImpl::GetType(const Uri &uri)
261 {
262 DATA_STORAGE_LOGI("GetType not supported.");
263 return "";
264 }
265
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)266 bool TelephonyDataShareStubImpl::RegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
267 {
268 DATA_STORAGE_LOGD("%{public}s begin.", __func__);
269 auto obsMgrClient = DataObsMgrClient::GetInstance();
270 if (obsMgrClient == nullptr) {
271 DATA_STORAGE_LOGE("%{public}s obsMgrClient is nullptr", __func__);
272 return false;
273 }
274
275 ErrCode ret = obsMgrClient->RegisterObserver(uri, dataObserver);
276 if (ret != ERR_OK) {
277 DATA_STORAGE_LOGE("%{public}s obsMgrClient->RegisterObserver error return %{public}d", __func__, ret);
278 return false;
279 }
280 return true;
281 }
282
UnregisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)283 bool TelephonyDataShareStubImpl::UnregisterObserver(const Uri &uri,
284 const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
285 {
286 DATA_STORAGE_LOGI("%{public}s begin.", __func__);
287 auto obsMgrClient = DataObsMgrClient::GetInstance();
288 if (obsMgrClient == nullptr) {
289 DATA_STORAGE_LOGE("%{public}s obsMgrClient is nullptr", __func__);
290 return false;
291 }
292
293 ErrCode ret = obsMgrClient->UnregisterObserver(uri, dataObserver);
294 if (ret != ERR_OK) {
295 DATA_STORAGE_LOGE("%{public}s obsMgrClient->UnregisterObserver error return %{public}d", __func__, ret);
296 return false;
297 }
298 return true;
299 }
300
NotifyChange(const Uri & uri)301 bool TelephonyDataShareStubImpl::NotifyChange(const Uri &uri)
302 {
303 auto obsMgrClient = DataObsMgrClient::GetInstance();
304 if (obsMgrClient == nullptr) {
305 DATA_STORAGE_LOGE("%{public}s obsMgrClient is nullptr", __func__);
306 return false;
307 }
308
309 ErrCode ret = obsMgrClient->NotifyChange(uri);
310 if (ret != ERR_OK) {
311 DATA_STORAGE_LOGE("%{public}s obsMgrClient->NotifyChange error return %{public}d", __func__, ret);
312 return false;
313 }
314 return true;
315 }
316
NormalizeUri(const Uri & uri)317 Uri TelephonyDataShareStubImpl::NormalizeUri(const Uri &uri)
318 {
319 DATA_STORAGE_LOGI("NormalizeUri not supported.");
320 return uri;
321 }
322
DenormalizeUri(const Uri & uri)323 Uri TelephonyDataShareStubImpl::DenormalizeUri(const Uri &uri)
324 {
325 DATA_STORAGE_LOGI("DenormalizeUri not supported.");
326 return uri;
327 }
328 } // namespace DataShare
329 } // namespace OHOS
330