• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2024 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 FOUNDATION_ACE_ADAPTER_OHOS_CPP_ACE_CONTAINER_H
17 #define FOUNDATION_ACE_ADAPTER_OHOS_CPP_ACE_CONTAINER_H
18 
19 #include <cstddef>
20 #include <list>
21 #include <memory>
22 #include <mutex>
23 #include <optional>
24 
25 #include "display_manager.h"
26 #include "dm_common.h"
27 #include "interfaces/inner_api/ace/arkui_rect.h"
28 #include "native_engine/native_reference.h"
29 #include "native_engine/native_value.h"
30 
31 #include "adapter/ohos/entrance/ace_ability.h"
32 #include "adapter/ohos/entrance/platform_event_callback.h"
33 #include "base/memory/ace_type.h"
34 #include "base/resource/asset_manager.h"
35 #include "base/thread/task_executor.h"
36 #include "base/utils/noncopyable.h"
37 #include "base/utils/utils.h"
38 #include "base/view_data/ace_auto_fill_error.h"
39 #include "base/view_data/hint_to_type_wrap.h"
40 #include "bridge/js_frontend/engine/jsi/js_value.h"
41 #include "base/view_data/view_data_wrap.h"
42 #include "core/common/ace_view.h"
43 #include "core/common/container.h"
44 #include "core/common/display_info.h"
45 #include "core/common/font_manager.h"
46 #include "core/common/js_message_dispatcher.h"
47 #include "core/common/render_boundary_manager.h"
48 #include "core/common/resource/resource_configuration.h"
49 #include "core/common/router_recover_record.h"
50 #include "core/components/common/layout/constants.h"
51 #include "core/pipeline/pipeline_context.h"
52 
53 namespace OHOS::Accessibility {
54 class AccessibilityElementInfo;
55 }
56 
57 namespace OHOS::Ace {
58 class FontManager;
59 }
60 
61 namespace OHOS::Ace::Platform {
62 using UIEnvCallback = std::function<void(const OHOS::Ace::RefPtr<OHOS::Ace::PipelineContext>& context)>;
63 using SharePanelCallback = std::function<void(const std::string& bundleName, const std::string& abilityName)>;
64 using AbilityOnQueryCallback = std::function<void(const std::string& queryWord)>;
65 using DataHandlerErr = OHOS::Rosen::DataHandlerErr;
66 using SubSystemId = OHOS::Rosen::SubSystemId;
67 using DataConsumeCallback = OHOS::Rosen::DataConsumeCallback;
68 
69 struct ParsedConfig {
70     std::string colorMode;
71     std::string deviceAccess;
72     std::string languageTag;
73     std::string direction;
74     std::string densitydpi;
75     std::string themeTag;
76     std::string fontFamily;
77     std::string fontScale;
78     std::string fontWeightScale;
79     std::string colorModeIsSetByApp;
80     std::string mcc;
81     std::string mnc;
82     std::string preferredLanguage;
83     std::string fontId;
IsValidParsedConfig84     bool IsValid() const
85     {
86         return !(colorMode.empty() && deviceAccess.empty() && languageTag.empty() && direction.empty() &&
87                  densitydpi.empty() && themeTag.empty() && fontScale.empty() && fontWeightScale.empty() &&
88                  colorModeIsSetByApp.empty() && mcc.empty() && mnc.empty() && fontFamily.empty() &&
89                  preferredLanguage.empty() && fontId.empty());
90     }
91 };
92 
93 struct SingleHandTransform {
94     SingleHandTransform() = default;
SingleHandTransformSingleHandTransform95     SingleHandTransform(float x, float y, float scaleX, float scaleY)
96         : x_(x), y_(y), scaleX_(scaleX), scaleY_(scaleY) {}
97 
98     float x_ = 0.0f;
99     float y_ = 0.0f;
100     float scaleX_ = 1.0f;
101     float scaleY_ = 1.0f;
102 };
103 
104 using ConfigurationChangedCallback = std::function<void(const ParsedConfig& config, const std::string& configuration)>;
105 
106 class ACE_FORCE_EXPORT AceContainer : public Container, public JsMessageDispatcher {
107     DECLARE_ACE_TYPE(AceContainer, Container, JsMessageDispatcher);
108 
109 public:
110     AceContainer(int32_t instanceId, FrontendType type, std::shared_ptr<OHOS::AppExecFwk::Ability> aceAbility,
111         std::unique_ptr<PlatformEventCallback> callback, bool useCurrentEventRunner = false,
112         bool useNewPipeline = false);
113     AceContainer(int32_t instanceId, FrontendType type, std::weak_ptr<OHOS::AbilityRuntime::Context> runtimeContext,
114         std::weak_ptr<OHOS::AppExecFwk::AbilityInfo> abilityInfo, std::unique_ptr<PlatformEventCallback> callback,
115         bool useCurrentEventRunner = false, bool isSubContainer = false, bool useNewPipeline = false);
116 
117     AceContainer(int32_t instanceId, FrontendType type, std::weak_ptr<OHOS::AbilityRuntime::Context> runtimeContext,
118         std::weak_ptr<OHOS::AppExecFwk::AbilityInfo> abilityInfo, std::unique_ptr<PlatformEventCallback> callback,
119         std::shared_ptr<TaskWrapper> taskWrapper, bool useCurrentEventRunner = false, bool isSubContainer = false,
120         bool useNewPipeline = false);
121 
122     AceContainer(int32_t instanceId, FrontendType type);
123 
124     ~AceContainer() override;
125 
126     bool UpdatePopupUIExtension(const RefPtr<NG::FrameNode>& node,
127         uint32_t autoFillSessionId, bool isNative = true) override;
128 
129     bool ClosePopupUIExtension(uint32_t autoFillSessionId) override;
130 
131     void Initialize() override;
132 
133     void Destroy() override;
134 
135     bool IsKeyboard() override;
136 
137     void DestroyView() override;
138 
139     static bool Register();
140 
GetInstanceId()141     int32_t GetInstanceId() const override
142     {
143         if (aceView_) {
144             return aceView_->GetInstanceId();
145         }
146         return -1;
147     }
148 
GetFrontend()149     RefPtr<Frontend> GetFrontend() const override
150     {
151         std::lock_guard<std::mutex> lock(frontendMutex_);
152         return frontend_;
153     }
154 
SetCardFrontend(WeakPtr<Frontend> frontend,int64_t cardId)155     void SetCardFrontend(WeakPtr<Frontend> frontend, int64_t cardId) override
156     {
157         std::lock_guard<std::mutex> lock(cardFrontMutex_);
158         cardFrontendMap_.try_emplace(cardId, frontend);
159     }
160 
GetCardFrontend(int64_t cardId)161     WeakPtr<Frontend> GetCardFrontend(int64_t cardId) const override
162     {
163         std::lock_guard<std::mutex> lock(cardFrontMutex_);
164         auto it = cardFrontendMap_.find(cardId);
165         if (it != cardFrontendMap_.end()) {
166             return it->second;
167         }
168         return nullptr;
169     }
170 
SetCardPipeline(WeakPtr<PipelineBase> pipeline,int64_t cardId)171     void SetCardPipeline(WeakPtr<PipelineBase> pipeline, int64_t cardId) override
172     {
173         std::lock_guard<std::mutex> lock(cardPipelineMutex_);
174         cardPipelineMap_.try_emplace(cardId, pipeline);
175     }
176 
GetCardPipeline(int64_t cardId)177     WeakPtr<PipelineBase> GetCardPipeline(int64_t cardId) const override
178     {
179         std::lock_guard<std::mutex> lock(cardPipelineMutex_);
180         auto it = cardPipelineMap_.find(cardId);
181         if (it == cardPipelineMap_.end()) {
182             return nullptr;
183         }
184         return it->second;
185     }
186 
GetTaskExecutor()187     RefPtr<TaskExecutor> GetTaskExecutor() const override
188     {
189         return taskExecutor_;
190     }
191 
SetAssetManager(const RefPtr<AssetManager> & assetManager)192     void SetAssetManager(const RefPtr<AssetManager>& assetManager)
193     {
194         assetManager_ = assetManager;
195         if (frontend_) {
196             frontend_->SetAssetManager(assetManager);
197         }
198     }
199 
GetAssetManager()200     RefPtr<AssetManager> GetAssetManager() const override
201     {
202         return assetManager_;
203     }
204 
GetPlatformResRegister()205     RefPtr<PlatformResRegister> GetPlatformResRegister() const override
206     {
207         return resRegister_;
208     }
209 
GetPipelineContext()210     RefPtr<PipelineBase> GetPipelineContext() const override
211     {
212         std::lock_guard<std::mutex> lock(pipelineMutex_);
213         return pipelineContext_;
214     }
215 
GetViewWidth()216     int32_t GetViewWidth() const override
217     {
218         return aceView_ ? aceView_->GetWidth() : 0;
219     }
220 
GetViewHeight()221     int32_t GetViewHeight() const override
222     {
223         return aceView_ ? aceView_->GetHeight() : 0;
224     }
225 
GetViewPosX()226     int32_t GetViewPosX() const override
227     {
228         return aceView_ ? aceView_->GetPosX() : 0;
229     }
230 
GetViewPosY()231     int32_t GetViewPosY() const override
232     {
233         return aceView_ ? aceView_->GetPosY() : 0;
234     }
235 
GetAceView()236     RefPtr<AceView> GetAceView() const override
237     {
238         std::lock_guard<std::mutex> lock(viewMutex_);
239         return aceView_;
240     }
241 
GetView()242     void* GetView() const override
243     {
244         std::lock_guard<std::mutex> lock(viewMutex_);
245         return static_cast<void*>(AceType::RawPtr(aceView_));
246     }
247 
SetWindowModal(WindowModal windowModal)248     void SetWindowModal(WindowModal windowModal)
249     {
250         windowModal_ = windowModal;
251     }
252 
SetInstallationFree(bool installationFree)253     void SetInstallationFree(bool installationFree)
254     {
255         installationFree_ = installationFree;
256     }
257 
SetSharePanelCallback(SharePanelCallback && callback)258     void SetSharePanelCallback(SharePanelCallback&& callback)
259     {
260         sharePanelCallback_ = std::move(callback);
261     }
262 
SetColorScheme(ColorScheme colorScheme)263     void SetColorScheme(ColorScheme colorScheme)
264     {
265         colorScheme_ = colorScheme;
266     }
267 
GetResourceConfiguration()268     ResourceConfiguration GetResourceConfiguration() const override
269     {
270         return resourceInfo_.GetResourceConfiguration();
271     }
272 
SetResourceConfiguration(const ResourceConfiguration & config)273     void SetResourceConfiguration(const ResourceConfiguration& config)
274     {
275         resourceInfo_.SetResourceConfiguration(config);
276     }
277 
GetPackagePathStr()278     std::string GetPackagePathStr() const
279     {
280         return resourceInfo_.GetPackagePath();
281     }
282 
SetPackagePathStr(const std::string & packagePath)283     void SetPackagePathStr(const std::string& packagePath)
284     {
285         resourceInfo_.SetPackagePath(packagePath);
286     }
287 
GetHapPath()288     std::string GetHapPath() const override
289     {
290         return resourceInfo_.GetHapPath();
291     }
292 
GetResourceInfo()293     const ResourceInfo& GetResourceInfo() const
294     {
295         return resourceInfo_;
296     }
297 
298     std::shared_ptr<Framework::JsValue> GetJsContext();
299     void SetJsContext(const std::shared_ptr<Framework::JsValue>& jsContext);
300     std::shared_ptr<OHOS::AbilityRuntime::Context> GetAbilityContext();
301 
SetOrientation(Orientation orientation)302     void SetOrientation(Orientation orientation) override
303     {
304         CHECK_NULL_VOID(uiWindow_);
305         auto dmOrientation = static_cast<Rosen::Orientation>(static_cast<uint32_t>(orientation));
306         uiWindow_->SetRequestedOrientation(dmOrientation);
307     }
308 
GetDisplayId()309     uint64_t GetDisplayId() const override
310     {
311         CHECK_NULL_RETURN(uiWindow_, -1);
312         return uiWindow_->GetDisplayId();
313     }
314 
GetOrientation()315     Orientation GetOrientation() override
316     {
317         CHECK_NULL_RETURN(uiWindow_, Orientation::UNSPECIFIED);
318         auto dmOrientation = uiWindow_->GetRequestedOrientation();
319         return static_cast<Orientation>(static_cast<uint32_t>(dmOrientation));
320     }
321 
322     void SetHapPath(const std::string& hapPath);
323 
324     void Dispatch(
325         const std::string& group, std::vector<uint8_t>&& data, int32_t id, bool replyToComponent) const override;
326 
DispatchSync(const std::string & group,std::vector<uint8_t> && data,uint8_t ** resData,int64_t & position)327     void DispatchSync(
328         const std::string& group, std::vector<uint8_t>&& data, uint8_t** resData, int64_t& position) const override
329     {}
330 
331     void DispatchPluginError(int32_t callbackId, int32_t errorCode, std::string&& errorMessage) const override;
332 
333     bool Dump(const std::vector<std::string>& params, std::vector<std::string>& info) override;
334     bool DumpCommon(
335         const std::vector<std::string>& params, std::vector<std::string>& info);
336     bool DumpDynamicUiContent(
337         const std::vector<std::string>& params, std::vector<std::string>& info);
338 
339     bool DumpInfo(const std::vector<std::string>& params);
340 
341     bool DumpRSNodeByStringID(const std::vector<std::string>& params);
342 
343     bool OnDumpInfo(const std::vector<std::string>& params);
344 
345     void TriggerGarbageCollection() override;
346 
347     void DumpHeapSnapshot(bool isPrivate) override;
348 
349     void DestroyHeapProfiler() override;
350 
351     void ForceFullGC() override;
352 
353     void SetLocalStorage(NativeReference* storage, const std::shared_ptr<OHOS::AbilityRuntime::Context>& context);
354 
355     void CheckAndSetFontFamily() override;
356 
OnFinish()357     void OnFinish()
358     {
359         if (platformEventCallback_) {
360             platformEventCallback_->OnFinish();
361         }
362     }
363 
OnStartAbility(const std::string & address)364     void OnStartAbility(const std::string& address)
365     {
366         if (platformEventCallback_) {
367             platformEventCallback_->OnStartAbility(address);
368         }
369     }
370 
OnStartAbilityOnQuery(const std::string & queryWord)371     void OnStartAbilityOnQuery(const std::string& queryWord)
372     {
373         if (abilityOnQueryCallback_) {
374             abilityOnQueryCallback_(queryWord);
375         }
376     }
377 
GeneratePageId()378     int32_t GeneratePageId()
379     {
380         return pageId_++;
381     }
382 
GetHostClassName()383     std::string GetHostClassName() const override
384     {
385         return "";
386     }
387 
SetSharedRuntime(void * runtime)388     void SetSharedRuntime(void* runtime) override
389     {
390         sharedRuntime_ = runtime;
391     }
392 
SetPageProfile(const std::string & pageProfile)393     void SetPageProfile(const std::string& pageProfile)
394     {
395         pageProfile_ = pageProfile;
396     }
397 
IsSubContainer()398     bool IsSubContainer() const override
399     {
400         return isSubContainer_;
401     }
402 
IsFormRender()403     bool IsFormRender() const override
404     {
405         return isFormRender_;
406     }
407 
GetSharedRuntime()408     void* GetSharedRuntime() override
409     {
410         return sharedRuntime_;
411     }
412 
SetParentId(int32_t parentId)413     void SetParentId(int32_t parentId) override
414     {
415         parentId_ = parentId;
416     }
417 
SetWindowScale(float windowScale)418     void SetWindowScale(float windowScale) override
419     {
420         windowScale_ = windowScale;
421     }
422 
GetWindowScale()423     float GetWindowScale() const override
424     {
425         return windowScale_;
426     }
427 
GetWindowDensity()428     double GetWindowDensity() const
429     {
430         if (!uiWindow_) {
431             return 1.0;
432         }
433         return static_cast<double>(uiWindow_->GetVirtualPixelRatio());
434     }
435 
GetParentId()436     int32_t GetParentId() const override
437     {
438         return parentId_;
439     }
440 
SetFocusWindowId(uint32_t focusWindowId)441     void SetFocusWindowId(uint32_t focusWindowId)
442     {
443         if (pipelineContext_) {
444             pipelineContext_->SetFocusWindowId(focusWindowId);
445         }
446     }
447 
SetRealHostWindowId(uint32_t realHostWindowId)448     void SetRealHostWindowId(uint32_t realHostWindowId)
449     {
450         if (pipelineContext_) {
451             pipelineContext_->SetRealHostWindowId(realHostWindowId);
452         }
453     }
454 
IsUseCustomBg()455     bool IsUseCustomBg() const
456     {
457         return isUseCustomBg_;
458     }
459 
SetIsUseCustomBg(bool isUseCustomBg)460     void SetIsUseCustomBg(bool isUseCustomBg)
461     {
462         isUseCustomBg_ = isUseCustomBg;
463     }
464 
465     bool IsTransparentBg() const;
466 
SetAbilityOnSearch(AbilityOnQueryCallback && callback)467     void SetAbilityOnSearch(AbilityOnQueryCallback&& callback)
468     {
469         abilityOnQueryCallback_ = std::move(callback);
470     }
471 
472     static void CreateContainer(int32_t instanceId, FrontendType type, const std::string& instanceName,
473         std::shared_ptr<OHOS::AppExecFwk::Ability> aceAbility, std::unique_ptr<PlatformEventCallback> callback,
474         bool useCurrentEventRunner = false, bool useNewPipeline = false);
475 
476     static void DestroyContainer(int32_t instanceId, const std::function<void()>& destroyCallback = nullptr);
477     static UIContentErrorCode RunPage(
478         int32_t instanceId, const std::string& content, const std::string& params, bool isNamedRouter = false);
479     static UIContentErrorCode RunPage(
480         int32_t instanceId, const std::shared_ptr<std::vector<uint8_t>>& content, const std::string& params);
481     static bool PushPage(int32_t instanceId, const std::string& content, const std::string& params);
482     static bool RunDynamicPage(
483         int32_t instanceId, const std::string& content, const std::string& params, const std::string& entryPoint);
484     static bool OnBackPressed(int32_t instanceId);
485     static void OnShow(int32_t instanceId);
486     static void OnHide(int32_t instanceId);
487     static void OnActive(int32_t instanceId);
488     static void OnInactive(int32_t instanceId);
489     static void ActiveWindow(int32_t instanceId);
490     static void UnActiveWindow(int32_t instanceId);
491     static void OnNewWant(int32_t instanceId, const std::string& data);
492     static bool OnStartContinuation(int32_t instanceId);
493     static std::string OnSaveData(int32_t instanceId);
494     static bool OnRestoreData(int32_t instanceId, const std::string& data);
495     static void OnCompleteContinuation(int32_t instanceId, int result);
496     static void OnRemoteTerminated(int32_t instanceId);
497     static void OnConfigurationUpdated(int32_t instanceId, const std::string& configuration);
498     static void OnNewRequest(int32_t instanceId, const std::string& data);
499     static void AddAssetPath(int32_t instanceId, const std::string& packagePath, const std::string& hapPath,
500         const std::vector<std::string>& paths);
501     static void AddLibPath(int32_t instanceId, const std::vector<std::string>& libPath);
502     static void SetView(const RefPtr<AceView>& view, double density, int32_t width, int32_t height,
503         sptr<OHOS::Rosen::Window> rsWindow, UIEnvCallback callback = nullptr);
504     static UIContentErrorCode SetViewNew(
505         const RefPtr<AceView>& view, double density, float width, float height, sptr<OHOS::Rosen::Window> rsWindow);
506     static void SetUIWindow(int32_t instanceId, sptr<OHOS::Rosen::Window> uiWindow);
507     static sptr<OHOS::Rosen::Window> GetUIWindow(int32_t instanceId);
508     static OHOS::AppExecFwk::Ability* GetAbility(int32_t instanceId);
509     static OHOS::AbilityRuntime::Context* GetRuntimeContext(int32_t instanceId);
510     static void SetWindowStyle(int32_t instanceId, WindowModal windowModal, ColorScheme colorScheme);
511     static std::pair<RouterRecoverRecord, UIContentErrorCode> RestoreRouterStack(
512         int32_t instanceId, const std::string& contentInfo, ContentInfoType type);
513     static std::string GetContentInfo(int32_t instanceId, ContentInfoType type);
514 
515     static RefPtr<AceContainer> GetContainer(int32_t instanceId);
516     static bool UpdatePage(int32_t instanceId, int32_t pageId, const std::string& content);
517     static bool RemoveOverlayBySubwindowManager(int32_t instanceId);
518 
519     static bool CloseWindow(int32_t instanceId);
520     static bool HideWindow(int32_t instanceId);
521 
522     // ArkTsCard
523     static std::shared_ptr<Rosen::RSSurfaceNode> GetFormSurfaceNode(int32_t instanceId);
524 
SetWindowName(const std::string & name)525     void SetWindowName(const std::string& name)
526     {
527         windowName_ = name;
528     }
529 
GetWindowName()530     std::string& GetWindowName()
531     {
532         return windowName_;
533     }
534 
SetWindowId(uint32_t windowId)535     void SetWindowId(uint32_t windowId) override
536     {
537         windowId_ = windowId;
538     }
539 
GetWindowId()540     uint32_t GetWindowId() const override
541     {
542         return windowId_;
543     }
544 
WindowIsShow()545     bool WindowIsShow() const override
546     {
547         if (!uiWindow_) {
548             return false;
549         }
550         return uiWindow_->GetWindowState() == Rosen::WindowState::STATE_SHOWN;
551     }
552 
553     void SetWindowPos(int32_t left, int32_t top);
554 
SetIsSubContainer(bool isSubContainer)555     void SetIsSubContainer(bool isSubContainer)
556     {
557         isSubContainer_ = isSubContainer;
558     }
559 
SetIsFormRender(bool isFormRender)560     void SetIsFormRender(bool isFormRender) override
561     {
562         isFormRender_ = isFormRender;
563     }
564 
565     void SetAppRunningUniqueId(const std::string& uniqueId) override;
566 
567     const std::string& GetAppRunningUniqueId() const override;
568 
569     void InitializeSubContainer(int32_t parentContainerId);
570     static void SetDialogCallback(int32_t instanceId, FrontendDialogCallback callback);
571 
572     std::shared_ptr<OHOS::AbilityRuntime::Context> GetAbilityContextByModule(
573         const std::string& bundle, const std::string& module);
574 
575     void BuildResConfig(
576         ResourceConfiguration& resConfig, ConfigurationChange& configurationChange, const ParsedConfig& parsedConfig);
577     void ProcessColorModeUpdate(
578         ResourceConfiguration& resConfig, ConfigurationChange& configurationChange, const ParsedConfig& parsedConfig);
579     void UpdateConfiguration(
580         const ParsedConfig& parsedConfig, const std::string& configuration, bool abilityLevel = false);
581     void UpdateConfigurationSyncForAll(
582         const ParsedConfig& parsedConfig, const std::string& configuration);
583 
584     void NotifyConfigurationChange(
585         bool needReloadTransition, const ConfigurationChange& configurationChange = { false, false }) override;
586 
AddOnConfigurationChange(int32_t instanceId,ConfigurationChangedCallback && callback)587     void AddOnConfigurationChange(int32_t instanceId, ConfigurationChangedCallback &&callback)
588     {
589         configurationChangedCallbacks_.emplace(instanceId, std::move(callback));
590     }
591 
RemoveOnConfigurationChange(int32_t instanceId)592     void RemoveOnConfigurationChange(int32_t instanceId)
593     {
594         configurationChangedCallbacks_.erase(instanceId_);
595     }
596 
597     void HotReload() override;
598 
IsUseStageModel()599     bool IsUseStageModel() const override
600     {
601         return useStageModel_;
602     }
603 
GetCardFrontendMap(std::unordered_map<int64_t,WeakPtr<Frontend>> & cardFrontendMap)604     void GetCardFrontendMap(std::unordered_map<int64_t, WeakPtr<Frontend>>& cardFrontendMap) const override
605     {
606         cardFrontendMap = cardFrontendMap_;
607     }
608 
609     void SetToken(sptr<IRemoteObject>& token);
610     sptr<IRemoteObject> GetToken();
611     void SetParentToken(sptr<IRemoteObject>& token);
612     sptr<IRemoteObject> GetParentToken();
613     uint32_t GetParentWindowType() const;
614     uint32_t GetWindowType() const;
615 
GetWebHapPath()616     std::string GetWebHapPath() const override
617     {
618         return webHapPath_;
619     }
620 
621     NG::SafeAreaInsets GetViewSafeAreaByType(OHOS::Rosen::AvoidAreaType type,
622         std::optional<NG::RectF> windowRect = std::nullopt);
623 
624     NG::SafeAreaInsets GetKeyboardSafeArea() override;
625 
626     Rosen::AvoidArea GetAvoidAreaByType(Rosen::AvoidAreaType type, int32_t apiVersion = Rosen::API_VERSION_INVALID);
627 
628     uint32_t GetStatusBarHeight();
629 
GetWindowMode()630     Rosen::WindowMode GetWindowMode() const
631     {
632         CHECK_NULL_RETURN(uiWindow_, Rosen::WindowMode::WINDOW_MODE_UNDEFINED);
633         return uiWindow_->GetWindowMode();
634     }
635 
636     // ArkTSCard
637     void UpdateFormData(const std::string& data);
638     void UpdateFormSharedImage(const std::map<std::string, sptr<OHOS::AppExecFwk::FormAshmem>>& imageDataMap);
639     void UpdateResource();
640 
641     void GetNamesOfSharedImage(std::vector<std::string>& picNameArray);
642     void UpdateSharedImage(std::vector<std::string>& picNameArray, std::vector<int32_t>& byteLenArray,
643         std::vector<int32_t>& fileDescriptorArray);
644     void GetImageDataFromAshmem(
645         const std::string& picName, Ashmem& ashmem, const RefPtr<PipelineBase>& pipelineContext, int len);
646 
647     bool IsLauncherContainer() override;
648     bool IsScenceBoardWindow() override;
649     bool IsCrossAxisWindow() override;
650     bool IsUIExtensionWindow() override;
651     bool IsSceneBoardEnabled() override;
652     bool IsMainWindow() const override;
653     bool IsSubWindow() const override;
654     bool IsDialogWindow() const override;
655     bool IsSystemWindow() const override;
656     bool IsHostMainWindow() const override;
657     bool IsHostSubWindow() const override;
658     bool IsHostDialogWindow() const override;
659     bool IsHostSystemWindow() const override;
660     bool IsHostSceneBoardWindow() const override;
661     uint32_t GetParentMainWindowId(uint32_t currentWindowId) const override;
662 
663     void SetCurPointerEvent(const std::shared_ptr<MMI::PointerEvent>& currentEvent);
664     bool GetCurPointerEventInfo(DragPointerEvent& dragPointerEvent, StopDragCallback&& stopDragCallback) override;
665 
666     bool GetCurPointerEventSourceType(int32_t& sourceType) override;
667 
668     int32_t RequestAutoFill(const RefPtr<NG::FrameNode>& node, AceAutoFillType autoFillType, bool isNewPassWord,
669         bool& isPopup, uint32_t& autoFillSessionId, bool isNative = true,
670         const std::function<void()>& onFinish = nullptr,
671         const std::function<void()>& onUIExtNodeBindingCompleted = nullptr) override;
672     bool IsNeedToCreatePopupWindow(const AceAutoFillType& autoFillType) override;
673     bool RequestAutoSave(const RefPtr<NG::FrameNode>& node, const std::function<void()>& onFinish,
674         const std::function<void()>& onUIExtNodeBindingCompleted, bool isNative = true,
675         int32_t instanceId = -1) override;
676     std::shared_ptr<NavigationController> GetNavigationController(const std::string& navigationId) override;
677     void OverwritePageNodeInfo(const RefPtr<NG::FrameNode>& frameNode, AbilityBase::ViewData& viewData);
678     HintToTypeWrap PlaceHolderToType(const std::string& onePlaceHolder) override;
679 
680     void SearchElementInfoByAccessibilityIdNG(
681         int64_t elementId, int32_t mode, int64_t baseParent,
682         std::list<Accessibility::AccessibilityElementInfo>& output);
683 
684     void SearchElementInfosByTextNG(
685         int64_t elementId, const std::string& text, int64_t baseParent,
686         std::list<Accessibility::AccessibilityElementInfo>& output);
687 
688     void FindFocusedElementInfoNG(
689         int64_t elementId, int32_t focusType, int64_t baseParent,
690         Accessibility::AccessibilityElementInfo& output);
691 
692     void FocusMoveSearchNG(
693         int64_t elementId, int32_t direction, int64_t baseParent,
694         Accessibility::AccessibilityElementInfo& output);
695 
696     bool NotifyExecuteAction(
697         int64_t elementId, const std::map<std::string, std::string>& actionArguments,
698         int32_t action, int64_t offset);
699 
700     void HandleAccessibilityHoverEvent(float pointX, float pointY, int32_t sourceType,
701         int32_t eventType, int64_t timeMs);
702 
703     void TerminateUIExtension() override;
704     bool UIExtensionIsHalfScreen() override;
SetUIExtensionSubWindow(bool isUIExtensionSubWindow)705     void SetUIExtensionSubWindow(bool isUIExtensionSubWindow)
706     {
707         isUIExtensionSubWindow_ = isUIExtensionSubWindow;
708     }
709 
IsUIExtensionSubWindow()710     bool IsUIExtensionSubWindow()
711     {
712         return isUIExtensionSubWindow_;
713     }
714 
SetUIExtensionAbilityProcess(bool isUIExtensionAbilityProcess)715     void SetUIExtensionAbilityProcess(bool isUIExtensionAbilityProcess)
716     {
717         isUIExtensionAbilityProcess_ = isUIExtensionAbilityProcess;
718     }
719 
IsUIExtensionAbilityProcess()720     bool IsUIExtensionAbilityProcess()
721     {
722         return isUIExtensionAbilityProcess_;
723     }
724 
SetUIExtensionAbilityHost(bool isUIExtensionAbilityHost)725     void SetUIExtensionAbilityHost(bool isUIExtensionAbilityHost)
726     {
727         isUIExtensionAbilityHost_ = isUIExtensionAbilityHost;
728     }
729 
IsUIExtensionAbilityHost()730     bool IsUIExtensionAbilityHost()
731     {
732         return isUIExtensionAbilityHost_;
733     }
734 
RecordResAdapter(const std::string & key)735     void RecordResAdapter(const std::string& key)
736     {
737         resAdapterRecord_.emplace(key);
738     }
739 
740     std::vector<Ace::RectF> GetOverlayNodePositions();
741 
742     void RegisterOverlayNodePositionsUpdateCallback(
743         const std::function<void(std::vector<Ace::RectF>)>&& callback);
744 
745     OHOS::Rosen::WMError RegisterAvoidAreaChangeListener(sptr<OHOS::Rosen::IAvoidAreaChangedListener>& listener);
746     OHOS::Rosen::WMError UnregisterAvoidAreaChangeListener(sptr<OHOS::Rosen::IAvoidAreaChangedListener>& listener);
747 
748     bool NeedFullUpdate(uint32_t limitKey);
749     void NotifyDensityUpdate(double density);
750     void NotifyDirectionUpdate();
751 
SetRegisterComponents(const std::vector<std::string> & registerComponents)752     void SetRegisterComponents(const std::vector<std::string>& registerComponents)
753     {
754         registerComponents_ = registerComponents;
755     }
756 
GetRegisterComponents()757     std::vector<std::string> GetRegisterComponents() override
758     {
759         return registerComponents_;
760     }
761     void RenderLayoutBoundary(bool isDebugBoundary);
762     void AddWatchSystemParameter();
763     void RemoveWatchSystemParameter();
764 
GetUieParams()765     const std::vector<std::string>& GetUieParams() const
766     {
767         return paramUie_;
768     }
769 
770     void UpdateResourceOrientation(int32_t orientation);
771     void UpdateResourceDensity(double density, bool isUpdateResConfig);
772     void SetDrawReadyEventCallback();
773 
IsFreeMultiWindow()774     bool IsFreeMultiWindow() const override
775     {
776         CHECK_NULL_RETURN(uiWindow_, false);
777         return uiWindow_->GetFreeMultiWindowModeEnabledState();
778     }
GetUIExtensionHostWindowRect(int32_t instanceId)779     Rect GetUIExtensionHostWindowRect(int32_t instanceId) override
780     {
781         CHECK_NULL_RETURN(IsUIExtensionWindow(), Rect());
782         auto rect = uiWindow_->GetHostWindowRect(instanceId);
783         return Rect(rect.posX_, rect.posY_, rect.width_, rect.height_);
784     }
785     void FireUIExtensionEventCallback(uint32_t eventId);
786     void FireAccessibilityEventCallback(uint32_t eventId, int64_t parameter);
787 
IsFloatingWindow()788     bool IsFloatingWindow() const override
789     {
790         CHECK_NULL_RETURN(uiWindow_, false);
791         return uiWindow_->GetWindowMode() == Rosen::WindowMode::WINDOW_MODE_FLOATING;
792     }
793 
SetSingleHandTransform(const SingleHandTransform & singleHandTransform)794     void SetSingleHandTransform(const SingleHandTransform& singleHandTransform)
795     {
796         singleHandTransform_ = singleHandTransform;
797     }
798 
GetSingleHandTransform()799     const SingleHandTransform& GetSingleHandTransform() const
800     {
801         return singleHandTransform_;
802     }
803 
804     bool GetLastMovingPointerPosition(DragPointerEvent& dragPointerEvent) override;
805 
806     Rect GetDisplayAvailableRect() const override;
807 
808     void GetExtensionConfig(AAFwk::WantParams& want);
809 
810     void SetIsFocusActive(bool isFocusActive);
811 
812     void SetFontScaleAndWeightScale(int32_t instanceId);
813 
814     sptr<OHOS::Rosen::Window> GetUIWindowInner() const;
815 
SetFoldStatusFromListener(FoldStatus foldStatus)816     void SetFoldStatusFromListener(FoldStatus foldStatus)
817     {
818         foldStatusFromListener_ = foldStatus;
819     }
820 
GetFoldStatusFromListener()821     FoldStatus GetFoldStatusFromListener() override
822     {
823         return foldStatusFromListener_;
824     }
825 
InitFoldStatusFromListener()826     void InitFoldStatusFromListener() override
827     {
828         foldStatusFromListener_ = GetCurrentFoldStatus();
829     }
830 
831 private:
832     virtual bool MaybeRelease() override;
833     void InitializeFrontend();
834     void InitializeCallback();
835     void InitializeTask(std::shared_ptr<TaskWrapper> taskWrapper = nullptr);
836     void InitWindowCallback();
837 
838     void AttachView(std::shared_ptr<Window> window, const RefPtr<AceView>& view, double density, float width,
839         float height, uint32_t windowId, UIEnvCallback callback = nullptr);
840     void SetUIWindowInner(sptr<OHOS::Rosen::Window> uiWindow);
841     std::weak_ptr<OHOS::AppExecFwk::Ability> GetAbilityInner() const;
842     std::weak_ptr<OHOS::AbilityRuntime::Context> GetRuntimeContextInner() const;
843 
844     void RegisterStopDragCallback(int32_t pointerId, StopDragCallback&& stopDragCallback);
845     void SetFontScaleAndWeightScale(const ParsedConfig& parsedConfig, ConfigurationChange& configurationChange);
846     void ReleaseResourceAdapter();
847     void FillAutoFillViewData(const RefPtr<NG::FrameNode> &node, RefPtr<ViewDataWrap> &viewDataWrap);
848 
849     void NotifyConfigToSubContainers(const ParsedConfig& parsedConfig, const std::string& configuration);
850     void ProcessThemeUpdate(const ParsedConfig& parsedConfig, ConfigurationChange& configurationChange);
851     DeviceOrientation ProcessDirectionUpdate(
852         const ParsedConfig& parsedConfig, ConfigurationChange& configurationChange);
853     void InitDragEventCallback();
854 
855     void RegisterUIExtDataConsumer();
856     void UnRegisterUIExtDataConsumer();
857     void DispatchUIExtDataConsume(
858         NG::UIContentBusinessCode code, const AAFwk::Want& data, std::optional<AAFwk::Want>& reply);
859     void RegisterUIExtDataSendToHost();
860     bool FireUIExtDataSendToHost(
861         NG::UIContentBusinessCode code, const AAFwk::Want& data, NG::BusinessDataSendType type);
862     bool FireUIExtDataSendToHostReply(
863         NG::UIContentBusinessCode code, const AAFwk::Want& data, AAFwk::Want& reply);
864 
865     void RegisterAvoidInfoCallback();
866     void RegisterAvoidInfoDataProcessCallback();
867 
868     int32_t instanceId_ = 0;
869     RefPtr<AceView> aceView_;
870     RefPtr<TaskExecutor> taskExecutor_;
871     RefPtr<AssetManager> assetManager_;
872     RefPtr<PlatformResRegister> resRegister_;
873     RefPtr<PipelineBase> pipelineContext_;
874     RefPtr<Frontend> frontend_;
875     std::unordered_map<int64_t, WeakPtr<Frontend>> cardFrontendMap_;
876     std::unordered_map<int64_t, WeakPtr<PipelineBase>> cardPipelineMap_;
877 
878     FrontendType type_ = FrontendType::JS;
879     std::unique_ptr<PlatformEventCallback> platformEventCallback_;
880     WindowModal windowModal_ { WindowModal::NORMAL };
881     ColorScheme colorScheme_ { ColorScheme::FIRST_VALUE };
882     ResourceInfo resourceInfo_;
883     std::weak_ptr<OHOS::AppExecFwk::Ability> aceAbility_;
884     std::weak_ptr<OHOS::AbilityRuntime::Context> runtimeContext_;
885     std::weak_ptr<OHOS::AppExecFwk::AbilityInfo> abilityInfo_;
886     void* sharedRuntime_ = nullptr;
887     std::string pageProfile_;
888     int32_t pageId_ = 0;
889     bool useCurrentEventRunner_ = false;
890     sptr<OHOS::Rosen::Window> uiWindow_ = nullptr;
891     std::string windowName_;
892     uint32_t windowId_ = OHOS::Rosen::INVALID_WINDOW_ID;
893     float windowScale_ = 1.0f;
894     sptr<IRemoteObject> token_;
895     sptr<IRemoteObject> parentToken_;
896     FoldStatus foldStatusFromListener_ = FoldStatus::UNKNOWN;
897 
898     bool isSubContainer_ = false;
899     bool isFormRender_ = false;
900     int32_t parentId_ = 0;
901     bool useStageModel_ = false;
902     bool isUIExtensionSubWindow_ = false;
903     bool isUIExtensionAbilityProcess_ = false;
904     bool isUIExtensionAbilityHost_ = false;
905     bool isUseCustomBg_ = false;
906 
907     DeviceOrientation orientation_ = DeviceOrientation::ORIENTATION_UNDEFINED;
908 
909     // for other AceContainer subscribe configuration from host AceContaier
910     // key is instanceId, value is callback function
911     std::unordered_map<int32_t, ConfigurationChangedCallback> configurationChangedCallbacks_;
912     std::vector<std::string> registerComponents_;
913 
914     std::unordered_set<std::string> resAdapterRecord_;
915 
916     mutable std::mutex frontendMutex_;
917     mutable std::mutex pipelineMutex_;
918     mutable std::mutex destructMutex_;
919     mutable std::mutex viewMutex_;
920 
921     mutable std::mutex cardFrontMutex_;
922     mutable std::mutex cardPipelineMutex_;
923     mutable std::mutex cardTokensMutex_;
924 
925     std::string webHapPath_;
926 
927     bool installationFree_ = false;
928     SharePanelCallback sharePanelCallback_ = nullptr;
929     AbilityOnQueryCallback abilityOnQueryCallback_ = nullptr;
930 
931     std::atomic_flag isDumping_ = ATOMIC_FLAG_INIT;
932 
933     std::string uniqueId_;
934 
935     // For custom drag event
936     std::mutex pointerEventMutex_;
937     std::shared_ptr<MMI::PointerEvent> currentPointerEvent_;
938     std::unordered_map<int32_t, std::list<StopDragCallback>> stopDragCallbackMap_;
939     std::map<int32_t, std::shared_ptr<MMI::PointerEvent>> currentEvents_;
940     friend class WindowFreeContainer;
941     ACE_DISALLOW_COPY_AND_MOVE(AceContainer);
942     RefPtr<RenderBoundaryManager> renderBoundaryManager_ = Referenced::MakeRefPtr<RenderBoundaryManager>();
943 
944     // for Ui Extension dump param get
945     std::vector<std::string> paramUie_;
946 
947     SingleHandTransform singleHandTransform_;
948 };
949 
950 } // namespace OHOS::Ace::Platform
951 
952 #endif // FOUNDATION_ACE_ADAPTER_OHOS_CPP_ACE_CONTAINER_H
953