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 "datashare_stub_impl.h"
17
18 #include "hilog_wrapper.h"
19
20 namespace OHOS {
21 namespace AppExecFwk {
GetOwner()22 std::shared_ptr<JsDataShareExtAbility> DataShareStubImpl::GetOwner()
23 {
24 return extension_;
25 }
26
GetFileTypes(const Uri & uri,const std::string & mimeTypeFilter)27 std::vector<std::string> DataShareStubImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
28 {
29 HILOG_INFO("%{public}s begin.", __func__);
30 std::vector<std::string> ret;
31 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
32 auto extension = client->GetOwner();
33 if (extension == nullptr) {
34 HILOG_ERROR("%{public}s end failed.", __func__);
35 return;
36 }
37 ret = extension->GetFileTypes(uri, mimeTypeFilter);
38 };
39 uvQueue_->SyncCall(syncTaskFunc);
40 HILOG_INFO("%{public}s end successfully.", __func__);
41 return ret;
42 }
43
OpenFile(const Uri & uri,const std::string & mode)44 int DataShareStubImpl::OpenFile(const Uri &uri, const std::string &mode)
45 {
46 HILOG_INFO("%{public}s begin.", __func__);
47 int ret = -1;
48 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
49 auto extension = client->GetOwner();
50 if (extension == nullptr) {
51 HILOG_ERROR("%{public}s end failed.", __func__);
52 return;
53 }
54 ret = extension->OpenFile(uri, mode);
55 };
56 uvQueue_->SyncCall(syncTaskFunc);
57 HILOG_INFO("%{public}s end successfully.", __func__);
58 return ret;
59 }
60
OpenRawFile(const Uri & uri,const std::string & mode)61 int DataShareStubImpl::OpenRawFile(const Uri &uri, const std::string &mode)
62 {
63 HILOG_INFO("%{public}s begin.", __func__);
64 int ret = -1;
65 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
66 auto extension = client->GetOwner();
67 if (extension == nullptr) {
68 HILOG_ERROR("%{public}s end failed.", __func__);
69 return;
70 }
71 ret = extension->OpenRawFile(uri, mode);
72 };
73 uvQueue_->SyncCall(syncTaskFunc);
74 HILOG_INFO("%{public}s end successfully.", __func__);
75 return ret;
76 }
77
Insert(const Uri & uri,const NativeRdb::ValuesBucket & value)78 int DataShareStubImpl::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
79 {
80 HILOG_INFO("%{public}s begin.", __func__);
81 int ret = 0;
82 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
83 auto extension = client->GetOwner();
84 if (extension == nullptr) {
85 HILOG_ERROR("%{public}s end failed.", __func__);
86 return;
87 }
88 ret = extension->Insert(uri, value);
89 };
90 uvQueue_->SyncCall(syncTaskFunc);
91 HILOG_INFO("%{public}s end successfully.", __func__);
92 return ret;
93 }
94
Update(const Uri & uri,const NativeRdb::ValuesBucket & value,const NativeRdb::DataAbilityPredicates & predicates)95 int DataShareStubImpl::Update(const Uri &uri, const NativeRdb::ValuesBucket &value,
96 const NativeRdb::DataAbilityPredicates &predicates)
97 {
98 HILOG_INFO("%{public}s begin.", __func__);
99 int ret = 0;
100 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
101 auto extension = client->GetOwner();
102 if (extension == nullptr) {
103 HILOG_ERROR("%{public}s end failed.", __func__);
104 return;
105 }
106 ret = extension->Update(uri, value, predicates);
107 };
108 uvQueue_->SyncCall(syncTaskFunc);
109 HILOG_INFO("%{public}s end successfully.", __func__);
110 return ret;
111 }
112
Delete(const Uri & uri,const NativeRdb::DataAbilityPredicates & predicates)113 int DataShareStubImpl::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
114 {
115 HILOG_INFO("%{public}s begin.", __func__);
116 int ret = 0;
117 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
118 auto extension = client->GetOwner();
119 if (extension == nullptr) {
120 HILOG_ERROR("%{public}s end failed.", __func__);
121 return;
122 }
123 ret = extension->Delete(uri, predicates);
124 };
125 uvQueue_->SyncCall(syncTaskFunc);
126 HILOG_INFO("%{public}s end successfully.", __func__);
127 return ret;
128 }
129
Query(const Uri & uri,std::vector<std::string> & columns,const NativeRdb::DataAbilityPredicates & predicates)130 std::shared_ptr<NativeRdb::AbsSharedResultSet> DataShareStubImpl::Query(const Uri &uri,
131 std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
132 {
133 HILOG_INFO("%{public}s begin.", __func__);
134 std::shared_ptr<NativeRdb::AbsSharedResultSet> ret = nullptr;
135 std::function<void()> syncTaskFunc = [=, &columns, &ret, client = sptr<DataShareStubImpl>(this)]() {
136 auto extension = client->GetOwner();
137 if (extension == nullptr) {
138 HILOG_ERROR("%{public}s end failed.", __func__);
139 return;
140 }
141 ret = extension->Query(uri, columns, predicates);
142 };
143 uvQueue_->SyncCall(syncTaskFunc);
144 HILOG_INFO("%{public}s end successfully.", __func__);
145 return ret;
146 }
147
GetType(const Uri & uri)148 std::string DataShareStubImpl::GetType(const Uri &uri)
149 {
150 HILOG_INFO("%{public}s begin.", __func__);
151 std::string ret = "";
152 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
153 auto extension = client->GetOwner();
154 if (extension == nullptr) {
155 HILOG_ERROR("%{public}s end failed.", __func__);
156 return;
157 }
158 ret = extension->GetType(uri);
159 };
160 uvQueue_->SyncCall(syncTaskFunc);
161 HILOG_INFO("%{public}s end successfully.", __func__);
162 return ret;
163 }
164
BatchInsert(const Uri & uri,const std::vector<NativeRdb::ValuesBucket> & values)165 int DataShareStubImpl::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
166 {
167 HILOG_INFO("%{public}s begin.", __func__);
168 int ret = 0;
169 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
170 auto extension = client->GetOwner();
171 if (extension == nullptr) {
172 HILOG_ERROR("%{public}s end failed.", __func__);
173 return;
174 }
175 ret = extension->BatchInsert(uri, values);
176 };
177 uvQueue_->SyncCall(syncTaskFunc);
178 HILOG_INFO("%{public}s end successfully.", __func__);
179 return ret;
180 }
181
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)182 bool DataShareStubImpl::RegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
183 {
184 HILOG_INFO("%{public}s begin.", __func__);
185 bool ret = false;
186 std::function<void()> syncTaskFunc = [=, &dataObserver, &ret, client = sptr<DataShareStubImpl>(this)]() {
187 auto extension = client->GetOwner();
188 if (extension == nullptr) {
189 HILOG_ERROR("%{public}s end failed.", __func__);
190 return;
191 }
192 ret = extension->RegisterObserver(uri, dataObserver);
193 };
194 uvQueue_->SyncCall(syncTaskFunc);
195 HILOG_INFO("%{public}s end successfully.", __func__);
196 return ret;
197 }
198
UnregisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)199 bool DataShareStubImpl::UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
200 {
201 HILOG_INFO("%{public}s begin.", __func__);
202 bool ret = false;
203 std::function<void()> syncTaskFunc = [=, &dataObserver, &ret, client = sptr<DataShareStubImpl>(this)]() {
204 auto extension = client->GetOwner();
205 if (extension == nullptr) {
206 HILOG_ERROR("%{public}s end failed.", __func__);
207 return;
208 }
209 ret = extension->UnregisterObserver(uri, dataObserver);
210 };
211 uvQueue_->SyncCall(syncTaskFunc);
212 HILOG_INFO("%{public}s end successfully.", __func__);
213 return ret;
214 }
215
NotifyChange(const Uri & uri)216 bool DataShareStubImpl::NotifyChange(const Uri &uri)
217 {
218 HILOG_INFO("%{public}s begin.", __func__);
219 bool ret = false;
220 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
221 auto extension = client->GetOwner();
222 if (extension == nullptr) {
223 HILOG_ERROR("%{public}s end failed.", __func__);
224 return;
225 }
226 ret = extension->NotifyChange(uri);
227 };
228 uvQueue_->SyncCall(syncTaskFunc);
229 HILOG_INFO("%{public}s end successfully.", __func__);
230 return ret;
231 }
232
NormalizeUri(const Uri & uri)233 Uri DataShareStubImpl::NormalizeUri(const Uri &uri)
234 {
235 HILOG_INFO("%{public}s begin.", __func__);
236 Uri urivalue("");
237 std::function<void()> syncTaskFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() {
238 auto extension = client->GetOwner();
239 if (extension == nullptr) {
240 HILOG_ERROR("%{public}s end failed.", __func__);
241 return;
242 }
243 urivalue = extension->NormalizeUri(uri);
244 };
245 uvQueue_->SyncCall(syncTaskFunc);
246 HILOG_INFO("%{public}s end successfully.", __func__);
247 return urivalue;
248 }
249
DenormalizeUri(const Uri & uri)250 Uri DataShareStubImpl::DenormalizeUri(const Uri &uri)
251 {
252 HILOG_INFO("%{public}s begin.", __func__);
253 Uri urivalue("");
254 std::function<void()> syncTaskFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() {
255 auto extension = client->GetOwner();
256 if (extension == nullptr) {
257 HILOG_ERROR("%{public}s end failed.", __func__);
258 return;
259 }
260 urivalue = extension->DenormalizeUri(uri);
261 };
262 uvQueue_->SyncCall(syncTaskFunc);
263 HILOG_INFO("%{public}s end successfully.", __func__);
264 return urivalue;
265 }
266
ExecuteBatch(const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>> & operations)267 std::vector<std::shared_ptr<AppExecFwk::DataAbilityResult>> DataShareStubImpl::ExecuteBatch(
268 const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>> &operations)
269 {
270 HILOG_INFO("%{public}s begin.", __func__);
271 std::vector<std::shared_ptr<DataAbilityResult>> results;
272 std::function<void()> syncTaskFunc = [=, &results, client = sptr<DataShareStubImpl>(this)]() {
273 auto extension = client->GetOwner();
274 if (extension == nullptr) {
275 HILOG_ERROR("%{public}s end failed.", __func__);
276 return;
277 }
278 results = extension->ExecuteBatch(operations);
279 };
280 uvQueue_->SyncCall(syncTaskFunc);
281 HILOG_INFO("%{public}s end successfully.", __func__);
282 return results;
283 }
284 } // namespace AppExecFwk
285 } // namespace OHOS
286