1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "frameworks/bridge/declarative_frontend/ng/frontend_delegate_declarative_ng.h"
17
18 #include "base/subwindow/subwindow_manager.h"
19 #include "core/components_ng/base/view_abstract.h"
20 #include "core/components_ng/base/view_stack_model.h"
21 #include "core/components_ng/pattern/stage/page_pattern.h"
22 #include "core/components_ng/pattern/overlay/dialog_manager.h"
23 #include "core/components_ng/render/adapter/component_snapshot.h"
24 #include "frameworks/core/common/ace_engine.h"
25 #include "base/subwindow/subwindow_manager.h"
26
27 namespace OHOS::Ace::Framework {
28
29 namespace {
30
31 const char MANIFEST_JSON[] = "manifest.json";
32 const char PAGES_JSON[] = "main_pages.json";
33 constexpr int32_t TOAST_TIME_MAX = 10000; // ms
34 constexpr int32_t TOAST_TIME_DEFAULT = 1500; // ms
35 constexpr int32_t CALLBACK_ERRORCODE_CANCEL = 1;
36 constexpr int32_t CALLBACK_DATACODE_ZERO = 0;
37
38 // helper function to run OverlayManager task
39 // ensures that the task runs in subwindow instead of main Window
MainWindowOverlay(std::function<void (RefPtr<NG::OverlayManager>)> && task,const std::string & name,const RefPtr<NG::OverlayManager> & overlay)40 void MainWindowOverlay(std::function<void(RefPtr<NG::OverlayManager>)>&& task, const std::string& name,
41 const RefPtr<NG::OverlayManager>& overlay)
42 {
43 auto currentId = Container::CurrentId();
44 ContainerScope scope(currentId);
45 auto context = NG::PipelineContext::GetCurrentContext();
46 CHECK_NULL_VOID(context);
47 auto overlayManager = context->GetOverlayManager();
48 if (overlay) {
49 overlayManager = overlay;
50 }
51 context->GetTaskExecutor()->PostTask(
52 [task = std::move(task), weak = WeakPtr<NG::OverlayManager>(overlayManager)] {
53 auto overlayManager = weak.Upgrade();
54 task(overlayManager);
55 },
56 TaskExecutor::TaskType::UI, name);
57 }
58 } // namespace
59
FrontendDelegateDeclarativeNG(const RefPtr<TaskExecutor> & taskExecutor)60 FrontendDelegateDeclarativeNG::FrontendDelegateDeclarativeNG(const RefPtr<TaskExecutor>& taskExecutor)
61 : taskExecutor_(taskExecutor), manifestParser_(AceType::MakeRefPtr<Framework::ManifestParser>()),
62 mediaQueryInfo_(AceType::MakeRefPtr<MediaQueryInfo>()),
63 jsAccessibilityManager_(AccessibilityNodeManager::Create())
64 {}
65
SetMediaQueryCallback(MediaQueryCallback && mediaQueryCallback)66 void FrontendDelegateDeclarativeNG::SetMediaQueryCallback(MediaQueryCallback&& mediaQueryCallback)
67 {
68 mediaQueryCallback_ = mediaQueryCallback;
69 }
70
SetLayoutInspectorCallback(const LayoutInspectorCallback & layoutInspectorCallback)71 void FrontendDelegateDeclarativeNG::SetLayoutInspectorCallback(const LayoutInspectorCallback& layoutInspectorCallback)
72 {
73 layoutInspectorCallback_ = layoutInspectorCallback;
74 }
75
SetDrawInspectorCallback(const DrawInspectorCallback & drawInspectorCallback)76 void FrontendDelegateDeclarativeNG::SetDrawInspectorCallback(const DrawInspectorCallback& drawInspectorCallback)
77 {
78 drawInspectorCallback_ = drawInspectorCallback;
79 }
80
SetDrawChildrenInspectorCallback(const DrawChildrenInspectorCallback & drawChildrenInspectorCallback)81 void FrontendDelegateDeclarativeNG::SetDrawChildrenInspectorCallback(
82 const DrawChildrenInspectorCallback& drawChildrenInspectorCallback)
83 {
84 drawChildrenInspectorCallback_ = drawChildrenInspectorCallback;
85 }
86
SetIsDrawChildrenCallbackFuncExistCallback(const IsDrawChildrenCallbackFuncExistCallback & IsDrawChildrenCallbackFuncExistCallback)87 void FrontendDelegateDeclarativeNG::SetIsDrawChildrenCallbackFuncExistCallback(
88 const IsDrawChildrenCallbackFuncExistCallback& IsDrawChildrenCallbackFuncExistCallback)
89 {
90 isDrawChildrenCallbackFuncExistCallback_ = IsDrawChildrenCallbackFuncExistCallback;
91 }
92
SetOnStartContinuationCallBack(OnStartContinuationCallBack && onStartContinuationCallBack)93 void FrontendDelegateDeclarativeNG::SetOnStartContinuationCallBack(
94 OnStartContinuationCallBack&& onStartContinuationCallBack)
95 {
96 onStartContinuationCallBack_ = onStartContinuationCallBack;
97 }
98
SetOnCompleteContinuationCallBack(OnCompleteContinuationCallBack && onCompleteContinuationCallBack)99 void FrontendDelegateDeclarativeNG::SetOnCompleteContinuationCallBack(
100 OnCompleteContinuationCallBack&& onCompleteContinuationCallBack)
101 {
102 onCompleteContinuationCallBack_ = onCompleteContinuationCallBack;
103 }
104
SetOnSaveDataCallBack(OnSaveDataCallBack && onSaveDataCallBack)105 void FrontendDelegateDeclarativeNG::SetOnSaveDataCallBack(OnSaveDataCallBack&& onSaveDataCallBack)
106 {
107 onSaveDataCallBack_ = onSaveDataCallBack;
108 }
109
SetOnRemoteTerminatedCallBack(OnRemoteTerminatedCallBack && onRemoteTerminatedCallBack)110 void FrontendDelegateDeclarativeNG::SetOnRemoteTerminatedCallBack(
111 OnRemoteTerminatedCallBack&& onRemoteTerminatedCallBack)
112 {
113 onRemoteTerminatedCallBack_ = onRemoteTerminatedCallBack;
114 }
115
SetOnRestoreDataCallBack(OnRestoreDataCallBack && onRestoreDataCallBack)116 void FrontendDelegateDeclarativeNG::SetOnRestoreDataCallBack(OnRestoreDataCallBack&& onRestoreDataCallBack)
117 {
118 onRestoreDataCallBack_ = onRestoreDataCallBack;
119 }
120
SetDestroyApplicationCallback(DestroyApplicationCallback && destroyApplicationCallback)121 void FrontendDelegateDeclarativeNG::SetDestroyApplicationCallback(
122 DestroyApplicationCallback&& destroyApplicationCallback)
123 {
124 destroyApplication_ = destroyApplicationCallback;
125 }
126
SetUpdateApplicationStateCallback(UpdateApplicationStateCallback && updateApplicationStateCallback)127 void FrontendDelegateDeclarativeNG::SetUpdateApplicationStateCallback(
128 UpdateApplicationStateCallback&& updateApplicationStateCallback)
129 {
130 updateApplicationState_ = updateApplicationStateCallback;
131 }
132
SetOnWindowDisplayModeChangedCallback(OnWindowDisplayModeChangedCallBack && onWindowDisplayModeChangedCallBack)133 void FrontendDelegateDeclarativeNG::SetOnWindowDisplayModeChangedCallback(
134 OnWindowDisplayModeChangedCallBack&& onWindowDisplayModeChangedCallBack)
135 {
136 onWindowDisplayModeChanged_ = onWindowDisplayModeChangedCallBack;
137 }
138
SetExternalEventCallback(ExternalEventCallback && externalEventCallback)139 void FrontendDelegateDeclarativeNG::SetExternalEventCallback(ExternalEventCallback&& externalEventCallback)
140 {
141 externalEvent_ = externalEventCallback;
142 }
143
SetTimerCallback(TimerCallback && timerCallback)144 void FrontendDelegateDeclarativeNG::SetTimerCallback(TimerCallback&& timerCallback)
145 {
146 timer_ = timerCallback;
147 }
148
AttachPipelineContext(const RefPtr<PipelineBase> & context)149 void FrontendDelegateDeclarativeNG::AttachPipelineContext(const RefPtr<PipelineBase>& context)
150 {
151 if (!context) {
152 return;
153 }
154 context->SetOnPageShow([weak = AceType::WeakClaim(this)] {
155 auto delegate = weak.Upgrade();
156 if (delegate) {
157 delegate->OnPageShow();
158 }
159 });
160
161 pipelineContextHolder_.Attach(context);
162 jsAccessibilityManager_->SetPipelineContext(context);
163 jsAccessibilityManager_->InitializeCallback();
164 }
165
AttachSubPipelineContext(const RefPtr<PipelineBase> & context)166 void FrontendDelegateDeclarativeNG::AttachSubPipelineContext(const RefPtr<PipelineBase>& context)
167 {
168 if (!context) {
169 return;
170 }
171 jsAccessibilityManager_->AddSubPipelineContext(context);
172 jsAccessibilityManager_->RegisterSubWindowInteractionOperation(context->GetWindowId());
173 }
174
RunPage(const std::string & url,const std::string & params,const std::string & profile,bool isNamedRouter)175 void FrontendDelegateDeclarativeNG::RunPage(
176 const std::string& url, const std::string& params, const std::string& profile, bool isNamedRouter)
177 {
178 ACE_SCOPED_TRACE("FrontendDelegateDeclarativeNG::RunPage");
179
180 LOGI("Frontend delegate declarative run page, url=%{public}s", url.c_str());
181 std::string jsonContent;
182 if (GetAssetContent(MANIFEST_JSON, jsonContent)) {
183 manifestParser_->Parse(jsonContent);
184 manifestParser_->Printer();
185 } else if (!profile.empty() && GetAssetContent(profile, jsonContent)) {
186 manifestParser_->Parse(jsonContent);
187 } else if (GetAssetContent(PAGES_JSON, jsonContent)) {
188 manifestParser_->Parse(jsonContent);
189 }
190 std::string mainPagePath;
191 if (!url.empty()) {
192 mainPagePath = manifestParser_->GetRouter()->GetPagePath(url);
193 } else {
194 mainPagePath = manifestParser_->GetRouter()->GetEntry();
195 }
196 taskExecutor_->PostTask(
197 [manifestParser = manifestParser_, delegate = Claim(this),
198 weakPtr = WeakPtr<NG::PageRouterManager>(pageRouterManager_), url, params, isNamedRouter]() {
199 auto pageRouterManager = weakPtr.Upgrade();
200 CHECK_NULL_VOID(pageRouterManager);
201 pageRouterManager->SetManifestParser(manifestParser);
202 if (isNamedRouter) {
203 pageRouterManager->RunPageByNamedRouter(url, params);
204 } else {
205 pageRouterManager->RunPage(url, params);
206 }
207 auto pipeline = delegate->GetPipelineContext();
208 // TODO: get platform version from context, and should stored in AceApplicationInfo.
209 if (manifestParser->GetMinPlatformVersion() > 0) {
210 pipeline->SetMinPlatformVersion(manifestParser->GetMinPlatformVersion());
211 }
212 },
213 TaskExecutor::TaskType::JS, "ArkUIRunPageUrl");
214 }
215
RunPage(const std::shared_ptr<std::vector<uint8_t>> & content,const std::string & params,const std::string & profile)216 void FrontendDelegateDeclarativeNG::RunPage(
217 const std::shared_ptr<std::vector<uint8_t>>& content, const std::string& params, const std::string& profile)
218 {
219 ACE_SCOPED_TRACE("FrontendDelegateDeclarativeNG::RunPage %zu", content->size());
220 taskExecutor_->PostTask(
221 [delegate = Claim(this), weakPtr = WeakPtr<NG::PageRouterManager>(pageRouterManager_), content, params]() {
222 auto pageRouterManager = weakPtr.Upgrade();
223 CHECK_NULL_VOID(pageRouterManager);
224 pageRouterManager->RunPage(content, params);
225 auto pipeline = delegate->GetPipelineContext();
226 },
227 TaskExecutor::TaskType::JS, "ArkUIRunPageContent");
228 }
229
RunIntentPage()230 void FrontendDelegateDeclarativeNG::RunIntentPage()
231 {
232 taskExecutor_->PostTask(
233 [delegate = Claim(this), weakPtr = WeakPtr<NG::PageRouterManager>(pageRouterManager_)]() {
234 auto pageRouterManager = weakPtr.Upgrade();
235 CHECK_NULL_VOID(pageRouterManager);
236 pageRouterManager->RunIntentPage();
237 },
238 TaskExecutor::TaskType::JS, "ArkUIRunIntentPage");
239 }
240
SetRouterIntentInfo(const std::string & intentInfoSerialized,bool isColdStart,const std::function<void ()> && loadPageCallback)241 void FrontendDelegateDeclarativeNG::SetRouterIntentInfo(const std::string& intentInfoSerialized, bool isColdStart,
242 const std::function<void()>&& loadPageCallback)
243 {
244 taskExecutor_->PostTask([weakPtr = WeakPtr<NG::PageRouterManager>(pageRouterManager_),
245 intentInfoSerialized, isColdStart, callback = std::move(loadPageCallback)]() {
246 auto pageRouterManager = weakPtr.Upgrade();
247 CHECK_NULL_VOID(pageRouterManager);
248 pageRouterManager->SetRouterIntentInfo(intentInfoSerialized, isColdStart, std::move(callback));
249 },
250 TaskExecutor::TaskType::JS, "ArkUISetRouterIntentInfo");
251 }
252
GetTopNavDestinationInfo(bool onlyFullScreen,bool needParam)253 std::string FrontendDelegateDeclarativeNG::GetTopNavDestinationInfo(bool onlyFullScreen, bool needParam)
254 {
255 if (pageRouterManager_) {
256 return pageRouterManager_->GetTopNavDestinationInfo(onlyFullScreen, needParam);
257 }
258 return "{}";
259 }
260
OnConfigurationUpdated(const std::string & data)261 void FrontendDelegateDeclarativeNG::OnConfigurationUpdated(const std::string& data)
262 {
263 // only support mediaQueryUpdate
264 OnMediaQueryUpdate();
265 }
266
OnStartContinuation()267 bool FrontendDelegateDeclarativeNG::OnStartContinuation()
268 {
269 bool ret = false;
270 taskExecutor_->PostSyncTask(
271 [weak = AceType::WeakClaim(this), &ret] {
272 auto delegate = weak.Upgrade();
273 if (delegate && delegate->onStartContinuationCallBack_) {
274 ret = delegate->onStartContinuationCallBack_();
275 }
276 },
277 TaskExecutor::TaskType::JS, "ArkUIStartContinuation");
278 return ret;
279 }
280
OnCompleteContinuation(int32_t code)281 void FrontendDelegateDeclarativeNG::OnCompleteContinuation(int32_t code)
282 {
283 taskExecutor_->PostSyncTask(
284 [weak = AceType::WeakClaim(this), code] {
285 auto delegate = weak.Upgrade();
286 if (delegate && delegate->onCompleteContinuationCallBack_) {
287 delegate->onCompleteContinuationCallBack_(code);
288 }
289 },
290 TaskExecutor::TaskType::JS, "ArkUICompleteContinuation");
291 }
292
OnRemoteTerminated()293 void FrontendDelegateDeclarativeNG::OnRemoteTerminated()
294 {
295 taskExecutor_->PostSyncTask(
296 [weak = AceType::WeakClaim(this)] {
297 auto delegate = weak.Upgrade();
298 if (delegate && delegate->onRemoteTerminatedCallBack_) {
299 delegate->onRemoteTerminatedCallBack_();
300 }
301 },
302 TaskExecutor::TaskType::JS, "ArkUIRemoteTerminated");
303 }
304
OnSaveData(std::string & data)305 void FrontendDelegateDeclarativeNG::OnSaveData(std::string& data)
306 {
307 std::string savedData;
308 taskExecutor_->PostSyncTask(
309 [weak = AceType::WeakClaim(this), &savedData] {
310 auto delegate = weak.Upgrade();
311 if (delegate && delegate->onSaveDataCallBack_) {
312 delegate->onSaveDataCallBack_(savedData);
313 }
314 },
315 TaskExecutor::TaskType::JS, "ArkUISaveData");
316 std::string pageUri = GetCurrentPageUrl();
317 data = std::string("{\"url\":\"").append(pageUri).append("\",\"__remoteData\":").append(savedData).append("}");
318 }
319
OnRestoreData(const std::string & data)320 bool FrontendDelegateDeclarativeNG::OnRestoreData(const std::string& data)
321 {
322 bool ret = false;
323 taskExecutor_->PostSyncTask(
324 [weak = AceType::WeakClaim(this), &data, &ret] {
325 auto delegate = weak.Upgrade();
326 if (delegate && delegate->onRestoreDataCallBack_) {
327 ret = delegate->onRestoreDataCallBack_(data);
328 }
329 },
330 TaskExecutor::TaskType::JS, "ArkUIRestoreData");
331 return ret;
332 }
333
OnApplicationDestroy(const std::string & packageName)334 void FrontendDelegateDeclarativeNG::OnApplicationDestroy(const std::string& packageName)
335 {
336 taskExecutor_->PostSyncTask(
337 [destroyApplication = destroyApplication_, packageName] { destroyApplication(packageName); },
338 TaskExecutor::TaskType::JS, "ArkUIApplicationDestroy");
339 }
340
UpdateApplicationState(const std::string & packageName,Frontend::State state)341 void FrontendDelegateDeclarativeNG::UpdateApplicationState(const std::string& packageName, Frontend::State state)
342 {
343 taskExecutor_->PostTask([updateApplicationState = updateApplicationState_, packageName,
344 state] { updateApplicationState(packageName, state); },
345 TaskExecutor::TaskType::JS, "ArkUIUpdateApplicationState");
346 }
347
OnWindowDisplayModeChanged(bool isShownInMultiWindow,const std::string & data)348 void FrontendDelegateDeclarativeNG::OnWindowDisplayModeChanged(bool isShownInMultiWindow, const std::string& data)
349 {
350 taskExecutor_->PostTask([onWindowDisplayModeChanged = onWindowDisplayModeChanged_, isShownInMultiWindow,
351 data] { onWindowDisplayModeChanged(isShownInMultiWindow, data); },
352 TaskExecutor::TaskType::JS, "ArkUIWindowDisplayModeChanged");
353 }
354
NotifyAppStorage(const WeakPtr<Framework::JsEngine> & jsEngineWeak,const std::string & key,const std::string & value)355 void FrontendDelegateDeclarativeNG::NotifyAppStorage(
356 const WeakPtr<Framework::JsEngine>& jsEngineWeak, const std::string& key, const std::string& value)
357 {
358 taskExecutor_->PostTask(
359 [jsEngineWeak, key, value] {
360 auto jsEngine = jsEngineWeak.Upgrade();
361 if (!jsEngine) {
362 return;
363 }
364 jsEngine->NotifyAppStorage(key, value);
365 },
366 TaskExecutor::TaskType::JS, "ArkUINotifyAppStorage");
367 }
368
FireAccessibilityEvent(const AccessibilityEvent & accessibilityEvent)369 void FrontendDelegateDeclarativeNG::FireAccessibilityEvent(const AccessibilityEvent& accessibilityEvent)
370 {
371 jsAccessibilityManager_->SendAccessibilityAsyncEvent(accessibilityEvent);
372 }
373
InitializeAccessibilityCallback()374 void FrontendDelegateDeclarativeNG::InitializeAccessibilityCallback()
375 {
376 jsAccessibilityManager_->InitializeCallback();
377 }
378
FireExternalEvent(const std::string &,const std::string & componentId,const uint32_t nodeId,const bool isDestroy)379 void FrontendDelegateDeclarativeNG::FireExternalEvent(
380 const std::string& /* eventId */, const std::string& componentId, const uint32_t nodeId, const bool isDestroy)
381 {
382 taskExecutor_->PostSyncTask(
383 [weak = AceType::WeakClaim(this), componentId, nodeId, isDestroy] {
384 auto delegate = weak.Upgrade();
385 if (delegate) {
386 delegate->externalEvent_(componentId, nodeId, isDestroy);
387 }
388 },
389 TaskExecutor::TaskType::JS, "ArkUIFireExternalEvent");
390 }
391
WaitTimer(const std::string & callbackId,const std::string & delay,bool isInterval,bool isFirst)392 void FrontendDelegateDeclarativeNG::WaitTimer(
393 const std::string& callbackId, const std::string& delay, bool isInterval, bool isFirst)
394 {
395 if (!isFirst) {
396 auto timeoutTaskIter = timeoutTaskMap_.find(callbackId);
397 // If not find the callbackId in map, means this timer already was removed,
398 // no need create a new cancelableTimer again.
399 if (timeoutTaskIter == timeoutTaskMap_.end()) {
400 return;
401 }
402 }
403
404 int32_t delayTime = StringToInt(delay);
405 // CancelableCallback class can only be executed once.
406 CancelableCallback<void()> cancelableTimer;
407 cancelableTimer.Reset([callbackId, delay, isInterval, call = timer_] { call(callbackId, delay, isInterval); });
408 auto result = timeoutTaskMap_.try_emplace(callbackId, cancelableTimer);
409 if (!result.second) {
410 result.first->second = cancelableTimer;
411 }
412 taskExecutor_->PostDelayedTask(cancelableTimer, TaskExecutor::TaskType::JS, delayTime, "ArkUIWaitTimer");
413 }
414
ClearTimer(const std::string & callbackId)415 void FrontendDelegateDeclarativeNG::ClearTimer(const std::string& callbackId)
416 {
417 auto timeoutTaskIter = timeoutTaskMap_.find(callbackId);
418 if (timeoutTaskIter != timeoutTaskMap_.end()) {
419 timeoutTaskIter->second.Cancel();
420 timeoutTaskMap_.erase(timeoutTaskIter);
421 }
422 }
423
Push(const std::string & uri,const std::string & params)424 void FrontendDelegateDeclarativeNG::Push(const std::string& uri, const std::string& params)
425 {
426 CHECK_NULL_VOID(pageRouterManager_);
427 NG::RouterPageInfo routerPageInfo;
428 routerPageInfo.url = uri;
429 routerPageInfo.params = params;
430 routerPageInfo.recoverable = true;
431 pageRouterManager_->Push(routerPageInfo);
432 OnMediaQueryUpdate();
433 }
434
PushWithMode(const std::string & uri,const std::string & params,uint32_t routerMode)435 void FrontendDelegateDeclarativeNG::PushWithMode(const std::string& uri, const std::string& params, uint32_t routerMode)
436 {
437 CHECK_NULL_VOID(pageRouterManager_);
438 NG::RouterPageInfo routerPageInfo;
439 routerPageInfo.url = uri;
440 routerPageInfo.params = params;
441 routerPageInfo.recoverable = true;
442 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
443 pageRouterManager_->Push(routerPageInfo);
444 OnMediaQueryUpdate();
445 }
446
PushWithCallback(const std::string & uri,const std::string & params,bool recoverable,const std::function<void (const std::string &,int32_t)> & errorCallback,uint32_t routerMode)447 void FrontendDelegateDeclarativeNG::PushWithCallback(const std::string& uri, const std::string& params,
448 bool recoverable, const std::function<void(const std::string&, int32_t)>& errorCallback, uint32_t routerMode)
449 {
450 CHECK_NULL_VOID(pageRouterManager_);
451 NG::RouterPageInfo routerPageInfo;
452 routerPageInfo.url = uri;
453 routerPageInfo.params = params;
454 routerPageInfo.recoverable = recoverable;
455 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
456 routerPageInfo.errorCallback = errorCallback;
457 pageRouterManager_->Push(routerPageInfo);
458 OnMediaQueryUpdate();
459 }
460
PushNamedRoute(const std::string & uri,const std::string & params,bool recoverable,const std::function<void (const std::string &,int32_t)> & errorCallback,uint32_t routerMode)461 void FrontendDelegateDeclarativeNG::PushNamedRoute(const std::string& uri, const std::string& params,
462 bool recoverable, const std::function<void(const std::string&, int32_t)>& errorCallback, uint32_t routerMode)
463 {
464 CHECK_NULL_VOID(pageRouterManager_);
465 NG::RouterPageInfo routerPageInfo;
466 routerPageInfo.url = uri;
467 routerPageInfo.params = params;
468 routerPageInfo.recoverable = recoverable;
469 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
470 routerPageInfo.errorCallback = errorCallback;
471 pageRouterManager_->PushNamedRoute(routerPageInfo);
472 OnMediaQueryUpdate();
473 }
474
Replace(const std::string & uri,const std::string & params)475 void FrontendDelegateDeclarativeNG::Replace(const std::string& uri, const std::string& params)
476 {
477 CHECK_NULL_VOID(pageRouterManager_);
478 NG::RouterPageInfo routerPageInfo;
479 routerPageInfo.url = uri;
480 routerPageInfo.params = params;
481 routerPageInfo.recoverable = true;
482 pageRouterManager_->Replace(routerPageInfo);
483 }
484
ReplaceWithMode(const std::string & uri,const std::string & params,uint32_t routerMode)485 void FrontendDelegateDeclarativeNG::ReplaceWithMode(
486 const std::string& uri, const std::string& params, uint32_t routerMode)
487 {
488 CHECK_NULL_VOID(pageRouterManager_);
489 NG::RouterPageInfo routerPageInfo;
490 routerPageInfo.url = uri;
491 routerPageInfo.params = params;
492 routerPageInfo.recoverable = true;
493 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
494 pageRouterManager_->Replace(routerPageInfo);
495 OnMediaQueryUpdate();
496 }
497
ReplaceWithCallback(const std::string & uri,const std::string & params,bool recoverable,const std::function<void (const std::string &,int32_t)> & errorCallback,uint32_t routerMode)498 void FrontendDelegateDeclarativeNG::ReplaceWithCallback(const std::string& uri, const std::string& params,
499 bool recoverable, const std::function<void(const std::string&, int32_t)>& errorCallback, uint32_t routerMode)
500 {
501 CHECK_NULL_VOID(pageRouterManager_);
502 NG::RouterPageInfo routerPageInfo;
503 routerPageInfo.url = uri;
504 routerPageInfo.params = params;
505 routerPageInfo.recoverable = recoverable;
506 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
507 routerPageInfo.errorCallback = errorCallback;
508 pageRouterManager_->Replace(routerPageInfo);
509 OnMediaQueryUpdate();
510 }
511
ReplaceNamedRoute(const std::string & uri,const std::string & params,bool recoverable,const std::function<void (const std::string &,int32_t)> & errorCallback,uint32_t routerMode)512 void FrontendDelegateDeclarativeNG::ReplaceNamedRoute(const std::string& uri, const std::string& params,
513 bool recoverable, const std::function<void(const std::string&, int32_t)>& errorCallback, uint32_t routerMode)
514 {
515 CHECK_NULL_VOID(pageRouterManager_);
516 NG::RouterPageInfo routerPageInfo;
517 routerPageInfo.url = uri;
518 routerPageInfo.params = params;
519 routerPageInfo.recoverable = recoverable;
520 routerPageInfo.routerMode = static_cast<NG::RouterMode>(routerMode);
521 routerPageInfo.errorCallback = errorCallback;
522 pageRouterManager_->ReplaceNamedRoute(routerPageInfo);
523 OnMediaQueryUpdate();
524 }
525
Back(const std::string & uri,const std::string & params)526 void FrontendDelegateDeclarativeNG::Back(const std::string& uri, const std::string& params)
527 {
528 CHECK_NULL_VOID(pageRouterManager_);
529 NG::RouterPageInfo routerPageInfo;
530 routerPageInfo.url = uri;
531 routerPageInfo.params = params;
532 pageRouterManager_->BackWithTarget(routerPageInfo);
533 }
534
BackToIndex(int32_t index,const std::string & params)535 void FrontendDelegateDeclarativeNG::BackToIndex(int32_t index, const std::string& params)
536 {
537 CHECK_NULL_VOID(pageRouterManager_);
538 pageRouterManager_->BackToIndexWithTarget(index, params);
539 }
540
Clear()541 void FrontendDelegateDeclarativeNG::Clear()
542 {
543 CHECK_NULL_VOID(pageRouterManager_);
544 pageRouterManager_->Clear();
545 }
546
GetStackSize() const547 int32_t FrontendDelegateDeclarativeNG::GetStackSize() const
548 {
549 CHECK_NULL_RETURN(pageRouterManager_, 0);
550 return pageRouterManager_->GetStackSize();
551 }
552
GetState(int32_t & index,std::string & name,std::string & path)553 void FrontendDelegateDeclarativeNG::GetState(int32_t& index, std::string& name, std::string& path)
554 {
555 CHECK_NULL_VOID(pageRouterManager_);
556 pageRouterManager_->GetState(index, name, path);
557 }
558
GetRouterStateByIndex(int32_t & index,std::string & name,std::string & path,std::string & params)559 void FrontendDelegateDeclarativeNG::GetRouterStateByIndex(int32_t& index, std::string& name,
560 std::string& path, std::string& params)
561 {
562 CHECK_NULL_VOID(pageRouterManager_);
563 pageRouterManager_->GetStateByIndex(index, name, path, params);
564 }
565
GetRouterStateByUrl(std::string & url,std::vector<StateInfo> & stateArray)566 void FrontendDelegateDeclarativeNG::GetRouterStateByUrl(std::string& url, std::vector<StateInfo>& stateArray)
567 {
568 CHECK_NULL_VOID(pageRouterManager_);
569 pageRouterManager_->GetStateByUrl(url, stateArray);
570 }
571
GetInitParams()572 std::string FrontendDelegateDeclarativeNG::GetInitParams()
573 {
574 CHECK_NULL_RETURN(pageRouterManager_, "");
575 return pageRouterManager_->GetInitParams();
576 }
577
GetParams()578 std::string FrontendDelegateDeclarativeNG::GetParams()
579 {
580 CHECK_NULL_RETURN(pageRouterManager_, "");
581 return pageRouterManager_->GetParams();
582 }
583
NavigatePage(uint8_t type,const PageTarget & target,const std::string & params)584 void FrontendDelegateDeclarativeNG::NavigatePage(uint8_t type, const PageTarget& target, const std::string& params)
585 {
586 switch (static_cast<NavigatorType>(type)) {
587 case NavigatorType::PUSH:
588 Push(target.url, params);
589 break;
590 case NavigatorType::REPLACE:
591 Replace(target.url, params);
592 break;
593 case NavigatorType::BACK:
594 Back(target.url, params);
595 break;
596 default:
597 Back(target.url, params);
598 }
599 }
600
PostJsTask(std::function<void ()> && task,const std::string & name)601 void FrontendDelegateDeclarativeNG::PostJsTask(std::function<void()>&& task, const std::string& name)
602 {
603 taskExecutor_->PostTask(task, TaskExecutor::TaskType::JS, name);
604 }
605
GetAppID() const606 const std::string& FrontendDelegateDeclarativeNG::GetAppID() const
607 {
608 return manifestParser_->GetAppInfo()->GetAppID();
609 }
610
GetAppName() const611 const std::string& FrontendDelegateDeclarativeNG::GetAppName() const
612 {
613 return manifestParser_->GetAppInfo()->GetAppName();
614 }
615
GetVersionName() const616 const std::string& FrontendDelegateDeclarativeNG::GetVersionName() const
617 {
618 return manifestParser_->GetAppInfo()->GetVersionName();
619 }
620
GetVersionCode() const621 int32_t FrontendDelegateDeclarativeNG::GetVersionCode() const
622 {
623 return manifestParser_->GetAppInfo()->GetVersionCode();
624 }
625
PostSyncTaskToPage(std::function<void ()> && task,const std::string & name)626 void FrontendDelegateDeclarativeNG::PostSyncTaskToPage(std::function<void()>&& task, const std::string& name)
627 {
628 pipelineContextHolder_.Get(); // Wait until Pipeline Context is attached.
629 taskExecutor_->PostSyncTask(task, TaskExecutor::TaskType::UI, name);
630 }
631
GetAssetContent(const std::string & url,std::string & content)632 bool FrontendDelegateDeclarativeNG::GetAssetContent(const std::string& url, std::string& content)
633 {
634 return GetAssetContentImpl(assetManager_, url, content);
635 }
636
GetAssetContent(const std::string & url,std::vector<uint8_t> & content)637 bool FrontendDelegateDeclarativeNG::GetAssetContent(const std::string& url, std::vector<uint8_t>& content)
638 {
639 return GetAssetContentImpl(assetManager_, url, content);
640 }
641
GetAssetPath(const std::string & url)642 std::string FrontendDelegateDeclarativeNG::GetAssetPath(const std::string& url)
643 {
644 return GetAssetPathImpl(assetManager_, url);
645 }
646
ChangeLocale(const std::string & language,const std::string & countryOrRegion)647 void FrontendDelegateDeclarativeNG::ChangeLocale(const std::string& language, const std::string& countryOrRegion)
648 {
649 taskExecutor_->PostTask(
650 [language, countryOrRegion]() { AceApplicationInfo::GetInstance().ChangeLocale(language, countryOrRegion); },
651 TaskExecutor::TaskType::PLATFORM, "ArkUIChangeLocale");
652 }
653
RegisterFont(const std::string & familyName,const std::string & familySrc,const std::string & bundleName,const std::string & moduleName)654 void FrontendDelegateDeclarativeNG::RegisterFont(const std::string& familyName, const std::string& familySrc,
655 const std::string& bundleName, const std::string& moduleName)
656 {
657 pipelineContextHolder_.Get()->RegisterFont(familyName, familySrc, bundleName, moduleName);
658 }
659
GetSystemFontList(std::vector<std::string> & fontList)660 void FrontendDelegateDeclarativeNG::GetSystemFontList(std::vector<std::string>& fontList)
661 {
662 pipelineContextHolder_.Get()->GetSystemFontList(fontList);
663 }
664
GetSystemFont(const std::string & fontName,FontInfo & fontInfo)665 bool FrontendDelegateDeclarativeNG::GetSystemFont(const std::string& fontName, FontInfo& fontInfo)
666 {
667 return pipelineContextHolder_.Get()->GetSystemFont(fontName, fontInfo);
668 }
669
GetUIFontConfig(FontConfigJsonInfo & fontConfigJsonInfo)670 void FrontendDelegateDeclarativeNG::GetUIFontConfig(FontConfigJsonInfo& fontConfigJsonInfo)
671 {
672 pipelineContextHolder_.Get()->GetUIFontConfig(fontConfigJsonInfo);
673 }
674
MeasureText(MeasureContext context)675 double FrontendDelegateDeclarativeNG::MeasureText(MeasureContext context)
676 {
677 if (context.isFontSizeUseDefaultUnit && context.fontSize.has_value() &&
678 !AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
679 context.fontSize = Dimension(context.fontSize->Value(), DimensionUnit::VP);
680 }
681 return MeasureUtil::MeasureText(context);
682 }
683
MeasureTextSize(MeasureContext context)684 Size FrontendDelegateDeclarativeNG::MeasureTextSize(MeasureContext context)
685 {
686 if (context.isFontSizeUseDefaultUnit && context.fontSize.has_value() &&
687 !AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
688 context.fontSize = Dimension(context.fontSize->Value(), DimensionUnit::VP);
689 }
690 return MeasureUtil::MeasureTextSize(context);
691 }
692
GetAnimationJsTask()693 SingleTaskExecutor FrontendDelegateDeclarativeNG::GetAnimationJsTask()
694 {
695 return SingleTaskExecutor::Make(taskExecutor_, TaskExecutor::TaskType::JS);
696 }
697
GetUiTask()698 SingleTaskExecutor FrontendDelegateDeclarativeNG::GetUiTask()
699 {
700 return SingleTaskExecutor::Make(taskExecutor_, TaskExecutor::TaskType::UI);
701 }
702
GetPipelineContext()703 RefPtr<PipelineBase> FrontendDelegateDeclarativeNG::GetPipelineContext()
704 {
705 return pipelineContextHolder_.Get();
706 }
707
OnPageBackPress()708 bool FrontendDelegateDeclarativeNG::OnPageBackPress()
709 {
710 CHECK_NULL_RETURN(pageRouterManager_, false);
711 auto pageNode = pageRouterManager_->GetCurrentPageNode();
712 CHECK_NULL_RETURN(pageNode, false);
713 auto pagePattern = pageNode->GetPattern<NG::PagePattern>();
714 CHECK_NULL_RETURN(pagePattern, false);
715 if (pagePattern->OnBackPressed()) {
716 return true;
717 }
718 return pageRouterManager_->Pop();
719 }
720
OnSurfaceChanged()721 void FrontendDelegateDeclarativeNG::OnSurfaceChanged()
722 {
723 if (mediaQueryInfo_->GetIsInit()) {
724 mediaQueryInfo_->SetIsInit(false);
725 }
726 mediaQueryInfo_->EnsureListenerIdValid();
727 OnMediaQueryUpdate();
728 }
729
ShowDialog(const std::string & title,const std::string & message,const std::vector<ButtonInfo> & buttons,bool autoCancel,std::function<void (int32_t,int32_t)> && callback,const std::set<std::string> & callbacks)730 void FrontendDelegateDeclarativeNG::ShowDialog(const std::string& title, const std::string& message,
731 const std::vector<ButtonInfo>& buttons, bool autoCancel, std::function<void(int32_t, int32_t)>&& callback,
732 const std::set<std::string>& callbacks)
733 {
734 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show dialog enter");
735 DialogProperties dialogProperties = {
736 .type = DialogType::ALERT_DIALOG,
737 .title = title,
738 .content = message,
739 .autoCancel = autoCancel,
740 .buttons = buttons,
741 };
742 ShowDialogInner(dialogProperties, std::move(callback), callbacks);
743 }
744
ShowDialog(const std::string & title,const std::string & message,const std::vector<ButtonInfo> & buttons,bool autoCancel,std::function<void (int32_t,int32_t)> && callback,const std::set<std::string> & callbacks,std::function<void (bool)> && onStatusChanged)745 void FrontendDelegateDeclarativeNG::ShowDialog(const std::string& title, const std::string& message,
746 const std::vector<ButtonInfo>& buttons, bool autoCancel, std::function<void(int32_t, int32_t)>&& callback,
747 const std::set<std::string>& callbacks, std::function<void(bool)>&& onStatusChanged)
748 {
749 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show dialog enter");
750 DialogProperties dialogProperties = {
751 .type = DialogType::ALERT_DIALOG,
752 .title = title,
753 .content = message,
754 .autoCancel = autoCancel,
755 .buttons = buttons,
756 .onStatusChanged = std::move(onStatusChanged),
757 };
758 ShowDialogInner(dialogProperties, std::move(callback), callbacks);
759 }
760
ShowDialog(const PromptDialogAttr & dialogAttr,const std::vector<ButtonInfo> & buttons,std::function<void (int32_t,int32_t)> && callback,const std::set<std::string> & callbacks)761 void FrontendDelegateDeclarativeNG::ShowDialog(const PromptDialogAttr& dialogAttr,
762 const std::vector<ButtonInfo>& buttons, std::function<void(int32_t, int32_t)>&& callback,
763 const std::set<std::string>& callbacks)
764 {
765 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show dialog enter");
766 DialogProperties dialogProperties = {
767 .type = DialogType::ALERT_DIALOG,
768 .title = dialogAttr.title,
769 .content = dialogAttr.message,
770 .autoCancel = dialogAttr.autoCancel,
771 .buttons = buttons,
772 .isShowInSubWindow = dialogAttr.showInSubWindow,
773 .isModal = dialogAttr.isModal,
774 .enableHoverMode = dialogAttr.enableHoverMode,
775 .maskRect = dialogAttr.maskRect,
776 .levelOrder = dialogAttr.levelOrder,
777 .dialogLevelMode = dialogAttr.dialogLevelMode,
778 .dialogLevelUniqueId = dialogAttr.dialogLevelUniqueId,
779 .dialogImmersiveMode = dialogAttr.dialogImmersiveMode,
780 .onDidAppear = dialogAttr.onDidAppear,
781 .onDidDisappear = dialogAttr.onDidDisappear,
782 .onWillAppear = dialogAttr.onWillAppear,
783 .onWillDisappear = dialogAttr.onWillDisappear,
784 };
785 if (dialogAttr.alignment.has_value()) {
786 dialogProperties.alignment = dialogAttr.alignment.value();
787 }
788 if (dialogAttr.offset.has_value()) {
789 dialogProperties.offset = dialogAttr.offset.value();
790 }
791 if (dialogAttr.shadow.has_value()) {
792 dialogProperties.shadow = dialogAttr.shadow.value();
793 }
794 if (dialogAttr.backgroundColor.has_value()) {
795 dialogProperties.backgroundColor = dialogAttr.backgroundColor.value();
796 }
797 if (dialogAttr.backgroundBlurStyle.has_value()) {
798 dialogProperties.backgroundBlurStyle = dialogAttr.backgroundBlurStyle.value();
799 }
800 if (dialogAttr.blurStyleOption.has_value()) {
801 dialogProperties.blurStyleOption = dialogAttr.blurStyleOption.value();
802 }
803 if (dialogAttr.effectOption.has_value()) {
804 dialogProperties.effectOption = dialogAttr.effectOption.value();
805 }
806 if (dialogAttr.hoverModeArea.has_value()) {
807 dialogProperties.hoverModeArea = dialogAttr.hoverModeArea.value();
808 }
809 ShowDialogInner(dialogProperties, std::move(callback), callbacks);
810 }
811
ShowDialog(const PromptDialogAttr & dialogAttr,const std::vector<ButtonInfo> & buttons,std::function<void (int32_t,int32_t)> && callback,const std::set<std::string> & callbacks,std::function<void (bool)> && onStatusChanged)812 void FrontendDelegateDeclarativeNG::ShowDialog(const PromptDialogAttr& dialogAttr,
813 const std::vector<ButtonInfo>& buttons, std::function<void(int32_t, int32_t)>&& callback,
814 const std::set<std::string>& callbacks, std::function<void(bool)>&& onStatusChanged)
815 {
816 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show dialog enter");
817 DialogProperties dialogProperties = {
818 .type = DialogType::ALERT_DIALOG,
819 .title = dialogAttr.title,
820 .content = dialogAttr.message,
821 .autoCancel = dialogAttr.autoCancel,
822 .buttons = buttons,
823 .isShowInSubWindow = dialogAttr.showInSubWindow,
824 .isModal = dialogAttr.isModal,
825 .onStatusChanged = std::move(onStatusChanged),
826 .maskRect = dialogAttr.maskRect,
827 .levelOrder = dialogAttr.levelOrder,
828 };
829 if (dialogAttr.alignment.has_value()) {
830 dialogProperties.alignment = dialogAttr.alignment.value();
831 }
832 if (dialogAttr.offset.has_value()) {
833 dialogProperties.offset = dialogAttr.offset.value();
834 }
835 ShowDialogInner(dialogProperties, std::move(callback), callbacks);
836 }
837
RemoveCustomDialog(int32_t instanceId)838 void FrontendDelegateDeclarativeNG::RemoveCustomDialog(int32_t instanceId)
839 {
840 TAG_LOGI(AceLogTag::ACE_DIALOG, "Dismiss custom dialog, instanceId: %{public}d", instanceId);
841 ContainerScope scope(instanceId);
842 NG::ViewAbstract::DismissDialog();
843 }
844
ParsePartialPropertiesFromAttr(DialogProperties & dialogProperties,const PromptDialogAttr & dialogAttr)845 void FrontendDelegateDeclarativeNG::ParsePartialPropertiesFromAttr(
846 DialogProperties& dialogProperties, const PromptDialogAttr& dialogAttr)
847 {
848 #if defined(PREVIEW)
849 if (dialogProperties.isShowInSubWindow) {
850 LOGW("[Engine Log] Unable to use the SubWindow in the Previewer. Perform this operation on the "
851 "emulator or a real device instead.");
852 dialogProperties.isShowInSubWindow = false;
853 }
854 #endif
855 if (dialogAttr.alignment.has_value()) {
856 dialogProperties.alignment = dialogAttr.alignment.value();
857 }
858 if (dialogAttr.offset.has_value()) {
859 dialogProperties.offset = dialogAttr.offset.value();
860 }
861 if (dialogAttr.hoverModeArea.has_value()) {
862 dialogProperties.hoverModeArea = dialogAttr.hoverModeArea.value();
863 }
864 if (Container::LessThanAPIVersion(PlatformVersion::VERSION_TWELVE)) {
865 dialogProperties.isSysBlurStyle = false;
866 } else {
867 if (dialogAttr.backgroundBlurStyle.has_value()) {
868 dialogProperties.backgroundBlurStyle = dialogAttr.backgroundBlurStyle.value();
869 }
870 }
871 }
872
ParsePropertiesFromAttr(const PromptDialogAttr & dialogAttr)873 DialogProperties FrontendDelegateDeclarativeNG::ParsePropertiesFromAttr(const PromptDialogAttr &dialogAttr)
874 {
875 DialogProperties dialogProperties = {
876 .autoCancel = dialogAttr.autoCancel, .customStyle = dialogAttr.customStyle,
877 .onWillDismiss = dialogAttr.customOnWillDismiss,
878 .onWillDismissRelease = dialogAttr.customOnWillDismissRelease, .maskColor = dialogAttr.maskColor,
879 .backgroundColor = dialogAttr.backgroundColor, .borderRadius = dialogAttr.borderRadius,
880 .isShowInSubWindow = dialogAttr.showInSubWindow, .isModal = dialogAttr.isModal,
881 .enableHoverMode = dialogAttr.enableHoverMode, .customBuilder = dialogAttr.customBuilder,
882 .customBuilderWithId = dialogAttr.customBuilderWithId,
883 .blurStyleOption = dialogAttr.blurStyleOption,
884 .effectOption = dialogAttr.effectOption,
885 .borderWidth = dialogAttr.borderWidth,
886 .borderColor = dialogAttr.borderColor, .borderStyle = dialogAttr.borderStyle, .shadow = dialogAttr.shadow,
887 .width = dialogAttr.width, .height = dialogAttr.height,
888 .isUserCreatedDialog = dialogAttr.isUserCreatedDialog,
889 .maskRect = dialogAttr.maskRect,
890 .transitionEffect = dialogAttr.transitionEffect, .contentNode = dialogAttr.contentNode,
891 .onDidAppear = dialogAttr.onDidAppear, .onDidDisappear = dialogAttr.onDidDisappear,
892 .onWillAppear = dialogAttr.onWillAppear, .onWillDisappear = dialogAttr.onWillDisappear,
893 .keyboardAvoidMode = dialogAttr.keyboardAvoidMode, .dialogCallback = dialogAttr.dialogCallback,
894 .keyboardAvoidDistance = dialogAttr.keyboardAvoidDistance,
895 .levelOrder = dialogAttr.levelOrder,
896 .focusable = dialogAttr.focusable,
897 .dialogLevelMode = dialogAttr.dialogLevelMode,
898 .dialogLevelUniqueId = dialogAttr.dialogLevelUniqueId,
899 .dialogImmersiveMode = dialogAttr.dialogImmersiveMode
900 };
901 ParsePartialPropertiesFromAttr(dialogProperties, dialogAttr);
902 return dialogProperties;
903 }
904
OpenCustomDialog(const PromptDialogAttr & dialogAttr,std::function<void (int32_t)> && callback)905 void FrontendDelegateDeclarativeNG::OpenCustomDialog(const PromptDialogAttr &dialogAttr,
906 std::function<void(int32_t)> &&callback)
907 {
908 DialogProperties dialogProperties = ParsePropertiesFromAttr(dialogAttr);
909 if (Container::IsCurrentUseNewPipeline()) {
910 auto task = [dialogAttr, dialogProperties, callback](const RefPtr<NG::OverlayManager>& overlayManager) mutable {
911 CHECK_NULL_VOID(overlayManager);
912 TAG_LOGD(AceLogTag::ACE_OVERLAY, "Begin to open custom dialog ");
913 if (dialogProperties.isShowInSubWindow) {
914 SubwindowManager::GetInstance()->OpenCustomDialogNG(dialogProperties, std::move(callback));
915 if (dialogProperties.isModal) {
916 TAG_LOGW(AceLogTag::ACE_OVERLAY, "temporary not support isShowInSubWindow and isModal");
917 }
918 } else {
919 overlayManager->OpenCustomDialog(dialogProperties, std::move(callback));
920 }
921 };
922 if (dialogProperties.dialogLevelMode == LevelMode::EMBEDDED) {
923 NG::DialogManager::ShowInEmbeddedOverlay(
924 std::move(task), "ArkUIOverlayShowDialog", dialogProperties.dialogLevelUniqueId);
925 } else {
926 MainWindowOverlay(std::move(task), "ArkUIOverlayOpenCustomDialog", nullptr);
927 }
928 return;
929 } else {
930 TAG_LOGW(AceLogTag::ACE_OVERLAY, "not support old pipeline");
931 }
932 }
933
CloseCustomDialog(const int32_t dialogId)934 void FrontendDelegateDeclarativeNG::CloseCustomDialog(const int32_t dialogId)
935 {
936 auto task = [dialogId](const RefPtr<NG::OverlayManager>& overlayManager) {
937 CHECK_NULL_VOID(overlayManager);
938 TAG_LOGD(AceLogTag::ACE_OVERLAY, "begin to close custom dialog.");
939 overlayManager->CloseCustomDialog(dialogId);
940 SubwindowManager::GetInstance()->CloseCustomDialogNG(dialogId);
941 };
942 auto dialogNode = NG::FrameNode::GetFrameNodeOnly(V2::DIALOG_ETS_TAG, dialogId);
943 auto currentOverlay = NG::DialogManager::GetInstance().GetEmbeddedOverlayWithNode(dialogNode);
944 MainWindowOverlay(std::move(task), "ArkUIOverlayCloseCustomDialog", currentOverlay);
945 return;
946 }
947
CloseCustomDialog(const WeakPtr<NG::UINode> & node,std::function<void (int32_t)> && callback)948 void FrontendDelegateDeclarativeNG::CloseCustomDialog(const WeakPtr<NG::UINode>& node,
949 std::function<void(int32_t)> &&callback)
950 {
951 auto nodePtr = node.Upgrade();
952 CHECK_NULL_VOID(nodePtr);
953 auto context = nodePtr->GetContextWithCheck();
954 CHECK_NULL_VOID(context);
955 auto overlayManager = context->GetOverlayManager();
956 auto parent = NG::DialogManager::GetInstance().GetDialogNodeByContentNode(nodePtr);
957 if (parent) {
958 auto currentOverlay = NG::DialogManager::GetInstance().GetEmbeddedOverlayWithNode(parent);
959 if (currentOverlay) {
960 overlayManager = currentOverlay;
961 }
962 }
963 context->GetTaskExecutor()->PostTask(
964 [node, callback, weak = WeakPtr<NG::OverlayManager>(overlayManager)]() mutable {
965 auto overlayManager = weak.Upgrade();
966 CHECK_NULL_VOID(overlayManager);
967 TAG_LOGI(AceLogTag::ACE_OVERLAY, "begin to close custom dialog.");
968 overlayManager->CloseCustomDialog(node, std::move(callback));
969 },
970 TaskExecutor::TaskType::UI, "ArkUIOverlayCloseCustomDialog");
971 }
972
UpdateCustomDialog(const WeakPtr<NG::UINode> & node,const PromptDialogAttr & dialogAttr,std::function<void (int32_t)> && callback)973 void FrontendDelegateDeclarativeNG::UpdateCustomDialog(
974 const WeakPtr<NG::UINode>& node, const PromptDialogAttr &dialogAttr, std::function<void(int32_t)> &&callback)
975 {
976 DialogProperties dialogProperties = {
977 .autoCancel = dialogAttr.autoCancel,
978 .maskColor = dialogAttr.maskColor,
979 .isSysBlurStyle = false
980 };
981 if (dialogAttr.alignment.has_value()) {
982 dialogProperties.alignment = dialogAttr.alignment.value();
983 }
984 if (dialogAttr.offset.has_value()) {
985 dialogProperties.offset = dialogAttr.offset.value();
986 }
987
988 auto nodePtr = node.Upgrade();
989 CHECK_NULL_VOID(nodePtr);
990 auto context = nodePtr->GetContextWithCheck();
991 CHECK_NULL_VOID(context);
992 auto overlayManager = context->GetOverlayManager();
993 context->GetTaskExecutor()->PostTask(
994 [dialogProperties, node, callback, weak = WeakPtr<NG::OverlayManager>(overlayManager)]() mutable {
995 auto overlayManager = weak.Upgrade();
996 CHECK_NULL_VOID(overlayManager);
997 TAG_LOGI(AceLogTag::ACE_OVERLAY, "begin to update custom dialog.");
998 overlayManager->UpdateCustomDialog(node, dialogProperties, std::move(callback));
999 },
1000 TaskExecutor::TaskType::UI, "ArkUIOverlayUpdateCustomDialog");
1001 }
1002
GetTopOrder()1003 std::optional<double> FrontendDelegateDeclarativeNG::GetTopOrder()
1004 {
1005 auto currentId = Container::CurrentId();
1006 ContainerScope scope(currentId);
1007 auto context = NG::PipelineContext::GetCurrentContext();
1008 CHECK_NULL_RETURN(context, std::nullopt);
1009 auto overlayManager = context->GetOverlayManager();
1010 CHECK_NULL_RETURN(overlayManager, std::nullopt);
1011 return overlayManager->GetTopOrder();
1012 }
1013
GetBottomOrder()1014 std::optional<double> FrontendDelegateDeclarativeNG::GetBottomOrder()
1015 {
1016 auto currentId = Container::CurrentId();
1017 ContainerScope scope(currentId);
1018 auto context = NG::PipelineContext::GetCurrentContext();
1019 CHECK_NULL_RETURN(context, std::nullopt);
1020 auto overlayManager = context->GetOverlayManager();
1021 CHECK_NULL_RETURN(overlayManager, std::nullopt);
1022 return overlayManager->GetBottomOrder();
1023 }
1024
ShowActionMenu(const std::string & title,const std::vector<ButtonInfo> & button,std::function<void (int32_t,int32_t)> && callback)1025 void FrontendDelegateDeclarativeNG::ShowActionMenu(
1026 const std::string& title, const std::vector<ButtonInfo>& button, std::function<void(int32_t, int32_t)>&& callback)
1027 {
1028 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show action menu enter");
1029 DialogProperties dialogProperties = {
1030 .title = title,
1031 .autoCancel = true,
1032 .isMenu = true,
1033 .buttons = button,
1034 };
1035 ShowActionMenuInner(dialogProperties, button, std::move(callback));
1036 }
1037
ShowActionMenu(const std::string & title,const std::vector<ButtonInfo> & button,std::function<void (int32_t,int32_t)> && callback,std::function<void (bool)> && onStatusChanged)1038 void FrontendDelegateDeclarativeNG::ShowActionMenu(const std::string& title, const std::vector<ButtonInfo>& button,
1039 std::function<void(int32_t, int32_t)>&& callback, std::function<void(bool)>&& onStatusChanged)
1040 {
1041 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show action menu enter");
1042 DialogProperties dialogProperties = {
1043 .title = title,
1044 .autoCancel = true,
1045 .isMenu = true,
1046 .buttons = button,
1047 .onStatusChanged = std::move(onStatusChanged),
1048 };
1049 ShowActionMenuInner(dialogProperties, button, std::move(callback));
1050 }
1051
OnMediaQueryUpdate(bool isSynchronous)1052 void FrontendDelegateDeclarativeNG::OnMediaQueryUpdate(bool isSynchronous)
1053 {
1054 auto containerId = Container::CurrentId();
1055 if (containerId < 0) {
1056 auto container = Container::GetActive();
1057 if (container) {
1058 containerId = container->GetInstanceId();
1059 }
1060 }
1061 bool isInSubwindow = containerId >= 1000000;
1062 if (isInSubwindow) {
1063 return;
1064 }
1065 if (mediaQueryInfo_->GetIsInit()) {
1066 return;
1067 }
1068
1069 taskExecutor_->PostTask(
1070 [weak = AceType::WeakClaim(this)] {
1071 auto delegate = weak.Upgrade();
1072 if (!delegate) {
1073 return;
1074 }
1075 const auto& info = delegate->mediaQueryInfo_->GetMediaQueryInfo();
1076
1077 // request js media query
1078 const auto& listenerId = delegate->mediaQueryInfo_->GetListenerId();
1079 delegate->mediaQueryCallback_(listenerId, info);
1080 delegate->mediaQueryInfo_->ResetListenerId();
1081 },
1082 TaskExecutor::TaskType::JS, "ArkUIMediaQueryUpdate");
1083 }
1084
OnLayoutCompleted(const std::string & componentId)1085 void FrontendDelegateDeclarativeNG::OnLayoutCompleted(const std::string& componentId)
1086 {
1087 taskExecutor_->PostTask(
1088 [weak = AceType::WeakClaim(this), componentId] {
1089 auto delegate = weak.Upgrade();
1090 if (!delegate) {
1091 return;
1092 }
1093 delegate->layoutInspectorCallback_(componentId);
1094 },
1095 TaskExecutor::TaskType::JS, "ArkUILayoutCompleted");
1096 }
1097
OnDrawCompleted(const std::string & componentId)1098 void FrontendDelegateDeclarativeNG::OnDrawCompleted(const std::string& componentId)
1099 {
1100 taskExecutor_->PostTask(
1101 [weak = AceType::WeakClaim(this), componentId] {
1102 auto delegate = weak.Upgrade();
1103 if (!delegate) {
1104 return;
1105 }
1106 delegate->drawInspectorCallback_(componentId);
1107 },
1108 TaskExecutor::TaskType::JS, "ArkUIDrawCompleted");
1109 }
1110
OnDrawChildrenCompleted(const std::string & componentId)1111 void FrontendDelegateDeclarativeNG::OnDrawChildrenCompleted(const std::string& componentId)
1112 {
1113 taskExecutor_->PostTask(
1114 [weak = AceType::WeakClaim(this), componentId] {
1115 auto delegate = weak.Upgrade();
1116 if (delegate && delegate->drawChildrenInspectorCallback_) {
1117 delegate->drawChildrenInspectorCallback_(componentId);
1118 }
1119 },
1120 TaskExecutor::TaskType::JS, "ArkUIDrawChildrenCompleted");
1121 }
1122
IsDrawChildrenCallbackFuncExist(const std::string & componentId)1123 bool FrontendDelegateDeclarativeNG::IsDrawChildrenCallbackFuncExist(const std::string& componentId)
1124 {
1125 if (isDrawChildrenCallbackFuncExistCallback_) {
1126 return isDrawChildrenCallbackFuncExistCallback_(componentId);
1127 }
1128 return false;
1129 }
1130
SetColorMode(ColorMode colorMode)1131 void FrontendDelegateDeclarativeNG::SetColorMode(ColorMode colorMode)
1132 {
1133 OnMediaQueryUpdate();
1134 }
1135
OnForeground()1136 void FrontendDelegateDeclarativeNG::OnForeground()
1137 {
1138 if (!isFirstNotifyShow_) {
1139 OnPageShow();
1140 }
1141 isFirstNotifyShow_ = false;
1142 }
1143
GetCurrentPageUrl()1144 std::string FrontendDelegateDeclarativeNG::GetCurrentPageUrl()
1145 {
1146 CHECK_NULL_RETURN(pageRouterManager_, "");
1147 return pageRouterManager_->GetCurrentPageUrl();
1148 }
1149
1150 // Get the currently running JS page information in NG structure.
GetCurrentPageSourceMap()1151 RefPtr<RevSourceMap> FrontendDelegateDeclarativeNG::GetCurrentPageSourceMap()
1152 {
1153 CHECK_NULL_RETURN(pageRouterManager_, nullptr);
1154 return pageRouterManager_->GetCurrentPageSourceMap(assetManager_);
1155 }
1156
1157 // Get the currently running JS page information in NG structure.
GetFaAppSourceMap()1158 RefPtr<RevSourceMap> FrontendDelegateDeclarativeNG::GetFaAppSourceMap()
1159 {
1160 if (appSourceMap_) {
1161 return appSourceMap_;
1162 }
1163 std::string appMap;
1164 if (GetAssetContent("app.js.map", appMap)) {
1165 appSourceMap_ = AceType::MakeRefPtr<RevSourceMap>();
1166 appSourceMap_->Init(appMap);
1167 }
1168 return appSourceMap_;
1169 }
1170
GetStageSourceMap(std::unordered_map<std::string,RefPtr<Framework::RevSourceMap>> & sourceMaps)1171 void FrontendDelegateDeclarativeNG::GetStageSourceMap(
1172 std::unordered_map<std::string, RefPtr<Framework::RevSourceMap>>& sourceMaps)
1173 {
1174 std::string maps;
1175 if (GetAssetContent(MERGE_SOURCEMAPS_PATH, maps)) {
1176 auto SourceMap = AceType::MakeRefPtr<RevSourceMap>();
1177 SourceMap->StageModeSourceMapSplit(maps, sourceMaps);
1178 }
1179 }
1180
CallPopPage()1181 void FrontendDelegateDeclarativeNG::CallPopPage()
1182 {
1183 Back("", "");
1184 }
1185
PostponePageTransition()1186 void FrontendDelegateDeclarativeNG::PostponePageTransition()
1187 {
1188 taskExecutor_->PostTask(
1189 [weak = AceType::WeakClaim(this)] {
1190 auto delegate = weak.Upgrade();
1191 if (!delegate) {
1192 return;
1193 }
1194 auto pipelineContext = delegate->pipelineContextHolder_.Get();
1195 pipelineContext->PostponePageTransition();
1196 },
1197 TaskExecutor::TaskType::UI, "ArkUIPostponePageTransition");
1198 }
1199
LaunchPageTransition()1200 void FrontendDelegateDeclarativeNG::LaunchPageTransition()
1201 {
1202 taskExecutor_->PostTask(
1203 [weak = AceType::WeakClaim(this)] {
1204 auto delegate = weak.Upgrade();
1205 if (!delegate) {
1206 return;
1207 }
1208 auto pipelineContext = delegate->pipelineContextHolder_.Get();
1209 pipelineContext->LaunchPageTransition();
1210 },
1211 TaskExecutor::TaskType::UI, "ArkUILaunchPageTransition");
1212 }
1213
GetComponentsCount()1214 size_t FrontendDelegateDeclarativeNG::GetComponentsCount()
1215 {
1216 CHECK_NULL_RETURN(pageRouterManager_, 0);
1217 auto pageNode = pageRouterManager_->GetCurrentPageNode();
1218 CHECK_NULL_RETURN(pageNode, 0);
1219 return pageNode->GetAllDepthChildrenCount();
1220 }
1221
ShowToast(const NG::ToastInfo & toastInfo,std::function<void (int32_t)> && callback)1222 void FrontendDelegateDeclarativeNG::ShowToast(const NG::ToastInfo& toastInfo, std::function<void(int32_t)>&& callback)
1223 {
1224 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show toast enter");
1225 NG::ToastInfo updatedToastInfo = toastInfo;
1226 updatedToastInfo.duration = std::clamp(toastInfo.duration, TOAST_TIME_DEFAULT, TOAST_TIME_MAX);
1227 updatedToastInfo.isRightToLeft = AceApplicationInfo::GetInstance().IsRightToLeft();
1228 auto task = [updatedToastInfo, callbackParam = std::move(callback), containerId = Container::CurrentId()](
1229 const RefPtr<NG::OverlayManager>& overlayManager) {
1230 CHECK_NULL_VOID(overlayManager);
1231 ContainerScope scope(containerId);
1232 overlayManager->ShowToast(
1233 updatedToastInfo, std::move(const_cast<std::function<void(int32_t)>&&>(callbackParam)));
1234 };
1235 MainWindowOverlay(std::move(task), "ArkUIOverlayShowToast", nullptr);
1236 }
1237
CloseToast(const int32_t toastId,std::function<void (int32_t)> && callback)1238 void FrontendDelegateDeclarativeNG::CloseToast(const int32_t toastId, std::function<void(int32_t)>&& callback)
1239 {
1240 TAG_LOGD(AceLogTag::ACE_OVERLAY, "close toast enter");
1241 auto currentId = Container::CurrentId();
1242 ContainerScope scope(currentId);
1243 auto context = NG::PipelineContext::GetCurrentContext();
1244 CHECK_NULL_VOID(context);
1245 auto overlayManager = context->GetOverlayManager();
1246 CHECK_NULL_VOID(overlayManager);
1247 overlayManager->CloseToast(toastId, std::move(callback));
1248 }
1249
ShowDialogInner(DialogProperties & dialogProperties,std::function<void (int32_t,int32_t)> && callback,const std::set<std::string> & callbacks)1250 void FrontendDelegateDeclarativeNG::ShowDialogInner(DialogProperties& dialogProperties,
1251 std::function<void(int32_t, int32_t)>&& callback, const std::set<std::string>& callbacks)
1252 {
1253 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show dialog inner enter");
1254 dialogProperties.onSuccess = std::move(callback);
1255 dialogProperties.onCancel = [callback, taskExecutor = taskExecutor_] {
1256 taskExecutor->PostTask(
1257 [callback]() { callback(CALLBACK_ERRORCODE_CANCEL, CALLBACK_DATACODE_ZERO); },
1258 TaskExecutor::TaskType::JS, "ArkUIOverlayShowDialogCancel");
1259 };
1260 auto task = [dialogProperties](const RefPtr<NG::OverlayManager>& overlayManager) {
1261 LOGI("Begin to show dialog ");
1262 CHECK_NULL_VOID(overlayManager);
1263 auto container = Container::Current();
1264 CHECK_NULL_VOID(container);
1265 if (container->IsSubContainer()) {
1266 auto currentId = SubwindowManager::GetInstance()->GetParentContainerId(Container::CurrentId());
1267 container = AceEngine::Get().GetContainer(currentId);
1268 CHECK_NULL_VOID(container);
1269 }
1270 RefPtr<NG::FrameNode> dialog;
1271 if (dialogProperties.isShowInSubWindow) {
1272 dialog = SubwindowManager::GetInstance()->ShowDialogNG(dialogProperties, nullptr);
1273 CHECK_NULL_VOID(dialog);
1274 if (dialogProperties.isModal && !container->IsUIExtensionWindow()) {
1275 DialogProperties Maskarg;
1276 Maskarg.isMask = true;
1277 Maskarg.autoCancel = dialogProperties.autoCancel;
1278 auto mask = overlayManager->ShowDialog(Maskarg, nullptr, false);
1279 CHECK_NULL_VOID(mask);
1280 overlayManager->SetMaskNodeId(dialog->GetId(), mask->GetId());
1281 }
1282 } else {
1283 dialog = overlayManager->ShowDialog(
1284 dialogProperties, nullptr, AceApplicationInfo::GetInstance().IsRightToLeft());
1285 CHECK_NULL_VOID(dialog);
1286 }
1287 };
1288 if (dialogProperties.dialogLevelMode == LevelMode::EMBEDDED) {
1289 NG::DialogManager::ShowInEmbeddedOverlay(
1290 std::move(task), "ArkUIOverlayShowDialog", dialogProperties.dialogLevelUniqueId);
1291 } else {
1292 MainWindowOverlay(std::move(task), "ArkUIOverlayShowDialog", nullptr);
1293 }
1294 return;
1295 }
1296
ShowActionMenuInner(DialogProperties & dialogProperties,const std::vector<ButtonInfo> & button,std::function<void (int32_t,int32_t)> && callback)1297 void FrontendDelegateDeclarativeNG::ShowActionMenuInner(DialogProperties& dialogProperties,
1298 const std::vector<ButtonInfo>& button, std::function<void(int32_t, int32_t)>&& callback)
1299 {
1300 TAG_LOGD(AceLogTag::ACE_OVERLAY, "show action menu inner enter");
1301 dialogProperties.onSuccess = std::move(callback);
1302 dialogProperties.onCancel = [callback, taskExecutor = taskExecutor_] {
1303 taskExecutor->PostTask(
1304 [callback]() { callback(CALLBACK_ERRORCODE_CANCEL, CALLBACK_DATACODE_ZERO); },
1305 TaskExecutor::TaskType::JS, "ArkUIOverlayShowActionMenuCancel");
1306 };
1307 auto context = DynamicCast<NG::PipelineContext>(pipelineContextHolder_.Get());
1308 auto overlayManager = context ? context->GetOverlayManager() : nullptr;
1309 taskExecutor_->PostTask(
1310 [dialogProperties, weak = WeakPtr<NG::OverlayManager>(overlayManager)] {
1311 auto overlayManager = weak.Upgrade();
1312 CHECK_NULL_VOID(overlayManager);
1313 overlayManager->ShowDialog(dialogProperties, nullptr, AceApplicationInfo::GetInstance().IsRightToLeft());
1314 },
1315 TaskExecutor::TaskType::UI, "ArkUIOverlayShowActionMenu");
1316 return;
1317 }
1318
EnableAlertBeforeBackPage(const std::string & message,std::function<void (int32_t)> && callback)1319 void FrontendDelegateDeclarativeNG::EnableAlertBeforeBackPage(
1320 const std::string& message, std::function<void(int32_t)>&& callback)
1321 {
1322 CHECK_NULL_VOID(pageRouterManager_);
1323 pageRouterManager_->EnableAlertBeforeBackPage(message, std::move(callback));
1324 return;
1325 }
1326
DisableAlertBeforeBackPage()1327 void FrontendDelegateDeclarativeNG::DisableAlertBeforeBackPage()
1328 {
1329 CHECK_NULL_VOID(pageRouterManager_);
1330 pageRouterManager_->DisableAlertBeforeBackPage();
1331 return;
1332 }
1333
RebuildAllPages()1334 void FrontendDelegateDeclarativeNG::RebuildAllPages()
1335 {
1336 CHECK_NULL_VOID(pageRouterManager_);
1337 auto url = pageRouterManager_->GetCurrentPageUrl();
1338 pageRouterManager_->Clear();
1339 pageRouterManager_->RunPage(url, "");
1340 return;
1341 }
1342
OnPageShow()1343 void FrontendDelegateDeclarativeNG::OnPageShow()
1344 {
1345 CHECK_NULL_VOID(pageRouterManager_);
1346 auto pageNode = pageRouterManager_->GetCurrentPageNode();
1347 CHECK_NULL_VOID(pageNode);
1348 auto pagePattern = pageNode->GetPattern<NG::PagePattern>();
1349 CHECK_NULL_VOID(pagePattern);
1350 pagePattern->OnShow();
1351 }
1352
OnPageHide()1353 void FrontendDelegateDeclarativeNG::OnPageHide()
1354 {
1355 CHECK_NULL_VOID(pageRouterManager_);
1356 auto pageNode = pageRouterManager_->GetCurrentPageNode();
1357 CHECK_NULL_VOID(pageNode);
1358 auto pagePattern = pageNode->GetPattern<NG::PagePattern>();
1359 CHECK_NULL_VOID(pagePattern);
1360 pagePattern->OnHide();
1361 }
1362
GetSnapshot(const std::string & componentId,NG::ComponentSnapshot::JsCallback && callback,const NG::SnapshotOptions & options)1363 void FrontendDelegateDeclarativeNG::GetSnapshot(
1364 const std::string& componentId, NG::ComponentSnapshot::JsCallback&& callback, const NG::SnapshotOptions& options)
1365 {
1366 #ifdef ENABLE_ROSEN_BACKEND
1367 NG::ComponentSnapshot::Get(componentId, std::move(callback), options);
1368 #endif
1369 }
1370
GetSyncSnapshot(RefPtr<NG::FrameNode> & node,const NG::SnapshotOptions & options)1371 std::pair<int32_t, std::shared_ptr<Media::PixelMap>> FrontendDelegateDeclarativeNG::GetSyncSnapshot(
1372 RefPtr<NG::FrameNode>& node, const NG::SnapshotOptions& options)
1373 {
1374 #ifdef ENABLE_ROSEN_BACKEND
1375 return NG::ComponentSnapshot::GetSync(node, options);
1376 #endif
1377 return { ERROR_CODE_INTERNAL_ERROR, nullptr };
1378 }
1379
GetSyncSnapshot(const std::string & componentId,const NG::SnapshotOptions & options)1380 std::pair<int32_t, std::shared_ptr<Media::PixelMap>> FrontendDelegateDeclarativeNG::GetSyncSnapshot(
1381 const std::string& componentId, const NG::SnapshotOptions& options)
1382 {
1383 #ifdef ENABLE_ROSEN_BACKEND
1384 return NG::ComponentSnapshot::GetSync(componentId, options);
1385 #endif
1386 return {ERROR_CODE_INTERNAL_ERROR, nullptr};
1387 }
1388
GetSnapshotByUniqueId(int32_t uniqueId,std::function<void (std::shared_ptr<Media::PixelMap>,int32_t,std::function<void ()>)> && callback,const NG::SnapshotOptions & options)1389 void FrontendDelegateDeclarativeNG::GetSnapshotByUniqueId(int32_t uniqueId,
1390 std::function<void(std::shared_ptr<Media::PixelMap>, int32_t, std::function<void()>)>&& callback,
1391 const NG::SnapshotOptions& options)
1392 {
1393 #ifdef ENABLE_ROSEN_BACKEND
1394 NG::ComponentSnapshot::GetByUniqueId(uniqueId, std::move(callback), options);
1395 #endif
1396 }
1397
GetSyncSnapshotByUniqueId(int32_t uniqueId,const NG::SnapshotOptions & options)1398 std::pair<int32_t, std::shared_ptr<Media::PixelMap>> FrontendDelegateDeclarativeNG::GetSyncSnapshotByUniqueId(
1399 int32_t uniqueId, const NG::SnapshotOptions& options)
1400 {
1401 #ifdef ENABLE_ROSEN_BACKEND
1402 return NG::ComponentSnapshot::GetSyncByUniqueId(uniqueId, options);
1403 #endif
1404 return {ERROR_CODE_INTERNAL_ERROR, nullptr};
1405 }
1406
GetSnapshotWithRange(const NG::NodeIdentity & startID,const NG::NodeIdentity & endID,const bool isStartRect,std::function<void (std::shared_ptr<Media::PixelMap>,int32_t,std::function<void ()>)> && callback,const NG::SnapshotOptions & options)1407 void FrontendDelegateDeclarativeNG::GetSnapshotWithRange(const NG::NodeIdentity& startID, const NG::NodeIdentity& endID,
1408 const bool isStartRect,
1409 std::function<void(std::shared_ptr<Media::PixelMap>, int32_t, std::function<void()>)>&& callback,
1410 const NG::SnapshotOptions& options)
1411 {
1412 #ifdef ENABLE_ROSEN_BACKEND
1413 NG::ComponentSnapshot::GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1414 #endif
1415 }
1416
CreateSnapshotFromComponent(const RefPtr<NG::UINode> & nodeWk,NG::ComponentSnapshot::JsCallback && callback,bool enableInspector,const NG::SnapshotParam & param)1417 void FrontendDelegateDeclarativeNG::CreateSnapshotFromComponent(const RefPtr<NG::UINode>& nodeWk,
1418 NG::ComponentSnapshot::JsCallback&& callback, bool enableInspector, const NG::SnapshotParam& param)
1419 {
1420 #ifdef ENABLE_ROSEN_BACKEND
1421 ViewStackModel::GetInstance()->NewScope();
1422 NG::ComponentSnapshot::Create(nodeWk, std::move(callback), enableInspector, param);
1423 #endif
1424 }
1425
GetContentInfo(ContentInfoType type)1426 std::string FrontendDelegateDeclarativeNG::GetContentInfo(ContentInfoType type)
1427 {
1428 auto jsonContentInfo = JsonUtil::Create(true);
1429
1430 CHECK_NULL_RETURN(pageRouterManager_, "");
1431 jsonContentInfo->Put("stackInfo", pageRouterManager_->GetStackInfo(type));
1432 if (type == ContentInfoType::RESOURCESCHEDULE_RECOVERY) {
1433 auto namedRouterInfo = pageRouterManager_->GetNamedRouterInfo();
1434 if (namedRouterInfo) {
1435 jsonContentInfo->Put("namedRouterInfo", std::move(namedRouterInfo));
1436 }
1437 }
1438
1439 if (type == ContentInfoType::CONTINUATION || type == ContentInfoType::APP_RECOVERY) {
1440 auto pipelineContext = pipelineContextHolder_.Get();
1441 CHECK_NULL_RETURN(pipelineContext, jsonContentInfo->ToString());
1442 jsonContentInfo->Put("nodeInfo", pipelineContext->GetStoredNodeInfo());
1443 }
1444
1445 return jsonContentInfo->ToString();
1446 }
1447
CreateSnapshot(std::function<void ()> && customBuilder,NG::ComponentSnapshot::JsCallback && callback,bool enableInspector,const NG::SnapshotParam & param)1448 void FrontendDelegateDeclarativeNG::CreateSnapshot(
1449 std::function<void()>&& customBuilder, NG::ComponentSnapshot::JsCallback&& callback, bool enableInspector,
1450 const NG::SnapshotParam& param)
1451 {
1452 #ifdef ENABLE_ROSEN_BACKEND
1453 ViewStackModel::GetInstance()->NewScope();
1454 CHECK_NULL_VOID(customBuilder);
1455 customBuilder();
1456 auto customNode = ViewStackModel::GetInstance()->Finish();
1457
1458 NG::ComponentSnapshot::Create(customNode, std::move(callback), enableInspector, param);
1459 #endif
1460 }
1461
AddFrameNodeToOverlay(const RefPtr<NG::FrameNode> & node,std::optional<int32_t> index)1462 void FrontendDelegateDeclarativeNG::AddFrameNodeToOverlay(
1463 const RefPtr<NG::FrameNode>& node, std::optional<int32_t> index)
1464 {
1465 auto task = [node, index, containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1466 CHECK_NULL_VOID(overlayManager);
1467 ContainerScope scope(containerId);
1468 overlayManager->AddFrameNodeToOverlay(node, index);
1469 };
1470 MainWindowOverlay(std::move(task), "ArkUIOverlayAddFrameNode", nullptr);
1471 }
1472
AddFrameNodeWithOrder(const RefPtr<NG::FrameNode> & node,std::optional<double> levelOrder)1473 void FrontendDelegateDeclarativeNG::AddFrameNodeWithOrder(
1474 const RefPtr<NG::FrameNode>& node, std::optional<double> levelOrder)
1475 {
1476 CHECK_NULL_VOID(node);
1477 auto pipelineContext = node->GetContext();
1478 CHECK_NULL_VOID(pipelineContext);
1479 auto overlayManager = pipelineContext->GetOverlayManager();
1480 CHECK_NULL_VOID(overlayManager);
1481 overlayManager->AddFrameNodeWithOrder(node, levelOrder);
1482 }
1483
RemoveFrameNodeOnOverlay(const RefPtr<NG::FrameNode> & node)1484 void FrontendDelegateDeclarativeNG::RemoveFrameNodeOnOverlay(const RefPtr<NG::FrameNode>& node)
1485 {
1486 auto task = [node, containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1487 CHECK_NULL_VOID(overlayManager);
1488 ContainerScope scope(containerId);
1489 overlayManager->RemoveFrameNodeOnOverlay(node);
1490 };
1491 MainWindowOverlay(std::move(task), "ArkUIOverlayRemoveFrameNode", nullptr);
1492 }
1493
ShowNodeOnOverlay(const RefPtr<NG::FrameNode> & node)1494 void FrontendDelegateDeclarativeNG::ShowNodeOnOverlay(const RefPtr<NG::FrameNode>& node)
1495 {
1496 auto task = [node, containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1497 CHECK_NULL_VOID(overlayManager);
1498 ContainerScope scope(containerId);
1499 overlayManager->ShowNodeOnOverlay(node);
1500 };
1501 MainWindowOverlay(std::move(task), "ArkUIOverlayShowNode", nullptr);
1502 }
1503
HideNodeOnOverlay(const RefPtr<NG::FrameNode> & node)1504 void FrontendDelegateDeclarativeNG::HideNodeOnOverlay(const RefPtr<NG::FrameNode>& node)
1505 {
1506 auto task = [node, containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1507 CHECK_NULL_VOID(overlayManager);
1508 ContainerScope scope(containerId);
1509 overlayManager->HideNodeOnOverlay(node);
1510 };
1511 MainWindowOverlay(std::move(task), "ArkUIOverlayHideNode", nullptr);
1512 }
1513
ShowAllNodesOnOverlay()1514 void FrontendDelegateDeclarativeNG::ShowAllNodesOnOverlay()
1515 {
1516 auto task = [containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1517 CHECK_NULL_VOID(overlayManager);
1518 ContainerScope scope(containerId);
1519 overlayManager->ShowAllNodesOnOverlay();
1520 };
1521 MainWindowOverlay(std::move(task), "ArkUIOverlayShowAllNodes", nullptr);
1522 }
1523
HideAllNodesOnOverlay()1524 void FrontendDelegateDeclarativeNG::HideAllNodesOnOverlay()
1525 {
1526 auto task = [containerId = Container::CurrentId()](const RefPtr<NG::OverlayManager>& overlayManager) {
1527 CHECK_NULL_VOID(overlayManager);
1528 ContainerScope scope(containerId);
1529 overlayManager->HideAllNodesOnOverlay();
1530 };
1531 MainWindowOverlay(std::move(task), "ArkUIOverlayHideAllNodes", nullptr);
1532 }
1533
SetOverlayManagerOptions(const NG::OverlayManagerInfo & overlayInfo)1534 bool FrontendDelegateDeclarativeNG::SetOverlayManagerOptions(const NG::OverlayManagerInfo& overlayInfo)
1535 {
1536 auto context = NG::PipelineContext::GetCurrentContext();
1537 CHECK_NULL_RETURN(context, false);
1538 auto overlayManager = context->GetOverlayManager();
1539 CHECK_NULL_RETURN(overlayManager, false);
1540 return overlayManager->SetOverlayManagerOptions(overlayInfo);
1541 };
GetOverlayManagerOptions()1542 std::optional<NG::OverlayManagerInfo> FrontendDelegateDeclarativeNG::GetOverlayManagerOptions()
1543 {
1544 auto context = NG::PipelineContext::GetCurrentContext();
1545 CHECK_NULL_RETURN(context, std::nullopt);
1546 auto overlayManager = context->GetOverlayManager();
1547 CHECK_NULL_RETURN(context, std::nullopt);
1548 return overlayManager->GetOverlayManagerOptions();
1549 };
1550 } // namespace OHOS::Ace::Framework
1551