1 /* 2 * Copyright (C) 2021-2025 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 #ifndef PASTE_BOARD_SERVICE_H 17 #define PASTE_BOARD_SERVICE_H 18 19 #include <system_ability_definition.h> 20 21 #include "bundle_mgr_proxy.h" 22 #include "clip/clip_plugin.h" 23 #include "common/block_object.h" 24 #include "device/distributed_module_config.h" 25 #include "eventcenter/event_center.h" 26 #include "ffrt/ffrt_utils.h" 27 #include "i_paste_data_processor.h" 28 #include "ientity_recognition_observer.h" 29 #include "input_manager.h" 30 #include "loader.h" 31 #include "pasteboard_account_state_subscriber.h" 32 #include "pasteboard_common_event_subscriber.h" 33 #include "pasteboard_dump_helper.h" 34 #include "pasteboard_event_common.h" 35 #include "pasteboard_service_stub.h" 36 #include "pasteboard_switch.h" 37 #include "privacy_kit.h" 38 #include "security_level.h" 39 #include "system_ability.h" 40 41 namespace OHOS { 42 namespace MiscServices { 43 constexpr int32_t ERROR_USERID = -1; 44 constexpr int32_t RESULT_OK = 0; 45 enum class ServiceRunningState { 46 STATE_NOT_START, 47 STATE_RUNNING 48 }; 49 struct AppInfo { 50 std::string bundleName = "com.pasteboard.default"; 51 int32_t tokenType = -1; 52 int32_t userId = ERROR_USERID; 53 uint32_t tokenId; 54 int32_t appIndex = 0; 55 }; 56 57 struct HistoryInfo { 58 std::string time; 59 std::string bundleName; 60 std::string state; 61 std::string remote; 62 }; 63 64 struct PasteDateTime { 65 int32_t syncTime = 0; 66 int32_t errorCode = 0; 67 std::shared_ptr<PasteData> data; 68 }; 69 70 struct PasteDateResult { 71 int32_t syncTime = 0; 72 int32_t errorCode = 0; 73 }; 74 75 struct PasteP2pEstablishInfo { 76 std::string networkId; 77 std::shared_ptr<BlockObject<int32_t>> pasteBlock; 78 }; 79 80 struct FocusedAppInfo { 81 int32_t windowId = 0; 82 sptr<IRemoteObject> abilityToken = nullptr; 83 }; 84 class PasteboardService; 85 class InputEventCallback : public MMI::IInputEventConsumer { 86 public: 87 enum InputType : int32_t { 88 INPUTTYPE_PASTE = 0, 89 INPUTTYPE_PRESYNC, 90 }; 91 InputEventCallback(int32_t inputType = INPUTTYPE_PASTE, PasteboardService *pasteboardService = nullptr) inputType_(inputType)92 : inputType_(inputType), pasteboardService_(pasteboardService) {}; 93 void OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const override; 94 void OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const override; 95 void OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const override; 96 void OnKeyInputEventForPaste(std::shared_ptr<MMI::KeyEvent> keyEvent) const; 97 bool IsCtrlVProcess(uint32_t callingPid, bool isFocused); 98 void Clear(); 99 100 private: 101 static constexpr uint32_t WAIT_TIME_OUT = 100; 102 mutable int32_t windowPid_ = -1; 103 mutable uint64_t actionTime_ = 0; 104 mutable std::shared_mutex inputEventMutex_; 105 mutable std::shared_mutex blockMapMutex_; 106 mutable std::map<uint32_t, std::shared_ptr<BlockObject<int32_t>>> blockMap_; 107 int32_t inputType_ = INPUTTYPE_PASTE; 108 PasteboardService *pasteboardService_ = nullptr; 109 }; 110 111 class PasteboardService final : public SystemAbility, public PasteboardServiceStub { 112 DECLARE_SYSTEM_ABILITY(PasteboardService) 113 114 public: 115 API_EXPORT PasteboardService(); 116 API_EXPORT ~PasteboardService(); 117 int32_t CallbackEnter(uint32_t code) override; 118 int32_t CallbackExit(uint32_t code, int32_t result) override; 119 virtual int32_t Clear() override; 120 virtual int32_t GetRecordValueByType(uint32_t dataId, uint32_t recordId, int64_t &rawDataSize, 121 std::vector<uint8_t> &buffer, int &fd) override; 122 virtual int32_t GetPasteData(int &fd, int64_t &size, std::vector<uint8_t> &rawData, 123 const std::string &pasteId, int32_t &syncTime) override; 124 virtual int32_t HasPasteData(bool &funcResult) override; 125 virtual int32_t SetPasteData(int fd, int64_t memSize, const std::vector<uint8_t> &buffer, 126 const sptr<IPasteboardDelayGetter> &delayGetter, const sptr<IPasteboardEntryGetter> &entryGetter) override; 127 virtual int32_t SetPasteDataDelayData(int fd, int64_t memSize, const std::vector<uint8_t> &buffer, 128 const sptr<IPasteboardDelayGetter> &delayGetter) override; 129 virtual int32_t SetPasteDataEntryData(int fd, int64_t memSize, const std::vector<uint8_t> &buffer, 130 const sptr<IPasteboardEntryGetter> &entryGetter) override; 131 virtual int32_t SetPasteDataOnly(int fd, int64_t memSize, const std::vector<uint8_t> &buffer) override; 132 virtual int32_t IsRemoteData(bool &funcResult) override; 133 virtual int32_t GetMimeTypes(std::vector<std::string> &funcResult) override; 134 virtual int32_t HasDataType(const std::string &mimeType, bool &funcResult) override; 135 virtual int32_t DetectPatterns( 136 const std::vector<Pattern> &patternsToCheck, std::vector<Pattern>& funcResult) override; 137 virtual int32_t GetDataSource(std::string &bundleNme) override; 138 virtual int32_t SubscribeEntityObserver( 139 EntityType entityType, uint32_t expectedDataLength, const sptr<IEntityRecognitionObserver> &observer) override; 140 virtual int32_t UnsubscribeEntityObserver( 141 EntityType entityType, uint32_t expectedDataLength, const sptr<IEntityRecognitionObserver> &observer) override; 142 virtual int32_t SubscribeObserver( 143 PasteboardObserverType type, const sptr<IPasteboardChangedObserver> &observer) override; 144 virtual int32_t ResubscribeObserver( 145 PasteboardObserverType type, const sptr<IPasteboardChangedObserver> &observer) override; 146 virtual int32_t UnsubscribeObserver( 147 PasteboardObserverType type, const sptr<IPasteboardChangedObserver> &observer) override; 148 virtual int32_t UnsubscribeAllObserver(PasteboardObserverType type) override; 149 int32_t SubscribeDisposableObserver(const sptr<IPasteboardDisposableObserver> &observer, 150 const std::string &targetBundleName, DisposableType type, uint32_t maxLength) override; 151 virtual int32_t SetGlobalShareOption(const std::unordered_map<uint32_t, int32_t> &globalShareOptions) override; 152 virtual int32_t RemoveGlobalShareOption(const std::vector<uint32_t> &tokenIds) override; 153 virtual int32_t GetGlobalShareOption( 154 const std::vector<uint32_t> &tokenIds, std::unordered_map<uint32_t, int32_t>& funcResult) override; 155 virtual int32_t SetAppShareOptions(int32_t shareOptions) override; 156 virtual int32_t RemoveAppShareOptions() override; 157 virtual void OnStart() override; 158 virtual void OnStop() override; 159 virtual int32_t PasteStart(const std::string &pasteId) override; 160 virtual int32_t PasteComplete(const std::string &deviceId, const std::string &pasteId) override; 161 int32_t GetRemoteDeviceName(std::string &deviceName, bool &isRemote); 162 virtual int32_t ShowProgress(const std::string &progressKey, const sptr<IRemoteObject> &observer) override; 163 virtual int32_t RegisterClientDeathObserver(const sptr<IRemoteObject> &observer) override; 164 static int32_t currentUserId_; 165 static ScreenEvent currentScreenStatus; 166 size_t GetDataSize(PasteData &data) const; 167 int Dump(int fd, const std::vector<std::u16string> &args) override; 168 void NotifyDelayGetterDied(int32_t userId); 169 void NotifyEntryGetterDied(int32_t userId); 170 virtual int32_t GetChangeCount(uint32_t &changeCount) override; 171 void ChangeStoreStatus(int32_t userId); 172 void CloseDistributedStore(int32_t user, bool isNeedClear); 173 void PreSyncRemotePasteboardData(); 174 PastedSwitch switch_; 175 static int32_t GetCurrentAccountId(); 176 void RevokeUriOnUninstall(int32_t tokenId); 177 void RevokeAndClearUri(std::shared_ptr<PasteData> pasteData); 178 179 private: 180 bool isCritical_ = false; 181 std::mutex saMutex_; 182 std::shared_mutex pasteDataMutex_; 183 using Event = ClipPlugin::GlobalEvent; 184 using GetProcessorFunc = IPasteDataProcessor& (*)(); 185 static constexpr const int32_t LISTENING_SERVICE[] = { DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, 186 WINDOW_MANAGER_SERVICE_ID, MEMORY_MANAGER_SA_ID, DISTRIBUTED_DEVICE_PROFILE_SA_ID }; 187 static constexpr const char *PLUGIN_NAME = "distributed_clip"; 188 static constexpr const char *SET_CRITICAL_ID = "pasteboard_service_set_critical_id"; 189 static constexpr uint32_t PLAIN_INDEX = 0; 190 static constexpr uint32_t HTML_INDEX = 1; 191 static constexpr uint32_t URI_INDEX = 2; 192 static constexpr uint32_t WANT_INDEX = 3; 193 static constexpr uint32_t PIXELMAP_INDEX = 4; 194 static constexpr uint32_t MAX_INDEX_LENGTH = 8; 195 static constexpr const pid_t EDM_UID = 3057; 196 static constexpr const pid_t ROOT_UID = 0; 197 static constexpr uint32_t EXPIRATION_INTERVAL = 2 * 60 * 1000; 198 static constexpr int MIN_TRANMISSION_TIME = 30 * 1000; // ms 199 static constexpr int PRESYNC_MONITOR_TIME = 2 * 60 * 1000; // ms 200 static constexpr int PRE_ESTABLISH_P2P_LINK_TIME = 2 * 60 * 1000; // ms 201 static constexpr uint32_t SET_DISTRIBUTED_DATA_INTERVAL = 40 * 1000; // 40 seconds 202 static constexpr int32_t ONE_HOUR_MINUTES = 60; 203 static constexpr int32_t MAX_AGED_TIME = 24 * 60; // minute 204 static constexpr int32_t MIN_AGED_TIME = 1; // minute 205 static constexpr int32_t MINUTES_TO_MILLISECONDS = 60 * 1000; 206 static constexpr uint32_t GET_REMOTE_DATA_WAIT_TIME = 30000; 207 static constexpr int64_t PRESYNC_MONITOR_INTERVAL_MILLISECONDS = 500; // ms 208 static constexpr int32_t INVALID_SUBSCRIBE_ID = -1; 209 static const std::string REGISTER_PRESYNC_MONITOR; 210 static const std::string UNREGISTER_PRESYNC_MONITOR; 211 static const std::string P2P_ESTABLISH_STR; 212 static const std::string P2P_PRESYNC_ID; 213 int32_t agedTime_ = ONE_HOUR_MINUTES * MINUTES_TO_MILLISECONDS; // 1 hour 214 bool SetPasteboardHistory(HistoryInfo &info); 215 bool IsFocusedApp(uint32_t tokenId); 216 void InitBundles(Loader &loader); 217 void SetInputMethodPid(int32_t userId, pid_t callPid); 218 void ClearInputMethodPidByPid(int32_t userId, pid_t callPid); 219 void ClearInputMethodPid(void); 220 bool IsSystemAppByFullTokenID(uint64_t tokenId); 221 FocusedAppInfo GetFocusedAppInfo(void) const; 222 class DelayGetterDeathRecipient final : public IRemoteObject::DeathRecipient { 223 public: 224 explicit DelayGetterDeathRecipient(int32_t userId, PasteboardService &service); 225 virtual ~DelayGetterDeathRecipient() = default; 226 void OnRemoteDied(const wptr<IRemoteObject> &remote) override; 227 228 private: 229 int32_t userId_ = ERROR_USERID; 230 PasteboardService &service_; 231 }; 232 233 class EntryGetterDeathRecipient final : public IRemoteObject::DeathRecipient { 234 public: 235 explicit EntryGetterDeathRecipient(int32_t userId, PasteboardService &service); 236 virtual ~EntryGetterDeathRecipient() = default; 237 void OnRemoteDied(const wptr<IRemoteObject> &remote) override; 238 239 private: 240 int32_t userId_ = ERROR_USERID; 241 PasteboardService &service_; 242 }; 243 244 class RemoteDataTaskManager { 245 public: 246 struct TaskContext { 247 std::atomic<bool> pasting_ = false; 248 ConcurrentMap<uint32_t, std::shared_ptr<BlockObject<bool>>> getDataBlocks_; 249 std::shared_ptr<PasteDateTime> data_; 250 }; 251 using DataTask = std::pair<std::shared_ptr<PasteboardService::RemoteDataTaskManager::TaskContext>, bool>; 252 DataTask GetRemoteDataTask(const Event &event); 253 void Notify(const Event &event, std::shared_ptr<PasteDateTime> data); 254 void ClearRemoteDataTask(const Event &event); 255 std::shared_ptr<PasteDateTime> WaitRemoteData(const Event &event); 256 257 private: 258 std::atomic<uint32_t> mapKey_ = 0; 259 std::mutex mutex_; 260 std::map<std::string, std::shared_ptr<TaskContext>> dataTasks_; 261 }; 262 263 struct classcomp { operatorclasscomp264 bool operator()(const sptr<IPasteboardChangedObserver> &l, const sptr<IPasteboardChangedObserver> &r) const 265 { 266 return l->AsObject() < r->AsObject(); 267 } 268 }; 269 struct EntityObserverInfo { 270 EntityType entityType; 271 uint32_t expectedDataLength; 272 uint32_t tokenId; 273 sptr<IEntityRecognitionObserver> observer; EntityObserverInfoEntityObserverInfo274 EntityObserverInfo(EntityType entityType_, uint32_t expectedDataLength_, uint32_t tokenId_, 275 sptr<IEntityRecognitionObserver> observer_) : entityType(entityType_), 276 expectedDataLength(expectedDataLength_), tokenId(tokenId_), observer(observer_) { } 277 }; 278 using ObserverMap = std::map<std::pair<int32_t, pid_t>, 279 std::shared_ptr<std::set<sptr<IPasteboardChangedObserver>, classcomp>>>; 280 uint32_t GetObserversSize(int32_t userId, pid_t pid, ObserverMap &observerMap); 281 uint32_t GetAllObserversSize(int32_t userId, pid_t pid); 282 void AddSysAbilityListener(); 283 int32_t Init(); 284 void InitScreenStatus(); 285 static ScreenEvent GetCurrentScreenStatus(); 286 std::string DumpHistory() const; 287 std::string DumpData(); 288 void ThawInputMethod(pid_t imePid); 289 bool IsNeedThaw(void); 290 int32_t ExtractEntity(const std::string &entity, std::string &location); 291 int32_t GetAllEntryPlainText(uint32_t dataId, uint32_t recordId, 292 std::vector<std::shared_ptr<PasteDataEntry>> &entries, std::string &primaryText); 293 std::string GetAllPrimaryText(const PasteData &pasteData); 294 void NotifyEntityObservers(std::string &entity, EntityType entityType, uint32_t dataLength); 295 void UnsubscribeAllEntityObserver(); 296 void NotifyObservers(std::string bundleName, int32_t userId, PasteboardEventStatus status); 297 void InitServiceHandler(); 298 bool IsCopyable(uint32_t tokenId) const; 299 std::mutex imeMutex_; 300 ConcurrentMap<int32_t, pid_t> imeMap_; 301 302 struct DistributedMemory { 303 std::mutex mutex; 304 bool isRunning = false; 305 std::shared_ptr<PasteData> data; 306 Event event; 307 }; 308 DistributedMemory setDistributedMemory_; 309 310 int32_t SaveData(PasteData &pasteData, int64_t dataSize, const sptr<IPasteboardDelayGetter> delayGetter = nullptr, 311 const sptr<IPasteboardEntryGetter> entryGetter = nullptr); 312 void SetPasteDataInfo(PasteData &pasteData, const AppInfo &appInfo, uint32_t tokenId); 313 void HandleDelayDataAndRecord(PasteData &pasteData, const sptr<IPasteboardDelayGetter> delayGetter, 314 const sptr<IPasteboardEntryGetter> entryGetter, const AppInfo &appInfo); 315 void RemovePasteData(const AppInfo &appInfo); 316 void SetPasteDataDot(PasteData &pasteData); 317 std::pair<int32_t, ClipPlugin::GlobalEvent> GetValidDistributeEvent(int32_t user); 318 int32_t GetSdkVersion(uint32_t tokenId); 319 bool IsPermissionGranted(const std::string &perm, uint32_t tokenId); 320 int32_t CheckAndGrantRemoteUri(PasteData &data, const AppInfo &appInfo, 321 const std::string &pasteId, const std::string &deviceId, std::shared_ptr<BlockObject<int32_t>> pasteBlock); 322 int32_t GetData(uint32_t tokenId, PasteData &data, int32_t &syncTime, bool &isPeerOnline, std::string &peerNetId, 323 std::string &peerUdid); 324 CommonInfo GetCommonState(int64_t dataSize); 325 void SetRadarEvent(const AppInfo &appInfo, PasteData &data, bool isPeerOnline, 326 RadarReportInfo &radarReportInfo, const std::string &peerNetId); 327 void SetUeEvent(const AppInfo &appInfo, PasteData &data, bool isPeerOnline, 328 UeReportInfo &ueReportInfo, const std::string &peerNetId); 329 int32_t GetPasteDataInner(int &fd, int64_t &size, std::vector<uint8_t> &rawData, 330 const std::string &pasteId, int32_t &syncTime, UeReportInfo &ueReportInfo); 331 void GetPasteDataDot(PasteData &pasteData, const std::string &bundleName); 332 int32_t GetLocalData(const AppInfo &appInfo, PasteData &data); 333 int32_t GetRemoteData(int32_t userId, const Event &event, PasteData &data, int32_t &syncTime); 334 int32_t GetRemotePasteData(int32_t userId, const Event &event, PasteData &data, int32_t &syncTime); 335 int32_t GetDelayPasteRecord(int32_t userId, PasteData &data); 336 void GetDelayPasteData(int32_t userId, PasteData &data); 337 int32_t ProcessDelayHtmlEntry(PasteData &data, const AppInfo &targetAppInfo, PasteDataEntry &entry); 338 int32_t PostProcessDelayHtmlEntry(PasteData &data, const AppInfo &targetInfo, PasteDataEntry &entry); 339 std::vector<Uri> CheckUriPermission(PasteData &data, const std::pair<std::string, int32_t> &targetBundleAppIndex); 340 int32_t GrantUriPermission(const std::vector<Uri> &grantUris, const std::string &targetBundleName, 341 bool isRemoteData, int32_t appIndex); 342 void GenerateDistributedUri(PasteData &data); 343 bool IsBundleOwnUriPermission(const std::string &bundleName, Uri &uri); 344 std::string GetAppLabel(uint32_t tokenId); 345 sptr<OHOS::AppExecFwk::IBundleMgr> GetAppBundleManager(); 346 void OpenP2PLink(const std::string &networkId); 347 std::shared_ptr<BlockObject<int32_t>> CheckAndReuseP2PLink(const std::string &networkId, 348 const std::string &pasteId); 349 void EstablishP2PLink(const std::string &networkId, const std::string &pasteId); 350 bool IsContainUri(const std::vector<std::string> &dataType); 351 std::shared_ptr<BlockObject<int32_t>> EstablishP2PLinkTask( 352 const std::string &pasteId, const ClipPlugin::GlobalEvent &event); 353 void OnEstablishP2PLinkTask(const std::string &networkId, std::shared_ptr<BlockObject<int32_t>> pasteBlock); 354 void ClearP2PEstablishTaskInfo(); 355 void CloseP2PLink(const std::string &networkId); 356 bool HasDistributedDataType(const std::string &mimeType); 357 358 std::pair<std::shared_ptr<PasteData>, PasteDateResult> GetDistributedData(const Event &event, int32_t user); 359 int32_t GetDistributedDelayData(const Event &evt, uint8_t version, std::vector<uint8_t> &rawData); 360 int32_t GetDistributedDelayEntry(const Event &evt, uint32_t recordId, const std::string &utdId, 361 std::vector<uint8_t> &rawData); 362 int32_t ProcessDistributedDelayUri(int32_t userId, PasteData &data, PasteDataEntry &entry, 363 std::vector<uint8_t> &rawData); 364 int32_t ProcessDistributedDelayHtml(PasteData &data, PasteDataEntry &entry, std::vector<uint8_t> &rawData); 365 int32_t ProcessDistributedDelayEntry(PasteDataEntry &entry, std::vector<uint8_t> &rawData); 366 int32_t GetRemoteEntryValue(const AppInfo &appInfo, PasteData &data, PasteDataRecord &record, 367 PasteDataEntry &entry); 368 int32_t ProcessRemoteDelayUri(const std::string &deviceId, const AppInfo &appInfo, 369 PasteData &data, PasteDataRecord &record, PasteDataEntry &entry); 370 int32_t ProcessRemoteDelayHtml(const std::string &remoteDeviceId, const AppInfo &appInfo, 371 const std::vector<uint8_t> &rawData, PasteData &data, PasteDataRecord &record, PasteDataEntry &entry); 372 int32_t ProcessRemoteDelayHtmlInner(const std::string &remoteDeviceId, const AppInfo &appInfo, 373 PasteData &tmpData, PasteData &data, PasteDataEntry &entry); 374 int32_t GetLocalEntryValue(int32_t userId, PasteData &data, PasteDataRecord &record, PasteDataEntry &entry); 375 int32_t GetFullDelayPasteData(int32_t userId, PasteData &data); 376 bool IsDisallowDistributed(); 377 bool SetDistributedData(int32_t user, PasteData &data); 378 bool SetCurrentDistributedData(PasteData &data, Event event); 379 bool SetCurrentData(Event event, PasteData &data); 380 void CleanDistributedData(int32_t user); 381 void OnConfigChange(bool isOn); 382 void OnConfigChangeInner(bool isOn); 383 std::shared_ptr<ClipPlugin> GetClipPlugin(); 384 void IncreaseChangeCount(int32_t userId); 385 386 static std::string GetTime(); 387 bool IsDataAged(); 388 bool VerifyPermission(uint32_t tokenId); 389 int32_t IsDataValid(PasteData &pasteData, uint32_t tokenId); 390 static AppInfo GetAppInfo(uint32_t tokenId); 391 static std::string GetAppBundleName(const AppInfo &appInfo); 392 static void SetLocalPasteFlag(bool isCrossPaste, uint32_t tokenId, PasteData &pasteData); 393 void RecognizePasteData(PasteData &pasteData); 394 void OnRecognizePasteData(const std::string &primaryText); 395 void ShowHintToast(uint32_t tokenId, uint32_t pid); 396 void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 397 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 398 void UpdateAgedTime(); 399 void CancelCriticalTimer(); 400 void SetCriticalTimer(); 401 void OnAddDeviceManager(); 402 void OnAddMemoryManager(); 403 void OnAddDeviceProfile(); 404 void OnRemoveDeviceProfile(); 405 void ReportUeCopyEvent(PasteData &pasteData, int64_t dataSize, int32_t result); 406 bool HasDataType(const std::string &mimeType); 407 bool HasPasteData(); 408 bool IsRemoteData(); 409 int32_t GetRecordValueByType(uint32_t dataId, uint32_t recordId, PasteDataEntry &value); 410 int32_t GetRecordValueByType(int64_t &rawDataSize, std::vector<uint8_t> &buffer, int &fd, 411 const PasteDataEntry &entryValue); 412 int32_t DealData(int &fd, int64_t &size, std::vector<uint8_t> &rawData, PasteData &data); 413 bool WriteRawData(const void *data, int64_t size, int &serFd); 414 int32_t WritePasteData( 415 int fd, int64_t rawDataSize, const std::vector<uint8_t> &buffer, PasteData &pasteData, bool &hasData); 416 void CloseSharedMemFd(int fd); 417 418 void RegisterPreSyncCallback(std::shared_ptr<ClipPlugin> clipPlugin); 419 bool OpenP2PLinkForPreEstablish(const std::string &networkId, ClipPlugin *clipPlugin); 420 void PreEstablishP2PLink(const std::string &networkId, ClipPlugin *clipPlugin); 421 void PreEstablishP2PLinkCallback(const std::string &networkId, ClipPlugin *clipPlugin); 422 void PreSyncSwitchMonitorCallback(); 423 void RegisterPreSyncMonitor(); 424 void UnRegisterPreSyncMonitor(); 425 void DeletePreSyncP2pFromP2pMap(const std::string &networkId); 426 void DeletePreSyncP2pMap(const std::string &networkId); 427 void AddPreSyncP2pTimeoutTask(const std::string &networkId); 428 429 static inline ServiceRunningState state_ = ServiceRunningState::STATE_NOT_START; 430 std::shared_ptr<AppExecFwk::EventHandler> serviceHandler_; 431 std::mutex observerMutex_; 432 ObserverMap observerLocalChangedMap_; 433 ObserverMap observerRemoteChangedMap_; 434 ObserverMap observerEventMap_; 435 ClipPlugin::GlobalEvent currentEvent_; 436 ClipPlugin::GlobalEvent remoteEvent_; 437 ConcurrentMap<int32_t, std::shared_ptr<PasteData>> clips_; 438 ConcurrentMap<int32_t, uint32_t> clipChangeCount_; 439 ConcurrentMap<pid_t, std::vector<EntityObserverInfo>> entityObserverMap_; 440 ConcurrentMap<int32_t, std::pair<sptr<IPasteboardEntryGetter>, sptr<EntryGetterDeathRecipient>>> entryGetters_; 441 ConcurrentMap<int32_t, std::pair<sptr<IPasteboardDelayGetter>, sptr<DelayGetterDeathRecipient>>> delayGetters_; 442 ConcurrentMap<int32_t, uint64_t> copyTime_; 443 std::set<std::pair<std::string, int32_t>> readBundles_; 444 std::shared_ptr<PasteBoardCommonEventSubscriber> commonEventSubscriber_ = nullptr; 445 std::shared_ptr<PasteBoardAccountStateSubscriber> accountStateSubscriber_ = nullptr; 446 447 std::recursive_mutex mutex; 448 std::shared_ptr<ClipPlugin> clipPlugin_ = nullptr; 449 std::atomic<uint16_t> sequenceId_ = 0; 450 std::atomic<uint32_t> dataId_ = 0; 451 std::atomic<uint32_t> delayTokenId_ = 0; 452 std::atomic<uint32_t> delayDataId_ = 0; 453 static std::mutex historyMutex_; 454 std::mutex bundleMutex_; 455 std::mutex readBundleMutex_; 456 static std::vector<std::string> dataHistory_; 457 static std::shared_ptr<Command> copyHistory; 458 static std::shared_ptr<Command> copyData; 459 std::atomic<bool> setting_ = false; 460 std::map<std::string, int> typeMap_ = { 461 {MIMETYPE_TEXT_PLAIN, PLAIN_INDEX }, 462 { MIMETYPE_TEXT_HTML, HTML_INDEX }, 463 { MIMETYPE_TEXT_URI, URI_INDEX }, 464 { MIMETYPE_TEXT_WANT, WANT_INDEX }, 465 { MIMETYPE_PIXELMAP, PIXELMAP_INDEX} 466 }; 467 468 std::shared_ptr<FFRTTimer> ffrtTimer_; 469 std::mutex p2pMapMutex_; 470 PasteP2pEstablishInfo p2pEstablishInfo_; 471 ConcurrentMap<std::string, ConcurrentMap<std::string, int32_t>> p2pMap_; 472 std::map<std::string, std::shared_ptr<BlockObject<int32_t>>> preSyncP2pMap_; 473 int32_t subscribeActiveId_ = INVALID_SUBSCRIBE_ID; 474 enum GlobalShareOptionSource { 475 MDM = 0, 476 APP = 1, 477 }; 478 479 struct GlobalShareOption { 480 GlobalShareOptionSource source; 481 ShareOption shareOption; 482 }; 483 484 ConcurrentMap<uint32_t, GlobalShareOption> globalShareOptions_; 485 486 bool AddObserver(int32_t userId, const sptr<IPasteboardChangedObserver> &observer, ObserverMap &observerMap); 487 void RemoveSingleObserver( 488 int32_t userId, const sptr<IPasteboardChangedObserver> &observer, ObserverMap &observerMap); 489 void RemoveAllObserver(int32_t userId, ObserverMap &observerMap); 490 bool IsCallerUidValid(); 491 std::vector<std::string> GetLocalMimeTypes(); 492 bool HasLocalDataType(const std::string &mimeType); 493 void AddPermissionRecord(uint32_t tokenId, bool isReadGrant, bool isSecureGrant); 494 bool SubscribeKeyboardEvent(); 495 bool IsAllowSendData(); 496 void UpdateShareOption(PasteData &pasteData); 497 bool CheckMdmShareOption(PasteData &pasteData); 498 void PasteboardEventSubscriber(); 499 void CommonEventSubscriber(); 500 void AccountStateSubscriber(); 501 bool IsBasicType(const std::string &mimeType); 502 std::function<void(const OHOS::MiscServices::Event &)> RemotePasteboardChange(); 503 std::shared_ptr<InputEventCallback> inputEventCallback_; 504 DistributedModuleConfig moduleConfig_; 505 int32_t uid_ = -1; 506 RemoteDataTaskManager taskMgr_; 507 pid_t setPasteDataUId_ = 0; 508 static constexpr pid_t TEST_SERVER_UID = 3500; 509 std::mutex eventMutex_; 510 SecurityLevel securityLevel_; 511 class PasteboardDeathRecipient final : public IRemoteObject::DeathRecipient { 512 public: 513 PasteboardDeathRecipient(PasteboardService &service, sptr<IRemoteObject> observer, pid_t pid); 514 virtual ~PasteboardDeathRecipient() = default; 515 void OnRemoteDied(const wptr<IRemoteObject> &remote) override; 516 517 private: 518 PasteboardService &service_; 519 sptr<IRemoteObject> observer_; 520 pid_t pid_; 521 }; 522 int32_t AppExit(pid_t pid); 523 void RemoveObserverByPid(int32_t userId, pid_t pid, ObserverMap &observerMap); 524 ConcurrentMap<pid_t, sptr<PasteboardDeathRecipient>> clients_; 525 static constexpr pid_t INVALID_UID = -1; 526 static constexpr pid_t INVALID_PID = -1; 527 static constexpr uint32_t INVALID_TOKEN = 0; 528 static constexpr uint32_t MAX_OBSERVER_COUNT = 10; 529 }; 530 } // namespace MiscServices 531 } // namespace OHOS 532 #endif // PASTE_BOARD_SERVICE_H