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 16 #ifndef OHOS_ABILITY_RUNTIME_ABILITY_CONNECT_MANAGER_H 17 #define OHOS_ABILITY_RUNTIME_ABILITY_CONNECT_MANAGER_H 18 19 #include <list> 20 #include <map> 21 #include <string> 22 #include <unordered_map> 23 #include "cpp/mutex.h" 24 25 #include "ability_connect_callback_interface.h" 26 #include "task_handler_wrap.h" 27 #include "event_handler_wrap.h" 28 #include "ability_record.h" 29 #include "ability_running_info.h" 30 #include "extension_config.h" 31 #include "extension_running_info.h" 32 #include "connection_record.h" 33 #include "element_name.h" 34 #include "ui_extension_ability_connect_info.h" 35 #include "extension_record_manager.h" 36 #include "want.h" 37 #include "iremote_object.h" 38 #include "nocopyable.h" 39 40 namespace OHOS { 41 namespace AAFwk { 42 using OHOS::AppExecFwk::AbilityType; 43 using UIExtensionAbilityConnectInfo = AbilityRuntime::UIExtensionAbilityConnectInfo; 44 using UIExtensionAbilityConnectManager = AbilityRuntime::ExtensionRecordManager; 45 46 /** 47 * @class AbilityConnectManager 48 * AbilityConnectManager provides a facility for managing service ability connection. 49 */ 50 class AbilityConnectManager : public std::enable_shared_from_this<AbilityConnectManager> { 51 public: 52 using ConnectMapType = std::map<sptr<IRemoteObject>, std::list<std::shared_ptr<ConnectionRecord>>>; 53 using ServiceMapType = std::map<std::string, std::shared_ptr<AbilityRecord>>; 54 using ConnectListType = std::list<std::shared_ptr<ConnectionRecord>>; 55 using RecipientMapType = std::map<sptr<IRemoteObject>, sptr<IRemoteObject::DeathRecipient>>; 56 using UIExtWindowMapValType = std::pair<std::weak_ptr<AbilityRecord>, sptr<SessionInfo>>; 57 using UIExtensionMapType = std::map<sptr<IRemoteObject>, UIExtWindowMapValType>; 58 using WindowExtMapValType = std::pair<uint32_t, sptr<SessionInfo>>; 59 using WindowExtensionMapType = std::map<sptr<IRemoteObject>, WindowExtMapValType>; 60 61 explicit AbilityConnectManager(int userId); 62 virtual ~AbilityConnectManager(); 63 64 /** 65 * StartAbility with request. 66 * 67 * @param abilityRequest, the request of the service ability to start. 68 * @return Returns ERR_OK on success, others on failure. 69 */ 70 int StartAbility(const AbilityRequest &abilityRequest); 71 72 /** 73 * TerminateAbility with token and result want. 74 * 75 * @param token, the token of service type's ability to terminate. 76 * @return Returns ERR_OK on success, others on failure. 77 */ 78 int TerminateAbility(const sptr<IRemoteObject> &token); 79 80 /** 81 * StopServiceAbility with request. 82 * 83 * @param abilityRequest, request. 84 * @return Returns ERR_OK on success, others on failure. 85 */ 86 int StopServiceAbility(const AbilityRequest &abilityRequest); 87 88 /** 89 * ConnectAbilityLocked, connect session with service ability. 90 * 91 * @param abilityRequest, Special want for service type's ability. 92 * @param connect, Callback used to notify caller the result of connecting or disconnecting. 93 * @param callerToken, caller ability token. 94 * @param sessionInfo the extension session info of the ability to connect. 95 * @param connectInfo the connect info. 96 * @return Returns ERR_OK on success, others on failure. 97 */ 98 int ConnectAbilityLocked(const AbilityRequest &abilityRequest, const sptr<IAbilityConnection> &connect, 99 const sptr<IRemoteObject> &callerToken, sptr<SessionInfo> sessionInfo = nullptr, 100 sptr<UIExtensionAbilityConnectInfo> connectInfo = nullptr); 101 102 /** 103 * DisconnectAbilityLocked, disconnect session with callback. 104 * 105 * @param connect, Callback used to notify caller the result of connecting or disconnecting. 106 * @return Returns ERR_OK on success, others on failure. 107 */ 108 int DisconnectAbilityLocked(const sptr<IAbilityConnection> &connect); 109 110 /** 111 * AttachAbilityThreadLocked, ability call this interface after loaded. 112 * 113 * @param scheduler, the interface handler of kit ability. 114 * @param token, ability's token. 115 * @return Returns ERR_OK on success, others on failure. 116 */ 117 int AttachAbilityThreadLocked(const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token); 118 119 void OnAbilityRequestDone(const sptr<IRemoteObject> &token, const int32_t state); 120 121 void OnAppStateChanged(const AppInfo &info); 122 123 /** 124 * AbilityTransitionDone, ability call this interface after lift cycle was changed. 125 * 126 * @param token, ability's token. 127 * @param state, the state of ability lift cycle. 128 * @return Returns ERR_OK on success, others on failure. 129 */ 130 int AbilityTransitionDone(const sptr<IRemoteObject> &token, int state); 131 132 /** 133 * ScheduleConnectAbilityDoneLocked, service ability call this interface while session was connected. 134 * 135 * @param token, service ability's token. 136 * @param remoteObject, the session proxy of service ability. 137 * @return Returns ERR_OK on success, others on failure. 138 */ 139 int ScheduleConnectAbilityDoneLocked(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject); 140 141 /** 142 * ScheduleDisconnectAbilityDone, service ability call this interface while session was disconnected. 143 * 144 * @param token,service ability's token. 145 * @return Returns ERR_OK on success, others on failure. 146 */ 147 int ScheduleDisconnectAbilityDoneLocked(const sptr<IRemoteObject> &token); 148 149 /** 150 * ScheduleCommandAbilityDoneLocked, service ability call this interface while session was onCommanded. 151 * 152 * @param token,service ability's token. 153 * @return Returns ERR_OK on success, others on failure. 154 */ 155 int ScheduleCommandAbilityDoneLocked(const sptr<IRemoteObject> &token); 156 157 int ScheduleCommandAbilityWindowDone( 158 const sptr<IRemoteObject> &token, 159 const sptr<SessionInfo> &sessionInfo, 160 WindowCommand winCmd, 161 AbilityCommand abilityCmd); 162 163 /** 164 * GetServiceRecordByElementName. 165 * 166 * @param element, service ability's element. 167 * @return Returns AbilityRecord shared_ptr. 168 */ 169 std::shared_ptr<AbilityRecord> GetServiceRecordByElementName(const std::string &element); 170 171 /** 172 * GetUIExtensioBySessionInfo. 173 * 174 * @param sessionToken, service ability's session token. 175 * @return Returns AbilityRecord shared_ptr. 176 */ 177 std::shared_ptr<AbilityRecord> GetUIExtensioBySessionInfo(const sptr<SessionInfo> &sessionInfo); 178 179 std::shared_ptr<AbilityRecord> GetExtensionByTokenFromServiceMap(const sptr<IRemoteObject> &token); 180 std::shared_ptr<AbilityRecord> GetExtensionByTokenFromTerminatingMap(const sptr<IRemoteObject> &token); 181 ConnectListType GetConnectRecordListByCallback(sptr<IAbilityConnection> callback); 182 183 void GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo> &info, 184 const int32_t userId, bool isPerm); 185 186 void GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info, bool isPerm); 187 188 void GetExtensionRunningInfo(std::shared_ptr<AbilityRecord> &abilityRecord, const int32_t userId, 189 std::vector<ExtensionRunningInfo> &info); 190 191 /** 192 * set from ability manager service for sequenced task 193 */ SetTaskHandler(const std::shared_ptr<TaskHandlerWrap> & taskHandler)194 inline void SetTaskHandler(const std::shared_ptr<TaskHandlerWrap> &taskHandler) 195 { 196 taskHandler_ = taskHandler; 197 } 198 /** 199 * SetEventHandler. 200 * 201 * @param handler,EventHandler 202 */ SetEventHandler(const std::shared_ptr<EventHandlerWrap> & handler)203 inline void SetEventHandler(const std::shared_ptr<EventHandlerWrap> &handler) 204 { 205 eventHandler_ = handler; 206 } 207 208 /** 209 * GetServiceMap. 210 * 211 * @return Returns service ability record map. 212 */ GetServiceMap()213 inline const ServiceMapType &GetServiceMap() const 214 { 215 return serviceMap_; 216 } 217 218 /** 219 * OnAbilityDied. 220 * 221 * @param abilityRecord, service ability record. 222 */ 223 void OnAbilityDied(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId); 224 225 void DumpState(std::vector<std::string> &info, bool isClient, const std::string &args = ""); 226 227 void DumpStateByUri(std::vector<std::string> &info, bool isClient, const std::string &args, 228 std::vector<std::string> ¶ms); 229 230 void PauseExtensions(); 231 232 void StartRootLauncher(const std::shared_ptr<AbilityRecord> &abilityRecord); 233 void OnTimeOut(uint32_t msgId, int64_t abilityRecordId); 234 235 void MoveToForeground(const std::shared_ptr<AbilityRecord> &abilityRecord); 236 /** 237 * @brief schedule to background 238 * 239 * @param abilityRecord the ability to move 240 */ 241 void MoveToBackground(const std::shared_ptr<AbilityRecord> &abilityRecord); 242 243 void CommandAbilityWindow(const std::shared_ptr<AbilityRecord> &abilityRecord, 244 const sptr<SessionInfo> &sessionInfo, WindowCommand winCmd); 245 246 bool IsUIExtensionFocused(uint32_t uiExtensionTokenId, const sptr<IRemoteObject>& focusToken); 247 248 bool IsWindowExtensionFocused(uint32_t extensionTokenId, const sptr<IRemoteObject>& focusToken); 249 250 void HandleProcessFrozen(const std::vector<int32_t> &pidList, int32_t uid); 251 252 void ForegroundAbilityWindowLocked(const std::shared_ptr<AbilityRecord> &abilityRecord, 253 const sptr<SessionInfo> &sessionInfo); 254 255 void BackgroundAbilityWindowLocked(const std::shared_ptr<AbilityRecord> &abilityRecord, 256 const sptr<SessionInfo> &sessionInfo); 257 258 void TerminateAbilityWindowLocked(const std::shared_ptr<AbilityRecord> &abilityRecord, 259 const sptr<SessionInfo> &sessionInfo); 260 261 void RemoveLauncherDeathRecipient(); 262 263 // MSG 0 - 20 represents timeout message 264 static constexpr uint32_t LOAD_TIMEOUT_MSG = 0; 265 static constexpr uint32_t CONNECT_TIMEOUT_MSG = 1; 266 267 private: 268 /** 269 * StartAbilityLocked with request. 270 * 271 * @param abilityRequest, the request of the service ability to start. 272 * @return Returns ERR_OK on success, others on failure. 273 */ 274 int StartAbilityLocked(const AbilityRequest &abilityRequest); 275 276 /** 277 * TerminateAbilityLocked with token and result want. 278 * 279 * @param token, the token of service type's ability to terminate. 280 * @param resultCode, the result code of service type's ability to terminate. 281 * @param resultWant, the result want for service type's ability to terminate. 282 * @return Returns ERR_OK on success, others on failure. 283 */ 284 int TerminateAbilityLocked(const sptr<IRemoteObject> &token); 285 286 /** 287 * StopAbilityLocked with request. 288 * 289 * @param abilityRequest, the request of the service ability to start. 290 * @return Returns ERR_OK on success, others on failure. 291 */ 292 int StopServiceAbilityLocked(const AbilityRequest &abilityRequest); 293 294 /** 295 * DisconnectAbilityLocked, disconnect session with callback. 296 * 297 * @param connect, Callback used to notify caller the result of connecting or disconnecting. 298 * @param force, Indicates forcing to disconnect and clear. For example, it is called when the source 299 * dies and the connection has not completed yet. 300 * @return Returns ERR_OK on success, others on failure. 301 */ 302 int DisconnectAbilityLocked(const sptr<IAbilityConnection> &connect, bool force); 303 304 /** 305 * LoadAbility. 306 * 307 * @param abilityRecord, the ptr of the ability to load. 308 */ 309 void LoadAbility(const std::shared_ptr<AbilityRecord> &abilityRecord); 310 311 /** 312 * ConnectAbility.Schedule connect ability 313 * 314 * @param abilityRecord, the ptr of the ability to connect. 315 */ 316 void ConnectAbility(const std::shared_ptr<AbilityRecord> &abilityRecord); 317 318 /** 319 * CommandAbility. Schedule command ability 320 * 321 * @param abilityRecord, the ptr of the ability to command. 322 */ 323 void CommandAbility(const std::shared_ptr<AbilityRecord> &abilityRecord); 324 325 /** 326 * CompleteCommandAbility. complete command ability 327 * 328 * @param abilityRecord, the ptr of the ability to command. 329 */ 330 void CompleteCommandAbility(std::shared_ptr<AbilityRecord> abilityRecord); 331 332 /** 333 * TerminateDone. 334 * 335 * @param abilityRecord, the ptr of the ability to terminate. 336 */ 337 void TerminateDone(const std::shared_ptr<AbilityRecord> &abilityRecord); 338 339 /** 340 * dispatch service ability life cycle . 341 * 342 * @param abilityRecord. 343 * @param state. 344 */ 345 int DispatchInactive(const std::shared_ptr<AbilityRecord> &abilityRecord, int state); 346 int DispatchForeground(const std::shared_ptr<AbilityRecord> &abilityRecord); 347 int DispatchBackground(const std::shared_ptr<AbilityRecord> &abilityRecord); 348 int DispatchTerminate(const std::shared_ptr<AbilityRecord> &abilityRecord); 349 350 void HandleStartTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord, int resultCode); 351 void HandleStopTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord); 352 void HandleTerminateDisconnectTask(const ConnectListType& connectlist); 353 void HandleCommandTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord); 354 void HandleCommandWindowTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord, 355 const sptr<SessionInfo> &sessionInfo, WindowCommand winCmd); 356 void HandleForegroundTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord); 357 void HandleRestartResidentTask(const AbilityRequest &abilityRequest); 358 void HandleActiveAbility(std::shared_ptr<AbilityRecord> &targetService, 359 std::shared_ptr<ConnectionRecord> &connectRecord); 360 void HandleCommandDestroy(const sptr<SessionInfo> &sessionInfo); 361 362 /** 363 * IsAbilityConnected. 364 * 365 * @param abilityRecord, the ptr of the connected ability. 366 * @param connectRecordList, connect record list. 367 * @return true: ability is connected, false: ability is not connected 368 */ 369 bool IsAbilityConnected(const std::shared_ptr<AbilityRecord> &abilityRecord, 370 const std::list<std::shared_ptr<ConnectionRecord>> &connectRecordList); 371 372 /** 373 * RemoveConnectionRecordFromMap. 374 * 375 * @param connect, the ptr of the connect record. 376 */ 377 void RemoveConnectionRecordFromMap(std::shared_ptr<ConnectionRecord> connect); 378 379 /** 380 * RemoveServiceAbility. 381 * 382 * @param service, the ptr of the ability record. 383 */ 384 void RemoveServiceAbility(const std::shared_ptr<AbilityRecord> &service); 385 386 /** 387 * GetOrCreateServiceRecord. 388 * 389 * @param abilityRequest, Special want for service type's ability. 390 * @param isCreatedByConnect, whether is created by connect ability mode. 391 * @param targetAbilityRecord, the target service ability record. 392 * @param isLoadedAbility, whether the target ability has been loaded. 393 */ 394 void GetOrCreateServiceRecord(const AbilityRequest &abilityRequest, const bool isCreatedByConnect, 395 std::shared_ptr<AbilityRecord> &targetAbilityRecord, bool &isLoadedAbility); 396 397 /** 398 * GetConnectRecordListFromMap. 399 * 400 * @param connect, callback object. 401 * @param isCreatedByConnect, whether is created by connect ability mode. 402 * @param connectRecordList, the target connectRecordList. 403 * @param isCallbackConnected, whether the callback has been connected. 404 */ 405 void GetConnectRecordListFromMap( 406 const sptr<IAbilityConnection> &connect, std::list<std::shared_ptr<ConnectionRecord>> &connectRecordList); 407 408 /** 409 * AddConnectDeathRecipient. 410 * 411 * @param connect, callback object. 412 */ 413 void AddConnectDeathRecipient(const sptr<IAbilityConnection> &connect); 414 415 /** 416 * RemoteConnectDeathRecipient. 417 * 418 * @param connect, callback object. 419 */ 420 void RemoveConnectDeathRecipient(const sptr<IAbilityConnection> &connect); 421 422 /** 423 * RemoteConnectDeathRecipient. 424 * 425 * @param remote, callback object. 426 */ 427 void OnCallBackDied(const wptr<IRemoteObject> &remote); 428 429 /** 430 * HandleOnCallBackDied. 431 * 432 * @param connect, callback object. 433 */ 434 void HandleCallBackDiedTask(const sptr<IRemoteObject> &connect); 435 436 /** 437 * HandleOnCallBackDied. 438 * 439 * @param abilityRecord, died ability. 440 */ 441 void HandleAbilityDiedTask(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId); 442 void HandleUIExtensionDied(const std::shared_ptr<AbilityRecord> &abilityRecord); 443 444 void RestartAbility(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId); 445 446 /** 447 * PostTimeOutTask. 448 * 449 * @param abilityRecord, ability. 450 * @param messageId, message id. 451 */ 452 void PostTimeOutTask(const std::shared_ptr<AbilityRecord> &abilityRecord, uint32_t messageId); 453 454 void CompleteForeground(const std::shared_ptr<AbilityRecord> &abilityRecord); 455 void CompleteBackground(const std::shared_ptr<AbilityRecord> &abilityRecord); 456 void PrintTimeOutLog(const std::shared_ptr<AbilityRecord> &ability, uint32_t msgId); 457 458 void PostRestartResidentTask(const AbilityRequest &abilityRequest); 459 460 bool IsAbilityNeedKeepAlive(const std::shared_ptr<AbilityRecord> &abilityRecord); 461 462 void ProcessPreload(const std::shared_ptr<AbilityRecord> &record) const; 463 464 std::shared_ptr<AbilityRecord> GetAbilityRecordById(int64_t abilityRecordId); 465 void HandleInactiveTimeout(const std::shared_ptr<AbilityRecord> &ability); 466 void MoveToTerminatingMap(const std::shared_ptr<AbilityRecord>& abilityRecord); 467 468 void DoForegroundUIExtension(std::shared_ptr<AbilityRecord> abilityRecord, const AbilityRequest &abilityRequest); 469 void SaveUIExtRequestSessionInfo(std::shared_ptr<AbilityRecord> abilityRecord, sptr<SessionInfo> sessionInfo); 470 void DoBackgroundAbilityWindow(const std::shared_ptr<AbilityRecord> &abilityRecord, 471 const sptr<SessionInfo> &sessionInfo); 472 void DoTerminateUIExtensionAbility(std::shared_ptr<AbilityRecord> abilityRecord, sptr<SessionInfo> sessionInfo); 473 474 /** 475 * When a service is under starting, enque the request and handle it after the service starting completes 476 */ 477 void EnqueueStartServiceReq(const AbilityRequest &abilityRequest, const std::string &serviceUri = ""); 478 /** 479 * After the service starting completes, complete the request list 480 */ 481 void CompleteStartServiceReq(const std::string &serviceUri); 482 483 void AddUIExtWindowDeathRecipient(const sptr<IRemoteObject> &session); 484 void RemoveUIExtWindowDeathRecipient(const sptr<IRemoteObject> &session); 485 void OnUIExtWindowDied(const wptr<IRemoteObject> &remote); 486 void HandleUIExtWindowDiedTask(const sptr<IRemoteObject> &remote); 487 488 /** 489 * Post an extension's disconnect task, auto disconnect when extension conected timeout. 490 */ 491 void PostExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord); 492 493 /** 494 * Remove the extension's disconnect task. 495 */ 496 void RemoveExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord); 497 498 /** 499 * Handle extension disconnect task. 500 */ 501 void HandleExtensionDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord); 502 503 private: 504 void TerminateRecord(std::shared_ptr<AbilityRecord> abilityRecord); 505 int DisconnectRecordNormal(ConnectListType &list, std::shared_ptr<ConnectionRecord> connectRecord) const; 506 void DisconnectRecordForce(ConnectListType &list, std::shared_ptr<ConnectionRecord> connectRecord); 507 std::shared_ptr<AbilityRecord> GetServiceRecordByElementNameInner(const std::string &element); 508 std::shared_ptr<AbilityRecord> GetExtensionFromServiceMapInner(const sptr<IRemoteObject> &token); 509 std::shared_ptr<AbilityRecord> GetExtensionFromServiceMapInner(int32_t abilityRecordId); 510 std::shared_ptr<AbilityRecord> GetExtensionFromTerminatingMapInner(const sptr<IRemoteObject> &token); 511 int TerminateAbilityInner(const sptr<IRemoteObject> &token); 512 bool IsLauncher(std::shared_ptr<AbilityRecord> serviceExtension) const; 513 bool IsSceneBoard(std::shared_ptr<AbilityRecord> serviceExtension) const; 514 void KillProcessesByUserId() const; 515 inline bool IsUIExtensionAbility(const std::shared_ptr<AbilityRecord> &abilityRecord); 516 inline bool CheckUIExtensionAbilityLoaded(const AbilityRequest &abilityRequest); 517 inline bool CheckUIExtensionAbilitySessionExistLocked(const std::shared_ptr<AbilityRecord> &abilityRecord); 518 inline void RemoveUIExtensionAbilityRecord(const std::shared_ptr<AbilityRecord> &abilityRecord); 519 int32_t GetOrCreateExtensionRecord(const AbilityRequest &abilityRequest, bool isCreatedByConnect, 520 const std::string &hostBundleName, std::shared_ptr<AbilityRecord> &extensionRecord, bool &isLoaded); 521 int32_t GetOrCreateTargetServiceRecord( 522 const AbilityRequest &abilityRequest, const sptr<UIExtensionAbilityConnectInfo> &connectInfo, 523 std::shared_ptr<AbilityRecord> &targetService, bool &isLoadedAbility); 524 525 private: 526 const std::string TASK_ON_CALLBACK_DIED = "OnCallbackDiedTask"; 527 const std::string TASK_ON_ABILITY_DIED = "OnAbilityDiedTask"; 528 529 ffrt::mutex Lock_; 530 ConnectMapType connectMap_; 531 ServiceMapType serviceMap_; 532 ServiceMapType terminatingExtensionMap_; 533 534 std::mutex recipientMapMutex_; 535 RecipientMapType recipientMap_; 536 RecipientMapType uiExtRecipientMap_; 537 std::shared_ptr<TaskHandlerWrap> taskHandler_; 538 std::shared_ptr<EventHandlerWrap> eventHandler_; 539 int userId_; 540 std::vector<AbilityRequest> restartResidentTaskList_; 541 std::unordered_map<std::string, std::shared_ptr<std::list<AbilityRequest>>> startServiceReqList_; 542 ffrt::mutex startServiceReqListLock_; 543 UIExtensionMapType uiExtensionMap_; 544 WindowExtensionMapType windowExtensionMap_; 545 std::unique_ptr<UIExtensionAbilityConnectManager> uiExtensionAbilityRecordMgr_ = nullptr; 546 547 DISALLOW_COPY_AND_MOVE(AbilityConnectManager); 548 }; 549 } // namespace AAFwk 550 } // namespace OHOS 551 #endif // OHOS_ABILITY_RUNTIME_ABILITY_CONNECT_MANAGER_H 552