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 "errors.h"
19 #include "hilog_tag_wrapper.h"
20 #include "dataobs_mgr_errors.h"
21 #include "common_utils.h"
22
23 namespace OHOS {
24 namespace AAFwk {
WriteInterfaceToken(MessageParcel & data)25 bool DataObsManagerProxy::WriteInterfaceToken(MessageParcel &data)
26 {
27 if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
28 TAG_LOGE(AAFwkTag::DBOBSMGR, "write token error");
29 return false;
30 }
31 return true;
32 }
33
WriteParam(MessageParcel & data,const Uri & uri,sptr<IDataAbilityObserver> dataObserver)34 bool DataObsManagerProxy::WriteParam(MessageParcel &data, const Uri &uri, sptr<IDataAbilityObserver> dataObserver)
35 {
36 if (!data.WriteString(uri.ToString())) {
37 TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error");
38 return false;
39 }
40
41 if (dataObserver == nullptr) {
42 TAG_LOGE(AAFwkTag::DBOBSMGR, "null dataObserver");
43 return false;
44 }
45
46 if (!data.WriteRemoteObject(dataObserver->AsObject())) {
47 TAG_LOGE(AAFwkTag::DBOBSMGR, "write dataObserver error");
48 return false;
49 }
50 return true;
51 }
52
RegisterObserver(const Uri & uri,sptr<IDataAbilityObserver> dataObserver)53 int32_t DataObsManagerProxy::RegisterObserver(const Uri &uri, sptr<IDataAbilityObserver> dataObserver)
54 {
55 MessageParcel data;
56 MessageParcel reply;
57 MessageOption option;
58
59 if (!WriteInterfaceToken(data)) {
60 return IPC_PARCEL_ERROR;
61 }
62
63 if (!WriteParam(data, uri, dataObserver)) {
64 return INVALID_PARAM;
65 }
66
67 auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER, data, reply, option);
68 if (error != NO_ERROR) {
69 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
70 CommonUtils::Anonymous(uri.ToString()).c_str());
71 return error;
72 }
73
74 int32_t res = IPC_ERROR;
75 return reply.ReadInt32(res) ? res : IPC_ERROR;
76 }
77
UnregisterObserver(const Uri & uri,sptr<IDataAbilityObserver> dataObserver)78 int32_t DataObsManagerProxy::UnregisterObserver(const Uri &uri, sptr<IDataAbilityObserver> dataObserver)
79 {
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option;
83
84 if (!WriteInterfaceToken(data)) {
85 return IPC_PARCEL_ERROR;
86 }
87
88 if (!WriteParam(data, uri, dataObserver)) {
89 return INVALID_PARAM;
90 }
91
92 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER, data, reply, option);
93 if (error != NO_ERROR) {
94 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
95 CommonUtils::Anonymous(uri.ToString()).c_str());
96 return error;
97 }
98 int32_t res = IPC_ERROR;
99 return reply.ReadInt32(res) ? res : IPC_ERROR;
100 }
101
NotifyChange(const Uri & uri)102 int32_t DataObsManagerProxy::NotifyChange(const Uri &uri)
103 {
104 MessageParcel data;
105 MessageParcel reply;
106 MessageOption option;
107
108 if (!WriteInterfaceToken(data)) {
109 return IPC_PARCEL_ERROR;
110 }
111 if (!data.WriteString(uri.ToString())) {
112 TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error, uri:%{public}s",
113 CommonUtils::Anonymous(uri.ToString()).c_str());
114 return INVALID_PARAM;
115 }
116 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE, data, reply, option);
117 if (error != NO_ERROR) {
118 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
119 CommonUtils::Anonymous(uri.ToString()).c_str());
120 return IPC_ERROR;
121 }
122
123 int32_t res = IPC_ERROR;
124 return reply.ReadInt32(res) ? res : IPC_ERROR;
125 }
126
RegisterObserverExt(const Uri & uri,sptr<IDataAbilityObserver> dataObserver,bool isDescendants)127 Status DataObsManagerProxy::RegisterObserverExt(const Uri &uri, sptr<IDataAbilityObserver> dataObserver,
128 bool isDescendants)
129 {
130 MessageParcel data;
131 MessageParcel reply;
132 MessageOption option;
133
134 if (!WriteInterfaceToken(data)) {
135 return IPC_PARCEL_ERROR;
136 }
137
138 if (!WriteParam(data, uri, dataObserver)) {
139 return INVALID_PARAM;
140 }
141
142 if (!data.WriteBool(isDescendants)) {
143 TAG_LOGE(AAFwkTag::DBOBSMGR, "isDescendants error, uri:%{public}s,isDescendants:%{public}d",
144 CommonUtils::Anonymous(uri.ToString()).c_str(), isDescendants);
145 return INVALID_PARAM;
146 }
147
148 auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER_EXT, data, reply, option);
149 if (error != NO_ERROR) {
150 TAG_LOGE(AAFwkTag::DBOBSMGR,
151 "sendRequest error: %{public}d, uri:%{public}s, isDescendants:%{public}d", error,
152 CommonUtils::Anonymous(uri.ToString()).c_str(), isDescendants);
153 return IPC_ERROR;
154 }
155 int32_t res = IPC_ERROR;
156 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
157 }
158
UnregisterObserverExt(const Uri & uri,sptr<IDataAbilityObserver> dataObserver)159 Status DataObsManagerProxy::UnregisterObserverExt(const Uri &uri, sptr<IDataAbilityObserver> dataObserver)
160 {
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option;
164
165 if (!WriteInterfaceToken(data)) {
166 return IPC_PARCEL_ERROR;
167 }
168
169 if (!WriteParam(data, uri, dataObserver)) {
170 return INVALID_PARAM;
171 }
172
173 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER_EXT, data, reply, option);
174 if (error != NO_ERROR) {
175 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error,
176 CommonUtils::Anonymous(uri.ToString()).c_str());
177 return IPC_ERROR;
178 }
179 int32_t res = IPC_ERROR;
180 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
181 }
182
UnregisterObserverExt(sptr<IDataAbilityObserver> dataObserver)183 Status DataObsManagerProxy::UnregisterObserverExt(sptr<IDataAbilityObserver> dataObserver)
184 {
185 MessageParcel data;
186 MessageParcel reply;
187 MessageOption option;
188
189 if (!WriteInterfaceToken(data)) {
190 return IPC_PARCEL_ERROR;
191 }
192
193 if (dataObserver == nullptr) {
194 TAG_LOGE(AAFwkTag::DBOBSMGR, "null dataObserver");
195 return INVALID_PARAM;
196 }
197
198 if (!data.WriteRemoteObject(dataObserver->AsObject())) {
199 TAG_LOGE(AAFwkTag::DBOBSMGR, "write dataObserver error");
200 return INVALID_PARAM;
201 }
202
203 auto error = SendTransactCmd(IDataObsMgr::UNREGISTER_OBSERVER_ALL_EXT, data, reply, option);
204 if (error != NO_ERROR) {
205 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d", error);
206 return IPC_ERROR;
207 }
208 int32_t res = IPC_ERROR;
209 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
210 }
211
NotifyChangeExt(const ChangeInfo & changeInfo)212 Status DataObsManagerProxy::NotifyChangeExt(const ChangeInfo &changeInfo)
213 {
214 MessageParcel data;
215 MessageParcel reply;
216 MessageOption option;
217
218 if (!WriteInterfaceToken(data)) {
219 return IPC_PARCEL_ERROR;
220 }
221
222 if (!ChangeInfo::Marshalling(changeInfo, data)) {
223 TAG_LOGE(AAFwkTag::DBOBSMGR,
224 "changeInfo marshalling error, changeType:%{public}ud, num:%{public}zu,"
225 "null data:%{public}d, size:%{public}ud",
226 changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_);
227 return INVALID_PARAM;
228 }
229
230 auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE_EXT, data, reply, option);
231 if (error != NO_ERROR) {
232 TAG_LOGE(AAFwkTag::DBOBSMGR,
233 "sendRequest error: %{public}d, changeType:%{public}ud, num:%{public}zu,"
234 "null data:%{public}d, size:%{public}ud",
235 error, changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_);
236 return IPC_ERROR;
237 }
238 int32_t res = IPC_ERROR;
239 return reply.ReadInt32(res) ? static_cast<Status>(res) : IPC_ERROR;
240 }
241
SendTransactCmd(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)242 int32_t DataObsManagerProxy::SendTransactCmd(uint32_t code, MessageParcel &data,
243 MessageParcel &reply, MessageOption &option)
244 {
245 sptr<IRemoteObject> remote = Remote();
246 if (remote == nullptr) {
247 TAG_LOGE(AAFwkTag::DBOBSMGR, "null remote");
248 return ERR_NULL_OBJECT;
249 }
250
251 int32_t ret = remote->SendRequest(code, data, reply, option);
252 if (ret != NO_ERROR) {
253 TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest errorcode:%{public}d, ret:%{public}d.", code, ret);
254 return ret;
255 }
256 return NO_ERROR;
257 }
258 } // namespace AAFwk
259 } // namespace OHOS
260