1 /*
2 * Copyright (c) 2021-2024 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_proxy.h"
17
18 #include "dataobs_mgr_interface.h"
19 #include "errors.h"
20 #include "hilog_tag_wrapper.h"
21 #include "dataobs_mgr_errors.h"
22 #include "common_utils.h"
23
24 namespace OHOS {
25 namespace AAFwk {
WriteInterfaceToken(MessageParcel & data)26 bool DataObsManagerProxy::WriteInterfaceToken(MessageParcel &data)
27 {
28 if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
29 TAG_LOGE(AAFwkTag::DBOBSMGR, "write token error");
30 return false;
31 }
32 return true;
33 }
34
WriteParam(MessageParcel & data,const Uri & uri,sptr<IDataAbilityObserver> dataObserver)35 bool DataObsManagerProxy::WriteParam(MessageParcel &data, const Uri &uri, sptr<IDataAbilityObserver> dataObserver)
36 {
37 if (!data.WriteString(uri.ToString())) {
38 TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error");
39 return false;
40 }
41
42 if (dataObserver == nullptr) {
43 TAG_LOGE(AAFwkTag::DBOBSMGR, "null dataObserver");
44 return false;
45 }
46
47 if (!data.WriteRemoteObject(dataObserver->AsObject())) {
48 TAG_LOGE(AAFwkTag::DBOBSMGR, "write dataObserver error");
49 return false;
50 }
51 return true;
52 }
53
WriteObsOpt(MessageParcel & data,DataObsOption opt)54 bool DataObsManagerProxy::WriteObsOpt(MessageParcel &data, DataObsOption opt)
55 {
56 if (!data.WriteBool(opt.IsSystem())) {
57 TAG_LOGE(AAFwkTag::DBOBSMGR, "write opt error");
58 return false;
59 }
60 if (!data.WriteUint32(opt.FirstCallerTokenID())) {
61 TAG_LOGE(AAFwkTag::DBOBSMGR, "write opt error");
62 return false;
63 }
64 return true;
65 }
66
RegisterObserver(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,int32_t userId,DataObsOption opt)67 int32_t DataObsManagerProxy::RegisterObserver(const Uri &uri,
68 sptr<IDataAbilityObserver> dataObserver, int32_t userId, DataObsOption opt)
69 {
70 MessageParcel data;
71 MessageParcel reply;
72 MessageOption option;
73
74 if (!WriteInterfaceToken(data)) {
75 return IPC_PARCEL_ERROR;
76 }
77
78 if (!WriteParam(data, uri, dataObserver)) {
79 return INVALID_PARAM;
80 }
81 if (!data.WriteInt32(userId)) {
82 return INVALID_PARAM;
83 }
84 if (!WriteObsOpt(data, opt)) {
85 return INVALID_PARAM;
86 }
87
88 auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER, data, reply, option);
89 if (error != NO_ERROR) {
90 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
91 CommonUtils::Anonymous(uri.ToString()).c_str());
92 return error;
93 }
94
95 int32_t res = IPC_ERROR;
96 return reply.ReadInt32(res) ? res : IPC_ERROR;
97 }
98
RegisterObserverFromExtension(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,int32_t userId,DataObsOption opt)99 int32_t DataObsManagerProxy::RegisterObserverFromExtension(const Uri &uri,
100 sptr<IDataAbilityObserver> dataObserver, int32_t userId,
101 DataObsOption opt)
102 {
103 MessageParcel data;
104 MessageParcel reply;
105 MessageOption option;
106
107 if (!WriteInterfaceToken(data)) {
108 return IPC_PARCEL_ERROR;
109 }
110
111 if (!WriteParam(data, uri, dataObserver)) {
112 return INVALID_PARAM;
113 }
114 if (!data.WriteInt32(userId)) {
115 return INVALID_PARAM;
116 }
117 if (!WriteObsOpt(data, opt)) {
118 return INVALID_PARAM;
119 }
120
121 auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER_FROM_EXTENSION, data, reply, option);
122 if (error != NO_ERROR) {
123 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
124 CommonUtils::Anonymous(uri.ToString()).c_str());
125 return error;
126 }
127
128 int32_t res = IPC_ERROR;
129 return reply.ReadInt32(res) ? res : IPC_ERROR;
130 }
131
UnregisterObserver(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,int32_t userId,DataObsOption opt)132 int32_t DataObsManagerProxy::UnregisterObserver(const Uri &uri, sptr<IDataAbilityObserver> dataObserver,
133 int32_t userId, DataObsOption opt)
134 {
135 MessageParcel data;
136 MessageParcel reply;
137 MessageOption option;
138
139 if (!WriteInterfaceToken(data)) {
140 return IPC_PARCEL_ERROR;
141 }
142
143 if (!WriteParam(data, uri, dataObserver)) {
144 return INVALID_PARAM;
145 }
146 if (!data.WriteInt32(userId)) {
147 return INVALID_PARAM;
148 }
149 if (!WriteObsOpt(data, opt)) {
150 return INVALID_PARAM;
151 }
152
153 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER, data, reply, option);
154 if (error != NO_ERROR) {
155 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
156 CommonUtils::Anonymous(uri.ToString()).c_str());
157 return error;
158 }
159 int32_t res = IPC_ERROR;
160 return reply.ReadInt32(res) ? res : IPC_ERROR;
161 }
162
NotifyChange(const Uri & uri,int32_t userId,DataObsOption opt)163 int32_t DataObsManagerProxy::NotifyChange(const Uri &uri, int32_t userId, DataObsOption opt)
164 {
165 MessageParcel data;
166 MessageParcel reply;
167 MessageOption option;
168
169 if (!WriteInterfaceToken(data)) {
170 return IPC_PARCEL_ERROR;
171 }
172 if (!data.WriteString(uri.ToString())) {
173 TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error, uri:%{public}s",
174 CommonUtils::Anonymous(uri.ToString()).c_str());
175 return INVALID_PARAM;
176 }
177 if (!data.WriteInt32(userId)) {
178 return INVALID_PARAM;
179 }
180 if (!WriteObsOpt(data, opt)) {
181 return INVALID_PARAM;
182 }
183 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE, data, reply, option);
184 if (error != NO_ERROR) {
185 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
186 CommonUtils::Anonymous(uri.ToString()).c_str());
187 return IPC_ERROR;
188 }
189
190 int32_t res = IPC_ERROR;
191 return reply.ReadInt32(res) ? res : IPC_ERROR;
192 }
193
NotifyChangeFromExtension(const Uri & uri,int32_t userId,DataObsOption opt)194 int32_t DataObsManagerProxy::NotifyChangeFromExtension(const Uri &uri, int32_t userId, DataObsOption opt)
195 {
196 MessageParcel data;
197 MessageParcel reply;
198 MessageOption option;
199
200 if (!WriteInterfaceToken(data)) {
201 return IPC_PARCEL_ERROR;
202 }
203 if (!data.WriteString(uri.ToString())) {
204 TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error, uri:%{public}s",
205 CommonUtils::Anonymous(uri.ToString()).c_str());
206 return INVALID_PARAM;
207 }
208 if (!data.WriteInt32(userId)) {
209 return INVALID_PARAM;
210 }
211 if (!WriteObsOpt(data, opt)) {
212 return INVALID_PARAM;
213 }
214 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE_FROM_EXTENSION, data, reply, option);
215 if (error != NO_ERROR) {
216 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
217 CommonUtils::Anonymous(uri.ToString()).c_str());
218 return IPC_ERROR;
219 }
220
221 int32_t res = IPC_ERROR;
222 return reply.ReadInt32(res) ? res : IPC_ERROR;
223 }
224
CheckTrusts(uint32_t consumerToken,uint32_t providerToken)225 ErrCode DataObsManagerProxy::CheckTrusts(uint32_t consumerToken, uint32_t providerToken)
226 {
227 MessageParcel data;
228 MessageParcel reply;
229 MessageOption option;
230
231 if (!WriteInterfaceToken(data)) {
232 return IPC_PARCEL_ERROR;
233 }
234
235 if (!data.WriteUint32(consumerToken)) {
236 return INVALID_PARAM;
237 }
238 if (!data.WriteUint32(providerToken)) {
239 return INVALID_PARAM;
240 }
241
242 auto error = SendTransactCmd(IDataObsMgr::CHECK_TRUSTS, data, reply, option);
243 if (error != NO_ERROR) {
244 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, consumer:%{public}d, provider:%{public}d", error,
245 consumerToken, providerToken);
246 return IPC_ERROR;
247 }
248
249 int32_t res = IPC_ERROR;
250 return reply.ReadInt32(res) ? res : IPC_ERROR;
251 }
252
RegisterObserverExt(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,bool isDescendants,DataObsOption opt)253 Status DataObsManagerProxy::RegisterObserverExt(const Uri &uri, sptr<IDataAbilityObserver> dataObserver,
254 bool isDescendants, DataObsOption opt)
255 {
256 MessageParcel data;
257 MessageParcel reply;
258 MessageOption option;
259
260 if (!WriteInterfaceToken(data)) {
261 return IPC_PARCEL_ERROR;
262 }
263
264 if (!WriteParam(data, uri, dataObserver)) {
265 return INVALID_PARAM;
266 }
267
268 if (!data.WriteBool(isDescendants)) {
269 TAG_LOGE(AAFwkTag::DBOBSMGR, "isDescendants error, uri:%{public}s,isDescendants:%{public}d",
270 CommonUtils::Anonymous(uri.ToString()).c_str(), isDescendants);
271 return INVALID_PARAM;
272 }
273 if (!WriteObsOpt(data, opt)) {
274 return INVALID_PARAM;
275 }
276
277 auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER_EXT, data, reply, option);
278 if (error != NO_ERROR) {
279 TAG_LOGE(AAFwkTag::DBOBSMGR,
280 "sendRequest error: %{public}d, uri:%{public}s, isDescendants:%{public}d", error,
281 CommonUtils::Anonymous(uri.ToString()).c_str(), isDescendants);
282 return IPC_ERROR;
283 }
284 int32_t res = IPC_ERROR;
285 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
286 }
287
UnregisterObserverExt(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,DataObsOption opt)288 Status DataObsManagerProxy::UnregisterObserverExt(const Uri &uri, sptr<IDataAbilityObserver> dataObserver,
289 DataObsOption opt)
290 {
291 MessageParcel data;
292 MessageParcel reply;
293 MessageOption option;
294
295 if (!WriteInterfaceToken(data)) {
296 return IPC_PARCEL_ERROR;
297 }
298
299 if (!WriteParam(data, uri, dataObserver)) {
300 return INVALID_PARAM;
301 }
302 if (!WriteObsOpt(data, opt)) {
303 return INVALID_PARAM;
304 }
305
306 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER_EXT, data, reply, option);
307 if (error != NO_ERROR) {
308 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
309 CommonUtils::Anonymous(uri.ToString()).c_str());
310 return IPC_ERROR;
311 }
312 int32_t res = IPC_ERROR;
313 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
314 }
315
UnregisterObserverExt(sptr<IDataAbilityObserver> dataObserver,DataObsOption opt)316 Status DataObsManagerProxy::UnregisterObserverExt(sptr<IDataAbilityObserver> dataObserver, DataObsOption opt)
317 {
318 MessageParcel data;
319 MessageParcel reply;
320 MessageOption option;
321
322 if (!WriteInterfaceToken(data)) {
323 return IPC_PARCEL_ERROR;
324 }
325
326 if (dataObserver == nullptr) {
327 TAG_LOGE(AAFwkTag::DBOBSMGR, "null dataObserver");
328 return INVALID_PARAM;
329 }
330
331 if (!data.WriteRemoteObject(dataObserver->AsObject())) {
332 TAG_LOGE(AAFwkTag::DBOBSMGR, "write dataObserver error");
333 return INVALID_PARAM;
334 }
335 if (!WriteObsOpt(data, opt)) {
336 return INVALID_PARAM;
337 }
338
339 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER_ALL_EXT, data, reply, option);
340 if (error != NO_ERROR) {
341 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d", error);
342 return IPC_ERROR;
343 }
344 int32_t res = IPC_ERROR;
345 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
346 }
347
NotifyChangeExt(const ChangeInfo & changeInfo,DataObsOption opt)348 Status DataObsManagerProxy::NotifyChangeExt(const ChangeInfo &changeInfo, DataObsOption opt)
349 {
350 MessageParcel data;
351 MessageParcel reply;
352 MessageOption option;
353
354 if (!WriteInterfaceToken(data)) {
355 return IPC_PARCEL_ERROR;
356 }
357
358 if (!ChangeInfo::Marshalling(changeInfo, data)) {
359 TAG_LOGE(AAFwkTag::DBOBSMGR,
360 "changeInfo marshalling error, changeType:%{public}ud, num:%{public}zu,"
361 "null data:%{public}d, size:%{public}ud",
362 changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_);
363 return INVALID_PARAM;
364 }
365 if (!WriteObsOpt(data, opt)) {
366 return INVALID_PARAM;
367 }
368
369 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE_EXT, data, reply, option);
370 if (error != NO_ERROR) {
371 TAG_LOGE(AAFwkTag::DBOBSMGR,
372 "sendRequest error: %{public}d, changeType:%{public}ud, num:%{public}zu,"
373 "null data:%{public}d, size:%{public}ud",
374 error, changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_);
375 return IPC_ERROR;
376 }
377 int32_t res = IPC_ERROR;
378 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
379 }
380
NotifyProcessObserver(const std::string & key,const sptr<IRemoteObject> & observer,DataObsOption opt)381 Status DataObsManagerProxy::NotifyProcessObserver(const std::string &key, const sptr<IRemoteObject> &observer,
382 DataObsOption opt)
383 {
384 MessageParcel data;
385 MessageParcel reply;
386 MessageOption option;
387 if (!WriteInterfaceToken(data)) {
388 return IPC_PARCEL_ERROR;
389 }
390
391 if (!data.WriteString(key)) {
392 TAG_LOGE(AAFwkTag::DBOBSMGR, "write key error");
393 return INVALID_PARAM;
394 }
395
396 if (!data.WriteRemoteObject(observer)) {
397 TAG_LOGE(AAFwkTag::DBOBSMGR, "write observer error");
398 return INVALID_PARAM;
399 }
400 if (!WriteObsOpt(data, opt)) {
401 return INVALID_PARAM;
402 }
403
404 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_PROCESS, data, reply, option);
405 if (error != NO_ERROR) {
406 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error: %{public}d, key:%{public}s", error, key.c_str());
407 return IPC_ERROR;
408 }
409 int32_t res = IPC_ERROR;
410 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
411 }
412
SendTransactCmd(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)413 int32_t DataObsManagerProxy::SendTransactCmd(uint32_t code, MessageParcel &data,
414 MessageParcel &reply, MessageOption &option)
415 {
416 sptr<IRemoteObject> remote = Remote();
417 if (remote == nullptr) {
418 TAG_LOGE(AAFwkTag::DBOBSMGR, "null remote");
419 return ERR_NULL_OBJECT;
420 }
421
422 int32_t ret = remote->SendRequest(code, data, reply, option);
423 if (ret != NO_ERROR) {
424 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest errorCode:%{public}d, ret:%{public}d", code, ret);
425 return ret;
426 }
427 return NO_ERROR;
428 }
429 } // namespace AAFwk
430 } // namespace OHOS
431