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 "datashare_itypes_utils.h"
21 #include "datashare_log.h"
22 #include "datashare_string_utils.h"
23 #include "ishared_result_set.h"
24 
25 namespace OHOS {
26 namespace DataShare {
27 using InterfaceCode = OHOS::DistributedShare::DataShare::DataShareServiceInterfaceCode;
DataShareServiceProxy(const sptr<IRemoteObject> & object)28 DataShareServiceProxy::DataShareServiceProxy(const sptr<IRemoteObject> &object)
29     : IRemoteProxy<IDataShareService>(object)
30 {
31 }
32 
Insert(const Uri & uri,const Uri & extUri,const DataShareValuesBucket & value)33 int32_t DataShareServiceProxy::Insert(const Uri &uri, const Uri &extUri, const DataShareValuesBucket &value)
34 {
35     auto [errCode, status] = InsertEx(uri, extUri, value);
36     if (errCode == NO_ERROR) {
37         return status;
38     } else if (errCode < NO_ERROR) {
39         return errCode;
40     }
41     LOG_ERROR("DataShareServiceProxy insert failed, errCode = %{public}d", errCode);
42     return DATA_SHARE_ERROR;
43 }
44 
Update(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate,const DataShareValuesBucket & valuesBucket)45 int32_t DataShareServiceProxy::Update(const Uri &uri, const Uri &extUri,
46     const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
47 {
48     auto [errCode, status] = UpdateEx(uri, extUri, predicate, valuesBucket);
49     if (errCode == NO_ERROR) {
50         return status;
51     } else if (errCode < NO_ERROR) {
52         return errCode;
53     }
54     LOG_ERROR("DataShareServiceProxy update failed, errCode = %{public}d", errCode);
55     return DATA_SHARE_ERROR;
56 }
57 
Delete(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate)58 int32_t DataShareServiceProxy::Delete(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate)
59 {
60     auto [errCode, status] = DeleteEx(uri, extUri, predicate);
61     if (errCode == NO_ERROR) {
62         return status;
63     } else if (errCode < NO_ERROR) {
64         return errCode;
65     }
66     LOG_ERROR("DataShareServiceProxy delete failed, errCode = %{public}d", errCode);
67     return DATA_SHARE_ERROR;
68 }
69 
InsertEx(const Uri & uri,const Uri & extUri,const DataShareValuesBucket & value)70 std::pair<int32_t, int32_t> DataShareServiceProxy::InsertEx(const Uri &uri, const Uri &extUri,
71     const DataShareValuesBucket &value)
72 {
73     const std::string &uriStr = uri.ToString();
74     MessageParcel data;
75     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
76         LOG_ERROR("Write descriptor failed!");
77         return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
78     }
79     if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), value)) {
80         LOG_ERROR("Write to message parcel failed!");
81         return std::make_pair(E_MARSHAL_ERROR, 0);
82     }
83 
84     int32_t result = -1;
85     int32_t errCode = -1;
86     MessageParcel reply;
87     MessageOption option;
88     int32_t err = Remote()->SendRequest(
89         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_INSERTEX), data, reply, option);
90     if (err != NO_ERROR) {
91         LOG_ERROR("InsertEx fail to sendRequest. uri: %{public}s, err: %{public}d",
92             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
93         return std::make_pair(DATA_SHARE_ERROR, 0);
94     }
95     if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
96         LOG_ERROR("fail to Unmarshal");
97         return std::make_pair(E_UNMARSHAL_ERROR, 0);
98     }
99     return std::make_pair(errCode, result);
100 }
101 
UpdateEx(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate,const DataShareValuesBucket & valuesBucket)102 std::pair<int32_t, int32_t> DataShareServiceProxy::UpdateEx(const Uri &uri, const Uri &extUri,
103     const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
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(), predicate, valuesBucket)) {
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         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UPDATEEX), data, reply, option);
122     if (err != NO_ERROR) {
123         LOG_ERROR("UpdateEx 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 
DeleteEx(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicate)134 std::pair<int32_t, int32_t> DataShareServiceProxy::DeleteEx(const Uri &uri, const Uri &extUri,
135     const DataSharePredicates &predicate)
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)) {
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         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DELETEEX), data, reply, option);
154     if (err != NO_ERROR) {
155         LOG_ERROR("DeleteEx 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 
Query(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)166 std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri, const Uri &extUri,
167     const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
168 {
169     const std::string &uriStr = uri.ToString();
170     MessageParcel data;
171     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
172         LOG_ERROR("WriteInterfaceToken failed!");
173         return nullptr;
174     }
175 
176     if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicates, columns)) {
177         LOG_ERROR("Write to message parcel failed!");
178         return nullptr;
179     }
180 
181     MessageParcel reply;
182     MessageOption option;
183     int32_t err = Remote()->SendRequest(
184         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_QUERY), data, reply, option);
185 
186     auto result = ISharedResultSet::ReadFromParcel(reply);
187     businessError.SetCode(reply.ReadInt32());
188     if (err != NO_ERROR) {
189         LOG_ERROR("Query fail to sendRequest. uri: %{public}s, err: %{public}d",
190             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
191         return nullptr;
192     }
193     return result;
194 }
195 
AddQueryTemplate(const std::string & uri,int64_t subscriberId,Template & tpl)196 int DataShareServiceProxy::AddQueryTemplate(const std::string &uri, int64_t subscriberId, Template &tpl)
197 {
198     MessageParcel data;
199     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
200         LOG_ERROR("Write descriptor failed!");
201         return DATA_SHARE_ERROR;
202     }
203     if (!ITypesUtil::Marshal(data, uri, subscriberId, tpl.predicates_, tpl.scheduler_)) {
204         LOG_ERROR("Write to message parcel failed!");
205         return DATA_SHARE_ERROR;
206     }
207 
208     MessageParcel reply;
209     MessageOption option;
210     int32_t err = Remote()->SendRequest(
211         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ADD_TEMPLATE), data, reply, option);
212     if (err != NO_ERROR) {
213         LOG_ERROR("AddTemplate fail to sendRequest. uri: %{public}s, err: %{public}d",
214             DataShareStringUtils::Anonymous(uri).c_str(), err);
215         return DATA_SHARE_ERROR;
216     }
217     return reply.ReadInt32();
218 }
219 
DelQueryTemplate(const std::string & uri,int64_t subscriberId)220 int DataShareServiceProxy::DelQueryTemplate(const std::string &uri, int64_t subscriberId)
221 {
222     MessageParcel data;
223     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
224         LOG_ERROR("Write descriptor failed!");
225         return DATA_SHARE_ERROR;
226     }
227     if (!ITypesUtil::Marshal(data, uri, subscriberId)) {
228         LOG_ERROR("Write to message parcel failed!");
229         return DATA_SHARE_ERROR;
230     }
231 
232     MessageParcel reply;
233     MessageOption option;
234     int32_t err = Remote()->SendRequest(
235         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DEL_TEMPLATE), data, reply, option);
236     if (err != NO_ERROR) {
237         LOG_ERROR("Delete template fail to sendRequest. uri: %{public}s, err: %{public}d",
238             DataShareStringUtils::Anonymous(uri).c_str(), err);
239         return DATA_SHARE_ERROR;
240     }
241     return reply.ReadInt32();
242 }
243 
Publish(const Data & data,const std::string & bundleName)244 std::vector<OperationResult> DataShareServiceProxy::Publish(const Data &data, const std::string &bundleName)
245 {
246     std::vector<OperationResult> results;
247     MessageParcel parcel;
248     if (!parcel.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
249         LOG_ERROR("Write descriptor failed!");
250         return results;
251     }
252     if (!ITypesUtil::Marshal(parcel, data, bundleName)) {
253         LOG_ERROR("Marshalfailed!");
254         return results;
255     }
256 
257     MessageParcel reply;
258     MessageOption option;
259     int32_t err = Remote()->SendRequest(
260         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_PUBLISH), parcel, reply, option);
261     if (err != NO_ERROR) {
262         LOG_ERROR("Publish fail to sendRequest. err: %{public}d", err);
263         return results;
264     }
265 
266     ITypesUtil::Unmarshal(reply, results);
267     return results;
268 }
269 
GetPublishedData(const std::string & bundleName,int & resultCode)270 Data DataShareServiceProxy::GetPublishedData(const std::string &bundleName, int &resultCode)
271 {
272     Data results;
273     MessageParcel data;
274     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
275         LOG_ERROR("Write descriptor failed!");
276         return results;
277     }
278     if (!ITypesUtil::Marshal(data, bundleName)) {
279         LOG_ERROR("Write to message parcel failed!");
280         return results;
281     }
282 
283     MessageParcel reply;
284     MessageOption option;
285     int32_t err = Remote()->SendRequest(
286         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_GET_DATA), data, reply, option);
287     if (err != NO_ERROR) {
288         LOG_ERROR("Get published data fail to sendRequest, err: %{public}d", err);
289         return results;
290     }
291     ITypesUtil::Unmarshal(reply, results.datas_, resultCode);
292     return results;
293 }
294 
SubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId,const sptr<IDataProxyRdbObserver> & observer)295 std::vector<OperationResult> DataShareServiceProxy::SubscribeRdbData(const std::vector<std::string> &uris,
296     const TemplateId &templateId, const sptr<IDataProxyRdbObserver> &observer)
297 {
298     std::vector<OperationResult> results;
299     if (observer == nullptr) {
300         LOG_ERROR("Observer is nullptr, subscriberId: %{public}" PRId64, templateId.subscriberId_);
301         return results;
302     }
303     MessageParcel data;
304     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
305         LOG_ERROR("Write descriptor failed!");
306         return results;
307     }
308 
309     if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
310         LOG_ERROR("Write to message parcel failed!");
311         return results;
312     }
313     if (!data.WriteRemoteObject(observer->AsObject())) {
314         LOG_ERROR("Failed to write parcelable dataObserver ");
315         return results;
316     }
317 
318     MessageParcel reply;
319     MessageOption option;
320     int32_t err = Remote()->SendRequest(
321         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_RDB), data, reply, option);
322     if (err != NO_ERROR) {
323         LOG_ERROR("SubscribeRdbData fail to sendRequest. err: %{public}d", err);
324         return results;
325     }
326     ITypesUtil::Unmarshal(reply, results);
327     return results;
328 }
329 
UnSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)330 std::vector<OperationResult> DataShareServiceProxy::UnSubscribeRdbData(
331     const std::vector<std::string> &uris, const TemplateId &templateId)
332 {
333     std::vector<OperationResult> results;
334     MessageParcel data;
335     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
336         LOG_ERROR("Write descriptor failed!");
337         return results;
338     }
339 
340     if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
341         LOG_ERROR("Write to message parcel failed!");
342         return results;
343     }
344 
345     MessageParcel reply;
346     MessageOption option;
347     int32_t err = Remote()->SendRequest(
348         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_RDB), data, reply, option);
349     if (err != NO_ERROR) {
350         LOG_ERROR("Fail to sendRequest. err: %{public}d", err);
351         return results;
352     }
353     ITypesUtil::Unmarshal(reply, results);
354     return results;
355 }
356 
EnableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)357 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribeRdbData(
358     const std::vector<std::string> &uris, const TemplateId &templateId)
359 {
360     std::vector<OperationResult> results;
361     MessageParcel data;
362     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
363         LOG_ERROR("Write descriptor failed!");
364         return results;
365     }
366 
367     if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
368         LOG_ERROR("Write to message parcel failed!");
369         return results;
370     }
371 
372     MessageParcel reply;
373     MessageOption option;
374     int32_t err = Remote()->SendRequest(
375         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_RDB), data, reply, option);
376     if (err != NO_ERROR) {
377         LOG_ERROR("Fail to sendRequest. err: %{public}d", err);
378         return results;
379     }
380     ITypesUtil::Unmarshal(reply, results);
381     return results;
382 }
383 
DisableSubscribeRdbData(const std::vector<std::string> & uris,const TemplateId & templateId)384 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribeRdbData(
385     const std::vector<std::string> &uris, const TemplateId &templateId)
386 {
387     std::vector<OperationResult> results;
388     MessageParcel data;
389     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
390         LOG_ERROR("Write descriptor failed!");
391         return results;
392     }
393 
394     if (!ITypesUtil::Marshal(data, uris, templateId.subscriberId_, templateId.bundleName_)) {
395         LOG_ERROR("Write to message parcel failed!");
396         return results;
397     }
398 
399     MessageParcel reply;
400     MessageOption option;
401     int32_t err = Remote()->SendRequest(
402         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_RDB), data, reply, option);
403     if (err != NO_ERROR) {
404         LOG_ERROR("Disable subscribe RdbData fail to sendRequest. err: %{public}d", err);
405         return results;
406     }
407     ITypesUtil::Unmarshal(reply, results);
408     return results;
409 }
410 
SubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId,const sptr<IDataProxyPublishedDataObserver> & observer)411 std::vector<OperationResult> DataShareServiceProxy::SubscribePublishedData(
412     const std::vector<std::string> &uris, int64_t subscriberId, const sptr<IDataProxyPublishedDataObserver> &observer)
413 {
414     std::vector<OperationResult> results;
415     if (observer == nullptr) {
416         LOG_ERROR("Observer is nullptr, subscriberId: %{public}" PRId64, subscriberId);
417         return results;
418     }
419     MessageParcel data;
420     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
421         LOG_ERROR("Write descriptor failed!");
422         return results;
423     }
424     if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
425         LOG_ERROR("Write to message parcel failed!");
426         return results;
427     }
428     if (!data.WriteRemoteObject(observer->AsObject())) {
429         LOG_ERROR("Failed to write remote object dataObserver ");
430         return results;
431     }
432 
433     MessageParcel reply;
434     MessageOption option;
435     int32_t err = Remote()->SendRequest(
436         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SUBSCRIBE_PUBLISHED), data, reply, option);
437     if (err != NO_ERROR) {
438         LOG_ERROR("Subscribe published data fail to sendRequest. err: %{public}d", err);
439         return results;
440     }
441     ITypesUtil::Unmarshal(reply, results);
442     return results;
443 }
444 
UnSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)445 std::vector<OperationResult> DataShareServiceProxy::UnSubscribePublishedData(
446     const std::vector<std::string> &uris, int64_t subscriberId)
447 {
448     std::vector<OperationResult> results;
449     MessageParcel data;
450     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
451         LOG_ERROR("Write descriptor failed!");
452         return results;
453     }
454     if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
455         LOG_ERROR("Write to message parcel failed!");
456         return results;
457     }
458 
459     MessageParcel reply;
460     MessageOption option;
461     int32_t err = Remote()->SendRequest(
462         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNSUBSCRIBE_PUBLISHED), data, reply, option);
463     if (err != NO_ERROR) {
464         LOG_ERROR("UnSubscribe published data fail to sendRequest. err: %{public}d", err);
465         return results;
466     }
467     ITypesUtil::Unmarshal(reply, results);
468     return results;
469 }
470 
EnableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)471 std::vector<OperationResult> DataShareServiceProxy::EnableSubscribePublishedData(
472     const std::vector<std::string> &uris, int64_t subscriberId)
473 {
474     std::vector<OperationResult> results;
475     MessageParcel data;
476     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
477         LOG_ERROR("Write descriptor failed!");
478         return results;
479     }
480     if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
481         LOG_ERROR("Write to message parcel failed!");
482         return results;
483     }
484 
485     MessageParcel reply;
486     MessageOption option;
487     int32_t err = Remote()->SendRequest(
488         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_ENABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
489     if (err != NO_ERROR) {
490         LOG_ERROR("Enable subscribe published data fail to sendRequest. err: %{public}d", err);
491         return results;
492     }
493     ITypesUtil::Unmarshal(reply, results);
494     return results;
495 }
496 
DisableSubscribePublishedData(const std::vector<std::string> & uris,int64_t subscriberId)497 std::vector<OperationResult> DataShareServiceProxy::DisableSubscribePublishedData(
498     const std::vector<std::string> &uris, int64_t subscriberId)
499 {
500     std::vector<OperationResult> results;
501     MessageParcel data;
502     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
503         LOG_ERROR("Write descriptor failed!");
504         return results;
505     }
506     if (!ITypesUtil::Marshal(data, uris, subscriberId)) {
507         LOG_ERROR("Write to message parcel failed!");
508         return results;
509     }
510 
511     MessageParcel reply;
512     MessageOption option;
513     int32_t err = Remote()->SendRequest(
514         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DISABLE_SUBSCRIBE_PUBLISHED), data, reply, option);
515     if (err != NO_ERROR) {
516         LOG_ERROR("Disable subscribe published data fail to sendRequest. err: %{public}d", err);
517         return results;
518     }
519     ITypesUtil::Unmarshal(reply, results);
520     return results;
521 }
522 
Notify(const std::string & uri)523 void DataShareServiceProxy::Notify(const std::string &uri)
524 {
525     MessageParcel data;
526     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
527         LOG_ERROR("Write descriptor failed!");
528         return;
529     }
530     if (!ITypesUtil::Marshal(data, uri)) {
531         LOG_ERROR("Write to message parcel failed!");
532         return;
533     }
534 
535     MessageParcel reply;
536     MessageOption option;
537     int32_t err = Remote()->SendRequest(
538         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_NOTIFY_OBSERVERS), data, reply, option);
539     if (err != NO_ERROR) {
540         LOG_ERROR("Notify fail to sendRequest. err: %{public}d", err);
541         return;
542     }
543 }
544 
SetSilentSwitch(const Uri & uri,bool enable)545 int DataShareServiceProxy::SetSilentSwitch(const Uri &uri, bool enable)
546 {
547     const std::string &uriStr = uri.ToString();
548     MessageParcel data;
549     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
550         LOG_ERROR("Write descriptor failed!");
551         return DATA_SHARE_ERROR;
552     }
553     if (!ITypesUtil::Marshal(data, uriStr, enable)) {
554         LOG_ERROR("Write to message parcel failed!");
555         return DATA_SHARE_ERROR;
556     }
557 
558     MessageParcel reply;
559     MessageOption option;
560     int32_t err = Remote()->SendRequest(
561         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_SET_SILENT_SWITCH), data, reply, option);
562     if (err != NO_ERROR) {
563         LOG_ERROR("SetSilentSwitch fail to sendRequest. uri: %{public}s, err: %{public}d",
564             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
565         return DATA_SHARE_ERROR;
566     }
567     return reply.ReadInt32();
568 }
569 
GetSilentProxyStatus(const std::string & uri)570 int DataShareServiceProxy::GetSilentProxyStatus(const std::string &uri)
571 {
572     MessageParcel data;
573     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
574         LOG_ERROR("Write descriptor failed!");
575         return DATA_SHARE_ERROR;
576     }
577     if (!ITypesUtil::Marshal(data, uri)) {
578         LOG_ERROR("Write to message parcel failed!");
579         return DATA_SHARE_ERROR;
580     }
581 
582     MessageParcel reply;
583     MessageOption option;
584     int32_t err = Remote()->SendRequest(
585         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_GET_SILENT_PROXY_STATUS), data, reply, option);
586     if (err != NO_ERROR) {
587         LOG_ERROR("Is silent proxy enable fail to sendRequest. uri: %{public}s, err: %{public}d",
588             DataShareStringUtils::Anonymous(uri).c_str(), err);
589         return DATA_SHARE_ERROR;
590     }
591     return reply.ReadInt32();
592 }
593 
RegisterObserver(const Uri & uri,const sptr<OHOS::IRemoteObject> & dataObserver)594 int DataShareServiceProxy::RegisterObserver(const Uri &uri, const sptr<OHOS::IRemoteObject> &dataObserver)
595 {
596     if (dataObserver == nullptr) {
597         LOG_ERROR("DataObserver is nullptr, uri:%{public}s",
598             DataShareStringUtils::Anonymous(uri.ToString()).c_str());
599         return DATA_SHARE_ERROR;
600     }
601     MessageParcel data;
602     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
603         LOG_ERROR("Write interface token failed");
604         return DATA_SHARE_ERROR;
605     }
606     if (!ITypesUtil::Marshal(data, uri.ToString(), dataObserver)) {
607         LOG_ERROR("Failed to marshalling");
608         return DATA_SHARE_ERROR;
609     }
610     MessageParcel reply;
611     MessageOption option;
612     int32_t err = Remote()->SendRequest(
613         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_REGISTER_OBSERVER), data, reply, option);
614     if (err != NO_ERROR) {
615         LOG_ERROR("RegisterObserver fail to sendRequest. uri:%{public}s, err:%{public}d",
616             DataShareStringUtils::Anonymous(uri.ToString()).c_str(), err);
617         return DATA_SHARE_ERROR;
618     }
619     return reply.ReadInt32();
620 }
621 
UnRegisterObserver(const Uri & uri,const sptr<OHOS::IRemoteObject> & dataObserver)622 int DataShareServiceProxy::UnRegisterObserver(const Uri &uri, const sptr<OHOS::IRemoteObject> &dataObserver)
623 {
624     if (dataObserver == nullptr) {
625         LOG_ERROR("DataObserver is nullptr, uri:%{public}s",
626             DataShareStringUtils::Anonymous(uri.ToString()).c_str());
627         return DATA_SHARE_ERROR;
628     }
629     MessageParcel data;
630     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
631         LOG_ERROR("Write interface token failed");
632         return DATA_SHARE_ERROR;
633     }
634     if (!ITypesUtil::Marshal(data, uri.ToString(), dataObserver)) {
635         LOG_ERROR("Failed to Marshalling");
636         return DATA_SHARE_ERROR;
637     }
638     MessageParcel reply;
639     MessageOption option;
640     int32_t err = Remote()->SendRequest(
641         static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UNREGISTER_OBSERVER), data, reply, option);
642     if (err != NO_ERROR) {
643         LOG_ERROR("UnRegisterObserver fail to sendRequest. uri: %{public}s, err: %{public}d",
644             DataShareStringUtils::Anonymous(uri.ToString()).c_str(), err);
645         return DATA_SHARE_ERROR;
646     }
647     return reply.ReadInt32();
648 }
649 } // namespace DataShare
650 } // namespace OHOS
651