1 /*
2  * Copyright (C) 2021-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 #ifndef N_NAPI_PASTE_H
16 #define N_NAPI_PASTE_H
17 
18 #include <atomic>
19 
20 #include "async_call.h"
21 #include "common/block_object.h"
22 #include "napi/native_api.h"
23 #include "napi/native_node_api.h"
24 #include "pasteboard_delay_getter.h"
25 #include "pasteboard_observer.h"
26 #include "pastedata_napi.h"
27 #include "pastedata_record_napi.h"
28 #include "pixel_map_napi.h"
29 #include "uri.h"
30 #include "unified_data.h"
31 #include "unified_data_napi.h"
32 
33 namespace OHOS {
34 namespace MiscServicesNapi {
35 class PasteboardObserverInstance : public std::enable_shared_from_this<PasteboardObserverInstance> {
36 public:
37     class PasteboardObserverImpl : public MiscServices::PasteboardObserver {
38     public:
39         explicit PasteboardObserverImpl() = default;
40         void OnPasteboardChanged() override;
41         void SetObserverWrapper(const std::shared_ptr<PasteboardObserverInstance> &observerInstance);
42 
43     private:
44         std::weak_ptr<PasteboardObserverInstance> wrapper_;
45     };
46 
47     explicit PasteboardObserverInstance(const napi_env &env, const napi_ref &ref);
48     ~PasteboardObserverInstance();
49 
50     void OnPasteboardChanged();
GetEnv()51     napi_env GetEnv()
52     {
53         return env_;
54     }
GetRef()55     napi_ref GetRef()
56     {
57         return ref_;
58     }
59     sptr<PasteboardObserverImpl> GetStub();
60 
61 private:
62     napi_env env_ = nullptr;
63     napi_ref ref_ = nullptr;
64     sptr<PasteboardObserverImpl> stub_ = nullptr;
65 };
66 
67 class PasteboardDelayGetterInstance : public std::enable_shared_from_this<PasteboardDelayGetterInstance> {
68 public:
69     class PasteboardDelayGetterImpl : public MiscServices::PasteboardDelayGetter {
70     public:
71         explicit PasteboardDelayGetterImpl() = default;
72         void GetPasteData(const std::string &type, MiscServices::PasteData &data) override;
73         void GetUnifiedData(const std::string &type, UDMF::UnifiedData &data) override;
74         void SetDelayGetterWrapper(const std::shared_ptr<PasteboardDelayGetterInstance> observerInstance);
75     private:
76         std::weak_ptr<PasteboardDelayGetterInstance> wrapper_;
77     };
78     explicit PasteboardDelayGetterInstance(const napi_env &env, const napi_ref &ref);
79     ~PasteboardDelayGetterInstance();
80 
81     void GetUnifiedData(const std::string &type, UDMF::UnifiedData &data);
82 
GetEnv()83     napi_env GetEnv()
84     {
85         return env_;
86     }
87 
GetRef()88     napi_ref GetRef()
89     {
90         return ref_;
91     }
92 
GetStub()93     std::shared_ptr<PasteboardDelayGetterImpl> GetStub()
94     {
95         return stub_;
96     }
97 
98 private:
99     napi_env env_ = nullptr;
100     napi_ref ref_ = nullptr;
101     std::shared_ptr<PasteboardDelayGetterImpl> stub_ = nullptr;
102 };
103 
104 struct PasteboardDataWorker {
105     std::shared_ptr<PasteboardObserverInstance> observer = nullptr;
106 };
107 
108 struct PasteboardDelayWorker {
109     std::string dataType;
110     std::shared_ptr<PasteboardDelayGetterInstance> delayGetter = nullptr;
111     std::shared_ptr<UDMF::UnifiedData> unifiedData = nullptr;
112     bool complete;
113     bool clean;
114     std::condition_variable cv;
115     std::mutex mutex;
116 };
117 
118 struct HasContextInfo : public AsyncCall::Context {
119     bool hasPasteData;
120     napi_status status = napi_generic_failure;
HasContextInfoHasContextInfo121     HasContextInfo() : Context(nullptr, nullptr){};
122 
operatorHasContextInfo123     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
124     {
125         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
126         return Context::operator()(env, argc, argv, self);
127     }
operatorHasContextInfo128     napi_status operator()(napi_env env, napi_value *result) override
129     {
130         if (status != napi_ok) {
131             return status;
132         }
133         return Context::operator()(env, result);
134     }
135 };
136 
137 struct SetContextInfo : public AsyncCall::Context {
138     std::shared_ptr<MiscServices::PasteData> obj;
139     napi_status status = napi_generic_failure;
SetContextInfoSetContextInfo140     SetContextInfo() : Context(nullptr, nullptr){};
141 
operatorSetContextInfo142     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
143     {
144         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
145         return Context::operator()(env, argc, argv, self);
146     }
operatorSetContextInfo147     napi_status operator()(napi_env env, napi_value *result) override
148     {
149         if (status != napi_ok) {
150             return status;
151         }
152         return Context::operator()(env, result);
153     }
154 };
155 
156 struct SetUnifiedContextInfo : public AsyncCall::Context {
157     std::shared_ptr<PasteboardDelayGetterInstance> delayGetter;
158     std::shared_ptr<UDMF::UnifiedData> obj;
159     bool isDelay = false;
160     napi_status status = napi_generic_failure;
SetUnifiedContextInfoSetUnifiedContextInfo161     SetUnifiedContextInfo() : Context(nullptr, nullptr){};
162 
operatorSetUnifiedContextInfo163     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
164     {
165         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
166         return Context::operator()(env, argc, argv, self);
167     }
operatorSetUnifiedContextInfo168     napi_status operator()(napi_env env, napi_value *result) override
169     {
170         if (status != napi_ok) {
171             return status;
172         }
173         return Context::operator()(env, result);
174     }
175 };
176 
177 struct GetContextInfo : public AsyncCall::Context {
178     std::shared_ptr<MiscServices::PasteData> pasteData;
179     napi_status status = napi_generic_failure;
GetContextInfoGetContextInfo180     GetContextInfo() : Context(nullptr, nullptr){};
181 
operatorGetContextInfo182     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
183     {
184         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
185         return Context::operator()(env, argc, argv, self);
186     }
operatorGetContextInfo187     napi_status operator()(napi_env env, napi_value *result) override
188     {
189         if (status != napi_ok) {
190             return status;
191         }
192         return Context::operator()(env, result);
193     }
194 };
195 
196 struct GetUnifiedContextInfo : public AsyncCall::Context {
197     std::shared_ptr<UDMF::UnifiedData> unifiedData;
198     napi_status status = napi_generic_failure;
GetUnifiedContextInfoGetUnifiedContextInfo199     GetUnifiedContextInfo() : Context(nullptr, nullptr){};
200 
operatorGetUnifiedContextInfo201     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
202     {
203         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
204         return Context::operator()(env, argc, argv, self);
205     }
operatorGetUnifiedContextInfo206     napi_status operator()(napi_env env, napi_value *result) override
207     {
208         if (status != napi_ok) {
209             return status;
210         }
211         return Context::operator()(env, result);
212     }
213 };
214 
215 struct GetMimeTypesContextInfo : public AsyncCall::Context {
216     std::vector<std::string> mimeTypes;
217     napi_status status = napi_generic_failure;
GetMimeTypesContextInfoGetMimeTypesContextInfo218     GetMimeTypesContextInfo() : Context(nullptr, nullptr){};
219 
operatorGetMimeTypesContextInfo220     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
221     {
222         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
223         return Context::operator()(env, argc, argv, self);
224     }
operatorGetMimeTypesContextInfo225     napi_status operator()(napi_env env, napi_value *result) override
226     {
227         if (status != napi_ok) {
228             return status;
229         }
230         return Context::operator()(env, result);
231     }
232 };
233 
234 struct DetectPatternsContextInfo : public AsyncCall::Context {
235     std::set<MiscServices::Pattern> patternsDetect;
236     std::set<MiscServices::Pattern> patternsToCheck;
237     napi_status status = napi_generic_failure;
DetectPatternsContextInfoDetectPatternsContextInfo238     DetectPatternsContextInfo() : Context(nullptr, nullptr){};
239 
operatorDetectPatternsContextInfo240     napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override
241     {
242         NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg);
243         return Context::operator()(env, argc, argv, self);
244     }
operatorDetectPatternsContextInfo245     napi_status operator()(napi_env env, napi_value *result) override
246     {
247         if (status != napi_ok) {
248             return status;
249         }
250         return Context::operator()(env, result);
251     }
252 };
253 
254 class SystemPasteboardNapi {
255 public:
256     static napi_value SystemPasteboardInit(napi_env env, napi_value exports);
257     static napi_value New(napi_env env, napi_callback_info info);
258     static napi_status NewInstance(napi_env env, napi_value &instance);
259     static void Destructor(napi_env env, void *nativeObject, void *finalize_hint);
260     static void DeleteObserver(const std::shared_ptr<PasteboardObserverInstance> &observer);
261     SystemPasteboardNapi();
262     ~SystemPasteboardNapi();
263 
264 private:
265     static napi_value On(napi_env env, napi_callback_info info);
266     static napi_value Off(napi_env env, napi_callback_info info);
267     static napi_value Clear(napi_env env, napi_callback_info info);
268     static napi_value GetPasteData(napi_env env, napi_callback_info info);
269     static napi_value SetPasteData(napi_env env, napi_callback_info info);
270     static napi_value HasPasteData(napi_env env, napi_callback_info info);
271     static napi_value ClearData(napi_env env, napi_callback_info info);
272     static napi_value GetData(napi_env env, napi_callback_info info);
273     static napi_value SetData(napi_env env, napi_callback_info info);
274     static napi_value HasData(napi_env env, napi_callback_info info);
275     static napi_value IsRemoteData(napi_env env, napi_callback_info info);
276     static napi_value GetDataSource(napi_env env, napi_callback_info info);
277     static napi_value GetMimeTypes(napi_env env, napi_callback_info info);
278     static napi_value HasDataType(napi_env env, napi_callback_info info);
279     static napi_value DetectPatterns(napi_env env, napi_callback_info info);
280     static napi_value ClearDataSync(napi_env env, napi_callback_info info);
281     static napi_value GetDataSync(napi_env env, napi_callback_info info);
282     static napi_value SetDataSync(napi_env env, napi_callback_info info);
283     static napi_value HasDataSync(napi_env env, napi_callback_info info);
284     static bool CheckAgrsOfOnAndOff(napi_env env, bool checkArgsCount, napi_value *argv, size_t argc);
285     static void SetObserver(napi_ref ref, std::shared_ptr<PasteboardObserverInstance> observer);
286     static std::shared_ptr<PasteboardObserverInstance> GetObserver(napi_env env, napi_value observer);
287     static void GetDataCommon(std::shared_ptr<GetContextInfo> &context);
288     static void SetDataCommon(std::shared_ptr<SetContextInfo> &context);
289 
290     static void GetDataCommon(std::shared_ptr<GetUnifiedContextInfo> &context);
291     static void SetDataCommon(std::shared_ptr<SetUnifiedContextInfo> &context);
292 
293     static napi_value GetUnifiedData(napi_env env, napi_callback_info info);
294     static napi_value GetUnifiedDataSync(napi_env env, napi_callback_info info);
295     static napi_value SetUnifiedData(napi_env env, napi_callback_info info);
296     static napi_value SetUnifiedDataSync(napi_env env, napi_callback_info info);
297 
298     static napi_value SetAppShareOptions(napi_env env, napi_callback_info info);
299     static napi_value RemoveAppShareOptions(napi_env env, napi_callback_info info);
300 
301     static std::mutex delayMutex_;
302     std::shared_ptr<PasteDataNapi> value_;
303     std::shared_ptr<MiscServices::PasteData> pasteData_;
304     napi_env env_;
305     static thread_local std::map<napi_ref, std::shared_ptr<PasteboardObserverInstance>> observers_;
306     static std::shared_ptr<PasteboardDelayGetterInstance> delayGetter_;
307 };
308 } // namespace MiscServicesNapi
309 } // namespace OHOS
310 #endif