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 "copy_uri_handler.h"
17#include "errors.h"
18#include "hiview_adapter.h"
19#include "paste_data.h"
20#include "paste_uri_handler.h"
21#include "pasteboard_error.h"
22#include "pasteboard_hilog.h"
23#include "pasteboard_observer_proxy.h"
24#include "pasteboard_serv_ipc_interface_code.h"
25#include "pasteboard_service_stub.h"
26
27using namespace OHOS::Security::PasteboardServ;
28namespace OHOS {
29namespace MiscServices {
30PasteboardServiceStub::PasteboardServiceStub()
31{
32    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::GET_PASTE_DATA)] =
33        &PasteboardServiceStub::OnGetPasteData;
34    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::HAS_PASTE_DATA)] =
35        &PasteboardServiceStub::OnHasPasteData;
36    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::SET_PASTE_DATA)] =
37        &PasteboardServiceStub::OnSetPasteData;
38    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::CLEAR_ALL)] = &PasteboardServiceStub::OnClear;
39    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::SUBSCRIBE_OBSERVER)] =
40        &PasteboardServiceStub::OnSubscribeObserver;
41    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::UNSUBSCRIBE_OBSERVER)] =
42        &PasteboardServiceStub::OnUnsubscribeObserver;
43    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::UNSUBSCRIBE_ALL_OBSERVER)] =
44        &PasteboardServiceStub::OnUnsubscribeAllObserver;
45    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::IS_REMOTE_DATA)] =
46        &PasteboardServiceStub::OnIsRemoteData;
47    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::GET_DATA_SOURCE)] =
48        &PasteboardServiceStub::OnGetDataSource;
49    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::HAS_DATA_TYPE)] =
50        &PasteboardServiceStub::OnHasDataType;
51    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::DETECT_PATTERNS)] =
52        &PasteboardServiceStub::OnDetectPatterns;
53    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::SET_GLOBAL_SHARE_OPTION)] =
54        &PasteboardServiceStub::OnSetGlobalShareOption;
55    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::REMOVE_GLOBAL_SHARE_OPTION)] =
56        &PasteboardServiceStub::OnRemoveGlobalShareOption;
57    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::GET_GLOBAL_SHARE_OPTION)] =
58        &PasteboardServiceStub::OnGetGlobalShareOption;
59    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::SET_APP_SHARE_OPTIONS)] =
60        &PasteboardServiceStub::OnSetAppShareOptions;
61    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::REMOVE_APP_SHARE_OPTIONS)] =
62        &PasteboardServiceStub::OnRemoveAppShareOptions;
63    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::PASTE_START)] =
64        &PasteboardServiceStub::OnPasteStart;
65    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::PASTE_COMPLETE)] =
66        &PasteboardServiceStub::OnPasteComplete;
67    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::REGISTER_CLIENT_DEATH_OBSERVER)] =
68        &PasteboardServiceStub::OnRegisterClientDeathObserver;
69    memberFuncMap_[static_cast<uint32_t>(PasteboardServiceInterfaceCode::GET_RECORD_VALUE)] =
70        &PasteboardServiceStub::OnGetRecordValueByType;
71}
72
73int32_t PasteboardServiceStub::OnRemoteRequest(
74    uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
75{
76    std::u16string myDescripter = PasteboardServiceStub::GetDescriptor();
77    std::u16string remoteDescripter = data.ReadInterfaceToken();
78    if (myDescripter != remoteDescripter) {
79        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "end##descriptor checked fail");
80        return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
81    }
82    pid_t p = IPCSkeleton::GetCallingPid();
83    pid_t p1 = IPCSkeleton::GetCallingUid();
84    if (code != static_cast<uint32_t>(PasteboardServiceInterfaceCode::HAS_PASTE_DATA)) {
85        PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "pid:%{public}d, uid:%{public}d, cmd:%{public}u", p, p1, code);
86    }
87    auto itFunc = memberFuncMap_.find(code);
88    if (itFunc != memberFuncMap_.end()) {
89        auto memberFunc = itFunc->second;
90        if (memberFunc != nullptr) {
91            return (this->*memberFunc)(data, reply);
92        }
93    }
94    int ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
95    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end##ret = %{public}d", ret);
96    return ret;
97}
98int32_t PasteboardServiceStub::OnClear(MessageParcel &data, MessageParcel &reply)
99{
100    Clear();
101    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
102    return ERR_OK;
103}
104
105int32_t PasteboardServiceStub::OnGetRecordValueByType(MessageParcel &data, MessageParcel &reply)
106{
107    uint32_t dataId = data.ReadUint32();
108    uint32_t recordId = data.ReadUint32();
109    PasteDataEntry entryValue;
110    int32_t rawDataSize = data.ReadInt32();
111    if (rawDataSize <= 0) {
112        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail to get raw data size");
113        return ERR_INVALID_VALUE;
114    }
115    const uint8_t *rawData = reinterpret_cast<const uint8_t *>(data.ReadRawData(rawDataSize));
116    if (rawData == nullptr) {
117        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail to get raw data");
118        return ERR_INVALID_VALUE;
119    }
120    std::vector<uint8_t> receiveTlv(rawData, rawData + rawDataSize);
121    bool ret = entryValue.Unmarshalling(receiveTlv);
122    if (!ret) {
123        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail to decode paste data entry");
124        return ERR_INVALID_VALUE;
125    }
126    auto result = GetRecordValueByType(dataId, recordId, entryValue);
127    if (!reply.WriteInt32(result)) {
128        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to write result:%{public}d", result);
129        return ERR_INVALID_VALUE;
130    }
131    std::vector<uint8_t> entryValueTLV(0);
132    ret = entryValue.Marshalling(entryValueTLV);
133    if (!ret) {
134        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail encode entry value");
135        return ERR_INVALID_VALUE;
136    }
137    if (!reply.WriteInt32(entryValueTLV.size())) {
138        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail write data size");
139        return ERR_INVALID_VALUE;
140    }
141    if (!reply.WriteRawData(entryValueTLV.data(), entryValueTLV.size())) {
142        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "fail write raw data");
143        return ERR_INVALID_VALUE;
144    }
145    return ERR_OK;
146}
147
148int32_t PasteboardServiceStub::OnGetPasteData(MessageParcel &data, MessageParcel &reply)
149{
150    std::string pasteId = data.ReadString();
151    PasteData pasteData{};
152    pasteData.SetPasteId(pasteId);
153    int32_t syncTime = 0;
154    auto result = GetPasteData(pasteData, syncTime);
155    HiViewAdapter::ReportUseBehaviour(pasteData, HiViewAdapter::PASTE_STATE, result);
156    std::vector<uint8_t> pasteDataTlv(0);
157    bool ret = pasteData.Encode(pasteDataTlv);
158    if (!ret) {
159        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to encode pastedata in TLV");
160        return ERR_INVALID_VALUE;
161    }
162    if (!reply.WriteInt32(pasteDataTlv.size())) {
163        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to write raw size");
164        return ERR_INVALID_VALUE;
165    }
166    if (!reply.WriteRawData(pasteDataTlv.data(), pasteDataTlv.size())) {
167        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to write raw data");
168        return ERR_INVALID_VALUE;
169    }
170    PasteUriHandler pasteUriHandler;
171    if (!pasteData.WriteUriFd(reply, pasteUriHandler, false)) {
172        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to write uri fd");
173        return ERR_INVALID_VALUE;
174    }
175    if (!reply.WriteInt32(syncTime)) {
176        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to GetPasteData syncTime");
177        return ERR_INVALID_VALUE;
178    }
179    if (!reply.WriteInt32(result)) {
180        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to GetPasteData result");
181        return ERR_INVALID_VALUE;
182    }
183    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, " end.");
184    return ERR_OK;
185}
186int32_t PasteboardServiceStub::OnHasPasteData(MessageParcel &data, MessageParcel &reply)
187{
188    auto result = HasPasteData();
189    reply.WriteBool(result);
190    return ERR_OK;
191}
192
193std::shared_ptr<PasteData> PasteboardServiceStub::UnmarshalPasteData(MessageParcel &data, MessageParcel &reply)
194{
195    int32_t rawDataSize = data.ReadInt32();
196    if (rawDataSize <= 0) {
197        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to read raw size");
198        return nullptr;
199    }
200    auto *rawData = (uint8_t *)data.ReadRawData(rawDataSize);
201    if (rawData == nullptr) {
202        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to get raw data");
203        return nullptr;
204    }
205    std::vector<uint8_t> pasteDataTlv(rawData, rawData + rawDataSize);
206    auto pasteData = std::make_shared<PasteData>();
207    bool ret = pasteData->Decode(pasteDataTlv);
208    if (!ret) {
209        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to decode pastedata in TLV");
210        return nullptr;
211    }
212    return pasteData;
213}
214
215int32_t PasteboardServiceStub::OnSetPasteData(MessageParcel &data, MessageParcel &reply)
216{
217    auto pasteData = UnmarshalPasteData(data, reply);
218    if (pasteData == nullptr) {
219        return ERR_INVALID_VALUE;
220    }
221    CopyUriHandler copyUriHandler;
222    if (!pasteData->ReadUriFd(data, copyUriHandler)) {
223        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to read uri fd");
224        return ERR_INVALID_VALUE;
225    }
226    sptr<IPasteboardDelayGetter> delayGetter = nullptr;
227    if (pasteData->IsDelayData()) {
228        sptr<IRemoteObject> obj = data.ReadRemoteObject();
229        if (obj == nullptr) {
230            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "delay getter is nullptr");
231            return ERR_INVALID_VALUE;
232        }
233        delayGetter = iface_cast<IPasteboardDelayGetter>(obj);
234        if (delayGetter == nullptr) {
235            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "delay getter is nullptr");
236            return ERR_INVALID_VALUE;
237        }
238    }
239    sptr<IPasteboardEntryGetter> entryGetter = nullptr;
240    if (pasteData->IsDelayRecord()) {
241        sptr<IRemoteObject> obj = data.ReadRemoteObject();
242        if (obj == nullptr) {
243            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "entry getter is nullptr");
244            return ERR_INVALID_VALUE;
245        }
246        entryGetter = iface_cast<IPasteboardEntryGetter>(obj);
247        if (entryGetter == nullptr) {
248            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "entry getter is nullptr");
249            return ERR_INVALID_VALUE;
250        }
251    }
252    auto result = SavePasteData(pasteData, delayGetter, entryGetter);
253    HiViewAdapter::ReportUseBehaviour(*pasteData, HiViewAdapter::COPY_STATE, result);
254    if (!reply.WriteInt32(result)) {
255        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to write SetPasteData result");
256        return ERR_INVALID_VALUE;
257    }
258    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, " end, ret is %{public}d.", result);
259    return ERR_OK;
260}
261
262int32_t PasteboardServiceStub::OnSubscribeObserver(MessageParcel &data, MessageParcel &reply)
263{
264    uint32_t type = 0;
265    sptr<IPasteboardChangedObserver> callback;
266    if (!IsObserverValid(data, type, callback)) {
267        return ERR_INVALID_VALUE;
268    }
269
270    SubscribeObserver(static_cast<PasteboardObserverType>(type), callback);
271    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
272    return ERR_OK;
273}
274int32_t PasteboardServiceStub::OnUnsubscribeObserver(MessageParcel &data, MessageParcel &reply)
275{
276    uint32_t type = 0;
277    sptr<IPasteboardChangedObserver> callback;
278    if (!IsObserverValid(data, type, callback)) {
279        return ERR_INVALID_VALUE;
280    }
281    UnsubscribeObserver(static_cast<PasteboardObserverType>(type), callback);
282    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
283    return ERR_OK;
284}
285
286int32_t PasteboardServiceStub::OnUnsubscribeAllObserver(MessageParcel &data, MessageParcel &reply)
287{
288    uint32_t type = 0;
289    if (!data.ReadUint32(type)) {
290        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read type failed.");
291        return ERR_INVALID_VALUE;
292    }
293    UnsubscribeAllObserver(static_cast<PasteboardObserverType>(type));
294    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
295    return ERR_OK;
296}
297
298bool PasteboardServiceStub::IsObserverValid(
299    MessageParcel &data, uint32_t &type, sptr<IPasteboardChangedObserver> &callback)
300{
301    if (!data.ReadUint32(type)) {
302        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read type failed.");
303        return false;
304    }
305    sptr<IRemoteObject> obj = data.ReadRemoteObject();
306    if (obj == nullptr) {
307        PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "obj nullptr");
308        return false;
309    }
310    callback = iface_cast<IPasteboardChangedObserver>(obj);
311    if (callback == nullptr) {
312        PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "callback nullptr");
313        return false;
314    }
315    return true;
316}
317
318int32_t PasteboardServiceStub::OnIsRemoteData(MessageParcel &data, MessageParcel &reply)
319{
320    auto result = IsRemoteData();
321    reply.WriteBool(result);
322    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
323    return ERR_OK;
324}
325
326int32_t PasteboardServiceStub::OnGetDataSource(MessageParcel &data, MessageParcel &reply)
327{
328    std::string bundleName;
329    auto ret = GetDataSource(bundleName);
330    if (bundleName.empty() || bundleName.length() > MAX_BUNDLE_NAME_LENGTH) {
331        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_CLIENT, "Failed to get bundleName");
332        return ERR_INVALID_VALUE;
333    }
334    if (!reply.WriteString(bundleName)) {
335        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to writeName result");
336        return ERR_INVALID_VALUE;
337    }
338    if (!reply.WriteInt32(ret)) {
339        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Failed to OnGetResourceApp result");
340        return ERR_INVALID_VALUE;
341    }
342    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end, ret is %{public}d.", ret);
343    return ERR_OK;
344}
345
346int32_t PasteboardServiceStub::OnHasDataType(MessageParcel &data, MessageParcel &reply)
347{
348    std::string mimeType = data.ReadString();
349    auto ret = HasDataType(mimeType);
350    reply.WriteBool(ret);
351    PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "end.");
352    return ERR_OK;
353}
354
355int32_t PasteboardServiceStub::OnDetectPatterns(MessageParcel &data, MessageParcel &reply)
356{
357    uint32_t size = 0;
358    if (!data.ReadUint32(size)) {
359        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read size failed.");
360        return ERR_INVALID_VALUE;
361    }
362    size_t readAbleSize = data.GetReadableBytes();
363    if (size > readAbleSize || size > static_cast<uint32_t>(Pattern::PatternCount)) {
364        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read oversize failed.");
365        return ERR_INVALID_VALUE;
366    }
367    std::set<Pattern> patternsToCheck;
368    for (uint32_t i = 0; i < size; i++) {
369        uint32_t pattern;
370        if (!data.ReadUint32(pattern)) {
371            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read pattern failed.");
372            return ERR_INVALID_VALUE;
373        }
374        patternsToCheck.insert(static_cast<Pattern>(pattern));
375    }
376    std::set<Pattern> existedPatterns = DetectPatterns(patternsToCheck);
377    if (!reply.WriteUint32(static_cast<uint32_t>(existedPatterns.size()))) {
378        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write size failed.");
379        return ERR_INVALID_VALUE;
380    }
381    for (const auto &pattern : existedPatterns) {
382        if (!reply.WriteUint32(static_cast<uint32_t>(pattern))) {
383            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write pattern failed.");
384            return ERR_INVALID_VALUE;
385        }
386    }
387    return ERR_OK;
388}
389
390int32_t PasteboardServiceStub::OnSetGlobalShareOption(MessageParcel &data, MessageParcel &reply)
391{
392    uint32_t size = 0;
393    if (!data.ReadUint32(size)) {
394        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read size failed.");
395        return ERR_INVALID_VALUE;
396    }
397    size_t readAbleSize = data.GetReadableBytes();
398    if (size > readAbleSize || size > MAX_SET_GLOBAL_SHARE_OPTION_SIZE) {
399        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read oversize failed.");
400        return ERR_INVALID_VALUE;
401    }
402    std::map<uint32_t, ShareOption> globalShareOptions;
403    for (uint32_t i = 0; i < size; i++) {
404        uint32_t tokenId;
405        if (!data.ReadUint32(tokenId)) {
406            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read tokenId failed.");
407            return ERR_INVALID_VALUE;
408        }
409        int32_t shareOption;
410        if (!data.ReadInt32(shareOption)) {
411            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read shareOption failed.");
412            return ERR_INVALID_VALUE;
413        }
414        globalShareOptions[tokenId] = static_cast<ShareOption>(shareOption);
415    }
416    int32_t result = SetGlobalShareOption(globalShareOptions);
417    if (!reply.WriteInt32(result)) {
418        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write result failed.");
419        return ERR_INVALID_VALUE;
420    }
421    return ERR_OK;
422}
423
424int32_t PasteboardServiceStub::OnRemoveGlobalShareOption(MessageParcel &data, MessageParcel &reply)
425{
426    std::vector<uint32_t> tokenIds;
427    if (!data.ReadUInt32Vector(&tokenIds)) {
428        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read tokenIds failed.");
429        return ERR_INVALID_VALUE;
430    }
431    int32_t result = RemoveGlobalShareOption(tokenIds);
432    if (!reply.WriteInt32(result)) {
433        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write result failed.");
434        return ERR_INVALID_VALUE;
435    }
436    return ERR_OK;
437}
438
439int32_t PasteboardServiceStub::OnGetGlobalShareOption(MessageParcel &data, MessageParcel &reply)
440{
441    std::vector<uint32_t> tokenIds;
442    if (!data.ReadUInt32Vector(&tokenIds)) {
443        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read tokenIds failed.");
444        return ERR_INVALID_VALUE;
445    }
446    std::map<uint32_t, ShareOption> globalShareOptions = GetGlobalShareOption(tokenIds);
447    if (!reply.WriteUint32(static_cast<uint32_t>(globalShareOptions.size()))) {
448        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write size failed.");
449        return ERR_INVALID_VALUE;
450    }
451    for (const auto &[tokenId, shareOption] : globalShareOptions) {
452        if (!reply.WriteUint32(tokenId)) {
453            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write tokenId failed.");
454            return ERR_INVALID_VALUE;
455        }
456        if (!reply.WriteInt32(static_cast<int32_t>(shareOption))) {
457            PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write shareOption failed.");
458            return ERR_INVALID_VALUE;
459        }
460    }
461    return ERR_OK;
462}
463
464int32_t PasteboardServiceStub::OnSetAppShareOptions(MessageParcel &data, MessageParcel &reply)
465{
466    int32_t shareOptions;
467    if (!data.ReadInt32(shareOptions)) {
468        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Read share options failed.");
469        return static_cast<int32_t>(PasteboardError::DESERIALIZATION_ERROR);
470    }
471    auto result = SetAppShareOptions(static_cast<ShareOption>(shareOptions));
472    if (!reply.WriteInt32(result)) {
473        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write result failed.");
474        return static_cast<int32_t>(PasteboardError::SERIALIZATION_ERROR);
475    }
476    return ERR_OK;
477}
478
479int32_t PasteboardServiceStub::OnRemoveAppShareOptions(MessageParcel &data, MessageParcel &reply)
480{
481    auto result = RemoveAppShareOptions();
482    if (!reply.WriteInt32(result)) {
483        PASTEBOARD_HILOGE(PASTEBOARD_MODULE_SERVICE, "Write result failed.");
484        return static_cast<int32_t>(PasteboardError::SERIALIZATION_ERROR);
485    }
486    return ERR_OK;
487}
488
489PasteboardServiceStub::~PasteboardServiceStub()
490{
491    memberFuncMap_.clear();
492}
493
494int32_t PasteboardServiceStub::OnPasteStart(MessageParcel &data, MessageParcel &reply)
495{
496    std::string pasteId = data.ReadString();
497    PasteStart(pasteId);
498    return ERR_OK;
499}
500
501int32_t PasteboardServiceStub::OnPasteComplete(MessageParcel &data, MessageParcel &reply)
502{
503    std::string deviceId = data.ReadString();
504    std::string pasteId = data.ReadString();
505    PasteComplete(deviceId, pasteId);
506    return ERR_OK;
507}
508
509int32_t PasteboardServiceStub::OnRegisterClientDeathObserver(MessageParcel &data, MessageParcel &reply)
510{
511    sptr<IRemoteObject> pasteboardClientDeathObserverProxy = data.ReadRemoteObject();
512    if (pasteboardClientDeathObserverProxy == nullptr) {
513        return ERR_INVALID_VALUE;
514    }
515    int32_t status = RegisterClientDeathObserver(std::move(pasteboardClientDeathObserverProxy));
516    if (!reply.WriteInt32(static_cast<int32_t>(status))) {
517        return ERR_INVALID_VALUE;
518    }
519    return ERR_OK;
520}
521} // namespace MiscServices
522} // namespace OHOS