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