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