1 /*
2 * Copyright (c) 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 "data_share_service_proxy.h"
17
18 #include "datashare_itypes_utils.h"
19 #include "datashare_log.h"
20 #include "ishared_result_set.h"
21
22 namespace OHOS {
23 namespace DataShare {
24 using InterfaceCode = OHOS::DistributedShare::DataShare::DataShareServiceInterfaceCode;
25
DataShareServiceProxy(const sptr<IRemoteObject> & object)26 DataShareServiceProxy::DataShareServiceProxy(const sptr<IRemoteObject> &object)
27 : IRemoteProxy<IDataShareService>(object)
28 {
29 LOG_INFO("Construct complete.");
30 }
31
Insert(const Uri & uri,const DataShareValuesBucket & value)32 int32_t DataShareServiceProxy::Insert(const Uri &uri, const DataShareValuesBucket &value)
33 {
34 const std::string &uriStr = uri.ToString();
35 MessageParcel data;
36 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
37 LOG_ERROR("Write descriptor failed!");
38 return DATA_SHARE_ERROR;
39 }
40 if (!ITypesUtil::Marshal(data, uriStr, value)) {
41 LOG_ERROR("Write to message parcel failed!");
42 return DATA_SHARE_ERROR;
43 }
44
45 MessageParcel reply;
46 MessageOption option;
47 int32_t err = Remote()->SendRequest(
48 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_INSERT), data, reply, option);
49 if (err != NO_ERROR) {
50 LOG_ERROR("Insert fail to SendRequest. uri: %{public}s, err: %{public}d", uriStr.c_str(), err);
51 return DATA_SHARE_ERROR;
52 }
53 return reply.ReadInt32();
54 }
55
Update(const Uri & uri,const DataSharePredicates & predicate,const DataShareValuesBucket & valuesBucket)56 int32_t DataShareServiceProxy::Update(const Uri &uri,
57 const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
58 {
59 const std::string &uriStr = uri.ToString();
60 MessageParcel data;
61 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
62 LOG_ERROR("Write descriptor failed!");
63 return DATA_SHARE_ERROR;
64 }
65 if (!ITypesUtil::Marshal(data, uriStr, predicate, valuesBucket)) {
66 LOG_ERROR("Write to message parcel failed!");
67 return DATA_SHARE_ERROR;
68 }
69
70 MessageParcel reply;
71 MessageOption option;
72 int32_t err = Remote()->SendRequest(
73 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UPDATE), data, reply, option);
74 if (err != NO_ERROR) {
75 LOG_ERROR("Update fail to SendRequest. uri: %{public}s, err: %{public}d", uriStr.c_str(), err);
76 return DATA_SHARE_ERROR;
77 }
78 return reply.ReadInt32();
79 }
80
Delete(const Uri & uri,const DataSharePredicates & predicate)81 int32_t DataShareServiceProxy::Delete(const Uri &uri, const DataSharePredicates &predicate)
82 {
83 const std::string &uriStr = uri.ToString();
84 MessageParcel data;
85 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
86 LOG_ERROR("Write descriptor failed!");
87 return DATA_SHARE_ERROR;
88 }
89 if (!ITypesUtil::Marshal(data, uriStr, predicate)) {
90 LOG_ERROR("Write to message parcel failed!");
91 return DATA_SHARE_ERROR;
92 }
93
94 MessageParcel reply;
95 MessageOption option;
96 int32_t err = Remote()->SendRequest(
97 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DELETE), data, reply, option);
98 if (err != NO_ERROR) {
99 LOG_ERROR("Delete fail to SendRequest. uri: %{public}s, err: %{public}d", uriStr.c_str(), err);
100 return DATA_SHARE_ERROR;
101 }
102 return reply.ReadInt32();
103 }
104
Query(const Uri & uri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)105 std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri, const DataSharePredicates &predicates,
106 std::vector<std::string> &columns, DatashareBusinessError &businessError)
107 {
108 const std::string &uriStr = uri.ToString();
109 MessageParcel data;
110 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
111 LOG_ERROR("WriteInterfaceToken failed!");
112 return nullptr;
113 }
114
115 if (!ITypesUtil::Marshal(data, uriStr, predicates, columns)) {
116 LOG_ERROR("Write to message parcel failed!");
117 return nullptr;
118 }
119
120 MessageParcel reply;
121 MessageOption option;
122 int32_t err = Remote()->SendRequest(
123 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_QUERY), data, reply, option);
124
125 auto result = ISharedResultSet::ReadFromParcel(reply);
126 businessError.SetCode(reply.ReadInt32());
127 if (err != NO_ERROR) {
128 LOG_ERROR("Query fail to SendRequest. uri: %{public}s, err: %{public}d", uriStr.c_str(), err);
129 return nullptr;
130 }
131 return result;
132 }
133
AddQueryTemplate(const std::string & uri,int64_t subscriberId,Template & tpl)134 int DataShareServiceProxy::AddQueryTemplate(const std::string &uri, int64_t subscriberId, Template &tpl)
135 {
136 MessageParcel data;
137 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
138 LOG_ERROR("Write descriptor failed!");
139 return DATA_SHARE_ERROR;
140 }
141 if (!ITypesUtil::Marshal(data, uri, subscriberId, tpl.predicates_, tpl.scheduler_)) {
142 LOG_ERROR("Write to message parcel failed!");
143 return DATA_SHARE_ERROR;
144 }
145
146 MessageParcel reply;
147 MessageOption option;
148 int32_t err = Remote()->SendRequest(
149 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ADD_TEMPLATE), data, reply, option);
150 if (err != NO_ERROR) {
151 LOG_ERROR("AddTemplate fail to SendRequest. uri: %{public}s, err: %{public}d", uri.c_str(), err);
152 return DATA_SHARE_ERROR;
153 }
154 return reply.ReadInt32();
155 }
156
DelQueryTemplate(const std::string & uri,int64_t subscriberId)157 int DataShareServiceProxy::DelQueryTemplate(const std::string &uri, int64_t subscriberId)
158 {
159 MessageParcel data;
160 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
161 LOG_ERROR("Write descriptor failed!");
162 return DATA_SHARE_ERROR;
163 }
164 if (!ITypesUtil::Marshal(data, uri, subscriberId)) {
165 LOG_ERROR("Write to message parcel failed!");
166 return DATA_SHARE_ERROR;
167 }
168
169 MessageParcel reply;
170 MessageOption option;
171 int32_t err = Remote()->SendRequest(
172 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DEL_TEMPLATE), data, reply, option);
173 if (err != NO_ERROR) {
174 LOG_ERROR("AddTemplate fail to SendRequest. uri: %{public}s, err: %{public}d", uri.c_str(), err);
175 return DATA_SHARE_ERROR;
176 }
177 return reply.ReadInt32();
178 }
179
Publish(const Data & data,const std::string & bundleName)180 std::vector<OperationResult> DataShareServiceProxy::Publish(const Data &data, const std::string &bundleName)
181 {
182 std::vector<OperationResult> results;
183 MessageParcel parcel;
184 if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
185 LOG_ERROR("Write descriptor failed!");
186 return results;
187 }
188 if (!ITypesUtil::Marshal(parcel, data, bundleName)) {
189 LOG_ERROR("Marshalfailed!");
190 return results;
191 }
192
193 MessageParcel reply;
194 MessageOption option;
195 int32_t err = Remote()->SendRequest(
196 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_PUBLISH), parcel, reply, option);
197 if (err != NO_ERROR) {
198 LOG_ERROR("Publish fail to SendRequest. err: %{public}d", err);
199 return results;
200 }
201
202 ITypesUtil::Unmarshal(reply, results);
203 return results;
204 }
205
GetPublishedData(const std::string & bundleName,int & resultCode)206 Data DataShareServiceProxy::GetPublishedData(const std::string &bundleName, int &resultCode)
207 {
208 Data results;
209 MessageParcel data;
210 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
211 LOG_ERROR("Write descriptor failed!");
212 return results;
213 }
214 if (!ITypesUtil::Marshal(data, bundleName)) {
215 LOG_ERROR("Write to message parcel failed!");
216 return results;
217 }
218
219 MessageParcel reply;
220 MessageOption option;
221 int32_t err = Remote()->SendRequest(
222 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_GET_DATA), data, reply, option);
223 if (err != NO_ERROR) {
224 LOG_ERROR("AddTemplate fail to SendRequest, err: %{public}d", err);
225 return results;
226 }
227 ITypesUtil::Unmarshal(reply, results.datas_, resultCode);
228 return results;
229 }
230
SubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId,const sptr<IDataProxyRdbObserver> & observer)231 std::vector<OperationResult> DataShareServiceProxy::SubscribeRdbData(const std::vector<std::string> &uris,
232 const TemplateId &templateId, const sptr<IDataProxyRdbObserver> &observer)
233 {
234 std::vector<OperationResult> results;
235 MessageParcel data;
236 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
237 LOG_ERROR("Write descriptor failed!");
238 return results;
239 }
240
241 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
242 LOG_ERROR("Write to message parcel failed!");
243 return results;
244 }
245 if (!data.WriteRemoteObject(observer->AsObject())) {
246 LOG_ERROR("failed to WriteParcelable dataObserver ");
247 return results;
248 }
249
250 MessageParcel reply;
251 MessageOption option;
252 int32_t err = Remote()->SendRequest(
253 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_RDB), data, reply, option);
254 if (err != NO_ERROR) {
255 LOG_ERROR("SubscribeRdbData fail to SendRequest. err: %{public}d", err);
256 return results;
257 }
258 ITypesUtil::Unmarshal(reply, results);
259 return results;
260 }
261
UnSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)262 std::vector<OperationResult> DataShareServiceProxy::UnSubscribeRdbData(
263 const std::vector<std::string> &uris, const TemplateId &templateId)
264 {
265 std::vector<OperationResult> results;
266 MessageParcel data;
267 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
268 LOG_ERROR("Write descriptor failed!");
269 return results;
270 }
271
272 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
273 LOG_ERROR("Write to message parcel failed!");
274 return results;
275 }
276
277 MessageParcel reply;
278 MessageOption option;
279 int32_t err = Remote()->SendRequest(
280 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_RDB), data, reply, option);
281 if (err != NO_ERROR) {
282 LOG_ERROR("fail to SendRequest. err: %{public}d", err);
283 return results;
284 }
285 ITypesUtil::Unmarshal(reply, results);
286 return results;
287 }
288
EnableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)289 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribeRdbData(
290 const std::vector<std::string> &uris, const TemplateId &templateId)
291 {
292 std::vector<OperationResult> results;
293 MessageParcel data;
294 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
295 LOG_ERROR("Write descriptor failed!");
296 return results;
297 }
298
299 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
300 LOG_ERROR("Write to message parcel failed!");
301 return results;
302 }
303
304 MessageParcel reply;
305 MessageOption option;
306 int32_t err = Remote()->SendRequest(
307 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_RDB), data, reply, option);
308 if (err != NO_ERROR) {
309 LOG_ERROR("fail to SendRequest. err: %{public}d", err);
310 return results;
311 }
312 ITypesUtil::Unmarshal(reply, results);
313 return results;
314 }
315
DisableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)316 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribeRdbData(
317 const std::vector<std::string> &uris, const TemplateId &templateId)
318 {
319 std::vector<OperationResult> results;
320 MessageParcel data;
321 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
322 LOG_ERROR("Write descriptor failed!");
323 return results;
324 }
325
326 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
327 LOG_ERROR("Write to message parcel failed!");
328 return results;
329 }
330
331 MessageParcel reply;
332 MessageOption option;
333 int32_t err = Remote()->SendRequest(
334 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_RDB), data, reply, option);
335 if (err != NO_ERROR) {
336 LOG_ERROR("AddTemplate fail to SendRequest. err: %{public}d", err);
337 return results;
338 }
339 ITypesUtil::Unmarshal(reply, results);
340 return results;
341 }
342
SubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId,const sptr<IDataProxyPublishedDataObserver> & observer)343 std::vector<OperationResult> DataShareServiceProxy::SubscribePublishedData(
344 const std::vector<std::string> &uris, int64_t subscriberId, const sptr<IDataProxyPublishedDataObserver> &observer)
345 {
346 std::vector<OperationResult> results;
347 MessageParcel data;
348 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
349 LOG_ERROR("Write descriptor failed!");
350 return results;
351 }
352 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
353 LOG_ERROR("Write to message parcel failed!");
354 return results;
355 }
356 if (!data.WriteRemoteObject(observer->AsObject())) {
357 LOG_ERROR("failed to WriteRemoteObject dataObserver ");
358 return results;
359 }
360
361 MessageParcel reply;
362 MessageOption option;
363 int32_t err = Remote()->SendRequest(
364 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_PUBLISHED), data, reply, option);
365 if (err != NO_ERROR) {
366 LOG_ERROR("AddTemplate fail to SendRequest. err: %{public}d", err);
367 return results;
368 }
369 ITypesUtil::Unmarshal(reply, results);
370 return results;
371 }
372
UnSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)373 std::vector<OperationResult> DataShareServiceProxy::UnSubscribePublishedData(
374 const std::vector<std::string> &uris, int64_t subscriberId)
375 {
376 std::vector<OperationResult> results;
377 MessageParcel data;
378 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
379 LOG_ERROR("Write descriptor failed!");
380 return results;
381 }
382 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
383 LOG_ERROR("Write to message parcel failed!");
384 return results;
385 }
386
387 MessageParcel reply;
388 MessageOption option;
389 int32_t err = Remote()->SendRequest(
390 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_PUBLISHED), data, reply, option);
391 if (err != NO_ERROR) {
392 LOG_ERROR("AddTemplate fail to SendRequest. err: %{public}d", err);
393 return results;
394 }
395 ITypesUtil::Unmarshal(reply, results);
396 return results;
397 }
398
EnableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)399 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribePublishedData(
400 const std::vector<std::string> &uris, int64_t subscriberId)
401 {
402 std::vector<OperationResult> results;
403 MessageParcel data;
404 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
405 LOG_ERROR("Write descriptor failed!");
406 return results;
407 }
408 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
409 LOG_ERROR("Write to message parcel failed!");
410 return results;
411 }
412
413 MessageParcel reply;
414 MessageOption option;
415 int32_t err = Remote()->SendRequest(
416 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
417 if (err != NO_ERROR) {
418 LOG_ERROR("AddTemplate fail to SendRequest. err: %{public}d", err);
419 return results;
420 }
421 ITypesUtil::Unmarshal(reply, results);
422 return results;
423 }
424
DisableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)425 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribePublishedData(
426 const std::vector<std::string> &uris, int64_t subscriberId)
427 {
428 std::vector<OperationResult> results;
429 MessageParcel data;
430 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
431 LOG_ERROR("Write descriptor failed!");
432 return results;
433 }
434 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
435 LOG_ERROR("Write to message parcel failed!");
436 return results;
437 }
438
439 MessageParcel reply;
440 MessageOption option;
441 int32_t err = Remote()->SendRequest(
442 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
443 if (err != NO_ERROR) {
444 LOG_ERROR("AddTemplate fail to SendRequest. err: %{public}d", err);
445 return results;
446 }
447 ITypesUtil::Unmarshal(reply, results);
448 return results;
449 }
450
Notify(const std::string & uri)451 void DataShareServiceProxy::Notify(const std::string &uri)
452 {
453 MessageParcel data;
454 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
455 LOG_ERROR("Write descriptor failed!");
456 return;
457 }
458 if (!ITypesUtil::Marshal(data, uri)) {
459 LOG_ERROR("Write to message parcel failed!");
460 return;
461 }
462
463 MessageParcel reply;
464 MessageOption option;
465 int32_t err = Remote()->SendRequest(
466 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_NOTIFY_OBSERVERS), data, reply, option);
467 if (err != NO_ERROR) {
468 LOG_ERROR("Notify fail to SendRequest. err: %{public}d", err);
469 return;
470 }
471 }
472 } // namespace DataShare
473 } // namespace OHOS
474