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 DetectPatternsContextInfo : public AsyncCall::Context { 216 std::set<MiscServices::Pattern> patternsDetect; 217 std::set<MiscServices::Pattern> patternsToCheck; 218 napi_status status = napi_generic_failure; DetectPatternsContextInfoDetectPatternsContextInfo219 DetectPatternsContextInfo() : Context(nullptr, nullptr){}; 220 operatorDetectPatternsContextInfo221 napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) override 222 { 223 NAPI_ASSERT_BASE(env, self != nullptr, "self is nullptr", napi_invalid_arg); 224 return Context::operator()(env, argc, argv, self); 225 } operatorDetectPatternsContextInfo226 napi_status operator()(napi_env env, napi_value *result) override 227 { 228 if (status != napi_ok) { 229 return status; 230 } 231 return Context::operator()(env, result); 232 } 233 }; 234 235 class SystemPasteboardNapi { 236 public: 237 static napi_value SystemPasteboardInit(napi_env env, napi_value exports); 238 static napi_value New(napi_env env, napi_callback_info info); 239 static napi_status NewInstance(napi_env env, napi_value &instance); 240 static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); 241 static void DeleteObserver(const std::shared_ptr<PasteboardObserverInstance> &observer); 242 SystemPasteboardNapi(); 243 ~SystemPasteboardNapi(); 244 245 private: 246 static napi_value On(napi_env env, napi_callback_info info); 247 static napi_value Off(napi_env env, napi_callback_info info); 248 static napi_value Clear(napi_env env, napi_callback_info info); 249 static napi_value GetPasteData(napi_env env, napi_callback_info info); 250 static napi_value SetPasteData(napi_env env, napi_callback_info info); 251 static napi_value HasPasteData(napi_env env, napi_callback_info info); 252 static napi_value ClearData(napi_env env, napi_callback_info info); 253 static napi_value GetData(napi_env env, napi_callback_info info); 254 static napi_value SetData(napi_env env, napi_callback_info info); 255 static napi_value HasData(napi_env env, napi_callback_info info); 256 static napi_value IsRemoteData(napi_env env, napi_callback_info info); 257 static napi_value GetDataSource(napi_env env, napi_callback_info info); 258 static napi_value HasDataType(napi_env env, napi_callback_info info); 259 static napi_value DetectPatterns(napi_env env, napi_callback_info info); 260 static napi_value ClearDataSync(napi_env env, napi_callback_info info); 261 static napi_value GetDataSync(napi_env env, napi_callback_info info); 262 static napi_value SetDataSync(napi_env env, napi_callback_info info); 263 static napi_value HasDataSync(napi_env env, napi_callback_info info); 264 static bool CheckAgrsOfOnAndOff(napi_env env, bool checkArgsCount, napi_value *argv, size_t argc); 265 static void SetObserver(napi_ref ref, std::shared_ptr<PasteboardObserverInstance> observer); 266 static std::shared_ptr<PasteboardObserverInstance> GetObserver(napi_env env, napi_value observer); 267 static void GetDataCommon(std::shared_ptr<GetContextInfo> &context); 268 static void SetDataCommon(std::shared_ptr<SetContextInfo> &context); 269 270 static void GetDataCommon(std::shared_ptr<GetUnifiedContextInfo> &context); 271 static void SetDataCommon(std::shared_ptr<SetUnifiedContextInfo> &context); 272 273 static napi_value GetUnifiedData(napi_env env, napi_callback_info info); 274 static napi_value GetUnifiedDataSync(napi_env env, napi_callback_info info); 275 static napi_value SetUnifiedData(napi_env env, napi_callback_info info); 276 static napi_value SetUnifiedDataSync(napi_env env, napi_callback_info info); 277 278 static napi_value SetAppShareOptions(napi_env env, napi_callback_info info); 279 static napi_value RemoveAppShareOptions(napi_env env, napi_callback_info info); 280 281 static std::mutex delayMutex_; 282 std::shared_ptr<PasteDataNapi> value_; 283 std::shared_ptr<MiscServices::PasteData> pasteData_; 284 napi_env env_; 285 static thread_local std::map<napi_ref, std::shared_ptr<PasteboardObserverInstance>> observers_; 286 static std::shared_ptr<PasteboardDelayGetterInstance> delayGetter_; 287 }; 288 } // namespace MiscServicesNapi 289 } // namespace OHOS 290 #endif