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