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