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 "pasteboard_service_proxy.h"
17
18 #include "copy_uri_handler.h"
19 #include "iremote_broker.h"
20 #include "paste_uri_handler.h"
21 #include "pasteboard_error.h"
22 #include "pasteboard_hilog.h"
23 #include "pasteboard_serv_ipc_interface_code.h"
24
25 using namespace OHOS::Security::PasteboardServ;
26 namespace OHOS {
27 namespace MiscServices {
PasteboardServiceProxy(const sptr<IRemoteObject> & object)28 PasteboardServiceProxy::PasteboardServiceProxy(const sptr<IRemoteObject> &object)
29 : IRemoteProxy<IPasteboardService>(object)
30 {
31 }
32
Clear()33 void PasteboardServiceProxy::Clear()
34 {
35 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
36 MessageParcel data;
37 MessageParcel reply;
38 MessageOption option;
39 if (!data.WriteInterfaceToken(GetDescriptor())) {
40 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
41 return;
42 }
43
44 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::CLEAR_ALL, data, reply, option);
45 if (result != ERR_NONE) {
46 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
47 }
48 }
49
HasPasteData()50 bool PasteboardServiceProxy::HasPasteData()
51 {
52 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
53 MessageParcel data;
54 MessageParcel reply;
55 MessageOption option;
56
57 if (!data.WriteInterfaceToken(GetDescriptor())) {
58 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
59 return false;
60 }
61
62 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::HAS_PASTE_DATA, data, reply, option);
63 if (result != ERR_NONE) {
64 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
65 return false;
66 }
67 auto has = reply.ReadBool();
68 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
69 return has;
70 }
71
SetPasteData(PasteData & pasteData)72 int32_t PasteboardServiceProxy::SetPasteData(PasteData &pasteData)
73 {
74 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
75 MessageParcel data;
76 MessageParcel reply;
77 MessageOption option;
78 if (!data.WriteInterfaceToken(GetDescriptor())) {
79 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
80 return ERR_INVALID_VALUE;
81 }
82 std::vector<uint8_t> pasteDataTlv(0);
83 bool ret = pasteData.Encode(pasteDataTlv);
84 if (!ret) {
85 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to encode pastedata in TLV");
86 return ERR_INVALID_VALUE;
87 }
88 if (!data.WriteInt32(pasteDataTlv.size())) {
89 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write raw size");
90 return ERR_INVALID_VALUE;
91 }
92 if (!data.WriteRawData(pasteDataTlv.data(), pasteDataTlv.size())) {
93 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write raw data");
94 return ERR_INVALID_VALUE;
95 }
96 CopyUriHandler copyHandler;
97 if (!pasteData.WriteUriFd(data, copyHandler)) {
98 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write record uri fd");
99 return ERR_INVALID_VALUE;
100 }
101
102 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::SET_PASTE_DATA, data, reply, option);
103 if (result != ERR_NONE) {
104 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
105 return ERR_INVALID_OPERATION;
106 }
107 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
108 return reply.ReadInt32();
109 }
110
GetPasteData(PasteData & pasteData)111 int32_t PasteboardServiceProxy::GetPasteData(PasteData &pasteData)
112 {
113 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
114 MessageParcel data;
115 MessageParcel reply;
116 MessageOption option;
117 if (!data.WriteInterfaceToken(GetDescriptor())) {
118 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
119 return ERR_INVALID_VALUE;
120 }
121 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::GET_PASTE_DATA, data, reply, option);
122 if (result != ERR_NONE) {
123 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
124 return ERR_INVALID_OPERATION;
125 }
126 int32_t rawDataSize = reply.ReadInt32();
127 if (rawDataSize <= 0) {
128 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to get raw size");
129 return ERR_INVALID_VALUE;
130 }
131 auto *rawData = (uint8_t *)reply.ReadRawData(rawDataSize);
132 if (rawData == nullptr) {
133 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to get raw data");
134 return ERR_INVALID_VALUE;
135 }
136 std::vector<uint8_t> pasteDataTlv(rawData, rawData + rawDataSize);
137 bool ret = pasteData.Decode(pasteDataTlv);
138 if (!ret) {
139 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to decode pastedata in TLV");
140 return ERR_INVALID_VALUE;
141 }
142 PasteUriHandler pasteHandler;
143 if (!pasteData.ReadUriFd(reply, pasteHandler)) {
144 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write record uri fd");
145 return ERR_INVALID_VALUE;
146 }
147
148 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
149 return reply.ReadInt32();
150 }
151
AddPasteboardChangedObserver(const sptr<IPasteboardChangedObserver> & observer)152 void PasteboardServiceProxy::AddPasteboardChangedObserver(const sptr<IPasteboardChangedObserver> &observer)
153 {
154 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
155 ProcessObserver(PasteboardServiceInterfaceCode::ADD_CHANGED_OBSERVER, observer);
156 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
157 }
158
RemovePasteboardChangedObserver(const sptr<IPasteboardChangedObserver> & observer)159 void PasteboardServiceProxy::RemovePasteboardChangedObserver(const sptr<IPasteboardChangedObserver> &observer)
160 {
161 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
162 ProcessObserver(PasteboardServiceInterfaceCode::DELETE_CHANGED_OBSERVER, observer);
163 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
164 }
RemoveAllChangedObserver()165 void PasteboardServiceProxy::RemoveAllChangedObserver()
166 {
167 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
168 MessageParcel data;
169 MessageParcel reply;
170 MessageOption option;
171 if (!data.WriteInterfaceToken(GetDescriptor())) {
172 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
173 return;
174 }
175 int32_t result =
176 Remote()->SendRequest(PasteboardServiceInterfaceCode::DELETE_ALL_CHANGED_OBSERVER, data, reply, option);
177 if (result != ERR_NONE) {
178 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
179 }
180 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
181 }
182
AddPasteboardEventObserver(const sptr<IPasteboardChangedObserver> & observer)183 void PasteboardServiceProxy::AddPasteboardEventObserver(const sptr<IPasteboardChangedObserver> &observer)
184 {
185 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
186 ProcessObserver(PasteboardServiceInterfaceCode::ADD_EVENT_OBSERVER, observer);
187 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
188 }
189
RemovePasteboardEventObserver(const sptr<IPasteboardChangedObserver> & observer)190 void PasteboardServiceProxy::RemovePasteboardEventObserver(const sptr<IPasteboardChangedObserver> &observer)
191 {
192 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
193 ProcessObserver(PasteboardServiceInterfaceCode::DELETE_EVENT_OBSERVER, observer);
194 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
195 }
RemoveAllEventObserver()196 void PasteboardServiceProxy::RemoveAllEventObserver()
197 {
198 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
199 MessageParcel data;
200 MessageParcel reply;
201 MessageOption option;
202 if (!data.WriteInterfaceToken(GetDescriptor())) {
203 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
204 return;
205 }
206 int32_t result =
207 Remote()->SendRequest(PasteboardServiceInterfaceCode::DELETE_ALL_EVENT_OBSERVER, data, reply, option);
208 if (result != ERR_NONE) {
209 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
210 }
211 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
212 }
213
ProcessObserver(uint32_t code,const sptr<IPasteboardChangedObserver> & observer)214 void PasteboardServiceProxy::ProcessObserver(uint32_t code, const sptr<IPasteboardChangedObserver> &observer)
215 {
216 if (observer == nullptr) {
217 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "observer nullptr");
218 return;
219 }
220 MessageParcel data;
221 MessageParcel reply;
222 MessageOption option;
223 if (!data.WriteInterfaceToken(GetDescriptor())) {
224 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
225 return;
226 }
227 if (!data.WriteRemoteObject(observer->AsObject())) {
228 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
229 return;
230 }
231 int32_t result = Remote()->SendRequest(code, data, reply, option);
232 if (result != ERR_NONE) {
233 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
234 }
235 }
236
IsRemoteData()237 bool PasteboardServiceProxy::IsRemoteData()
238 {
239 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
240 MessageParcel data;
241 MessageParcel reply;
242 MessageOption option;
243 if (!data.WriteInterfaceToken(GetDescriptor())) {
244 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
245 return false;
246 }
247
248 int32_t ret = Remote()->SendRequest(PasteboardServiceInterfaceCode::IS_REMOTE_DATA, data, reply, option);
249 if (ret != ERR_NONE) {
250 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", ret);
251 return false;
252 }
253 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
254 return reply.ReadBool();
255 }
256
GetDataSource(std::string & bundleName)257 int32_t PasteboardServiceProxy::GetDataSource(std::string &bundleName)
258 {
259 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
260 MessageParcel data;
261 MessageParcel reply;
262 MessageOption option;
263 if (!data.WriteInterfaceToken(GetDescriptor())) {
264 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
265 return ERR_INVALID_VALUE;
266 }
267 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::GET_DATA_SOURCE, data, reply, option);
268 if (result != ERR_NONE) {
269 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
270 return ERR_INVALID_OPERATION;
271 }
272 bundleName = reply.ReadString();
273 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
274 return reply.ReadInt32();
275 }
276
HasDataType(const std::string & mimeType)277 bool PasteboardServiceProxy::HasDataType(const std::string &mimeType)
278 {
279 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
280 MessageParcel data;
281 MessageParcel reply;
282 MessageOption option;
283 if (!data.WriteInterfaceToken(GetDescriptor())) {
284 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
285 return ERR_INVALID_VALUE;
286 }
287 if (!data.WriteString(mimeType)) {
288 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write string");
289 return ERR_INVALID_VALUE;
290 }
291 int32_t result = Remote()->SendRequest(PasteboardServiceInterfaceCode::HAS_DATA_TYPE, data, reply, option);
292 if (result != ERR_NONE) {
293 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
294 return ERR_INVALID_OPERATION;
295 }
296
297 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
298 return reply.ReadBool();
299 }
300 } // namespace MiscServices
301 } // namespace OHOS