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