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 <cinttypes>
19 #include "data_ability_observer_interface.h"
20 #include "dataproxy_handle_common.h"
21 #include "datashare_errno.h"
22 #include "datashare_itypes_utils.h"
23 #include "datashare_log.h"
24 #include "datashare_string_utils.h"
25 #include "distributeddata_data_share_ipc_interface_code.h"
26 #include "ishared_result_set.h"
27
28 namespace OHOS {
29 namespace DataShare {
30 using InterfaceCode = OHOS::DistributedShare::DataShare::DataShareServiceInterfaceCode;
DataShareServiceProxy(const sptr<IRemoteObject> & object)31 DataShareServiceProxy::DataShareServiceProxy(const sptr<IRemoteObject> &object)
32 : IRemoteProxy<IDataShareService>(object)
33 {
34 }
35
CleanSystem()36 void DataShareServiceProxy::CleanSystem()
37 {
38 GetSystem() = false;
39 }
40
IsSystem()41 bool DataShareServiceProxy::IsSystem()
42 {
43 return GetSystem();
44 }
45
SetSystem(bool isSystem)46 void DataShareServiceProxy::SetSystem(bool isSystem)
47 {
48 GetSystem() = isSystem;
49 }
50
GetSystem()51 bool& DataShareServiceProxy::GetSystem()
52 {
53 static thread_local bool isSystem = false;
54 return isSystem;
55 }
56
CastIPCCode(DistributedShare::DataShare::DataShareServiceInterfaceCode code)57 uint32_t DataShareServiceProxy::CastIPCCode(DistributedShare::DataShare::DataShareServiceInterfaceCode code)
58 {
59 if (IsSystem()) {
60 return static_cast<uint32_t>(code) + DistributedShare::DataShare::DATA_SHARE_CMD_SYSTEM_CODE;
61 }
62 return static_cast<uint32_t>(code);
63 }
64
Insert(const Uri & uri,const Uri & extUri,const DataShareValuesBucket & value)65 int32_t DataShareServiceProxy::Insert(const Uri &uri, const Uri &extUri, const DataShareValuesBucket &value)
66 {
67 auto [errCode, status] = InsertEx(uri, extUri, value);
68 if (errCode == NO_ERROR) {
69 return status;
70 } else if (errCode < NO_ERROR) {
71 return errCode;
72 }
73 LOG_ERROR("DataShareServiceProxy insert failed, errCode = %{public}d", errCode);
74 return DATA_SHARE_ERROR;
75 }
76
Update(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate,const DataShareValuesBucket & valuesBucket)77 int32_t DataShareServiceProxy::Update(const Uri &uri, const Uri &extUri,
78 const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
79 {
80 auto [errCode, status] = UpdateEx(uri, extUri, predicate, valuesBucket);
81 if (errCode == NO_ERROR) {
82 return status;
83 } else if (errCode < NO_ERROR) {
84 return errCode;
85 }
86 LOG_ERROR("DataShareServiceProxy update failed, errCode = %{public}d", errCode);
87 return DATA_SHARE_ERROR;
88 }
89
Delete(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate)90 int32_t DataShareServiceProxy::Delete(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate)
91 {
92 auto [errCode, status] = DeleteEx(uri, extUri, predicate);
93 if (errCode == NO_ERROR) {
94 return status;
95 } else if (errCode < NO_ERROR) {
96 return errCode;
97 }
98 LOG_ERROR("DataShareServiceProxy delete failed, errCode = %{public}d", errCode);
99 return DATA_SHARE_ERROR;
100 }
101
InsertEx(const Uri & uri,const Uri & extUri,const DataShareValuesBucket & value)102 std::pair<int32_t, int32_t> DataShareServiceProxy::InsertEx(const Uri &uri, const Uri &extUri,
103 const DataShareValuesBucket &value)
104 {
105 const std::string &uriStr = uri.ToString();
106 MessageParcel data;
107 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
108 LOG_ERROR("Write descriptor failed!");
109 return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
110 }
111 if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), value)) {
112 LOG_ERROR("Write to message parcel failed!");
113 return std::make_pair(E_MARSHAL_ERROR, 0);
114 }
115
116 int32_t result = -1;
117 int32_t errCode = -1;
118 MessageParcel reply;
119 MessageOption option;
120 int32_t err = Remote()->SendRequest(
121 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_INSERTEX), data, reply, option);
122 if (err != NO_ERROR) {
123 LOG_ERROR("InsertEx fail to sendRequest. uri: %{public}s, err: %{public}d",
124 DataShareStringUtils::Anonymous(uriStr).c_str(), err);
125 return std::make_pair(DATA_SHARE_ERROR, 0);
126 }
127 if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
128 LOG_ERROR("fail to Unmarshal");
129 return std::make_pair(E_UNMARSHAL_ERROR, 0);
130 }
131 return std::make_pair(errCode, result);
132 }
133
UpdateEx(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate,const DataShareValuesBucket & valuesBucket)134 std::pair<int32_t, int32_t> DataShareServiceProxy::UpdateEx(const Uri &uri, const Uri &extUri,
135 const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
136 {
137 const std::string &uriStr = uri.ToString();
138 MessageParcel data;
139 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
140 LOG_ERROR("Write descriptor failed!");
141 return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
142 }
143 if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicate, valuesBucket)) {
144 LOG_ERROR("Write to message parcel failed!");
145 return std::make_pair(E_MARSHAL_ERROR, 0);
146 }
147
148 int32_t result = -1;
149 int32_t errCode = -1;
150 MessageParcel reply;
151 MessageOption option;
152 int32_t err = Remote()->SendRequest(
153 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_UPDATEEX), data, reply, option);
154 if (err != NO_ERROR) {
155 LOG_ERROR("UpdateEx fail to sendRequest. uri: %{public}s, err: %{public}d",
156 DataShareStringUtils::Anonymous(uriStr).c_str(), err);
157 return std::make_pair(DATA_SHARE_ERROR, 0);
158 }
159 if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
160 LOG_ERROR("fail to Unmarshal");
161 return std::make_pair(E_UNMARSHAL_ERROR, 0);
162 }
163 return std::make_pair(errCode, result);
164 }
165
DeleteEx(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate)166 std::pair<int32_t, int32_t> DataShareServiceProxy::DeleteEx(const Uri &uri, const Uri &extUri,
167 const DataSharePredicates &predicate)
168 {
169 const std::string &uriStr = uri.ToString();
170 MessageParcel data;
171 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
172 LOG_ERROR("Write descriptor failed!");
173 return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
174 }
175 if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicate)) {
176 LOG_ERROR("Write to message parcel failed!");
177 return std::make_pair(E_MARSHAL_ERROR, 0);
178 }
179
180 int32_t result = -1;
181 int32_t errCode = -1;
182 MessageParcel reply;
183 MessageOption option;
184 int32_t err = Remote()->SendRequest(
185 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_DELETEEX), data, reply, option);
186 if (err != NO_ERROR) {
187 LOG_ERROR("DeleteEx fail to sendRequest. uri: %{public}s, err: %{public}d",
188 DataShareStringUtils::Anonymous(uriStr).c_str(), err);
189 return std::make_pair(DATA_SHARE_ERROR, 0);
190 }
191 if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
192 LOG_ERROR("fail to Unmarshal");
193 return std::make_pair(E_UNMARSHAL_ERROR, 0);
194 }
195 return std::make_pair(errCode, result);
196 }
197
Query(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)198 std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri, const Uri &extUri,
199 const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
200 {
201 const std::string &uriStr = uri.ToString();
202 MessageParcel data;
203 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
204 LOG_ERROR("WriteInterfaceToken failed!");
205 businessError.SetCode(E_WRITE_TO_PARCE_ERROR);
206 return nullptr;
207 }
208
209 if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicates, columns)) {
210 LOG_ERROR("Write to message parcel failed!");
211 businessError.SetCode(E_MARSHAL_ERROR);
212 return nullptr;
213 }
214
215 MessageParcel reply;
216 MessageOption option;
217 int32_t err = Remote()->SendRequest(
218 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_QUERY), data, reply, option);
219
220 auto result = ISharedResultSet::ReadFromParcel(reply);
221 if (err != NO_ERROR) {
222 LOG_ERROR("Query fail to sendRequest. uri: %{public}s, err: %{public}d",
223 DataShareStringUtils::Anonymous(uriStr).c_str(), err);
224 businessError.SetCode(err);
225 return nullptr;
226 }
227 businessError.SetCode(reply.ReadInt32());
228 return result;
229 }
230
AddQueryTemplate(const std::string & uri,int64_t subscriberId,Template & tpl)231 int DataShareServiceProxy::AddQueryTemplate(const std::string &uri, int64_t subscriberId, Template &tpl)
232 {
233 MessageParcel data;
234 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
235 LOG_ERROR("Write descriptor failed!");
236 return DATA_SHARE_ERROR;
237 }
238 if (!tpl.update_.empty()) {
239 std::string updateSqlPrefix = "UPDATE";
240 std::string checkPrefix = tpl.update_.substr(0, updateSqlPrefix.size());
241 std::for_each(std::begin(checkPrefix), std::end(checkPrefix), [](auto &c) {
242 c = std::toupper(c);
243 });
244 if (checkPrefix != updateSqlPrefix) {
245 LOG_ERROR("Parameter update only support update SQL, Parameter: %{public}s", checkPrefix.c_str());
246 return DATA_SHARE_ERROR;
247 }
248 }
249 if (!ITypesUtil::Marshal(data, uri, subscriberId, tpl.update_, tpl.predicates_, tpl.scheduler_)) {
250 LOG_ERROR("Write to message parcel failed!");
251 return DATA_SHARE_ERROR;
252 }
253
254 MessageParcel reply;
255 MessageOption option;
256 int32_t err = Remote()->SendRequest(
257 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_ADD_TEMPLATE), data, reply, option);
258 if (err != NO_ERROR) {
259 LOG_ERROR("AddTemplate fail to sendRequest. uri: %{public}s, err: %{public}d",
260 DataShareStringUtils::Anonymous(uri).c_str(), err);
261 return DATA_SHARE_ERROR;
262 }
263 return reply.ReadInt32();
264 }
265
DelQueryTemplate(const std::string & uri,int64_t subscriberId)266 int DataShareServiceProxy::DelQueryTemplate(const std::string &uri, int64_t subscriberId)
267 {
268 MessageParcel data;
269 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
270 LOG_ERROR("Write descriptor failed!");
271 return DATA_SHARE_ERROR;
272 }
273 if (!ITypesUtil::Marshal(data, uri, subscriberId)) {
274 LOG_ERROR("Write to message parcel failed!");
275 return DATA_SHARE_ERROR;
276 }
277
278 MessageParcel reply;
279 MessageOption option;
280 int32_t err = Remote()->SendRequest(
281 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_DEL_TEMPLATE), data, reply, option);
282 if (err != NO_ERROR) {
283 LOG_ERROR("Delete template fail to sendRequest. uri: %{public}s, err: %{public}d",
284 DataShareStringUtils::Anonymous(uri).c_str(), err);
285 return DATA_SHARE_ERROR;
286 }
287 return reply.ReadInt32();
288 }
289
Publish(const Data & data,const std::string & bundleName)290 std::vector<OperationResult> DataShareServiceProxy::Publish(const Data &data, const std::string &bundleName)
291 {
292 std::vector<OperationResult> results;
293 MessageParcel parcel;
294 if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
295 LOG_ERROR("Write descriptor failed!");
296 return results;
297 }
298 if (!ITypesUtil::Marshal(parcel, data, bundleName)) {
299 LOG_ERROR("Marshalfailed!");
300 return results;
301 }
302
303 MessageParcel reply;
304 MessageOption option;
305 int32_t err = Remote()->SendRequest(
306 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_PUBLISH), parcel, reply, option);
307 if (err != NO_ERROR) {
308 LOG_ERROR("Publish fail to sendRequest. err: %{public}d", err);
309 return results;
310 }
311
312 ITypesUtil::Unmarshal(reply, results);
313 return results;
314 }
315
GetPublishedData(const std::string & bundleName,int & resultCode)316 Data DataShareServiceProxy::GetPublishedData(const std::string &bundleName, int &resultCode)
317 {
318 Data results;
319 MessageParcel data;
320 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
321 LOG_ERROR("Write descriptor failed!");
322 return results;
323 }
324 if (!ITypesUtil::Marshal(data, bundleName)) {
325 LOG_ERROR("Write to message parcel failed!");
326 return results;
327 }
328
329 MessageParcel reply;
330 MessageOption option;
331 int32_t err = Remote()->SendRequest(
332 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_GET_DATA), data, reply, option);
333 if (err != NO_ERROR) {
334 LOG_ERROR("Get published data fail to sendRequest, err: %{public}d", err);
335 return results;
336 }
337 ITypesUtil::Unmarshal(reply, results.datas_, resultCode);
338 return results;
339 }
340
SubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId,const sptr<IDataProxyRdbObserver> & observer)341 std::vector<OperationResult> DataShareServiceProxy::SubscribeRdbData(const std::vector<std::string> &uris,
342 const TemplateId &templateId, const sptr<IDataProxyRdbObserver> &observer)
343 {
344 std::vector<OperationResult> results;
345 if (observer == nullptr) {
346 LOG_ERROR("Observer is nullptr, subscriberId: %{public}" PRId64, templateId.subscriberId_);
347 return results;
348 }
349 MessageParcel data;
350 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
351 LOG_ERROR("Write descriptor failed!");
352 return results;
353 }
354
355 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
356 LOG_ERROR("Write to message parcel failed!");
357 return results;
358 }
359 if (!data.WriteRemoteObject(observer->AsObject())) {
360 LOG_ERROR("Failed to write parcelable dataObserver ");
361 return results;
362 }
363
364 MessageParcel reply;
365 MessageOption option;
366 int32_t err = Remote()->SendRequest(
367 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_RDB), data, reply, option);
368 if (err != NO_ERROR) {
369 LOG_ERROR("SubscribeRdbData fail to sendRequest. err: %{public}d", err);
370 return results;
371 }
372 ITypesUtil::Unmarshal(reply, results);
373 return results;
374 }
375
UnSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)376 std::vector<OperationResult> DataShareServiceProxy::UnSubscribeRdbData(
377 const std::vector<std::string> &uris, const TemplateId &templateId)
378 {
379 std::vector<OperationResult> results;
380 MessageParcel data;
381 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
382 LOG_ERROR("Write descriptor failed!");
383 return results;
384 }
385
386 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
387 LOG_ERROR("Write to message parcel failed!");
388 return results;
389 }
390
391 MessageParcel reply;
392 MessageOption option;
393 int32_t err = Remote()->SendRequest(
394 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_RDB), data, reply, option);
395 if (err != NO_ERROR) {
396 LOG_ERROR("Fail to sendRequest. err: %{public}d", err);
397 return results;
398 }
399 ITypesUtil::Unmarshal(reply, results);
400 return results;
401 }
402
EnableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)403 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribeRdbData(
404 const std::vector<std::string> &uris, const TemplateId &templateId)
405 {
406 std::vector<OperationResult> results;
407 MessageParcel data;
408 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
409 LOG_ERROR("Write descriptor failed!");
410 return results;
411 }
412
413 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
414 LOG_ERROR("Write to message parcel failed!");
415 return results;
416 }
417
418 MessageParcel reply;
419 MessageOption option;
420 int32_t err = Remote()->SendRequest(
421 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_RDB), data, reply, option);
422 if (err != NO_ERROR) {
423 LOG_ERROR("Fail to sendRequest. err: %{public}d", err);
424 return results;
425 }
426 ITypesUtil::Unmarshal(reply, results);
427 return results;
428 }
429
DisableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)430 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribeRdbData(
431 const std::vector<std::string> &uris, const TemplateId &templateId)
432 {
433 std::vector<OperationResult> results;
434 MessageParcel data;
435 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
436 LOG_ERROR("Write descriptor failed!");
437 return results;
438 }
439
440 if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
441 LOG_ERROR("Write to message parcel failed!");
442 return results;
443 }
444
445 MessageParcel reply;
446 MessageOption option;
447 int32_t err = Remote()->SendRequest(
448 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_RDB), data, reply, option);
449 if (err != NO_ERROR) {
450 LOG_ERROR("Disable subscribe RdbData fail to sendRequest. err: %{public}d", err);
451 return results;
452 }
453 ITypesUtil::Unmarshal(reply, results);
454 return results;
455 }
456
SubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId,const sptr<IDataProxyPublishedDataObserver> & observer)457 std::vector<OperationResult> DataShareServiceProxy::SubscribePublishedData(
458 const std::vector<std::string> &uris, int64_t subscriberId, const sptr<IDataProxyPublishedDataObserver> &observer)
459 {
460 std::vector<OperationResult> results;
461 if (observer == nullptr) {
462 LOG_ERROR("Observer is nullptr, subscriberId: %{public}" PRId64, subscriberId);
463 return results;
464 }
465 MessageParcel data;
466 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
467 LOG_ERROR("Write descriptor failed!");
468 return results;
469 }
470 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
471 LOG_ERROR("Write to message parcel failed!");
472 return results;
473 }
474 if (!data.WriteRemoteObject(observer->AsObject())) {
475 LOG_ERROR("Failed to write remote object dataObserver ");
476 return results;
477 }
478
479 MessageParcel reply;
480 MessageOption option;
481 int32_t err = Remote()->SendRequest(
482 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_PUBLISHED), data, reply, option);
483 if (err != NO_ERROR) {
484 LOG_ERROR("Subscribe published data fail to sendRequest. err: %{public}d", err);
485 return results;
486 }
487 ITypesUtil::Unmarshal(reply, results);
488 return results;
489 }
490
UnSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)491 std::vector<OperationResult> DataShareServiceProxy::UnSubscribePublishedData(
492 const std::vector<std::string> &uris, int64_t subscriberId)
493 {
494 std::vector<OperationResult> results;
495 MessageParcel data;
496 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
497 LOG_ERROR("Write descriptor failed!");
498 return results;
499 }
500 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
501 LOG_ERROR("Write to message parcel failed!");
502 return results;
503 }
504
505 MessageParcel reply;
506 MessageOption option;
507 int32_t err = Remote()->SendRequest(
508 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_PUBLISHED), data, reply, option);
509 if (err != NO_ERROR) {
510 LOG_ERROR("UnSubscribe published data fail to sendRequest. err: %{public}d", err);
511 return results;
512 }
513 ITypesUtil::Unmarshal(reply, results);
514 return results;
515 }
516
EnableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)517 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribePublishedData(
518 const std::vector<std::string> &uris, int64_t subscriberId)
519 {
520 std::vector<OperationResult> results;
521 MessageParcel data;
522 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
523 LOG_ERROR("Write descriptor failed!");
524 return results;
525 }
526 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
527 LOG_ERROR("Write to message parcel failed!");
528 return results;
529 }
530
531 MessageParcel reply;
532 MessageOption option;
533 int32_t err = Remote()->SendRequest(
534 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
535 if (err != NO_ERROR) {
536 LOG_ERROR("Enable subscribe published data fail to sendRequest. err: %{public}d", err);
537 return results;
538 }
539 ITypesUtil::Unmarshal(reply, results);
540 return results;
541 }
542
DisableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)543 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribePublishedData(
544 const std::vector<std::string> &uris, int64_t subscriberId)
545 {
546 std::vector<OperationResult> results;
547 MessageParcel data;
548 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
549 LOG_ERROR("Write descriptor failed!");
550 return results;
551 }
552 if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
553 LOG_ERROR("Write to message parcel failed!");
554 return results;
555 }
556
557 MessageParcel reply;
558 MessageOption option;
559 int32_t err = Remote()->SendRequest(
560 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
561 if (err != NO_ERROR) {
562 LOG_ERROR("Disable subscribe published data fail to sendRequest. err: %{public}d", err);
563 return results;
564 }
565 ITypesUtil::Unmarshal(reply, results);
566 return results;
567 }
568
Notify(const std::string & uri)569 void DataShareServiceProxy::Notify(const std::string &uri)
570 {
571 MessageParcel data;
572 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
573 LOG_ERROR("Write descriptor failed!");
574 return;
575 }
576 if (!ITypesUtil::Marshal(data, uri)) {
577 LOG_ERROR("Write to message parcel failed!");
578 return;
579 }
580
581 MessageParcel reply;
582 MessageOption option;
583 int32_t err = Remote()->SendRequest(
584 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_NOTIFY_OBSERVERS), data, reply, option);
585 if (err != NO_ERROR) {
586 LOG_ERROR("Notify fail to sendRequest. err: %{public}d", err);
587 return;
588 }
589 }
590
SetSilentSwitch(const Uri & uri,bool enable)591 int DataShareServiceProxy::SetSilentSwitch(const Uri &uri, bool enable)
592 {
593 const std::string &uriStr = uri.ToString();
594 MessageParcel data;
595 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
596 LOG_ERROR("Write descriptor failed!");
597 return DATA_SHARE_ERROR;
598 }
599 if (!ITypesUtil::Marshal(data, uriStr, enable)) {
600 LOG_ERROR("Write to message parcel failed!");
601 return DATA_SHARE_ERROR;
602 }
603
604 MessageParcel reply;
605 MessageOption option;
606 int32_t err = Remote()->SendRequest(
607 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_SET_SILENT_SWITCH), data, reply, option);
608 if (err != NO_ERROR) {
609 LOG_ERROR("SetSilentSwitch fail to sendRequest. uri: %{public}s, err: %{public}d",
610 DataShareStringUtils::Anonymous(uriStr).c_str(), err);
611 if (err == E_NOT_SYSTEM_APP) {
612 return E_NOT_SYSTEM_APP;
613 }
614 return DATA_SHARE_ERROR;
615 }
616 return reply.ReadInt32();
617 }
618
GetSilentProxyStatus(const std::string & uri)619 int DataShareServiceProxy::GetSilentProxyStatus(const std::string &uri)
620 {
621 MessageParcel data;
622 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
623 LOG_ERROR("Write descriptor failed!");
624 return DATA_SHARE_ERROR;
625 }
626 if (!ITypesUtil::Marshal(data, uri)) {
627 LOG_ERROR("Write to message parcel failed!");
628 return DATA_SHARE_ERROR;
629 }
630
631 MessageParcel reply;
632 MessageOption option;
633 int32_t err = Remote()->SendRequest(
634 CastIPCCode(InterfaceCode::DATA_SHARE_SERVICE_CMD_GET_SILENT_PROXY_STATUS), data, reply, option);
635 if (err != NO_ERROR) {
636 LOG_ERROR("Is silent proxy enable fail to sendRequest. uri: %{public}s, err: %{public}d",
637 DataShareStringUtils::Anonymous(uri).c_str(), err);
638 return DATA_SHARE_ERROR;
639 }
640 return reply.ReadInt32();
641 }
642
RegisterObserver(const Uri & uri,const sptr<OHOS::IRemoteObject> & dataObserver)643 int DataShareServiceProxy::RegisterObserver(const Uri &uri, const sptr<OHOS::IRemoteObject> &dataObserver)
644 {
645 if (dataObserver == nullptr) {
646 LOG_ERROR("DataObserver is nullptr, uri:%{public}s",
647 DataShareStringUtils::Anonymous(uri.ToString()).c_str());
648 return DATA_SHARE_ERROR;
649 }
650 MessageParcel data;
651 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
652 LOG_ERROR("Write interface token failed");
653 return DATA_SHARE_ERROR;
654 }
655 if (!ITypesUtil::Marshal(data, uri.ToString(), dataObserver)) {
656 LOG_ERROR("Failed to marshalling");
657 return DATA_SHARE_ERROR;
658 }
659 MessageParcel reply;
660 MessageOption option;
661 int32_t err = Remote()->SendRequest(
662 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_REGISTER_OBSERVER), data, reply, option);
663 if (err != NO_ERROR) {
664 LOG_ERROR("RegisterObserver fail to sendRequest. uri:%{public}s, err:%{public}d",
665 DataShareStringUtils::Anonymous(uri.ToString()).c_str(), err);
666 return DATA_SHARE_ERROR;
667 }
668 return reply.ReadInt32();
669 }
670
UnRegisterObserver(const Uri & uri,const sptr<OHOS::IRemoteObject> & dataObserver)671 int DataShareServiceProxy::UnRegisterObserver(const Uri &uri, const sptr<OHOS::IRemoteObject> &dataObserver)
672 {
673 if (dataObserver == nullptr) {
674 LOG_ERROR("DataObserver is nullptr, uri:%{public}s",
675 DataShareStringUtils::Anonymous(uri.ToString()).c_str());
676 return DATA_SHARE_ERROR;
677 }
678 MessageParcel data;
679 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
680 LOG_ERROR("Write interface token failed");
681 return DATA_SHARE_ERROR;
682 }
683 if (!ITypesUtil::Marshal(data, uri.ToString(), dataObserver)) {
684 LOG_ERROR("Failed to Marshalling");
685 return DATA_SHARE_ERROR;
686 }
687 MessageParcel reply;
688 MessageOption option;
689 int32_t err = Remote()->SendRequest(
690 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNREGISTER_OBSERVER), data, reply, option);
691 if (err != NO_ERROR) {
692 LOG_ERROR("UnRegisterObserver fail to sendRequest. uri: %{public}s, err: %{public}d",
693 DataShareStringUtils::Anonymous(uri.ToString()).c_str(), err);
694 return DATA_SHARE_ERROR;
695 }
696 return reply.ReadInt32();
697 }
698
PublishProxyData(const std::vector<DataShareProxyData> & proxyDatas,const DataProxyConfig & proxyConfig)699 std::vector<DataProxyResult> DataShareServiceProxy::PublishProxyData(
700 const std::vector<DataShareProxyData> &proxyDatas, const DataProxyConfig &proxyConfig)
701 {
702 std::vector<DataProxyResult> results;
703 MessageParcel parcel;
704 if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
705 LOG_ERROR("Write descriptor failed!");
706 return results;
707 }
708 if (!ITypesUtil::Marshal(parcel, proxyDatas, proxyConfig)) {
709 LOG_ERROR("Marshal failed!");
710 return results;
711 }
712
713 MessageParcel reply;
714 MessageOption option;
715 int32_t err = Remote()->SendRequest(
716 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_PROXY_PUBLISH), parcel, reply, option);
717 if (err != NO_ERROR) {
718 LOG_ERROR("PublishProxyData fail to sendRequest. err: %{public}d", err);
719 return results;
720 }
721
722 ITypesUtil::Unmarshal(reply, results);
723 return results;
724 }
725
DeleteProxyData(const std::vector<std::string> & uris,const DataProxyConfig & proxyConfig)726 std::vector<DataProxyResult> DataShareServiceProxy::DeleteProxyData(
727 const std::vector<std::string> &uris, const DataProxyConfig &proxyConfig)
728 {
729 std::vector<DataProxyResult> results;
730 MessageParcel parcel;
731 if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
732 LOG_ERROR("Write descriptor failed!");
733 return results;
734 }
735 if (!ITypesUtil::Marshal(parcel, uris, proxyConfig)) {
736 LOG_ERROR("Marshal failed!");
737 return results;
738 }
739
740 MessageParcel reply;
741 MessageOption option;
742 int32_t err = Remote()->SendRequest(
743 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_PROXY_DELETE), parcel, reply, option);
744 if (err != NO_ERROR) {
745 LOG_ERROR("DeleteProxyData fail to sendRequest. err: %{public}d", err);
746 return results;
747 }
748
749 ITypesUtil::Unmarshal(reply, results);
750 return results;
751 }
752
GetProxyData(const std::vector<std::string> uris,const DataProxyConfig & proxyConfig)753 std::vector<DataProxyGetResult> DataShareServiceProxy::GetProxyData(const std::vector<std::string> uris,
754 const DataProxyConfig &proxyConfig)
755 {
756 std::vector<DataProxyGetResult> results;
757 MessageParcel parcel;
758 if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
759 LOG_ERROR("Write descriptor failed!");
760 return results;
761 }
762 if (!ITypesUtil::Marshal(parcel, uris, proxyConfig)) {
763 LOG_ERROR("Marshal failed!");
764 return results;
765 }
766
767 MessageParcel reply;
768 MessageOption option;
769 int32_t err = Remote()->SendRequest(
770 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_PROXY_GET), parcel, reply, option);
771 if (err != NO_ERROR) {
772 LOG_ERROR("GetProxyData fail to sendRequest. err: %{public}d", err);
773 return results;
774 }
775
776 ITypesUtil::Unmarshal(reply, results);
777 return results;
778 }
779
SubscribeProxyData(const std::vector<std::string> & uris,const sptr<IProxyDataObserver> & observer)780 std::vector<DataProxyResult> DataShareServiceProxy::SubscribeProxyData(const std::vector<std::string> &uris,
781 const sptr<IProxyDataObserver> &observer)
782 {
783 std::vector<DataProxyResult> results;
784 if (observer == nullptr) {
785 LOG_ERROR("Observer is nullptr");
786 return results;
787 }
788 MessageParcel data;
789 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
790 LOG_ERROR("Write descriptor failed!");
791 return results;
792 }
793
794 if (!ITypesUtil::Marshal(data, uris)) {
795 LOG_ERROR("Write to message parcel failed!");
796 return results;
797 }
798 if (!data.WriteRemoteObject(observer->AsObject())) {
799 LOG_ERROR("Failed to write parcelable dataObserver ");
800 return results;
801 }
802
803 MessageParcel reply;
804 MessageOption option;
805 int32_t err = Remote()->SendRequest(
806 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_PROXY_DATA), data, reply, option);
807 if (err != NO_ERROR) {
808 LOG_ERROR("SubscribeRdbData fail to sendRequest. err: %{public}d", err);
809 return results;
810 }
811 ITypesUtil::Unmarshal(reply, results);
812 return results;
813 }
814
UnsubscribeProxyData(const std::vector<std::string> & uris)815 std::vector<DataProxyResult> DataShareServiceProxy::UnsubscribeProxyData(const std::vector<std::string> &uris)
816 {
817 std::vector<DataProxyResult> results;
818 MessageParcel data;
819 if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
820 LOG_ERROR("Write descriptor failed!");
821 return results;
822 }
823
824 if (!ITypesUtil::Marshal(data, uris)) {
825 LOG_ERROR("Write to message parcel failed!");
826 return results;
827 }
828
829 MessageParcel reply;
830 MessageOption option;
831 int32_t err = Remote()->SendRequest(
832 static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_PROXY_DATA), data, reply, option);
833 if (err != NO_ERROR) {
834 LOG_ERROR("Fail to sendRequest. err: %{public}d", err);
835 return results;
836 }
837 ITypesUtil::Unmarshal(reply, results);
838 return results;
839 }
840 } // namespace DataShare
841 } // namespace OHOS
842