1 /*
2 * Copyright (C) 2021 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 "iremote_broker.h"
19 #include "pasteboard_error.h"
20 #include "pasteboard_hilog.h"
21 #include "paste_uri_handler.h"
22 #include "copy_uri_handler.h"
23
24 namespace OHOS {
25 namespace MiscServices {
PasteboardServiceProxy(const sptr<IRemoteObject> & object)26 PasteboardServiceProxy::PasteboardServiceProxy(const sptr<IRemoteObject> &object)
27 : IRemoteProxy<IPasteboardService>(object)
28 {
29 }
30
Clear()31 void PasteboardServiceProxy::Clear()
32 {
33 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
34 MessageParcel data, reply;
35 MessageOption option;
36 if (!data.WriteInterfaceToken(GetDescriptor())) {
37 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
38 return;
39 }
40
41 int32_t result = Remote()->SendRequest(CLEAR_ALL, data, reply, option);
42 if (result != ERR_NONE) {
43 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
44 }
45 }
46
HasPasteData()47 bool PasteboardServiceProxy::HasPasteData()
48 {
49 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
50 MessageParcel data, reply;
51 MessageOption option;
52
53 if (!data.WriteInterfaceToken(GetDescriptor())) {
54 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
55 return false;
56 }
57
58 int32_t result = Remote()->SendRequest(HAS_PASTE_DATA, data, reply, option);
59 if (result != ERR_NONE) {
60 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
61 return false;
62 }
63 auto has = reply.ReadBool();
64 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
65 return has;
66 }
67
SetPasteData(PasteData & pasteData)68 int32_t PasteboardServiceProxy::SetPasteData(PasteData &pasteData)
69 {
70 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
71 MessageParcel data, reply;
72 MessageOption option;
73 if (!data.WriteInterfaceToken(GetDescriptor())) {
74 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
75 return ERR_INVALID_VALUE;
76 }
77 std::vector<uint8_t> pasteDataTlv(0);
78 bool ret = pasteData.Encode(pasteDataTlv);
79 if (!ret) {
80 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to encode pastedata in TLV");
81 return ERR_INVALID_VALUE;
82 }
83 if (!data.WriteInt32(pasteDataTlv.size())) {
84 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write raw size");
85 return ERR_INVALID_VALUE;
86 }
87 if (!data.WriteRawData(pasteDataTlv.data(), pasteDataTlv.size())) {
88 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write raw data");
89 return ERR_INVALID_VALUE;
90 }
91 CopyUriHandler copyHandler;
92 if (!pasteData.WriteUriFd(data, copyHandler)) {
93 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write record uri fd");
94 return ERR_INVALID_VALUE;
95 }
96
97 int32_t result = Remote()->SendRequest(SET_PASTE_DATA, data, reply, option);
98 if (result != ERR_NONE) {
99 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
100 return ERR_INVALID_OPERATION;
101 }
102 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
103 return reply.ReadInt32();
104 }
105
GetPasteData(PasteData & pasteData)106 int32_t PasteboardServiceProxy::GetPasteData(PasteData &pasteData)
107 {
108 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
109 MessageParcel data, reply;
110 MessageOption option;
111 if (!data.WriteInterfaceToken(GetDescriptor())) {
112 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
113 return ERR_INVALID_VALUE;
114 }
115 int32_t result = Remote()->SendRequest(GET_PASTE_DATA, data, reply, option);
116 if (result != ERR_NONE) {
117 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
118 return ERR_INVALID_OPERATION;
119 }
120 int32_t rawDataSize = reply.ReadInt32();
121 if (rawDataSize <= 0) {
122 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to get raw size");
123 return ERR_INVALID_VALUE;
124 }
125 auto *rawData = (uint8_t *)reply.ReadRawData(rawDataSize);
126 if (rawData == nullptr) {
127 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to get raw data");
128 return ERR_INVALID_VALUE;
129 }
130 std::vector<uint8_t> pasteDataTlv(rawData, rawData + rawDataSize);
131 bool ret = pasteData.Decode(pasteDataTlv);
132 if (!ret) {
133 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to decode pastedata in TLV");
134 return ERR_INVALID_VALUE;
135 }
136 PasteUriHandler pasteHandler;
137 if (!pasteData.ReadUriFd(reply, pasteHandler)) {
138 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write record uri fd");
139 return ERR_INVALID_VALUE;
140 }
141
142 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
143 return reply.ReadInt32();
144 }
145
AddPasteboardChangedObserver(const sptr<IPasteboardChangedObserver> & observer)146 void PasteboardServiceProxy::AddPasteboardChangedObserver(const sptr<IPasteboardChangedObserver> &observer)
147 {
148 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
149 ProcessObserver(ADD_CHANGED_OBSERVER, observer);
150 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
151 }
152
RemovePasteboardChangedObserver(const sptr<IPasteboardChangedObserver> & observer)153 void PasteboardServiceProxy::RemovePasteboardChangedObserver(const sptr<IPasteboardChangedObserver> &observer)
154 {
155 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
156 ProcessObserver(DELETE_CHANGED_OBSERVER, observer);
157 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
158 }
RemoveAllChangedObserver()159 void PasteboardServiceProxy::RemoveAllChangedObserver()
160 {
161 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
162 MessageParcel data, reply;
163 MessageOption option;
164 if (!data.WriteInterfaceToken(GetDescriptor())) {
165 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
166 return;
167 }
168 int32_t result = Remote()->SendRequest(DELETE_ALL_CHANGED_OBSERVER, data, reply, option);
169 if (result != ERR_NONE) {
170 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
171 }
172 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
173 }
174
AddPasteboardEventObserver(const sptr<IPasteboardChangedObserver> & observer)175 void PasteboardServiceProxy::AddPasteboardEventObserver(const sptr<IPasteboardChangedObserver> &observer)
176 {
177 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
178 ProcessObserver(ADD_EVENT_OBSERVER, observer);
179 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
180 }
181
RemovePasteboardEventObserver(const sptr<IPasteboardChangedObserver> & observer)182 void PasteboardServiceProxy::RemovePasteboardEventObserver(const sptr<IPasteboardChangedObserver> &observer)
183 {
184 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
185 ProcessObserver(DELETE_EVENT_OBSERVER, observer);
186 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
187 }
RemoveAllEventObserver()188 void PasteboardServiceProxy::RemoveAllEventObserver()
189 {
190 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "start.");
191 MessageParcel data, reply;
192 MessageOption option;
193 if (!data.WriteInterfaceToken(GetDescriptor())) {
194 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
195 return;
196 }
197 int32_t result = Remote()->SendRequest(DELETE_ALL_EVENT_OBSERVER, data, reply, option);
198 if (result != ERR_NONE) {
199 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
200 }
201 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "end.");
202 }
203
ProcessObserver(uint32_t code,const sptr<IPasteboardChangedObserver> & observer)204 void PasteboardServiceProxy::ProcessObserver(uint32_t code, const sptr<IPasteboardChangedObserver> &observer)
205 {
206 if (observer == nullptr) {
207 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "observer nullptr");
208 return;
209 }
210 MessageParcel data, reply;
211 MessageOption option;
212 if (!data.WriteInterfaceToken(GetDescriptor())) {
213 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
214 return;
215 }
216 if (!data.WriteRemoteObject(observer->AsObject())) {
217 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to write parcelable");
218 return;
219 }
220 int32_t result = Remote()->SendRequest(code, data, reply, option);
221 if (result != ERR_NONE) {
222 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "failed, error code is: %{public}d", result);
223 }
224 }
225
226 } // namespace MiscServices
227 } // namespace OHOS