1 /*
2 * Copyright (c) 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 #include "core/components_ng/pattern/ui_extension/dynamic_component/dynamic_pattern.h"
17
18 #include "adapter/ohos/entrance/ace_container.h"
19 #include "adapter/ohos/entrance/mmi_event_convertor.h"
20 #include "adapter/ohos/osal/want_wrap_ohos.h"
21 #include "base/log/log_wrapper.h"
22 #include "base/log/dump_log.h"
23 #include "core/components_ng/pattern/ui_extension/platform_utils.h"
24 #include "core/components_ng/render/animation_utils.h"
25 #include "core/pipeline_ng/pipeline_context.h"
26 #include "display_manager.h"
27 #include "parameters.h"
28
29 namespace OHOS::Ace::NG {
30 namespace {
31 constexpr char DC_DEPTH_PREFIX[] = "dcDepth_";
32 constexpr char PARAM_NAME_DC_EXCEED_MAX_NUM[] = "dcExceedMaxNumInWorker";
33 constexpr char PARAM_MSG_DC_EXCEED_MAX_NUM[] = "Dc exceed max num in the worker";
34 constexpr char PARAM_NAME_DC_ONLY_ON_SCB[] = "onlyRunOnSCB";
35 constexpr char PARAM_MSG_DC_ONLY_ON_SCB[] = "DC only run on SCB";
36 constexpr char PARAM_NAME_INTERNAL_ERROR[] = "internalError";
37 constexpr char PARAM_MSG_INTERNAL_ERROR[] = "Internal error";
38 constexpr char PARAM_NAME_PARAM_ERROR[] = "paramError";
39 constexpr char PARAM_MSG_PARAM_ERROR[] = "Param error";
40 constexpr char PARAM_NAME_NOT_SUPPORT_UI_CONTENT_TYPE[] = "notSupportUIContentType";
41 constexpr char PARAM_MSG_NOT_SUPPORT_UI_CONTENT_TYPE[] = "Not support uIContent type";
42 constexpr char PARAM_NAME_EXCEED_MAX_NUM[] = "exceedMaxNum";
43 constexpr char PARAM_MSG_EXCEED_MAX_NUM[] = "Workers exceed Max Num";
44 const char ENABLE_DEBUG_DC_KEY[] = "persist.ace.debug.dc.enabled";
45 constexpr double SHOW_START = 0.0;
46 constexpr double SHOW_FULL = 1.0;
47
IsDebugDCEnabled()48 bool IsDebugDCEnabled()
49 {
50 return OHOS::system::GetParameter(ENABLE_DEBUG_DC_KEY, "false") == "true";
51 }
52 }
53
54 int32_t DynamicPattern::dynamicGenerator_ = 0;
55
56 class DCAccessibilitySAObserverCallback : public AccessibilitySAObserverCallback {
57 public:
DCAccessibilitySAObserverCallback(const WeakPtr<DynamicPattern> & weakPattern,int64_t accessibilityId)58 DCAccessibilitySAObserverCallback(
59 const WeakPtr<DynamicPattern>& weakPattern, int64_t accessibilityId)
60 : AccessibilitySAObserverCallback(accessibilityId), weakUECPattern_(weakPattern) {}
61 ~DCAccessibilitySAObserverCallback() override = default;
62
OnState(bool state)63 bool OnState(bool state) override
64 {
65 auto pattern = weakUECPattern_.Upgrade();
66 CHECK_NULL_RETURN(pattern, false);
67 if (state) {
68 // first time turn on Accessibility, add TransferAccessibilityRectInfo
69 pattern->TransferAccessibilityRectInfo(true);
70 }
71
72 return true;
73 }
74
75 private:
76 WeakPtr<DynamicPattern> weakUECPattern_;
77 };
78
DynamicPattern()79 DynamicPattern::DynamicPattern()
80 : PlatformPattern(AceLogTag::ACE_DYNAMIC_COMPONENT, ++dynamicGenerator_)
81 {
82 uiExtensionId_ = UIExtensionIdUtility::GetInstance().ApplyExtensionId();
83 instanceId_ = -1;
84 PLATFORM_LOGI("The DynamicPattern is created.");
85 }
86
~DynamicPattern()87 DynamicPattern::~DynamicPattern()
88 {
89 UIExtensionIdUtility::GetInstance().RecycleExtensionId(uiExtensionId_);
90 PLATFORM_LOGI("The DynamicPattern is destroyed.");
91 }
92
WrapExtensionAbilityId(int64_t extensionOffset,int64_t abilityId)93 int64_t DynamicPattern::WrapExtensionAbilityId(int64_t extensionOffset, int64_t abilityId)
94 {
95 return uiExtensionId_ * extensionOffset + abilityId;
96 }
97
GetAccessibilitySessionAdapter()98 RefPtr<AccessibilitySessionAdapter> DynamicPattern::GetAccessibilitySessionAdapter()
99 {
100 return accessibilitySessionAdapter_;
101 }
102
InitializeDynamicComponent(const std::string & hapPath,const std::string & abcPath,const std::string & entryPoint,void * runtime)103 void DynamicPattern::InitializeDynamicComponent(
104 const std::string& hapPath, const std::string& abcPath, const std::string& entryPoint, void* runtime)
105 {
106 if (entryPoint.empty() || runtime == nullptr) {
107 PLATFORM_LOGE("The param empty.");
108 HandleErrorCallback(DCResultCode::DC_PARAM_ERROE);
109 return;
110 }
111
112 curDynamicInfo_.entryPoint = entryPoint;
113 InitializeRender(runtime);
114 RegisterVisibleAreaChange();
115 }
116
HandleErrorCallback(DCResultCode resultCode)117 void DynamicPattern::HandleErrorCallback(DCResultCode resultCode)
118 {
119 switch (resultCode) {
120 case DCResultCode::DC_EXCEED_MAX_NUM_IN_WORKER:
121 FireOnErrorCallbackOnUI(
122 resultCode, PARAM_NAME_DC_EXCEED_MAX_NUM, PARAM_MSG_DC_EXCEED_MAX_NUM);
123 break;
124 case DCResultCode::DC_ONLY_RUN_ON_SCB:
125 FireOnErrorCallbackOnUI(
126 resultCode, PARAM_NAME_DC_ONLY_ON_SCB, PARAM_MSG_DC_ONLY_ON_SCB);
127 break;
128 case DCResultCode::DC_INTERNAL_ERROR:
129 FireOnErrorCallbackOnUI(
130 resultCode, PARAM_NAME_INTERNAL_ERROR, PARAM_MSG_INTERNAL_ERROR);
131 break;
132 case DCResultCode::DC_PARAM_ERROE:
133 FireOnErrorCallbackOnUI(
134 resultCode, PARAM_NAME_PARAM_ERROR, PARAM_MSG_PARAM_ERROR);
135 break;
136 case DCResultCode::DC_NOT_SUPPORT_UI_CONTENT_TYPE:
137 FireOnErrorCallbackOnUI(
138 resultCode, PARAM_NAME_NOT_SUPPORT_UI_CONTENT_TYPE, PARAM_MSG_NOT_SUPPORT_UI_CONTENT_TYPE);
139 break;
140 case DCResultCode::DC_WORKER_EXCEED_MAX_NUM:
141 FireOnErrorCallbackOnUI(
142 resultCode, PARAM_NAME_EXCEED_MAX_NUM, PARAM_MSG_EXCEED_MAX_NUM);
143 break;
144 default:
145 PLATFORM_LOGI("HandleErrorCallback code: %{public}d is invalid.", resultCode);
146 }
147 }
148
CheckConstraint()149 DCResultCode DynamicPattern::CheckConstraint()
150 {
151 auto instanceId = GetHostInstanceId();
152 PLATFORM_LOGI("CheckConstraint instanceId: %{public}d.", instanceId);
153 auto container = Platform::AceContainer::GetContainer(instanceId);
154 if (!container) {
155 PLATFORM_LOGE("container is null.");
156 return DCResultCode::DC_INTERNAL_ERROR;
157 }
158
159 UIContentType uIContentType = container->GetUIContentType();
160 static std::set<UIContentType> dcNotSupportUIContentType = {
161 UIContentType::ISOLATED_COMPONENT,
162 UIContentType::DYNAMIC_COMPONENT
163 };
164
165 if (dcNotSupportUIContentType.find(uIContentType) != dcNotSupportUIContentType.end()) {
166 PLATFORM_LOGE("Not support dc in uIContentType: %{public}d.",
167 static_cast<int32_t>(uIContentType));
168 return DCResultCode::DC_NOT_SUPPORT_UI_CONTENT_TYPE;
169 }
170
171 if (container->IsSceneBoardWindow()) {
172 return DCResultCode::DC_NO_ERRORS;
173 }
174
175 return IsDebugDCEnabled() ? DCResultCode::DC_NO_ERRORS : DCResultCode::DC_ONLY_RUN_ON_SCB;
176 }
177
CheckDynamicRendererConstraint(void * runtime)178 bool DynamicPattern::CheckDynamicRendererConstraint(void* runtime)
179 {
180 CHECK_NULL_RETURN(dynamicComponentRenderer_, false);
181 if (!dynamicComponentRenderer_->CheckDCMaxConstraintInWorker(runtime)) {
182 HandleErrorCallback(DCResultCode::DC_EXCEED_MAX_NUM_IN_WORKER);
183 return false;
184 }
185
186 if (!dynamicComponentRenderer_->CheckWorkerMaxConstraint(runtime)) {
187 HandleErrorCallback(DCResultCode::DC_WORKER_EXCEED_MAX_NUM);
188 return false;
189 }
190
191 return true;
192 }
193
InitializeRender(void * runtime)194 void DynamicPattern::InitializeRender(void* runtime)
195 {
196 auto host = GetHost();
197 CHECK_NULL_VOID(host);
198 dynamicDumpInfo_.createLimitedWorkerTime = GetCurrentTimestamp();
199 #if !defined(PREVIEW)
200 auto code = CheckConstraint();
201 if (code != DCResultCode::DC_NO_ERRORS) {
202 HandleErrorCallback(code);
203 PLATFORM_LOGE("CheckConstraint failed, code: %{public}d.", code);
204 return;
205 }
206
207 if (!dynamicComponentRenderer_) {
208 ContainerScope scope(instanceId_);
209 SetHostNode(host);
210 dynamicComponentRenderer_ =
211 DynamicComponentRenderer::Create(GetHost(), runtime, curDynamicInfo_);
212 if (!CheckDynamicRendererConstraint(runtime)) {
213 return;
214 }
215
216 dynamicComponentRenderer_->SetUIContentType(UIContentType::DYNAMIC_COMPONENT);
217 dynamicComponentRenderer_->SetAdaptiveSize(adaptiveWidth_, adaptiveHeight_);
218 dynamicComponentRenderer_->SetBackgroundTransparent(backgroundTransparent_);
219 dynamicComponentRenderer_->CreateContent();
220 accessibilitySessionAdapter_ =
221 AceType::MakeRefPtr<AccessibilitySessionAdapterIsolatedComponent>(dynamicComponentRenderer_);
222 SetContainerHostPattern(WeakClaim(this));
223 auto eventHub = host->GetOrCreateEventHub<EventHub>();
224 CHECK_NULL_VOID(eventHub);
225 OnAreaChangedFunc onAreaChangedFunc = [renderer = dynamicComponentRenderer_](
226 const RectF& oldRect,
227 const OffsetF& oldOrigin,
228 const RectF& rect,
229 const OffsetF& origin) {
230 CHECK_NULL_VOID(renderer);
231 renderer->UpdateParentOffsetToWindow(origin + rect.GetOffset());
232 };
233 eventHub->AddInnerOnAreaChangedCallback(host->GetId(), std::move(onAreaChangedFunc));
234 }
235 #else
236 PLATFORM_LOGE("DynamicComponent not support preview.");
237 #endif
238 }
239
SetBackgroundTransparent(bool backgroundTransparent)240 void DynamicPattern::SetBackgroundTransparent(bool backgroundTransparent)
241 {
242 backgroundTransparent_ = backgroundTransparent;
243 }
244
OnAccessibilityParentRectInfoUpdate()245 void DynamicPattern::OnAccessibilityParentRectInfoUpdate()
246 {
247 CHECK_NULL_VOID(dynamicComponentRenderer_);
248 dynamicComponentRenderer_->OnAccessibilityParentRectInfoUpdate();
249 }
250
FireOnErrorCallbackOnUI(int32_t code,const std::string & name,const std::string & msg)251 void DynamicPattern::FireOnErrorCallbackOnUI(
252 int32_t code, const std::string& name, const std::string& msg)
253 {
254 ContainerScope scope(instanceId_);
255 auto host = GetHost();
256 CHECK_NULL_VOID(host);
257 auto pipeline = host->GetContext();
258 CHECK_NULL_VOID(pipeline);
259 auto uiTaskExecutor = SingleTaskExecutor::Make(
260 pipeline->GetTaskExecutor(), TaskExecutor::TaskType::UI);
261 uiTaskExecutor.PostTask([weak = WeakClaim(this), code, name, msg] {
262 auto pattern = weak.Upgrade();
263 CHECK_NULL_VOID(pattern);
264 pattern->FireOnErrorCallback(code, name, msg);
265 }, "FireOnErrorCallback");
266 }
267
DispatchPointerEvent(const std::shared_ptr<MMI::PointerEvent> & pointerEvent)268 void DynamicPattern::DispatchPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent)
269 {
270 CHECK_NULL_VOID(pointerEvent);
271 CHECK_NULL_VOID(dynamicComponentRenderer_);
272 dynamicComponentRenderer_->TransferPointerEvent(pointerEvent);
273 }
274
DispatchFocusActiveEvent(bool isFocusActive)275 void DynamicPattern::DispatchFocusActiveEvent(bool isFocusActive)
276 {
277 CHECK_NULL_VOID(dynamicComponentRenderer_);
278 dynamicComponentRenderer_->TransferFocusActiveEvent(isFocusActive);
279 }
280
HandleKeyEvent(const KeyEvent & event)281 bool DynamicPattern::HandleKeyEvent(const KeyEvent& event)
282 {
283 CHECK_NULL_RETURN(event.rawKeyEvent, false);
284 CHECK_NULL_RETURN(dynamicComponentRenderer_, false);
285 return dynamicComponentRenderer_->TransferKeyEvent(event);
286 }
287
HandleFocusEvent()288 void DynamicPattern::HandleFocusEvent()
289 {
290 CHECK_NULL_VOID(dynamicComponentRenderer_);
291 auto host = GetHost();
292 CHECK_NULL_VOID(host);
293 auto pipeline = host->GetContext();
294 CHECK_NULL_VOID(pipeline);
295 if (pipeline->GetIsFocusActive()) {
296 dynamicComponentRenderer_->TransferFocusActiveEvent(true);
297 }
298 dynamicComponentRenderer_->TransferFocusState(true);
299 }
300
HandleBlurEvent()301 void DynamicPattern::HandleBlurEvent()
302 {
303 CHECK_NULL_VOID(dynamicComponentRenderer_);
304 dynamicComponentRenderer_->TransferFocusActiveEvent(false);
305 dynamicComponentRenderer_->TransferFocusState(false);
306 }
307
OnAttachToFrameNode()308 void DynamicPattern::OnAttachToFrameNode()
309 {
310 ContainerScope scope(instanceId_);
311 auto host = GetHost();
312 CHECK_NULL_VOID(host);
313 auto pipeline = host->GetContext();
314 CHECK_NULL_VOID(pipeline);
315 pipeline->AddOnAreaChangeNode(host->GetId());
316 }
317
OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper> & dirty,const DirtySwapConfig & config)318 bool DynamicPattern::OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config)
319 {
320 if (config.skipLayout || config.skipMeasure) {
321 return false;
322 }
323 CHECK_NULL_RETURN(dynamicComponentRenderer_, false);
324 auto& node = dirty->GetGeometryNode();
325 CHECK_NULL_RETURN(node, false);
326 auto size = node->GetContentSize();
327
328 auto host = GetHost();
329 CHECK_NULL_RETURN(host, false);
330 auto pipeline = host->GetContext();
331 CHECK_NULL_RETURN(pipeline, false);
332 float density = pipeline->GetDensity();
333 int32_t orientation = 0;
334 auto container = Platform::AceContainer::GetContainer(instanceId_);
335 if (container) {
336 orientation = static_cast<int32_t>(container->GetOrientation());
337 }
338
339 auto animationOption = pipeline->GetSyncAnimationOption();
340 auto parentGlobalOffset = dirty->GetParentGlobalOffsetWithSafeArea(true, true) +
341 dirty->GetFrameRectWithSafeArea(true).GetOffset();
342 dynamicComponentRenderer_->UpdateViewportConfig(size, density, orientation, animationOption, parentGlobalOffset);
343 TransferAccessibilityRectInfo(true);
344 return false;
345 }
346
SetIsReportFrameEvent(bool isReportFrameEvent)347 void DynamicPattern::SetIsReportFrameEvent(bool isReportFrameEvent)
348 {
349 hostConfig_.isReportFrameEvent = isReportFrameEvent;
350 }
351
OnDetachFromFrameNode(FrameNode * frameNode)352 void DynamicPattern::OnDetachFromFrameNode(FrameNode* frameNode)
353 {
354 CHECK_NULL_VOID(dynamicComponentRenderer_);
355 dynamicComponentRenderer_->DestroyContent();
356 dynamicComponentRenderer_ = nullptr;
357 }
358
SetAdaptiveWidth(bool state)359 void DynamicPattern::SetAdaptiveWidth(bool state)
360 {
361 adaptiveWidth_ = state;
362 CHECK_NULL_VOID(dynamicComponentRenderer_);
363 dynamicComponentRenderer_->SetAdaptiveSize(adaptiveWidth_, adaptiveHeight_);
364 }
365
SetAdaptiveHeight(bool state)366 void DynamicPattern::SetAdaptiveHeight(bool state)
367 {
368 adaptiveHeight_ = state;
369 CHECK_NULL_VOID(dynamicComponentRenderer_);
370 dynamicComponentRenderer_->SetAdaptiveSize(adaptiveWidth_, adaptiveHeight_);
371 }
372
OnAttachContext(PipelineContext * context)373 void DynamicPattern::OnAttachContext(PipelineContext *context)
374 {
375 CHECK_NULL_VOID(context);
376 auto newInstanceId = context->GetInstanceId();
377 PLATFORM_LOGI("OnAttachContext newInstanceId: %{public}d, oldInstanceId: %{public}d.",
378 newInstanceId, instanceId_);
379 if (newInstanceId != instanceId_) {
380 UnRegisterPipelineEvent(instanceId_);
381 RegisterPipelineEvent(newInstanceId);
382 instanceId_ = newInstanceId;
383 }
384 AddToPageEventController();
385 }
386
RegisterPipelineEvent(int32_t instanceId)387 void DynamicPattern::RegisterPipelineEvent(int32_t instanceId)
388 {
389 auto host = GetHost();
390 CHECK_NULL_VOID(host);
391 auto context = PipelineContext::GetContextByContainerId(instanceId);
392 CHECK_NULL_VOID(context);
393 context->AddWindowStateChangedCallback(host->GetId());
394 surfacePositionCallBackId_ =
395 context->RegisterSurfacePositionChangedCallback([weak = WeakClaim(this)](int32_t, int32_t) {
396 auto pattern = weak.Upgrade();
397 CHECK_NULL_VOID(pattern);
398 pattern->TransferAccessibilityRectInfo();
399 });
400
401 RegisterAccessibilitySAObserverCallback(instanceId);
402 RegisterSingleHandTransformChangedCallback(instanceId);
403 }
404
RegisterAccessibilitySAObserverCallback(int32_t instanceId)405 void DynamicPattern::RegisterAccessibilitySAObserverCallback(int32_t instanceId)
406 {
407 auto host = GetHost();
408 CHECK_NULL_VOID(host);
409 auto context = PipelineContext::GetContextByContainerId(instanceId);
410 CHECK_NULL_VOID(context);
411 auto frontend = context->GetFrontend();
412 CHECK_NULL_VOID(frontend);
413 auto accessibilityManager = frontend->GetAccessibilityManager();
414 CHECK_NULL_VOID(accessibilityManager);
415 if (accessibilitySAObserverCallback_ == nullptr) {
416 accessibilitySAObserverCallback_ = std::make_shared<DCAccessibilitySAObserverCallback>(
417 WeakClaim(this), host->GetAccessibilityId());
418 }
419
420 accessibilityManager->RegisterAccessibilitySAObserverCallback(host->GetAccessibilityId(),
421 accessibilitySAObserverCallback_);
422 }
423
UnRegisterAccessibilitySAObserverCallback(int32_t instanceId)424 void DynamicPattern::UnRegisterAccessibilitySAObserverCallback(int32_t instanceId)
425 {
426 auto host = GetHost();
427 CHECK_NULL_VOID(host);
428 auto context = PipelineContext::GetContextByContainerId(instanceId);
429 CHECK_NULL_VOID(context);
430 auto frontend = context->GetFrontend();
431 CHECK_NULL_VOID(frontend);
432 auto accessibilityManager = frontend->GetAccessibilityManager();
433 CHECK_NULL_VOID(accessibilityManager);
434 accessibilityManager->DeregisterAccessibilitySAObserverCallback(
435 host->GetAccessibilityId());
436 }
437
RegisterSingleHandTransformChangedCallback(int32_t instanceId)438 void DynamicPattern::RegisterSingleHandTransformChangedCallback(int32_t instanceId)
439 {
440 auto host = GetHost();
441 CHECK_NULL_VOID(host);
442 auto context = PipelineContext::GetContextByContainerId(instanceId);
443 CHECK_NULL_VOID(context);
444 auto uiExtManager = context->GetUIExtensionManager();
445 CHECK_NULL_VOID(uiExtManager);
446 uiExtManager->RegisterSingleHandTransformChangedCallback(host->GetId(),
447 [weak = WeakClaim(this)] () {
448 auto pattern = weak.Upgrade();
449 CHECK_NULL_VOID(pattern);
450 pattern->TransferAccessibilityRectInfo();
451 });
452 }
453
UnRegisterSingleHandTransformChangedCallback(int32_t instanceId)454 void DynamicPattern::UnRegisterSingleHandTransformChangedCallback(int32_t instanceId)
455 {
456 auto host = GetHost();
457 CHECK_NULL_VOID(host);
458 auto context = PipelineContext::GetContextByContainerId(instanceId);
459 CHECK_NULL_VOID(context);
460 auto uiExtManager = context->GetUIExtensionManager();
461 CHECK_NULL_VOID(uiExtManager);
462 uiExtManager->UnregisterSingleHandTransformChangedCallback(host->GetId());
463 }
464
GetAccessibilityRectInfo() const465 AccessibilityParentRectInfo DynamicPattern::GetAccessibilityRectInfo() const
466 {
467 AccessibilityParentRectInfo rectInfo;
468 auto host = GetHost();
469 CHECK_NULL_RETURN(host, rectInfo);
470 auto pipeline = host->GetContextRefPtr();
471 if (pipeline) {
472 auto accessibilityManager = pipeline->GetAccessibilityManager();
473 if (accessibilityManager) {
474 return accessibilityManager->GetTransformRectInfoRelativeToWindow(host, pipeline);
475 }
476 }
477
478 auto rect = host->GetTransformRectRelativeToWindow(true);
479 VectorF finalScale = host->GetTransformScaleRelativeToWindow();
480 rectInfo.left = static_cast<int32_t>(rect.Left());
481 rectInfo.top = static_cast<int32_t>(rect.Top());
482 rectInfo.scaleX = finalScale.x;
483 rectInfo.scaleY = finalScale.y;
484 return rectInfo;
485 }
486
TransferAccessibilityRectInfo(bool isForce)487 void DynamicPattern::TransferAccessibilityRectInfo(bool isForce)
488 {
489 if (!(isForce || AceApplicationInfo::GetInstance().IsAccessibilityEnabled())) {
490 return;
491 }
492
493 UpdateAccessibilityParentRectInfo(GetAccessibilityRectInfo());
494 }
495
OnFrameNodeChanged(FrameNodeChangeInfoFlag flag)496 void DynamicPattern::OnFrameNodeChanged(FrameNodeChangeInfoFlag flag)
497 {
498 if (!(IsAncestorNodeTransformChange(flag) || IsAncestorNodeGeometryChange(flag))) {
499 return;
500 }
501
502 TransferAccessibilityRectInfo();
503 }
504
IsAncestorNodeGeometryChange(FrameNodeChangeInfoFlag flag)505 bool DynamicPattern::IsAncestorNodeGeometryChange(FrameNodeChangeInfoFlag flag)
506 {
507 return ((flag & FRAME_NODE_CHANGE_GEOMETRY_CHANGE) == FRAME_NODE_CHANGE_GEOMETRY_CHANGE);
508 }
509
IsAncestorNodeTransformChange(FrameNodeChangeInfoFlag flag)510 bool DynamicPattern::IsAncestorNodeTransformChange(FrameNodeChangeInfoFlag flag)
511 {
512 return ((flag & FRAME_NODE_CHANGE_TRANSFORM_CHANGE) == FRAME_NODE_CHANGE_TRANSFORM_CHANGE);
513 }
514
OnDetachContext(PipelineContext * context)515 void DynamicPattern::OnDetachContext(PipelineContext *context)
516 {
517 CHECK_NULL_VOID(context);
518 auto instanceId = context->GetInstanceId();
519 PLATFORM_LOGI("OnDetachContext instanceId: %{public}d.", instanceId);
520 UnRegisterPipelineEvent(instanceId);
521 }
522
UnRegisterPipelineEvent(int32_t instanceId)523 void DynamicPattern::UnRegisterPipelineEvent(int32_t instanceId)
524 {
525 auto host = GetHost();
526 CHECK_NULL_VOID(host);
527 auto context = PipelineContext::GetContextByContainerId(instanceId);
528 CHECK_NULL_VOID(context);
529 context->RemoveWindowStateChangedCallback(host->GetId());
530 context->UnregisterSurfacePositionChangedCallback(surfacePositionCallBackId_);
531 UnRegisterAccessibilitySAObserverCallback(instanceId);
532 UnRegisterSingleHandTransformChangedCallback(instanceId);
533 }
534
DumpDynamicRenderer(int32_t depth,bool hasJson)535 void DynamicPattern::DumpDynamicRenderer(int32_t depth, bool hasJson)
536 {
537 CHECK_NULL_VOID(dynamicComponentRenderer_);
538 auto container = Platform::AceContainer::GetContainer(instanceId_);
539 CHECK_NULL_VOID(container);
540 std::vector<std::string> params = container->GetUieParams();
541 std::string deptParam;
542 deptParam.append(DC_DEPTH_PREFIX).append(std::to_string(depth));
543 params.push_back(deptParam);
544 if (hasJson) {
545 params.push_back("-json");
546 }
547 std::vector<std::string> dumpInfo;
548 dynamicComponentRenderer_->NotifyUieDump(params, dumpInfo);
549 }
550
DumpInfo()551 void DynamicPattern::DumpInfo()
552 {
553 DumpLog::GetInstance().AddDesc(std::string("dynamicId: ").append(std::to_string(platformId_)));
554 DumpLog::GetInstance().AddDesc(std::string("entryPoint: ").append(curDynamicInfo_.entryPoint));
555 DumpLog::GetInstance().AddDesc(std::string("createLimitedWorkerTime: ")
556 .append(std::to_string(dynamicDumpInfo_.createLimitedWorkerTime)));
557 CHECK_NULL_VOID(dynamicComponentRenderer_);
558 RendererDumpInfo rendererDumpInfo;
559 dynamicComponentRenderer_->Dump(rendererDumpInfo);
560 DumpLog::GetInstance().AddDesc(std::string("createUiContenTime: ")
561 .append(std::to_string(rendererDumpInfo.createUiContenTime)));
562 DumpLog::GetInstance().AddDesc(std::string("limitedWorkerInitTime: ")
563 .append(std::to_string(rendererDumpInfo.limitedWorkerInitTime)));
564 DumpLog::GetInstance().AddDesc(std::string("loadAbcTime: ")
565 .append(std::to_string(rendererDumpInfo.loadAbcTime)));
566 std::string isReportFrameEvent = hostConfig_.isReportFrameEvent ? "true" : "false";
567 DumpLog::GetInstance().AddDesc(std::string("isReportFrameEvent: ")
568 .append(isReportFrameEvent));
569 }
570
DumpInfo(std::unique_ptr<JsonValue> & json)571 void DynamicPattern::DumpInfo(std::unique_ptr<JsonValue>& json)
572 {
573 json->Put("dynamicId", platformId_);
574 json->Put("resourcePath", curDynamicInfo_.resourcePath.c_str());
575 json->Put("entryPoint", curDynamicInfo_.entryPoint.c_str());
576 json->Put("createLimitedWorkerTime", std::to_string(dynamicDumpInfo_.createLimitedWorkerTime).c_str());
577
578 CHECK_NULL_VOID(dynamicComponentRenderer_);
579 RendererDumpInfo rendererDumpInfo;
580 dynamicComponentRenderer_->Dump(rendererDumpInfo);
581 json->Put("createUiContenTime", std::to_string(rendererDumpInfo.createUiContenTime).c_str());
582 json->Put("limitedWorkerInitTime", std::to_string(rendererDumpInfo.limitedWorkerInitTime).c_str());
583 json->Put("loadAbcTime", std::to_string(rendererDumpInfo.createUiContenTime).c_str());
584 std::string isReportFrameEvent = hostConfig_.isReportFrameEvent ? "true" : "false";
585 json->Put("isReportFrameEvent", isReportFrameEvent.c_str());
586 }
587
InitializeAccessibility()588 void DynamicPattern::InitializeAccessibility()
589 {
590 if (accessibilityChildTreeCallback_ != nullptr) {
591 return;
592 }
593 ContainerScope scope(instanceId_);
594 auto host = GetHost();
595 CHECK_NULL_VOID(host);
596 auto ngPipeline = host->GetContextRefPtr();
597 CHECK_NULL_VOID(ngPipeline);
598 auto frontend = ngPipeline->GetFrontend();
599 CHECK_NULL_VOID(frontend);
600 auto accessibilityManager = frontend->GetAccessibilityManager();
601 CHECK_NULL_VOID(accessibilityManager);
602 auto frameNode = frameNode_.Upgrade();
603 CHECK_NULL_VOID(frameNode);
604 int64_t accessibilityId = frameNode->GetAccessibilityId();
605 accessibilityChildTreeCallback_ = std::make_shared<PlatformAccessibilityChildTreeCallback>(
606 WeakClaim(this), accessibilityId);
607 CHECK_NULL_VOID(accessibilityChildTreeCallback_);
608 auto realHostWindowId = ngPipeline->GetRealHostWindowId();
609 if (accessibilityManager->IsRegister()) {
610 accessibilityChildTreeCallback_->OnRegister(
611 realHostWindowId, accessibilityManager->GetTreeId());
612 }
613 PLATFORM_LOGI("DynamicComponent: %{public}" PRId64 " register child tree, realHostWindowId: %{public}u",
614 accessibilityId, realHostWindowId);
615 accessibilityManager->RegisterAccessibilityChildTreeCallback(accessibilityId, accessibilityChildTreeCallback_);
616 }
617
OnAccessibilityChildTreeRegister(uint32_t windowId,int32_t treeId,int64_t accessibilityId) const618 void DynamicPattern::OnAccessibilityChildTreeRegister(
619 uint32_t windowId, int32_t treeId, int64_t accessibilityId) const
620 {
621 PLATFORM_LOGI("treeId: %{public}d, id: %{public}" PRId64, treeId, accessibilityId);
622 if (dynamicComponentRenderer_ == nullptr) {
623 PLATFORM_LOGI("dynamicComponentRenderer_ is null");
624 return;
625 }
626 dynamicComponentRenderer_->TransferAccessibilityChildTreeRegister(windowId, treeId, accessibilityId);
627 }
628
OnAccessibilityChildTreeDeregister() const629 void DynamicPattern::OnAccessibilityChildTreeDeregister() const
630 {
631 PLATFORM_LOGI("deregister accessibility child tree");
632 if (dynamicComponentRenderer_ == nullptr) {
633 PLATFORM_LOGI("dynamicComponentRenderer_ is null");
634 return;
635 }
636 dynamicComponentRenderer_->TransferAccessibilityChildTreeDeregister();
637 }
638
AddToPageEventController()639 void DynamicPattern::AddToPageEventController()
640 {
641 ContainerScope scope(instanceId_);
642 auto host = GetHost();
643 CHECK_NULL_VOID(host);
644 auto pipeline = host->GetContext();
645 CHECK_NULL_VOID(pipeline);
646 auto frontend = pipeline->GetFrontend();
647 CHECK_NULL_VOID(frontend);
648 auto accessibilityManager = frontend->GetAccessibilityManager();
649 CHECK_NULL_VOID(accessibilityManager);
650 accessibilityManager->AddToPageEventController(host);
651 }
652
ReleasePageEvent() const653 void DynamicPattern::ReleasePageEvent() const
654 {
655 auto host = GetHost();
656 CHECK_NULL_VOID(host);
657 auto pipeline = host->GetContext();
658 CHECK_NULL_VOID(pipeline);
659 auto frontend = pipeline->GetFrontend();
660 CHECK_NULL_VOID(frontend);
661 auto accessibilityManager = frontend->GetAccessibilityManager();
662 CHECK_NULL_VOID(accessibilityManager);
663 accessibilityManager->ReleasePageEvent(host, true);
664 }
665
OnSetAccessibilityChildTree(int32_t childWindowId,int32_t childTreeId)666 void DynamicPattern::OnSetAccessibilityChildTree(int32_t childWindowId, int32_t childTreeId)
667 {
668 auto frameNode = frameNode_.Upgrade();
669 CHECK_NULL_VOID(frameNode);
670 auto accessibilityProperty = frameNode->GetAccessibilityProperty<AccessibilityProperty>();
671 CHECK_NULL_VOID(accessibilityProperty);
672 accessibilityProperty->SetChildWindowId(childWindowId);
673 accessibilityProperty->SetChildTreeId(childTreeId);
674 ReleasePageEvent();
675 TransferAccessibilityRectInfo(true);
676 }
677
OnAccessibilityDumpChildInfo(const std::vector<std::string> & params,std::vector<std::string> & info) const678 void DynamicPattern::OnAccessibilityDumpChildInfo(
679 const std::vector<std::string>& params, std::vector<std::string>& info) const
680 {
681 PLATFORM_LOGI("dump accessibility child info");
682 if (dynamicComponentRenderer_ == nullptr) {
683 PLATFORM_LOGI("dynamicComponentRenderer_ is null");
684 return;
685 }
686 dynamicComponentRenderer_->TransferAccessibilityDumpChildInfo(params, info);
687 }
688
ResetAccessibilityChildTreeCallback()689 void DynamicPattern::ResetAccessibilityChildTreeCallback()
690 {
691 CHECK_NULL_VOID(accessibilityChildTreeCallback_);
692 ContainerScope scope(instanceId_);
693 auto ngPipeline = NG::PipelineContext::GetCurrentContext();
694 CHECK_NULL_VOID(ngPipeline);
695 auto frontend = ngPipeline->GetFrontend();
696 CHECK_NULL_VOID(frontend);
697 auto accessibilityManager = frontend->GetAccessibilityManager();
698 CHECK_NULL_VOID(accessibilityManager);
699 accessibilityManager->DeregisterAccessibilityChildTreeCallback(
700 accessibilityChildTreeCallback_->GetAccessibilityId());
701 accessibilityChildTreeCallback_.reset();
702 accessibilityChildTreeCallback_ = nullptr;
703 }
704
RegisterVisibleAreaChange()705 void DynamicPattern::RegisterVisibleAreaChange()
706 {
707 PLATFORM_LOGI("Register visible area change.");
708 auto pipeline = PipelineContext::GetCurrentContext();
709 CHECK_NULL_VOID(pipeline);
710 auto host = GetHost();
711 CHECK_NULL_VOID(host);
712 auto callback = [weak = WeakClaim(this)](bool visible, double ratio) {
713 auto pattern = weak.Upgrade();
714 CHECK_NULL_VOID(pattern);
715 pattern->HandleVisibleAreaChange(visible, ratio);
716 };
717 std::vector<double> ratioList = { SHOW_START, SHOW_FULL };
718 pipeline->AddVisibleAreaChangeNode(host, ratioList, callback, false);
719 }
720
HandleVisibleAreaChange(bool visible,double ratio)721 void DynamicPattern::HandleVisibleAreaChange(bool visible, double ratio)
722 {
723 PLATFORM_LOGI("HandleVisibleAreaChange visible: %{public}d, curVisible: %{public}d, "
724 "ratio: %{public}f.", visible, isVisible_, ratio);
725 bool curVisible = !NearEqual(ratio, SHOW_START);
726 if (isVisible_ != curVisible) {
727 isVisible_ = curVisible;
728 CHECK_NULL_VOID(dynamicComponentRenderer_);
729 if (isVisible_) {
730 dynamicComponentRenderer_->NotifyForeground();
731 } else {
732 dynamicComponentRenderer_->NotifyBackground();
733 }
734 }
735 TransferAccessibilityRectInfo();
736 }
737
HandleTouchEvent(const std::shared_ptr<MMI::PointerEvent> & pointerEvent)738 bool DynamicPattern::HandleTouchEvent(
739 const std::shared_ptr<MMI::PointerEvent>& pointerEvent)
740 {
741 CHECK_NULL_RETURN(pointerEvent, false);
742 auto originAction = pointerEvent->GetPointerAction();
743 if (originAction == OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_MOVE ||
744 originAction == OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_UP) {
745 return false;
746 }
747 return PlatformPattern::HandleTouchEvent(pointerEvent);
748 }
749
HandleMouseEvent(const MouseInfo & info)750 void DynamicPattern::HandleMouseEvent(const MouseInfo& info)
751 {
752 if (info.GetSourceDevice() != SourceType::MOUSE) {
753 return;
754 }
755 if (info.GetPullAction() == MouseAction::PULL_MOVE || info.GetPullAction() == MouseAction::PULL_UP) {
756 return;
757 }
758 PlatformPattern::HandleMouseEvent(info);
759 }
760 } // namespace OHOS::Ace::NG
761