1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/interfaces/native/node/node_api.h"
17
18 #include <deque>
19 #include <securec.h>
20 #include <vector>
21
22 #include "base/error/error_code.h"
23 #include "base/log/ace_trace.h"
24 #include "base/log/log_wrapper.h"
25 #include "base/utils/macros.h"
26 #include "base/utils/utils.h"
27 #include "core/common/container.h"
28 #include "core/components_ng/base/frame_node.h"
29 #include "core/components_ng/base/observer_handler.h"
30 #include "core/components_ng/base/view_stack_processor.h"
31 #include "core/components_ng/base/ui_node.h"
32 #include "core/components_ng/base/view_stack_processor.h"
33 #include "core/components_ng/pattern/navigation/navigation_stack.h"
34 #include "core/components_ng/pattern/text/span/span_string.h"
35 #include "core/interfaces/arkoala/arkoala_api.h"
36 #include "core/interfaces/native/node/alphabet_indexer_modifier.h"
37 #include "core/interfaces/native/node/calendar_picker_modifier.h"
38 #include "core/interfaces/native/node/canvas_rendering_context_2d_modifier.h"
39 #include "core/interfaces/native/node/custom_dialog_model.h"
40 #include "core/interfaces/native/node/drag_adapter_impl.h"
41 #include "core/interfaces/native/node/grid_modifier.h"
42 #include "core/interfaces/native/node/image_animator_modifier.h"
43 #include "core/interfaces/native/node/node_adapter_impl.h"
44 #include "core/interfaces/native/node/node_animate.h"
45 #include "core/interfaces/native/node/node_canvas_modifier.h"
46 #include "core/interfaces/native/node/node_checkbox_modifier.h"
47 #include "core/interfaces/native/node/node_common_modifier.h"
48 #include "core/interfaces/native/node/node_drag_modifier.h"
49 #include "core/interfaces/native/node/node_date_picker_modifier.h"
50 #include "core/interfaces/native/node/node_image_modifier.h"
51 #include "core/interfaces/native/node/node_list_item_modifier.h"
52 #include "core/interfaces/native/node/node_list_modifier.h"
53 #include "core/interfaces/native/node/node_refresh_modifier.h"
54 #include "core/interfaces/native/node/node_scroll_modifier.h"
55 #include "core/interfaces/native/node/node_slider_modifier.h"
56 #include "core/interfaces/native/node/node_swiper_modifier.h"
57 #include "core/interfaces/native/node/node_span_modifier.h"
58 #include "core/interfaces/native/node/node_text_area_modifier.h"
59 #include "core/interfaces/native/node/node_text_input_modifier.h"
60 #include "core/interfaces/native/node/node_text_modifier.h"
61 #include "core/interfaces/native/node/node_textpicker_modifier.h"
62 #include "core/interfaces/native/node/node_timepicker_modifier.h"
63 #include "core/interfaces/native/node/node_toggle_modifier.h"
64 #include "core/interfaces/native/node/radio_modifier.h"
65 #include "core/interfaces/native/node/search_modifier.h"
66 #include "core/interfaces/native/node/select_modifier.h"
67 #include "core/interfaces/native/node/util_modifier.h"
68 #include "core/interfaces/native/node/view_model.h"
69 #include "core/interfaces/native/node/water_flow_modifier.h"
70 #include "core/pipeline_ng/pipeline_context.h"
71 #include "core/text/html_utils.h"
72 #include "interfaces/native/native_type.h"
73 #include "core/interfaces/native/node/checkboxgroup_modifier.h"
74 #include "frameworks/bridge/common/utils/engine_helper.h"
75
76 namespace OHOS::Ace::NG {
77 namespace {
78 constexpr int32_t INVLID_VALUE = -1;
79
WriteStringToBuffer(const std::string & src,char * buffer,int32_t bufferSize,int32_t * writeLen)80 int32_t WriteStringToBuffer(const std::string& src, char* buffer, int32_t bufferSize, int32_t* writeLen)
81 {
82 CHECK_NULL_RETURN(buffer, ERROR_CODE_PARAM_INVALID);
83 CHECK_NULL_RETURN(writeLen, ERROR_CODE_PARAM_INVALID);
84 if (src.empty()) {
85 return ERROR_CODE_NO_ERROR;
86 }
87 int32_t srcLength = static_cast<int32_t>(src.length());
88 if (bufferSize - 1 < srcLength) {
89 *writeLen = srcLength == INT32_MAX ? INT32_MAX : srcLength + 1;
90 return ERROR_CODE_NATIVE_IMPL_BUFFER_SIZE_ERROR;
91 }
92 src.copy(buffer, srcLength);
93 buffer[srcLength] = '\0';
94 *writeLen = srcLength;
95 return ERROR_CODE_NO_ERROR;
96 }
97
GetNavDestinationInfoByNode(ArkUINodeHandle node)98 std::shared_ptr<NavDestinationInfo> GetNavDestinationInfoByNode(ArkUINodeHandle node)
99 {
100 FrameNode* currentNode = reinterpret_cast<FrameNode*>(node);
101 CHECK_NULL_RETURN(currentNode, nullptr);
102 return NG::UIObserverHandler::GetInstance().GetNavigationState(Ace::AceType::Claim<FrameNode>(currentNode));
103 }
104
GetRouterPageInfoByNode(ArkUINodeHandle node)105 std::shared_ptr<RouterPageInfoNG> GetRouterPageInfoByNode(ArkUINodeHandle node)
106 {
107 FrameNode* currentNode = reinterpret_cast<FrameNode*>(node);
108 CHECK_NULL_RETURN(currentNode, nullptr);
109 return NG::UIObserverHandler::GetInstance().GetRouterPageState(Ace::AceType::Claim<FrameNode>(currentNode));
110 }
111
GetNavigationStackByNode(ArkUINodeHandle node)112 RefPtr<NavigationStack> GetNavigationStackByNode(ArkUINodeHandle node)
113 {
114 FrameNode* currentNode = reinterpret_cast<FrameNode*>(node);
115 CHECK_NULL_RETURN(currentNode, nullptr);
116 auto pipeline = currentNode->GetContext();
117 CHECK_NULL_RETURN(pipeline, nullptr);
118 auto navigationMgr = pipeline->GetNavigationManager();
119 CHECK_NULL_RETURN(navigationMgr, nullptr);
120 auto result = navigationMgr->GetNavigationInfo(Ace::AceType::Claim<FrameNode>(currentNode));
121 CHECK_NULL_RETURN(result, nullptr);
122 return result->pathStack.Upgrade();
123 }
124 } // namespace
125
GetUIState(ArkUINodeHandle node)126 ArkUI_Int64 GetUIState(ArkUINodeHandle node)
127 {
128 auto* frameNode = reinterpret_cast<FrameNode*>(node);
129 CHECK_NULL_RETURN(frameNode, 0);
130 auto eventHub = frameNode->GetEventHub<EventHub>();
131 CHECK_NULL_RETURN(eventHub, 0);
132 return eventHub->GetCurrentUIState();
133 }
134
SetSupportedUIState(ArkUINodeHandle node,ArkUI_Int64 state)135 void SetSupportedUIState(ArkUINodeHandle node, ArkUI_Int64 state)
136 {
137 auto* frameNode = reinterpret_cast<FrameNode*>(node);
138 CHECK_NULL_VOID(frameNode);
139 auto eventHub = frameNode->GetEventHub<EventHub>();
140 CHECK_NULL_VOID(eventHub);
141 eventHub->AddSupportedState(static_cast<uint64_t>(state));
142 }
143
144 namespace NodeModifier {
GetUIStateModifier()145 const ArkUIStateModifier* GetUIStateModifier()
146 {
147 static const ArkUIStateModifier modifier = { GetUIState, SetSupportedUIState };
148 return &modifier;
149 }
150
GetCJUIStateModifier()151 const CJUIStateModifier* GetCJUIStateModifier()
152 {
153 static const CJUIStateModifier modifier = {
154 GetUIState,
155 SetSupportedUIState
156 };
157 return &modifier;
158 }
159 } // namespace NodeModifier
160
161 namespace NodeEvent {
162 std::deque<ArkUINodeEvent> g_eventQueue;
CheckEvent(ArkUINodeEvent * event)163 int CheckEvent(ArkUINodeEvent* event)
164 {
165 if (!g_eventQueue.empty()) {
166 *event = g_eventQueue.front();
167 g_eventQueue.pop_front();
168 return 1;
169 }
170 return 0;
171 }
172
173 static EventReceiver globalEventReceiver = nullptr;
174
SendArkUIAsyncEvent(ArkUINodeEvent * event)175 void SendArkUIAsyncEvent(ArkUINodeEvent* event)
176 {
177 if (globalEventReceiver) {
178 globalEventReceiver(event);
179 } else {
180 g_eventQueue.push_back(*event);
181 }
182 }
183 } // namespace NodeEvent
184
185 namespace CustomNodeEvent {
186 std::deque<ArkUICustomNodeEvent> g_eventQueue;
CheckEvent(ArkUICustomNodeEvent * event)187 int CheckEvent(ArkUICustomNodeEvent* event)
188 {
189 if (!g_eventQueue.empty()) {
190 *event = g_eventQueue.front();
191 g_eventQueue.pop_front();
192 return 1;
193 }
194 return 0;
195 }
196
197 void (*g_fliter)(ArkUICustomNodeEvent* event) = nullptr;
SendArkUIAsyncEvent(ArkUICustomNodeEvent * event)198 void SendArkUIAsyncEvent(ArkUICustomNodeEvent* event)
199 {
200 if (g_fliter) {
201 g_fliter(event);
202 } else {
203 g_eventQueue.push_back(*event);
204 }
205 }
206 } // namespace CustomNodeEvent
207
208 namespace {
209
SetCustomCallback(ArkUIVMContext context,ArkUINodeHandle node,ArkUI_Int32 callback)210 void SetCustomCallback(ArkUIVMContext context, ArkUINodeHandle node, ArkUI_Int32 callback)
211 {
212 ViewModel::SetCustomCallback(context, node, callback);
213 }
214
CreateNode(ArkUINodeType type,int peerId,ArkUI_Int32 flags)215 ArkUINodeHandle CreateNode(ArkUINodeType type, int peerId, ArkUI_Int32 flags)
216 {
217 ArkUINodeHandle node = nullptr;
218 if (flags == ARKUI_NODE_FLAG_C) {
219 ContainerScope Scope(Container::CurrentIdSafelyWithCheck());
220 node = reinterpret_cast<ArkUINodeHandle>(ViewModel::CreateNode(type, peerId));
221 auto* uiNode = reinterpret_cast<UINode*>(node);
222 if (uiNode) {
223 uiNode->setIsCNode(true);
224 }
225 } else {
226 node = reinterpret_cast<ArkUINodeHandle>(ViewModel::CreateNode(type, peerId));
227 }
228 return node;
229 }
230
CreateNodeWithParams(ArkUINodeType type,int peerId,ArkUI_Int32 flags,const ArkUI_Params & params)231 ArkUINodeHandle CreateNodeWithParams(ArkUINodeType type, int peerId, ArkUI_Int32 flags, const ArkUI_Params& params)
232 {
233 auto* node = reinterpret_cast<ArkUINodeHandle>(ViewModel::CreateNodeWithParams(type, peerId, params));
234 return node;
235 }
236
GetNodeByViewStack()237 ArkUINodeHandle GetNodeByViewStack()
238 {
239 auto node = ViewStackProcessor::GetInstance()->Finish();
240 node->IncRefCount();
241 return reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(node));
242 }
243
DisposeNode(ArkUINodeHandle node)244 void DisposeNode(ArkUINodeHandle node)
245 {
246 ViewModel::DisposeNode(node);
247 }
248
GetName(ArkUINodeHandle node)249 ArkUI_CharPtr GetName(ArkUINodeHandle node)
250 {
251 return ViewModel::GetName(node);
252 }
253
DumpTree(ArkUINodeHandle node,int indent)254 static void DumpTree(ArkUINodeHandle node, int indent) {}
255
DumpTreeNode(ArkUINodeHandle node)256 void DumpTreeNode(ArkUINodeHandle node)
257 {
258 DumpTree(node, 0);
259 }
260
AddChild(ArkUINodeHandle parent,ArkUINodeHandle child)261 ArkUI_Int32 AddChild(ArkUINodeHandle parent, ArkUINodeHandle child)
262 {
263 auto* nodeAdapter = NodeAdapter::GetNodeAdapterAPI()->getNodeAdapter(parent);
264 if (nodeAdapter) {
265 return ERROR_CODE_NATIVE_IMPL_NODE_ADAPTER_EXIST;
266 }
267 ViewModel::AddChild(parent, child);
268 return ERROR_CODE_NO_ERROR;
269 }
270
InsertChildAt(ArkUINodeHandle parent,ArkUINodeHandle child,int32_t position)271 ArkUI_Int32 InsertChildAt(ArkUINodeHandle parent, ArkUINodeHandle child, int32_t position)
272 {
273 auto* nodeAdapter = NodeAdapter::GetNodeAdapterAPI()->getNodeAdapter(parent);
274 if (nodeAdapter) {
275 return ERROR_CODE_NATIVE_IMPL_NODE_ADAPTER_EXIST;
276 }
277 ViewModel::InsertChildAt(parent, child, position);
278 return ERROR_CODE_NO_ERROR;
279 }
280
RemoveChild(ArkUINodeHandle parent,ArkUINodeHandle child)281 void RemoveChild(ArkUINodeHandle parent, ArkUINodeHandle child)
282 {
283 ViewModel::RemoveChild(parent, child);
284 }
285
InsertChildAfter(ArkUINodeHandle parent,ArkUINodeHandle child,ArkUINodeHandle sibling)286 ArkUI_Int32 InsertChildAfter(ArkUINodeHandle parent, ArkUINodeHandle child, ArkUINodeHandle sibling)
287 {
288 auto* nodeAdapter = NodeAdapter::GetNodeAdapterAPI()->getNodeAdapter(parent);
289 if (nodeAdapter) {
290 return ERROR_CODE_NATIVE_IMPL_NODE_ADAPTER_EXIST;
291 }
292 ViewModel::InsertChildAfter(parent, child, sibling);
293 return ERROR_CODE_NO_ERROR;
294 }
295
IsBuilderNode(ArkUINodeHandle node)296 ArkUI_Bool IsBuilderNode(ArkUINodeHandle node)
297 {
298 return ViewModel::IsBuilderNode(node);
299 }
300
ConvertLengthMetricsUnit(ArkUI_Float64 value,ArkUI_Int32 originUnit,ArkUI_Int32 targetUnit)301 ArkUI_Float64 ConvertLengthMetricsUnit(ArkUI_Float64 value, ArkUI_Int32 originUnit, ArkUI_Int32 targetUnit)
302 {
303 Dimension lengthMetric(value, static_cast<DimensionUnit>(originUnit));
304 return lengthMetric.GetNativeValue(static_cast<DimensionUnit>(targetUnit));
305 }
306
InsertChildBefore(ArkUINodeHandle parent,ArkUINodeHandle child,ArkUINodeHandle sibling)307 ArkUI_Int32 InsertChildBefore(ArkUINodeHandle parent, ArkUINodeHandle child, ArkUINodeHandle sibling)
308 {
309 auto* nodeAdapter = NodeAdapter::GetNodeAdapterAPI()->getNodeAdapter(parent);
310 if (nodeAdapter) {
311 return ERROR_CODE_NATIVE_IMPL_NODE_ADAPTER_EXIST;
312 }
313 ViewModel::InsertChildBefore(parent, child, sibling);
314 return ERROR_CODE_NO_ERROR;
315 }
316
SetAttribute(ArkUINodeHandle node,ArkUI_CharPtr attribute,ArkUI_CharPtr value)317 void SetAttribute(ArkUINodeHandle node, ArkUI_CharPtr attribute, ArkUI_CharPtr value) {}
318
GetAttribute(ArkUINodeHandle node,ArkUI_CharPtr attribute)319 ArkUI_CharPtr GetAttribute(ArkUINodeHandle node, ArkUI_CharPtr attribute)
320 {
321 return "";
322 }
323
ResetAttribute(ArkUINodeHandle nodePtr,ArkUI_CharPtr attribute)324 void ResetAttribute(ArkUINodeHandle nodePtr, ArkUI_CharPtr attribute)
325 {
326 TAG_LOGI(AceLogTag::ACE_NATIVE_NODE, "Reset attribute %{public}s", attribute);
327 }
328
329 typedef void (*ComponentAsyncEventHandler)(ArkUINodeHandle node, void* extraParam);
330
331 typedef void (*ResetComponentAsyncEventHandler)(ArkUINodeHandle node);
332
333 /**
334 * IMPORTANT!!!
335 * the order of declaring the handler must be same as the in the ArkUIEventSubKind enum
336 */
337 /* clang-format off */
338 const ComponentAsyncEventHandler commonNodeAsyncEventHandlers[] = {
339 NodeModifier::SetOnAppear,
340 NodeModifier::SetOnDisappear,
341 NodeModifier::SetOnTouch,
342 NodeModifier::SetOnClick,
343 NodeModifier::SetOnHover,
344 NodeModifier::SetOnBlur,
345 NodeModifier::SetOnKeyEvent,
346 NodeModifier::SetOnMouse,
347 NodeModifier::SetOnAreaChange,
348 nullptr,
349 nullptr,
350 NodeModifier::SetOnFocus,
351 NodeModifier::SetOnTouchIntercept,
352 NodeModifier::SetOnAttach,
353 NodeModifier::SetOnDetach,
354 NodeModifier::SetOnAccessibilityActions,
355 NodeModifier::SetOnDragStart,
356 NodeModifier::SetOnDragEnter,
357 NodeModifier::SetOnDragDrop,
358 NodeModifier::SetOnDragMove,
359 NodeModifier::SetOnDragLeave,
360 NodeModifier::SetOnDragEnd,
361 NodeModifier::SetOnPreDrag,
362 NodeModifier::SetOnKeyPreIme,
363 NodeModifier::SetOnFocusAxisEvent,
364 NodeModifier::SetOnKeyEventDispatch,
365 NodeModifier::SetOnHoverMove,
366 };
367
368 const ComponentAsyncEventHandler scrollNodeAsyncEventHandlers[] = {
369 NodeModifier::SetOnScroll,
370 NodeModifier::SetOnScrollFrameBegin,
371 NodeModifier::SetScrollOnWillScroll,
372 NodeModifier::SetScrollOnDidScroll,
373 NodeModifier::SetOnScrollStart,
374 NodeModifier::SetOnScrollStop,
375 NodeModifier::SetOnScrollEdge,
376 NodeModifier::SetOnScrollReachStart,
377 NodeModifier::SetOnScrollReachEnd,
378 };
379
380 const ComponentAsyncEventHandler TEXT_NODE_ASYNC_EVENT_HANDLERS[] = {
381 NodeModifier::SetOnDetectResultUpdate,
382 };
383
384 const ComponentAsyncEventHandler textInputNodeAsyncEventHandlers[] = {
385 NodeModifier::SetOnTextInputEditChange,
386 NodeModifier::SetTextInputOnSubmit,
387 NodeModifier::SetOnTextInputChange,
388 NodeModifier::SetOnTextInputCut,
389 NodeModifier::SetOnTextInputPaste,
390 NodeModifier::SetOnTextInputSelectionChange,
391 NodeModifier::SetOnTextInputContentSizeChange,
392 NodeModifier::SetOnTextInputInputFilterError,
393 NodeModifier::SetTextInputOnTextContentScroll,
394 NodeModifier::SetTextInputOnWillInsert,
395 NodeModifier::SetTextInputOnDidInsert,
396 NodeModifier::SetTextInputOnWillDelete,
397 NodeModifier::SetTextInputOnDidDelete,
398 NodeModifier::SetOnTextInputChangeWithPreviewText,
399 };
400
401 const ComponentAsyncEventHandler textAreaNodeAsyncEventHandlers[] = {
402 NodeModifier::SetOnTextAreaEditChange,
403 nullptr,
404 NodeModifier::SetOnTextAreaChange,
405 NodeModifier::SetOnTextAreaPaste,
406 NodeModifier::SetOnTextAreaSelectionChange,
407 NodeModifier::SetTextAreaOnSubmit,
408 NodeModifier::SetOnTextAreaContentSizeChange,
409 NodeModifier::SetOnTextAreaInputFilterError,
410 NodeModifier::SetTextAreaOnTextContentScroll,
411 NodeModifier::SetTextAreaOnWillInsertValue,
412 NodeModifier::SetTextAreaOnDidInsertValue,
413 NodeModifier::SetTextAreaOnWillDeleteValue,
414 NodeModifier::SetTextAreaOnDidDeleteValue,
415 NodeModifier::SetOnTextAreaChangeWithPreviewText,
416 };
417
418 const ComponentAsyncEventHandler refreshNodeAsyncEventHandlers[] = {
419 NodeModifier::SetRefreshOnStateChange,
420 NodeModifier::SetOnRefreshing,
421 NodeModifier::SetRefreshOnOffsetChange,
422 NodeModifier::SetRefreshChangeEvent,
423 };
424
425 const ComponentAsyncEventHandler TOGGLE_NODE_ASYNC_EVENT_HANDLERS[] = {
426 NodeModifier::SetOnToggleChange,
427 };
428
429 const ComponentAsyncEventHandler imageNodeAsyncEventHandlers[] = {
430 NodeModifier::SetImageOnComplete,
431 NodeModifier::SetImageOnError,
432 NodeModifier::SetImageOnSvgPlayFinish,
433 NodeModifier::SetImageOnDownloadProgress,
434 };
435
436 const ComponentAsyncEventHandler DATE_PICKER_NODE_ASYNC_EVENT_HANDLERS[] = {
437 NodeModifier::SetDatePickerOnDateChange,
438 };
439
440 const ComponentAsyncEventHandler TIME_PICKER_NODE_ASYNC_EVENT_HANDLERS[] = {
441 NodeModifier::SetTimePickerOnChange,
442 };
443
444 const ComponentAsyncEventHandler TEXT_PICKER_NODE_ASYNC_EVENT_HANDLERS[] = {
445 NodeModifier::SetTextPickerOnChange,
446 NodeModifier::SetTextPickerOnScrollStop,
447 };
448
449 const ComponentAsyncEventHandler CALENDAR_PICKER_NODE_ASYNC_EVENT_HANDLERS[] = {
450 NodeModifier::SetCalendarPickerOnChange,
451 };
452
453 const ComponentAsyncEventHandler CHECKBOX_NODE_ASYNC_EVENT_HANDLERS[] = {
454 NodeModifier::SetCheckboxChange,
455 };
456
457 const ComponentAsyncEventHandler CHECKBOX_GROUP_NODE_ASYNC_EVENT_HANDLERS[] = {
458 NodeModifier::SetCheckboxGroupChange,
459 };
460
461 const ComponentAsyncEventHandler SLIDER_NODE_ASYNC_EVENT_HANDLERS[] = {
462 NodeModifier::SetSliderChange,
463 };
464
465 const ComponentAsyncEventHandler SWIPER_NODE_ASYNC_EVENT_HANDLERS[] = {
466 NodeModifier::SetSwiperChange,
467 NodeModifier::SetSwiperAnimationStart,
468 NodeModifier::SetSwiperAnimationEnd,
469 NodeModifier::SetSwiperGestureSwipe,
470 NodeModifier::SetSwiperOnContentDidScroll,
471 NodeModifier::SetSwiperContentWillScroll,
472 };
473
474 const ComponentAsyncEventHandler CANVAS_NODE_ASYNC_EVENT_HANDLERS[] = {
475 NodeModifier::SetCanvasOnReady,
476 };
477
478 const ComponentAsyncEventHandler listNodeAsyncEventHandlers[] = {
479 NodeModifier::SetOnListScroll,
480 NodeModifier::SetOnListScrollIndex,
481 NodeModifier::SetOnListScrollStart,
482 NodeModifier::SetOnListScrollStop,
483 NodeModifier::SetOnListScrollFrameBegin,
484 NodeModifier::SetOnListWillScroll,
485 NodeModifier::SetOnListDidScroll,
486 NodeModifier::SetOnListReachStart,
487 NodeModifier::SetOnListReachEnd,
488 NodeModifier::SetOnListScrollVisibleContentChange,
489 };
490
491 const ComponentAsyncEventHandler LIST_ITEM_NODE_ASYNC_EVENT_HANDLERS[] = {
492 NodeModifier::SetListItemOnSelect,
493 };
494
495 const ComponentAsyncEventHandler WATER_FLOW_NODE_ASYNC_EVENT_HANDLERS[] = {
496 NodeModifier::SetOnWillScroll,
497 NodeModifier::SetOnWaterFlowReachEnd,
498 NodeModifier::SetOnDidScroll,
499 NodeModifier::SetOnWaterFlowScrollStart,
500 NodeModifier::SetOnWaterFlowScrollStop,
501 NodeModifier::SetOnWaterFlowScrollFrameBegin,
502 NodeModifier::SetOnWaterFlowScrollIndex,
503 NodeModifier::SetOnWaterFlowReachStart,
504 };
505
506 const ComponentAsyncEventHandler GRID_NODE_ASYNC_EVENT_HANDLERS[] = {
507 nullptr,
508 nullptr,
509 nullptr,
510 NodeModifier::SetOnGridScrollIndex,
511 };
512
513 const ComponentAsyncEventHandler ALPHABET_INDEXER_NODE_ASYNC_EVENT_HANDLERS[] = {
514 NodeModifier::SetOnIndexerSelected,
515 NodeModifier::SetOnIndexerRequestPopupData,
516 NodeModifier::SetOnIndexerPopupSelected,
517 NodeModifier::SetIndexerChangeEvent,
518 NodeModifier::SetIndexerCreatChangeEvent,
519 };
520
521 const ComponentAsyncEventHandler SEARCH_NODE_ASYNC_EVENT_HANDLERS[] = {
522 NodeModifier::SetOnSearchSubmit,
523 NodeModifier::SetOnSearchChange,
524 NodeModifier::SetOnSearchCopy,
525 NodeModifier::SetOnSearchCut,
526 NodeModifier::SetOnSearchPaste,
527 };
528
529 const ComponentAsyncEventHandler RADIO_NODE_ASYNC_EVENT_HANDLERS[] = {
530 NodeModifier::SetOnRadioChange,
531 };
532
533 const ComponentAsyncEventHandler SELECT_NODE_ASYNC_EVENT_HANDLERS[] = {
534 NodeModifier::SetOnSelectSelect,
535 };
536
537 const ComponentAsyncEventHandler IMAGE_ANIMATOR_NODE_ASYNC_EVENT_HANDLERS[] = {
538 NodeModifier::SetImageAnimatorOnStart,
539 NodeModifier::SetImageAnimatorOnPause,
540 NodeModifier::SetImageAnimatorOnRepeat,
541 NodeModifier::SetImageAnimatorOnCancel,
542 NodeModifier::SetImageAnimatorOnFinish,
543 };
544
545 const ResetComponentAsyncEventHandler COMMON_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
546 NodeModifier::ResetOnAppear,
547 NodeModifier::ResetOnDisappear,
548 NodeModifier::ResetOnTouch,
549 NodeModifier::ResetOnClick,
550 NodeModifier::ResetOnHover,
551 NodeModifier::ResetOnBlur,
552 NodeModifier::ResetOnKeyEvent,
553 NodeModifier::ResetOnMouse,
554 NodeModifier::ResetOnAreaChange,
555 NodeModifier::ResetOnVisibleAreaChange,
556 nullptr,
557 NodeModifier::ResetOnFocus,
558 NodeModifier::ResetOnTouchIntercept,
559 NodeModifier::ResetOnAttach,
560 NodeModifier::ResetOnDetach,
561 nullptr,
562 nullptr,
563 nullptr,
564 nullptr,
565 nullptr,
566 nullptr,
567 nullptr,
568 nullptr,
569 NodeModifier::ResetOnKeyPreIme,
570 NodeModifier::ResetOnFocusAxisEvent,
571 nullptr,
572 NodeModifier::ResetOnHoverMove,
573 };
574
575 const ResetComponentAsyncEventHandler SCROLL_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
576 NodeModifier::ResetOnScroll,
577 NodeModifier::ResetOnScrollFrameBegin,
578 NodeModifier::ResetScrollOnWillScroll,
579 NodeModifier::ResetScrollOnDidScroll,
580 NodeModifier::ResetOnScrollStart,
581 NodeModifier::ResetOnScrollStop,
582 NodeModifier::ResetOnScrollEdge,
583 NodeModifier::ResetOnScrollReachStart,
584 NodeModifier::ResetOnScrollReachEnd,
585 };
586
587 const ResetComponentAsyncEventHandler TEXT_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
588 NodeModifier::ResetOnDetectResultUpdate,
589 };
590
591 const ResetComponentAsyncEventHandler TEXT_INPUT_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
592 NodeModifier::ResetOnTextInputEditChange,
593 NodeModifier::ResetTextInputOnSubmit,
594 NodeModifier::ResetOnTextInputChange,
595 NodeModifier::ResetOnTextInputCut,
596 NodeModifier::ResetOnTextInputPaste,
597 NodeModifier::ResetOnTextInputSelectionChange,
598 NodeModifier::ResetOnTextInputContentSizeChange,
599 NodeModifier::ResetOnTextInputInputFilterError,
600 NodeModifier::ResetTextInputOnTextContentScroll,
601 nullptr,
602 nullptr,
603 nullptr,
604 nullptr,
605 NodeModifier::ResetOnTextInputChangeWithPreviewText,
606 };
607
608 const ResetComponentAsyncEventHandler TEXT_AREA_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
609 NodeModifier::ResetOnTextAreaEditChange,
610 nullptr,
611 NodeModifier::ResetOnTextAreaChange,
612 NodeModifier::ResetOnTextAreaPaste,
613 NodeModifier::ResetOnTextAreaSelectionChange,
614 NodeModifier::ResetTextAreaOnSubmit,
615 NodeModifier::ResetOnTextAreaContentSizeChange,
616 NodeModifier::ResetOnTextAreaInputFilterError,
617 NodeModifier::ResetTextAreaOnTextContentScroll,
618 nullptr,
619 nullptr,
620 nullptr,
621 nullptr,
622 NodeModifier::ResetOnTextAreaChangeWithPreviewText,
623 };
624
625 const ResetComponentAsyncEventHandler REFRESH_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
626 NodeModifier::ResetRefreshOnStateChange,
627 NodeModifier::ResetOnRefreshing,
628 NodeModifier::ResetRefreshOnOffsetChange,
629 NodeModifier::ResetRefreshChangeEvent,
630 };
631
632 const ResetComponentAsyncEventHandler TOGGLE_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
633 NodeModifier::ResetOnToggleChange,
634 };
635
636 const ResetComponentAsyncEventHandler IMAGE_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
637 NodeModifier::ResetImageOnComplete,
638 NodeModifier::ResetImageOnError,
639 NodeModifier::ResetImageOnSvgPlayFinish,
640 NodeModifier::ResetImageOnDownloadProgress,
641 };
642
643 const ResetComponentAsyncEventHandler DATE_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
644 nullptr,
645 };
646
647 const ResetComponentAsyncEventHandler TIME_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
648 nullptr,
649 };
650
651 const ResetComponentAsyncEventHandler TEXT_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
652 nullptr,
653 };
654
655 const ResetComponentAsyncEventHandler CALENDAR_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
656 nullptr,
657 };
658
659 const ResetComponentAsyncEventHandler CHECKBOX_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
660 nullptr,
661 };
662
663 const ResetComponentAsyncEventHandler CHECKBOX_GROUP_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
664 NodeModifier::ResetCheckboxGroupChange,
665 };
666
667 const ResetComponentAsyncEventHandler SLIDER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
668 nullptr,
669 };
670
671 const ResetComponentAsyncEventHandler SWIPER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
672 nullptr,
673 nullptr,
674 nullptr,
675 nullptr,
676 nullptr,
677 nullptr,
678 };
679
680 const ResetComponentAsyncEventHandler CANVAS_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
681 nullptr,
682 };
683
684 const ResetComponentAsyncEventHandler LIST_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
685 NodeModifier::ResetOnListScroll,
686 NodeModifier::ResetOnListScrollIndex,
687 NodeModifier::ResetOnListScrollStart,
688 NodeModifier::ResetOnListScrollStop,
689 NodeModifier::ResetOnListScrollFrameBegin,
690 NodeModifier::ResetOnListWillScroll,
691 NodeModifier::ResetOnListDidScroll,
692 NodeModifier::ResetOnListReachStart,
693 NodeModifier::ResetOnListReachEnd,
694 NodeModifier::ResetOnScrollVisibleContentChange,
695 };
696
697 const ResetComponentAsyncEventHandler LIST_ITEM_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
698 NodeModifier::ResetListItemOnSelect,
699 };
700
701 const ResetComponentAsyncEventHandler WATERFLOW_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
702 NodeModifier::ResetOnWillScroll,
703 NodeModifier::ResetOnWaterFlowReachEnd,
704 NodeModifier::ResetOnDidScroll,
705 NodeModifier::ResetOnWaterFlowScrollStart,
706 NodeModifier::ResetOnWaterFlowScrollStop,
707 NodeModifier::ResetOnWaterFlowScrollFrameBegin,
708 NodeModifier::ResetOnWaterFlowScrollIndex,
709 NodeModifier::ResetOnWaterFlowReachStart,
710 };
711
712 const ResetComponentAsyncEventHandler GRID_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
713 nullptr,
714 nullptr,
715 nullptr,
716 NodeModifier::ResetOnGridScrollIndex,
717 };
718
719 const ResetComponentAsyncEventHandler ALPHABET_INDEXER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
720 nullptr,
721 nullptr,
722 nullptr,
723 nullptr,
724 nullptr,
725 };
726
727 const ResetComponentAsyncEventHandler SEARCH_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
728 nullptr,
729 nullptr,
730 nullptr,
731 nullptr,
732 nullptr,
733 };
734
735 const ResetComponentAsyncEventHandler RADIO_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
736 nullptr,
737 };
738
739 const ResetComponentAsyncEventHandler SELECT_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
740 nullptr,
741 };
742
743 const ResetComponentAsyncEventHandler IMAGE_ANIMATOR_NODE_RESET_ASYNC_EVENT_HANDLERS[] = {
744 NodeModifier::ResetImageAnimatorOnStart,
745 NodeModifier::ResetImageAnimatorOnPause,
746 NodeModifier::ResetImageAnimatorOnRepeat,
747 NodeModifier::ResetImageAnimatorOnCancel,
748 NodeModifier::ResetImageAnimatorOnFinish,
749 };
750
751 /* clang-format on */
NotifyComponentAsyncEvent(ArkUINodeHandle node,ArkUIEventSubKind kind,ArkUI_Int64 extraParam)752 void NotifyComponentAsyncEvent(ArkUINodeHandle node, ArkUIEventSubKind kind, ArkUI_Int64 extraParam)
753 {
754 unsigned int subClassType = kind / ARKUI_MAX_EVENT_NUM;
755 unsigned int subKind = kind % ARKUI_MAX_EVENT_NUM;
756 ComponentAsyncEventHandler eventHandle = nullptr;
757 switch (subClassType) {
758 case 0: {
759 // common event type.
760 if (subKind >= sizeof(commonNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
761 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
762 return;
763 }
764 eventHandle = commonNodeAsyncEventHandlers[subKind];
765 break;
766 }
767 case ARKUI_IMAGE: {
768 if (subKind >= sizeof(imageNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
769 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
770 return;
771 }
772 eventHandle = imageNodeAsyncEventHandlers[subKind];
773 break;
774 }
775 case ARKUI_SCROLL: {
776 // scroll event type.
777 if (subKind >= sizeof(scrollNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
778 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
779 return;
780 }
781 eventHandle = scrollNodeAsyncEventHandlers[subKind];
782 break;
783 }
784 case ARKUI_TEXT: {
785 // text event type.
786 if (subKind >= sizeof(TEXT_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
787 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
788 return;
789 }
790 eventHandle = TEXT_NODE_ASYNC_EVENT_HANDLERS[subKind];
791 break;
792 }
793 case ARKUI_TEXT_INPUT: {
794 // text input event type.
795 if (subKind >= sizeof(textInputNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
796 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
797 return;
798 }
799 eventHandle = textInputNodeAsyncEventHandlers[subKind];
800 break;
801 }
802 case ARKUI_TEXTAREA: {
803 // textarea event type.
804 if (subKind >= sizeof(textAreaNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
805 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
806 return;
807 }
808 eventHandle = textAreaNodeAsyncEventHandlers[subKind];
809 break;
810 }
811 case ARKUI_REFRESH: {
812 // refresh event type.
813 if (subKind >= sizeof(refreshNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
814 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
815 return;
816 }
817 eventHandle = refreshNodeAsyncEventHandlers[subKind];
818 break;
819 }
820 case ARKUI_TOGGLE: {
821 // toggle event type.
822 if (subKind >= sizeof(TOGGLE_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
823 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
824 return;
825 }
826 eventHandle = TOGGLE_NODE_ASYNC_EVENT_HANDLERS[subKind];
827 break;
828 }
829 case ARKUI_DATE_PICKER: {
830 // datepicker event type.
831 if (subKind >= sizeof(DATE_PICKER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
832 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
833 return;
834 }
835 eventHandle = DATE_PICKER_NODE_ASYNC_EVENT_HANDLERS[subKind];
836 break;
837 }
838 case ARKUI_TIME_PICKER: {
839 // timepicker event type.
840 if (subKind >= sizeof(TIME_PICKER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
841 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
842 return;
843 }
844 eventHandle = TIME_PICKER_NODE_ASYNC_EVENT_HANDLERS[subKind];
845 break;
846 }
847 case ARKUI_TEXT_PICKER: {
848 if (subKind >= sizeof(TEXT_PICKER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
849 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
850 return;
851 }
852 eventHandle = TEXT_PICKER_NODE_ASYNC_EVENT_HANDLERS[subKind];
853 break;
854 }
855 case ARKUI_CALENDAR_PICKER: {
856 // calendar picker event type.
857 if (subKind >= sizeof(CALENDAR_PICKER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
858 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
859 return;
860 }
861 eventHandle = CALENDAR_PICKER_NODE_ASYNC_EVENT_HANDLERS[subKind];
862 break;
863 }
864 case ARKUI_CHECKBOX: {
865 // timepicker event type.
866 if (subKind >= sizeof(CHECKBOX_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
867 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
868 return;
869 }
870 eventHandle = CHECKBOX_NODE_ASYNC_EVENT_HANDLERS[subKind];
871 break;
872 }
873 case ARKUI_SLIDER: {
874 // timepicker event type.
875 if (subKind >= sizeof(SLIDER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
876 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
877 return;
878 }
879 eventHandle = SLIDER_NODE_ASYNC_EVENT_HANDLERS[subKind];
880 break;
881 }
882 case ARKUI_SWIPER: {
883 // swiper event type.
884 if (subKind >= sizeof(SWIPER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
885 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
886 return;
887 }
888 eventHandle = SWIPER_NODE_ASYNC_EVENT_HANDLERS[subKind];
889 break;
890 }
891 case ARKUI_CANVAS: {
892 if (subKind >= sizeof(CANVAS_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
893 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
894 return;
895 }
896 eventHandle = CANVAS_NODE_ASYNC_EVENT_HANDLERS[subKind];
897 break;
898 }
899 case ARKUI_LIST: {
900 // list event type.
901 if (subKind >= sizeof(listNodeAsyncEventHandlers) / sizeof(ComponentAsyncEventHandler)) {
902 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
903 return;
904 }
905 eventHandle = listNodeAsyncEventHandlers[subKind];
906 break;
907 }
908 case ARKUI_LIST_ITEM: {
909 // list item event type.
910 if (subKind >= sizeof(LIST_ITEM_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
911 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
912 return;
913 }
914 eventHandle = LIST_ITEM_NODE_ASYNC_EVENT_HANDLERS[subKind];
915 break;
916 }
917 case ARKUI_WATER_FLOW: {
918 // swiper event type.
919 if (subKind >= sizeof(WATER_FLOW_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
920 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
921 return;
922 }
923 eventHandle = WATER_FLOW_NODE_ASYNC_EVENT_HANDLERS[subKind];
924 break;
925 }
926 case ARKUI_GRID: {
927 // grid event type.
928 if (subKind >= sizeof(GRID_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
929 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
930 return;
931 }
932 eventHandle = GRID_NODE_ASYNC_EVENT_HANDLERS[subKind];
933 break;
934 }
935 case ARKUI_ALPHABET_INDEXER: {
936 // alphabet indexer event type.
937 if (subKind >= sizeof(ALPHABET_INDEXER_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
938 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
939 return;
940 }
941 eventHandle = ALPHABET_INDEXER_NODE_ASYNC_EVENT_HANDLERS[subKind];
942 break;
943 }
944 case ARKUI_SEARCH: {
945 // search event type.
946 if (subKind >= sizeof(SEARCH_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
947 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
948 return;
949 }
950 eventHandle = SEARCH_NODE_ASYNC_EVENT_HANDLERS[subKind];
951 break;
952 }
953 case ARKUI_RADIO: {
954 // search event type.
955 if (subKind >= sizeof(RADIO_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
956 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
957 return;
958 }
959 eventHandle = RADIO_NODE_ASYNC_EVENT_HANDLERS[subKind];
960 break;
961 }
962 case ARKUI_SELECT: {
963 // select event type.
964 if (subKind >= sizeof(SELECT_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
965 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
966 return;
967 }
968 eventHandle = SELECT_NODE_ASYNC_EVENT_HANDLERS[subKind];
969 break;
970 }
971 case ARKUI_IMAGE_ANIMATOR: {
972 // imageAnimator event type.
973 if (subKind >= sizeof(IMAGE_ANIMATOR_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
974 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
975 return;
976 }
977 eventHandle = IMAGE_ANIMATOR_NODE_ASYNC_EVENT_HANDLERS[subKind];
978 break;
979 }
980 case ARKUI_CHECK_BOX_GROUP: {
981 if (subKind >= sizeof(CHECKBOX_GROUP_NODE_ASYNC_EVENT_HANDLERS) / sizeof(ComponentAsyncEventHandler)) {
982 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
983 return;
984 }
985 eventHandle = CHECKBOX_GROUP_NODE_ASYNC_EVENT_HANDLERS[subKind];
986 break;
987 }
988 default: {
989 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
990 }
991 }
992 if (eventHandle) {
993 // TODO: fix handlers.
994 eventHandle(node, reinterpret_cast<void*>(static_cast<intptr_t>(extraParam)));
995 } else {
996 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyComponentAsyncEvent kind:%{public}d EMPTY IMPLEMENT", kind);
997 }
998 }
999
NotifyResetComponentAsyncEvent(ArkUINodeHandle node,ArkUIEventSubKind kind)1000 void NotifyResetComponentAsyncEvent(ArkUINodeHandle node, ArkUIEventSubKind kind)
1001 {
1002 unsigned int subClassType = kind / ARKUI_MAX_EVENT_NUM;
1003 unsigned int subKind = kind % ARKUI_MAX_EVENT_NUM;
1004 ResetComponentAsyncEventHandler eventHandle = nullptr;
1005 switch (subClassType) {
1006 case 0: {
1007 // common event type.
1008 if (subKind >= sizeof(COMMON_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1009 TAG_LOGE(
1010 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1011 return;
1012 }
1013 eventHandle = COMMON_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1014 break;
1015 }
1016 case ARKUI_IMAGE: {
1017 if (subKind >= sizeof(IMAGE_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1018 TAG_LOGE(
1019 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1020 return;
1021 }
1022 eventHandle = IMAGE_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1023 break;
1024 }
1025 case ARKUI_SCROLL: {
1026 // scroll event type.
1027 if (subKind >= sizeof(SCROLL_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1028 TAG_LOGE(
1029 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1030 return;
1031 }
1032 eventHandle = SCROLL_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1033 break;
1034 }
1035 case ARKUI_TEXT: {
1036 // text event type.
1037 if (subKind >= sizeof(TEXT_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1038 TAG_LOGE(
1039 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1040 return;
1041 }
1042 eventHandle = TEXT_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1043 break;
1044 }
1045 case ARKUI_TEXT_INPUT: {
1046 // text input event type.
1047 if (subKind >=
1048 sizeof(TEXT_INPUT_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1049 TAG_LOGE(
1050 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1051 return;
1052 }
1053 eventHandle = TEXT_INPUT_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1054 break;
1055 }
1056 case ARKUI_TEXTAREA: {
1057 // textarea event type.
1058 if (subKind >=
1059 sizeof(TEXT_AREA_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1060 TAG_LOGE(
1061 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1062 return;
1063 }
1064 eventHandle = TEXT_AREA_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1065 break;
1066 }
1067 case ARKUI_REFRESH: {
1068 // refresh event type.
1069 if (subKind >= sizeof(REFRESH_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1070 TAG_LOGE(
1071 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1072 return;
1073 }
1074 eventHandle = REFRESH_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1075 break;
1076 }
1077 case ARKUI_TOGGLE: {
1078 // toggle event type.
1079 if (subKind >= sizeof(TOGGLE_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1080 TAG_LOGE(
1081 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1082 return;
1083 }
1084 eventHandle = TOGGLE_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1085 break;
1086 }
1087 case ARKUI_DATE_PICKER: {
1088 // datepicker event type.
1089 if (subKind >=
1090 sizeof(DATE_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1091 TAG_LOGE(
1092 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1093 return;
1094 }
1095 eventHandle = DATE_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1096 break;
1097 }
1098 case ARKUI_TIME_PICKER: {
1099 // timepicker event type.
1100 if (subKind >=
1101 sizeof(TIME_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1102 TAG_LOGE(
1103 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1104 return;
1105 }
1106 eventHandle = TIME_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1107 break;
1108 }
1109 case ARKUI_TEXT_PICKER: {
1110 if (subKind >=
1111 sizeof(TEXT_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1112 TAG_LOGE(
1113 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1114 return;
1115 }
1116 eventHandle = TEXT_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1117 break;
1118 }
1119 case ARKUI_CALENDAR_PICKER: {
1120 // calendar picker event type.
1121 if (subKind >= sizeof(CALENDAR_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(
1122 ResetComponentAsyncEventHandler)) {
1123 TAG_LOGE(
1124 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1125 return;
1126 }
1127 eventHandle = CALENDAR_PICKER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1128 break;
1129 }
1130 case ARKUI_CHECKBOX: {
1131 // timepicker event type.
1132 if (subKind >= sizeof(CHECKBOX_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1133 TAG_LOGE(
1134 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1135 return;
1136 }
1137 eventHandle = CHECKBOX_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1138 break;
1139 }
1140 case ARKUI_SLIDER: {
1141 // timepicker event type.
1142 if (subKind >= sizeof(SLIDER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1143 TAG_LOGE(
1144 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1145 return;
1146 }
1147 eventHandle = SLIDER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1148 break;
1149 }
1150 case ARKUI_SWIPER: {
1151 // swiper event type.
1152 if (subKind >= sizeof(SWIPER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1153 TAG_LOGE(
1154 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1155 return;
1156 }
1157 eventHandle = SWIPER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1158 break;
1159 }
1160 case ARKUI_CANVAS: {
1161 if (subKind >= sizeof(CANVAS_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1162 TAG_LOGE(
1163 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1164 return;
1165 }
1166 eventHandle = CANVAS_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1167 break;
1168 }
1169 case ARKUI_LIST: {
1170 // list event type.
1171 if (subKind >= sizeof(LIST_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1172 TAG_LOGE(
1173 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1174 return;
1175 }
1176 eventHandle = LIST_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1177 break;
1178 }
1179 case ARKUI_LIST_ITEM: {
1180 // list item event type.
1181 if (subKind >=
1182 sizeof(LIST_ITEM_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1183 TAG_LOGE(
1184 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1185 return;
1186 }
1187 eventHandle = LIST_ITEM_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1188 break;
1189 }
1190 case ARKUI_WATER_FLOW: {
1191 // swiper event type.
1192 if (subKind >=
1193 sizeof(WATERFLOW_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1194 TAG_LOGE(
1195 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1196 return;
1197 }
1198 eventHandle = WATERFLOW_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1199 break;
1200 }
1201 case ARKUI_GRID: {
1202 // grid event type.
1203 if (subKind >= sizeof(GRID_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1204 TAG_LOGE(
1205 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1206 return;
1207 }
1208 eventHandle = GRID_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1209 break;
1210 }
1211 case ARKUI_ALPHABET_INDEXER: {
1212 // alphabet indexer event type.
1213 if (subKind >= sizeof(ALPHABET_INDEXER_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(
1214 ResetComponentAsyncEventHandler)) {
1215 TAG_LOGE(
1216 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1217 return;
1218 }
1219 eventHandle = ALPHABET_INDEXER_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1220 break;
1221 }
1222 case ARKUI_SEARCH: {
1223 // search event type.
1224 if (subKind >= sizeof(SEARCH_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1225 TAG_LOGE(
1226 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1227 return;
1228 }
1229 eventHandle = SEARCH_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1230 break;
1231 }
1232 case ARKUI_RADIO: {
1233 // search event type.
1234 if (subKind >= sizeof(RADIO_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1235 TAG_LOGE(
1236 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1237 return;
1238 }
1239 eventHandle = RADIO_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1240 break;
1241 }
1242 case ARKUI_SELECT: {
1243 // select event type.
1244 if (subKind >= sizeof(SELECT_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1245 TAG_LOGE(
1246 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1247 return;
1248 }
1249 eventHandle = SELECT_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1250 break;
1251 }
1252 case ARKUI_IMAGE_ANIMATOR: {
1253 // imageAnimator event type.
1254 if (subKind >=
1255 sizeof(IMAGE_ANIMATOR_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1256 TAG_LOGE(
1257 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1258 return;
1259 }
1260 eventHandle = IMAGE_ANIMATOR_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1261 break;
1262 }
1263 case ARKUI_CHECK_BOX_GROUP: {
1264 if (subKind >=
1265 sizeof(CHECKBOX_GROUP_NODE_RESET_ASYNC_EVENT_HANDLERS) / sizeof(ResetComponentAsyncEventHandler)) {
1266 TAG_LOGE(
1267 AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1268 return;
1269 }
1270 eventHandle = CHECKBOX_GROUP_NODE_RESET_ASYNC_EVENT_HANDLERS[subKind];
1271 break;
1272 }
1273 default: {
1274 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d NOT IMPLEMENT", kind);
1275 }
1276 }
1277 if (eventHandle) {
1278 eventHandle(node);
1279 } else {
1280 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "NotifyResetComponentAsyncEvent kind:%{public}d EMPTY IMPLEMENT", kind);
1281 }
1282 }
1283
RegisterNodeAsyncEventReceiver(EventReceiver eventReceiver)1284 void RegisterNodeAsyncEventReceiver(EventReceiver eventReceiver)
1285 {
1286 NodeEvent::globalEventReceiver = eventReceiver;
1287 }
1288
UnregisterNodeAsyncEventReceiver()1289 void UnregisterNodeAsyncEventReceiver()
1290 {
1291 NodeEvent::globalEventReceiver = nullptr;
1292 }
1293
ApplyModifierFinish(ArkUINodeHandle nodePtr)1294 void ApplyModifierFinish(ArkUINodeHandle nodePtr)
1295 {
1296 auto* uiNode = reinterpret_cast<UINode*>(nodePtr);
1297 auto* frameNode = AceType::DynamicCast<FrameNode>(uiNode);
1298 if (frameNode) {
1299 frameNode->MarkModifyDone();
1300 }
1301 }
1302
MarkDirty(ArkUINodeHandle nodePtr,ArkUI_Uint32 flag)1303 void MarkDirty(ArkUINodeHandle nodePtr, ArkUI_Uint32 flag)
1304 {
1305 auto* uiNode = reinterpret_cast<UINode*>(nodePtr);
1306 if (uiNode) {
1307 uiNode->MarkDirtyNode(flag);
1308 }
1309 }
1310
SetCallbackMethod(ArkUIAPICallbackMethod * method)1311 static void SetCallbackMethod(ArkUIAPICallbackMethod* method)
1312 {
1313 ViewModel::SetCallbackMethod(method);
1314 }
1315
GetArkUIAPICallbackMethod()1316 ArkUIAPICallbackMethod* GetArkUIAPICallbackMethod()
1317 {
1318 return ViewModel::GetCallbackMethod();
1319 }
1320
GetPipelineContext(ArkUINodeHandle node)1321 ArkUIPipelineContext GetPipelineContext(ArkUINodeHandle node)
1322 {
1323 auto frameNode = reinterpret_cast<FrameNode*>(node);
1324 return reinterpret_cast<ArkUIPipelineContext>(frameNode->GetContext());
1325 }
1326
SetVsyncCallback(ArkUIVMContext vmContext,ArkUIPipelineContext pipelineContext,ArkUI_Int32 callbackId)1327 void SetVsyncCallback(ArkUIVMContext vmContext, ArkUIPipelineContext pipelineContext, ArkUI_Int32 callbackId)
1328 {
1329 static int vsyncCount = 1;
1330 auto vsync = [vmContext, callbackId]() {
1331 ArkUIEventCallbackArg args[] = { {.i32 =vsyncCount++ } };
1332 ArkUIAPICallbackMethod* cbs = GetArkUIAPICallbackMethod();
1333 CHECK_NULL_VOID(vmContext);
1334 CHECK_NULL_VOID(cbs);
1335 cbs->CallInt(vmContext, callbackId, 1, &args[0]);
1336 };
1337
1338 reinterpret_cast<PipelineContext*>(pipelineContext)->SetVsyncListener(vsync);
1339 }
1340
UnblockVsyncWait(ArkUIVMContext vmContext,ArkUIPipelineContext pipelineContext)1341 void UnblockVsyncWait(ArkUIVMContext vmContext, ArkUIPipelineContext pipelineContext)
1342 {
1343 reinterpret_cast<PipelineContext*>(pipelineContext)->RequestFrame();
1344 }
1345
MeasureNode(ArkUIVMContext vmContext,ArkUINodeHandle node,ArkUI_Float32 * data)1346 ArkUI_Int32 MeasureNode(ArkUIVMContext vmContext, ArkUINodeHandle node, ArkUI_Float32* data)
1347 {
1348 return ViewModel::MeasureNode(vmContext, node, data);
1349 }
1350
LayoutNode(ArkUIVMContext vmContext,ArkUINodeHandle node,ArkUI_Float32 (* data)[2])1351 ArkUI_Int32 LayoutNode(ArkUIVMContext vmContext, ArkUINodeHandle node, ArkUI_Float32 (*data)[2])
1352 {
1353 return ViewModel::LayoutNode(vmContext, node, data);
1354 }
1355
DrawNode(ArkUIVMContext vmContext,ArkUINodeHandle node,ArkUI_Float32 * data)1356 ArkUI_Int32 DrawNode(ArkUIVMContext vmContext, ArkUINodeHandle node, ArkUI_Float32* data)
1357 {
1358 return ViewModel::DrawNode(vmContext, node, data);
1359 }
1360
SetAttachNodePtr(ArkUINodeHandle node,void * value)1361 void SetAttachNodePtr(ArkUINodeHandle node, void* value)
1362 {
1363 return ViewModel::SetAttachNodePtr(node, value);
1364 }
1365
GetAttachNodePtr(ArkUINodeHandle node)1366 void* GetAttachNodePtr(ArkUINodeHandle node)
1367 {
1368 return ViewModel::GetAttachNodePtr(node);
1369 }
1370
MeasureLayoutAndDraw(ArkUIVMContext vmContext,ArkUINodeHandle rootPtr)1371 ArkUI_Int32 MeasureLayoutAndDraw(ArkUIVMContext vmContext, ArkUINodeHandle rootPtr)
1372 {
1373 auto* root = reinterpret_cast<FrameNode*>(rootPtr);
1374 float width = root->GetGeometryNode()->GetFrameSize().Width();
1375 float height = root->GetGeometryNode()->GetFrameSize().Height();
1376 // measure
1377 ArkUI_Float32 measureData[] = { width, height, width, height, width, height };
1378 MeasureNode(vmContext, rootPtr, &measureData[0]);
1379 // layout
1380 ArkUI_Float32 layoutData[] = { 0, 0 };
1381 LayoutNode(vmContext, rootPtr, &layoutData);
1382 // draw
1383 ArkUI_Float32 drawData[] = { 0, 0, 0, 0 };
1384 DrawNode(vmContext, rootPtr, &drawData[0]);
1385
1386 return 0;
1387 }
1388
RegisterCustomNodeAsyncEvent(ArkUINodeHandle node,int32_t eventType,void * extraParam)1389 void RegisterCustomNodeAsyncEvent(ArkUINodeHandle node, int32_t eventType, void* extraParam)
1390 {
1391 auto companion = ViewModel::GetCompanion(node);
1392 if (!companion) {
1393 ViewModel::RegisterCompanion(node, -1, eventType);
1394 auto companion = ViewModel::GetCompanion(node);
1395 CHECK_NULL_VOID(companion);
1396 companion->SetExtraParam(eventType, extraParam);
1397 } else {
1398 auto originEventType = companion->GetFlags();
1399 companion->SetFlags(static_cast<uint32_t>(originEventType) | static_cast<uint32_t>(eventType));
1400 companion->SetExtraParam(eventType, extraParam);
1401 }
1402 }
1403
RegisterCustomSpanAsyncEvent(ArkUINodeHandle node,int32_t eventType,void * extraParam)1404 void RegisterCustomSpanAsyncEvent(ArkUINodeHandle node, int32_t eventType, void* extraParam)
1405 {
1406 switch (eventType) {
1407 case ArkUIAPINodeFlags::CUSTOM_MEASURE:
1408 NodeModifier::SetCustomSpanOnMeasure(node, extraParam);
1409 break;
1410 case ArkUIAPINodeFlags::CUSTOM_DRAW:
1411 NodeModifier::SetCustomSpanOnDraw(node, extraParam);
1412 break;
1413 default:
1414 break;
1415 }
1416 }
1417
UnregisterCustomNodeEvent(ArkUINodeHandle node,ArkUI_Int32 eventType)1418 ArkUI_Int32 UnregisterCustomNodeEvent(ArkUINodeHandle node, ArkUI_Int32 eventType)
1419 {
1420 auto companion = ViewModel::GetCompanion(node);
1421 CHECK_NULL_RETURN(companion, -1);
1422 auto originEventType = static_cast<uint32_t>(companion->GetFlags());
1423 //check is Contains
1424 if ((originEventType & static_cast<uint32_t>(eventType)) != static_cast<uint32_t>(eventType)) {
1425 return -1;
1426 }
1427 companion->SetFlags(static_cast<uint32_t>(originEventType) ^ static_cast<uint32_t>(eventType));
1428 companion->EraseExtraParam(eventType);
1429 return 0;
1430 }
1431
RegisterCustomNodeEventReceiver(void (* eventReceiver)(ArkUICustomNodeEvent * event))1432 void RegisterCustomNodeEventReceiver(void (*eventReceiver)(ArkUICustomNodeEvent* event))
1433 {
1434 CustomNodeEvent::g_fliter = eventReceiver;
1435 }
1436
SetMeasureWidth(ArkUINodeHandle node,ArkUI_Int32 value)1437 void SetMeasureWidth(ArkUINodeHandle node, ArkUI_Int32 value)
1438 {
1439 // directly set frameNode measure width.
1440 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1441 if (!frameNode) {
1442 return;
1443 }
1444 frameNode->GetGeometryNode()->SetFrameWidth(value);
1445 }
1446
GetMeasureWidth(ArkUINodeHandle node)1447 ArkUI_Int32 GetMeasureWidth(ArkUINodeHandle node)
1448 {
1449 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1450 if (!frameNode) {
1451 return 0;
1452 }
1453 return frameNode->GetGeometryNode()->GetFrameSize().Width();
1454 }
1455
SetMeasureHeight(ArkUINodeHandle node,ArkUI_Int32 value)1456 void SetMeasureHeight(ArkUINodeHandle node, ArkUI_Int32 value)
1457 {
1458 // directly set frameNode measure height.
1459 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1460 if (!frameNode) {
1461 return;
1462 }
1463 frameNode->GetGeometryNode()->SetFrameHeight(value);
1464 }
1465
GetMeasureHeight(ArkUINodeHandle node)1466 ArkUI_Int32 GetMeasureHeight(ArkUINodeHandle node)
1467 {
1468 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1469 if (!frameNode) {
1470 return 0;
1471 }
1472 return frameNode->GetGeometryNode()->GetFrameSize().Height();
1473 }
1474
SetX(ArkUINodeHandle node,ArkUI_Int32 value)1475 void SetX(ArkUINodeHandle node, ArkUI_Int32 value)
1476 {
1477 // directly set frameNode measure postionX.
1478 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1479 if (!frameNode) {
1480 return;
1481 }
1482 frameNode->GetGeometryNode()->SetMarginFrameOffsetX(value);
1483 }
1484
SetY(ArkUINodeHandle node,ArkUI_Int32 value)1485 void SetY(ArkUINodeHandle node, ArkUI_Int32 value)
1486 {
1487 // directly set frameNode measure postionY.
1488 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1489 if (!frameNode) {
1490 return;
1491 }
1492 frameNode->GetGeometryNode()->SetMarginFrameOffsetY(value);
1493 }
1494
GetX(ArkUINodeHandle node)1495 ArkUI_Int32 GetX(ArkUINodeHandle node)
1496 {
1497 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1498 if (!frameNode) {
1499 return 0;
1500 }
1501 return frameNode->GetGeometryNode()->GetMarginFrameOffset().GetX();
1502 }
1503
GetY(ArkUINodeHandle node)1504 ArkUI_Int32 GetY(ArkUINodeHandle node)
1505 {
1506 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1507 if (!frameNode) {
1508 return 0;
1509 }
1510 return frameNode->GetGeometryNode()->GetMarginFrameOffset().GetY();
1511 }
1512
SetCustomMethodFlag(ArkUINodeHandle node,ArkUI_Int32 flag)1513 void SetCustomMethodFlag(ArkUINodeHandle node, ArkUI_Int32 flag)
1514 {
1515 auto* companion = ViewModel::GetCompanion(node);
1516 CHECK_NULL_VOID(companion);
1517 companion->SetFlags(flag);
1518 }
1519
GetCustomMethodFlag(ArkUINodeHandle node)1520 ArkUI_Int32 GetCustomMethodFlag(ArkUINodeHandle node)
1521 {
1522 auto* companion = ViewModel::GetCompanion(node);
1523 CHECK_NULL_RETURN(companion, 0);
1524 return companion->GetFlags();
1525 }
1526
SetAlignment(ArkUINodeHandle node,ArkUI_Int32 value)1527 void SetAlignment(ArkUINodeHandle node, ArkUI_Int32 value)
1528 {
1529 auto* companion = ViewModel::GetCompanion(node);
1530 CHECK_NULL_VOID(companion);
1531 companion->SetAlignmentValue(value);
1532 }
1533
GetAlignment(ArkUINodeHandle node)1534 ArkUI_Int32 GetAlignment(ArkUINodeHandle node)
1535 {
1536 auto* companion = ViewModel::GetCompanion(node);
1537 CHECK_NULL_RETURN(companion, 0);
1538 return companion->GetAlignmentValue();
1539 }
1540
GetLayoutConstraint(ArkUINodeHandle node,ArkUI_Int32 * value)1541 void GetLayoutConstraint(ArkUINodeHandle node, ArkUI_Int32* value)
1542 {
1543 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
1544 CHECK_NULL_VOID(frameNode);
1545 auto layoutConstraint = frameNode->GetLayoutProperty()->GetContentLayoutConstraint();
1546 if (layoutConstraint.has_value()) {
1547 //min
1548 value[0] = static_cast<ArkUI_Int32>(layoutConstraint.value().minSize.Width());
1549 //min
1550 value[1] = static_cast<ArkUI_Int32>(layoutConstraint.value().minSize.Height());
1551 //.max
1552 value[2] = static_cast<ArkUI_Int32>(layoutConstraint.value().maxSize.Width());
1553 //.max
1554 value[3] = static_cast<ArkUI_Int32>(layoutConstraint.value().maxSize.Height());
1555 //percentReference
1556 value[4] = static_cast<ArkUI_Int32>(layoutConstraint.value().percentReference.Width());
1557 //percentReference
1558 value[5] = static_cast<ArkUI_Int32>(layoutConstraint.value().percentReference.Height());
1559 }
1560 }
1561
1562
1563
GetNavigationId(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1564 ArkUI_Int32 GetNavigationId(
1565 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1566 {
1567 auto navDesInfo = GetNavDestinationInfoByNode(node);
1568 CHECK_NULL_RETURN(navDesInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1569 std::string navigationId = navDesInfo->navigationId;
1570 return WriteStringToBuffer(navigationId, buffer, bufferSize, writeLen);
1571 }
1572
GetNavDestinationName(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1573 ArkUI_Int32 GetNavDestinationName(
1574 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1575 {
1576 auto navDesInfo = GetNavDestinationInfoByNode(node);
1577 CHECK_NULL_RETURN(navDesInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1578 std::string name = navDesInfo->name;
1579 return WriteStringToBuffer(name, buffer, bufferSize, writeLen);
1580 }
1581
GetStackLength(ArkUINodeHandle node)1582 ArkUI_Int32 GetStackLength(ArkUINodeHandle node)
1583 {
1584 auto navigationStack = GetNavigationStackByNode(node);
1585 CHECK_NULL_RETURN(navigationStack, INVLID_VALUE);
1586 return navigationStack->Size();
1587 }
1588
GetNavDesNameByIndex(ArkUINodeHandle node,ArkUI_Int32 index,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1589 ArkUI_Int32 GetNavDesNameByIndex(
1590 ArkUINodeHandle node, ArkUI_Int32 index, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1591 {
1592 auto navigationStack = GetNavigationStackByNode(node);
1593 CHECK_NULL_RETURN(navigationStack, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1594 if (index < 0 || index >= navigationStack->Size()) {
1595 return ERROR_CODE_NATIVE_IMPL_NODE_INDEX_INVALID;
1596 }
1597
1598 std::string name = navigationStack->GetNavDesNameByIndex(index);
1599 return WriteStringToBuffer(name, buffer, bufferSize, writeLen);
1600 }
1601
GetNavDestinationId(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1602 ArkUI_Int32 GetNavDestinationId(
1603 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1604 {
1605 auto navDesInfo = GetNavDestinationInfoByNode(node);
1606 CHECK_NULL_RETURN(navDesInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1607 std::string navDestinationId = navDesInfo->navDestinationId;
1608 return WriteStringToBuffer(navDestinationId, buffer, bufferSize, writeLen);
1609 }
1610
GetNavDestinationState(ArkUINodeHandle node)1611 ArkUI_Int32 GetNavDestinationState(ArkUINodeHandle node)
1612 {
1613 auto navDesInfo = GetNavDestinationInfoByNode(node);
1614 CHECK_NULL_RETURN(navDesInfo, INVLID_VALUE);
1615 return static_cast<int32_t>(navDesInfo->state);
1616 }
1617
GetNavDestinationIndex(ArkUINodeHandle node)1618 ArkUI_Int32 GetNavDestinationIndex(ArkUINodeHandle node)
1619 {
1620 auto navDesInfo = GetNavDestinationInfoByNode(node);
1621 CHECK_NULL_RETURN(navDesInfo, INVLID_VALUE);
1622 return navDesInfo->index;
1623 }
1624
GetNavDestinationParam(ArkUINodeHandle node)1625 void* GetNavDestinationParam(ArkUINodeHandle node)
1626 {
1627 auto navDesInfo = GetNavDestinationInfoByNode(node);
1628 CHECK_NULL_RETURN(navDesInfo, nullptr);
1629 return reinterpret_cast<void*>(navDesInfo->param);
1630 }
1631
GetRouterPageIndex(ArkUINodeHandle node)1632 ArkUI_Int32 GetRouterPageIndex(ArkUINodeHandle node)
1633 {
1634 auto routerInfo = GetRouterPageInfoByNode(node);
1635 CHECK_NULL_RETURN(routerInfo, INVLID_VALUE);
1636 return routerInfo->index;
1637 }
1638
GetRouterPageName(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1639 ArkUI_Int32 GetRouterPageName(
1640 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1641 {
1642 auto routerInfo = GetRouterPageInfoByNode(node);
1643 CHECK_NULL_RETURN(routerInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1644 std::string name = routerInfo->name;
1645 return WriteStringToBuffer(name, buffer, bufferSize, writeLen);
1646 }
1647
GetRouterPagePath(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1648 ArkUI_Int32 GetRouterPagePath(
1649 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1650 {
1651 auto routerInfo = GetRouterPageInfoByNode(node);
1652 CHECK_NULL_RETURN(routerInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1653 std::string path = routerInfo->path;
1654 return WriteStringToBuffer(path, buffer, bufferSize, writeLen);
1655 }
1656
GetRouterPageState(ArkUINodeHandle node)1657 ArkUI_Int32 GetRouterPageState(ArkUINodeHandle node)
1658 {
1659 auto routerInfo = GetRouterPageInfoByNode(node);
1660 CHECK_NULL_RETURN(routerInfo, INVLID_VALUE);
1661 return static_cast<int32_t>(routerInfo->state);
1662 }
1663
GetRouterPageId(ArkUINodeHandle node,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * writeLen)1664 ArkUI_Int32 GetRouterPageId(
1665 ArkUINodeHandle node, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* writeLen)
1666 {
1667 auto routerInfo = GetRouterPageInfoByNode(node);
1668 CHECK_NULL_RETURN(routerInfo, ERROR_CODE_NATIVE_IMPL_GET_INFO_FAILED);
1669 std::string pageId = routerInfo->pageId;
1670 return WriteStringToBuffer(pageId, buffer, bufferSize, writeLen);
1671 }
1672
GetContextByNode(ArkUINodeHandle node)1673 int32_t GetContextByNode(ArkUINodeHandle node)
1674 {
1675 int32_t instanceId = -1;
1676 FrameNode* currentNode = reinterpret_cast<FrameNode*>(node);
1677 CHECK_NULL_RETURN(currentNode, instanceId);
1678 auto pipeline = currentNode->GetContext();
1679 CHECK_NULL_RETURN(pipeline, instanceId);
1680 instanceId = pipeline->GetInstanceId();
1681 return instanceId;
1682 }
1683
GetBasicAPI()1684 const ArkUIBasicAPI* GetBasicAPI()
1685 {
1686 /* clang-format off */
1687 static const ArkUIBasicAPI basicImpl = {
1688 CreateNode,
1689 CreateNodeWithParams,
1690 GetNodeByViewStack,
1691 DisposeNode,
1692 GetName,
1693 DumpTreeNode,
1694
1695 AddChild,
1696 RemoveChild,
1697 InsertChildAfter,
1698 InsertChildBefore,
1699 InsertChildAt,
1700 GetAttribute,
1701 SetAttribute,
1702 ResetAttribute,
1703
1704 NotifyComponentAsyncEvent,
1705 NotifyResetComponentAsyncEvent,
1706 RegisterNodeAsyncEventReceiver,
1707 UnregisterNodeAsyncEventReceiver,
1708
1709 nullptr,
1710
1711 ApplyModifierFinish,
1712 MarkDirty,
1713 IsBuilderNode,
1714 ConvertLengthMetricsUnit,
1715
1716 GetContextByNode,
1717 };
1718 /* clang-format on */
1719
1720 return &basicImpl;
1721 }
1722
GetCJUIBasicAPI()1723 const CJUIBasicAPI* GetCJUIBasicAPI()
1724 {
1725 /* clang-format off */
1726 static const CJUIBasicAPI basicImpl = {
1727 CreateNode,
1728 DisposeNode,
1729 GetName,
1730 DumpTreeNode,
1731
1732 AddChild,
1733 RemoveChild,
1734 InsertChildAfter,
1735 InsertChildBefore,
1736 InsertChildAt,
1737 GetAttribute,
1738 SetAttribute,
1739 ResetAttribute,
1740
1741 NotifyComponentAsyncEvent,
1742 NotifyResetComponentAsyncEvent,
1743 RegisterNodeAsyncEventReceiver,
1744 UnregisterNodeAsyncEventReceiver,
1745
1746 nullptr,
1747
1748 ApplyModifierFinish,
1749 MarkDirty,
1750 IsBuilderNode,
1751 ConvertLengthMetricsUnit,
1752
1753 GetContextByNode,
1754 };
1755 /* clang-format on */
1756
1757 return &basicImpl;
1758 }
1759
CreateDialog()1760 ArkUIDialogHandle CreateDialog()
1761 {
1762 return CustomDialog::CreateDialog();
1763 }
1764
DisposeDialog(ArkUIDialogHandle handle)1765 void DisposeDialog(ArkUIDialogHandle handle)
1766 {
1767 CustomDialog::DisposeDialog(handle);
1768 }
1769
SetDialogContent(ArkUIDialogHandle handle,ArkUINodeHandle contentNode)1770 ArkUI_Int32 SetDialogContent(ArkUIDialogHandle handle, ArkUINodeHandle contentNode)
1771 {
1772 return CustomDialog::SetDialogContent(handle, contentNode);
1773 }
1774
RemoveDialogContent(ArkUIDialogHandle handle)1775 ArkUI_Int32 RemoveDialogContent(ArkUIDialogHandle handle)
1776 {
1777 return CustomDialog::RemoveDialogContent(handle);
1778 }
1779
SetDialogContentAlignment(ArkUIDialogHandle handle,ArkUI_Int32 alignment,ArkUI_Float32 offsetX,ArkUI_Float32 offsetY)1780 ArkUI_Int32 SetDialogContentAlignment(
1781 ArkUIDialogHandle handle, ArkUI_Int32 alignment, ArkUI_Float32 offsetX, ArkUI_Float32 offsetY)
1782 {
1783 return CustomDialog::SetDialogContentAlignment(handle, alignment, offsetX, offsetY);
1784 }
1785
ResetDialogContentAlignment(ArkUIDialogHandle handle)1786 ArkUI_Int32 ResetDialogContentAlignment(ArkUIDialogHandle handle)
1787 {
1788 return CustomDialog::ResetDialogContentAlignment(handle);
1789 }
1790
SetDialogModalMode(ArkUIDialogHandle handle,ArkUI_Bool isModal)1791 ArkUI_Int32 SetDialogModalMode(ArkUIDialogHandle handle, ArkUI_Bool isModal)
1792 {
1793 return CustomDialog::SetDialogModalMode(handle, isModal);
1794 }
1795
SetDialogAutoCancel(ArkUIDialogHandle handle,ArkUI_Bool autoCancel)1796 ArkUI_Int32 SetDialogAutoCancel(ArkUIDialogHandle handle, ArkUI_Bool autoCancel)
1797 {
1798 return CustomDialog::SetDialogAutoCancel(handle, autoCancel);
1799 }
1800
SetDialogMask(ArkUIDialogHandle handle,ArkUI_Uint32 maskColor,ArkUIRect * rect)1801 ArkUI_Int32 SetDialogMask(ArkUIDialogHandle handle, ArkUI_Uint32 maskColor, ArkUIRect* rect)
1802 {
1803 return CustomDialog::SetDialogMask(handle, maskColor, rect);
1804 }
1805
SetDialogBackgroundColor(ArkUIDialogHandle handle,uint32_t backgroundColor)1806 ArkUI_Int32 SetDialogBackgroundColor(ArkUIDialogHandle handle, uint32_t backgroundColor)
1807 {
1808 return CustomDialog::SetDialogBackgroundColor(handle, backgroundColor);
1809 }
1810
SetDialogCornerRadius(ArkUIDialogHandle handle,float topLeft,float topRight,float bottomLeft,float bottomRight)1811 ArkUI_Int32 SetDialogCornerRadius(
1812 ArkUIDialogHandle handle, float topLeft, float topRight, float bottomLeft, float bottomRight)
1813 {
1814 return CustomDialog::SetDialogCornerRadius(handle, topLeft, topRight, bottomLeft, bottomRight);
1815 }
1816
SetDialogGridColumnCount(ArkUIDialogHandle handle,int32_t gridCount)1817 ArkUI_Int32 SetDialogGridColumnCount(ArkUIDialogHandle handle, int32_t gridCount)
1818 {
1819 return CustomDialog::SetDialogGridColumnCount(handle, gridCount);
1820 }
1821
EnableDialogCustomStyle(ArkUIDialogHandle handle,ArkUI_Bool enableCustomStyle)1822 ArkUI_Int32 EnableDialogCustomStyle(ArkUIDialogHandle handle, ArkUI_Bool enableCustomStyle)
1823 {
1824 return CustomDialog::EnableDialogCustomStyle(handle, enableCustomStyle);
1825 }
1826
EnableDialogCustomAnimation(ArkUIDialogHandle handle,ArkUI_Bool enableCustomAnimation)1827 ArkUI_Int32 EnableDialogCustomAnimation(ArkUIDialogHandle handle, ArkUI_Bool enableCustomAnimation)
1828 {
1829 return CustomDialog::EnableDialogCustomAnimation(handle, enableCustomAnimation);
1830 }
1831
ShowDialog(ArkUIDialogHandle handle,ArkUI_Bool showInSubWindow)1832 ArkUI_Int32 ShowDialog(ArkUIDialogHandle handle, ArkUI_Bool showInSubWindow)
1833 {
1834 return CustomDialog::ShowDialog(handle, showInSubWindow);
1835 }
1836
CloseDialog(ArkUIDialogHandle handle)1837 ArkUI_Int32 CloseDialog(ArkUIDialogHandle handle)
1838 {
1839 return CustomDialog::CloseDialog(handle);
1840 }
1841
1842 // Register closing event
RegisterOnWillDialogDismiss(ArkUIDialogHandle handle,bool (* eventHandler)(ArkUI_Int32))1843 ArkUI_Int32 RegisterOnWillDialogDismiss(ArkUIDialogHandle handle, bool (*eventHandler)(ArkUI_Int32))
1844 {
1845 return CustomDialog::RegisterOnWillDialogDismiss(handle, eventHandler);
1846 }
1847
1848 // Register closing event
RegisterOnWillDismissWithUserData(ArkUIDialogHandle handler,void * userData,void (* callback)(ArkUI_DialogDismissEvent * event))1849 ArkUI_Int32 RegisterOnWillDismissWithUserData(
1850 ArkUIDialogHandle handler, void* userData, void (*callback)(ArkUI_DialogDismissEvent* event))
1851 {
1852 return CustomDialog::RegisterOnWillDialogDismissWithUserData(handler, userData, callback);
1853 }
1854
SetKeyboardAvoidDistance(ArkUIDialogHandle handle,float distance,ArkUI_Int32 unit)1855 ArkUI_Int32 SetKeyboardAvoidDistance(ArkUIDialogHandle handle, float distance, ArkUI_Int32 unit)
1856 {
1857 return CustomDialog::SetKeyboardAvoidDistance(handle, distance, unit);
1858 }
1859
SetDialogLevelMode(ArkUIDialogHandle handle,ArkUI_Int32 mode)1860 ArkUI_Int32 SetDialogLevelMode(ArkUIDialogHandle handle, ArkUI_Int32 mode)
1861 {
1862 return CustomDialog::SetLevelMode(handle, mode);
1863 }
1864
SetDialogLevelUniqueId(ArkUIDialogHandle handle,ArkUI_Int32 uniqueId)1865 ArkUI_Int32 SetDialogLevelUniqueId(ArkUIDialogHandle handle, ArkUI_Int32 uniqueId)
1866 {
1867 return CustomDialog::SetLevelUniqueId(handle, uniqueId);
1868 }
1869
SetDialogImmersiveMode(ArkUIDialogHandle handle,ArkUI_Int32 mode)1870 ArkUI_Int32 SetDialogImmersiveMode(ArkUIDialogHandle handle, ArkUI_Int32 mode)
1871 {
1872 return CustomDialog::SetImmersiveMode(handle, mode);
1873 }
1874
GetDialogAPI()1875 const ArkUIDialogAPI* GetDialogAPI()
1876 {
1877 static const ArkUIDialogAPI dialogImpl = {
1878 CreateDialog,
1879 DisposeDialog,
1880 SetDialogContent,
1881 RemoveDialogContent,
1882 SetDialogContentAlignment,
1883 ResetDialogContentAlignment,
1884 SetDialogModalMode,
1885 SetDialogAutoCancel,
1886 SetDialogMask,
1887 SetDialogBackgroundColor,
1888 SetDialogCornerRadius,
1889 SetDialogGridColumnCount,
1890 EnableDialogCustomStyle,
1891 EnableDialogCustomAnimation,
1892 ShowDialog,
1893 CloseDialog,
1894 RegisterOnWillDialogDismiss,
1895 RegisterOnWillDismissWithUserData,
1896 SetKeyboardAvoidDistance,
1897 SetDialogLevelMode,
1898 SetDialogLevelUniqueId,
1899 SetDialogImmersiveMode,
1900 };
1901 return &dialogImpl;
1902 }
1903
ShowCrash(ArkUI_CharPtr message)1904 void ShowCrash(ArkUI_CharPtr message)
1905 {
1906 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Arkoala crash: %{public}s", message);
1907 }
1908
1909 /* clang-format off */
1910 ArkUIExtendedNodeAPI impl_extended = {
1911 ARKUI_EXTENDED_API_VERSION,
1912
1913 NodeModifier::GetUtilsModifier, // getUtilsModifier
1914 NodeModifier::GetCanvasRenderingContext2DModifier,
1915
1916 SetCallbackMethod,
1917 SetCustomMethodFlag,
1918 GetCustomMethodFlag,
1919 RegisterCustomNodeAsyncEvent,
1920 RegisterCustomSpanAsyncEvent,
1921 UnregisterCustomNodeEvent,
1922 RegisterCustomNodeEventReceiver,
1923 SetCustomCallback, // setCustomCallback
1924 MeasureLayoutAndDraw,
1925 MeasureNode,
1926 LayoutNode,
1927 DrawNode,
1928 SetAttachNodePtr,
1929 GetAttachNodePtr,
1930 SetMeasureWidth, // setMeasureWidth
1931 GetMeasureWidth, // getMeasureWidth
1932 SetMeasureHeight, // setMeasureHeight
1933 GetMeasureHeight, // getMeasureHeight
1934 SetX, // setX
1935 SetY, // setY
1936 GetX, // getX
1937 GetY, // getY
1938 GetLayoutConstraint,
1939 SetAlignment,
1940 GetAlignment,
1941 nullptr, // indexerChecker
1942 nullptr, // setRangeUpdater
1943 nullptr, // setLazyItemIndexer
1944 GetPipelineContext,
1945 SetVsyncCallback,
1946 UnblockVsyncWait,
1947 NodeEvent::CheckEvent,
1948 NodeEvent::SendArkUIAsyncEvent, // sendEvent
1949 nullptr, // callContinuation
1950 nullptr, // setChildTotalCount
1951 ShowCrash,
1952 };
1953 /* clang-format on */
1954
CanvasDrawRect(ArkUICanvasHandle canvas,ArkUI_Float32 left,ArkUI_Float32 top,ArkUI_Float32 right,ArkUI_Float32 bottom,ArkUIPaintHandle paint)1955 void CanvasDrawRect(ArkUICanvasHandle canvas, ArkUI_Float32 left, ArkUI_Float32 top, ArkUI_Float32 right,
1956 ArkUI_Float32 bottom, ArkUIPaintHandle paint) {}
1957
GetCanvasAPI()1958 const ArkUIGraphicsCanvas* GetCanvasAPI()
1959 {
1960 static const ArkUIGraphicsCanvas modifier = { nullptr, nullptr, nullptr, nullptr, nullptr, CanvasDrawRect,
1961 nullptr };
1962 return &modifier;
1963 }
1964
1965 struct DummyPaint {
1966 ArkUI_Int32 color;
1967 };
1968
PaintMake()1969 ArkUIPaintHandle PaintMake()
1970 {
1971 return reinterpret_cast<ArkUIPaintHandle>(new DummyPaint());
1972 }
1973
PaintFinalize(ArkUIPaintHandle paintPtr)1974 void PaintFinalize(ArkUIPaintHandle paintPtr)
1975 {
1976 auto* paint = reinterpret_cast<DummyPaint*>(paintPtr);
1977 delete paint;
1978 }
1979
GetPaintAPI()1980 const ArkUIGraphicsPaint* GetPaintAPI()
1981 {
1982 static const ArkUIGraphicsPaint modifier = { PaintMake, PaintFinalize, nullptr, nullptr, nullptr, nullptr };
1983 return &modifier;
1984 }
1985
GetFontAPI()1986 const ArkUIGraphicsFont* GetFontAPI()
1987 {
1988 static const ArkUIGraphicsFont modifier = {
1989 nullptr,
1990 };
1991 return &modifier;
1992 }
1993
GetGraphicsAPI()1994 const ArkUIGraphicsAPI* GetGraphicsAPI()
1995 {
1996 static const ArkUIGraphicsAPI api = { ARKUI_NODE_GRAPHICS_API_VERSION, SetCallbackMethod, GetCanvasAPI, GetPaintAPI,
1997 GetFontAPI };
1998 return &api;
1999 }
2000
AnimateTo(ArkUIContext * context,ArkUIAnimateOption option,void * event,void * user)2001 void AnimateTo(ArkUIContext* context, ArkUIAnimateOption option, void* event, void* user)
2002 {
2003 ViewAnimate::AnimateTo(context, option, reinterpret_cast<void (*)(void*)>(event), user);
2004 }
2005
KeyframeAnimateTo(ArkUIContext * context,ArkUIKeyframeAnimateOption * animateOption)2006 void KeyframeAnimateTo(ArkUIContext* context, ArkUIKeyframeAnimateOption* animateOption)
2007 {
2008 ViewAnimate::KeyframeAnimateTo(context, animateOption);
2009 }
2010
CreateAnimator(ArkUIContext * context,ArkUIAnimatorOption * animateOption)2011 ArkUIAnimatorHandle CreateAnimator(ArkUIContext* context, ArkUIAnimatorOption* animateOption)
2012 {
2013 return ViewAnimate::CreateAnimator(context, animateOption);
2014 }
2015
DisposeAnimator(ArkUIAnimatorHandle animator)2016 void DisposeAnimator(ArkUIAnimatorHandle animator)
2017 {
2018 ViewAnimate::DisposeAnimator(animator);
2019 }
2020
AnimatorReset(ArkUIAnimatorHandle animator,ArkUIAnimatorOption * option)2021 ArkUI_Int32 AnimatorReset(ArkUIAnimatorHandle animator, ArkUIAnimatorOption* option)
2022 {
2023 return ViewAnimate::AnimatorReset(animator, option);
2024 }
2025
AnimatorPlay(ArkUIAnimatorHandle animator)2026 ArkUI_Int32 AnimatorPlay(ArkUIAnimatorHandle animator)
2027 {
2028 return ViewAnimate::AnimatorPlay(animator);
2029 }
2030
AnimatorFinish(ArkUIAnimatorHandle animator)2031 ArkUI_Int32 AnimatorFinish(ArkUIAnimatorHandle animator)
2032 {
2033 return ViewAnimate::AnimatorFinish(animator);
2034 }
2035
AnimatorPause(ArkUIAnimatorHandle animator)2036 ArkUI_Int32 AnimatorPause(ArkUIAnimatorHandle animator)
2037 {
2038 return ViewAnimate::AnimatorPause(animator);
2039 }
2040
AnimatorCancel(ArkUIAnimatorHandle animator)2041 ArkUI_Int32 AnimatorCancel(ArkUIAnimatorHandle animator)
2042 {
2043 return ViewAnimate::AnimatorCancel(animator);
2044 }
2045
AnimatorReverse(ArkUIAnimatorHandle animator)2046 ArkUI_Int32 AnimatorReverse(ArkUIAnimatorHandle animator)
2047 {
2048 return ViewAnimate::AnimatorReverse(animator);
2049 }
2050
CreateCurve(ArkUI_Int32 curve)2051 ArkUICurveHandle CreateCurve(ArkUI_Int32 curve)
2052 {
2053 return ViewAnimate::CreateCurve(curve);
2054 }
2055
CreateStepsCurve(ArkUI_Int32 count,ArkUI_Bool end)2056 ArkUICurveHandle CreateStepsCurve(ArkUI_Int32 count, ArkUI_Bool end)
2057 {
2058 return ViewAnimate::CreateStepsCurve(count, end);
2059 }
2060
CreateCubicBezierCurve(ArkUI_Float32 x1,ArkUI_Float32 y1,ArkUI_Float32 x2,ArkUI_Float32 y2)2061 ArkUICurveHandle CreateCubicBezierCurve(ArkUI_Float32 x1, ArkUI_Float32 y1, ArkUI_Float32 x2, ArkUI_Float32 y2)
2062 {
2063 return ViewAnimate::CreateCubicBezierCurve(x1, y1, x2, y2);
2064 }
2065
CreateSpringCurve(ArkUI_Float32 velocity,ArkUI_Float32 mass,ArkUI_Float32 stiffness,ArkUI_Float32 damping)2066 ArkUICurveHandle CreateSpringCurve(
2067 ArkUI_Float32 velocity, ArkUI_Float32 mass, ArkUI_Float32 stiffness, ArkUI_Float32 damping)
2068 {
2069 return ViewAnimate::CreateSpringCurve(velocity, mass, stiffness, damping);
2070 }
2071
CreateSpringMotion(ArkUI_Float32 response,ArkUI_Float32 dampingFraction,ArkUI_Float32 overlapDuration)2072 ArkUICurveHandle CreateSpringMotion(
2073 ArkUI_Float32 response, ArkUI_Float32 dampingFraction, ArkUI_Float32 overlapDuration)
2074 {
2075 return ViewAnimate::CreateSpringMotion(response, dampingFraction, overlapDuration);
2076 }
2077
CreateResponsiveSpringMotion(ArkUI_Float32 response,ArkUI_Float32 dampingFraction,ArkUI_Float32 overlapDuration)2078 ArkUICurveHandle CreateResponsiveSpringMotion(
2079 ArkUI_Float32 response, ArkUI_Float32 dampingFraction, ArkUI_Float32 overlapDuration)
2080 {
2081 return ViewAnimate::CreateResponsiveSpringMotion(response, dampingFraction, overlapDuration);
2082 }
2083
CreateInterpolatingSpring(ArkUI_Float32 velocity,ArkUI_Float32 mass,ArkUI_Float32 stiffness,ArkUI_Float32 damping)2084 ArkUICurveHandle CreateInterpolatingSpring(
2085 ArkUI_Float32 velocity, ArkUI_Float32 mass, ArkUI_Float32 stiffness, ArkUI_Float32 damping)
2086 {
2087 return ViewAnimate::CreateInterpolatingSpring(velocity, mass, stiffness, damping);
2088 }
2089
CreateCustomCurve(ArkUI_Float32 (* interpolate)(ArkUI_Float32 fraction,void * userData),void * userData)2090 ArkUICurveHandle CreateCustomCurve(ArkUI_Float32 (*interpolate)(ArkUI_Float32 fraction, void* userData), void* userData)
2091 {
2092 return ViewAnimate::CreateCustomCurve(interpolate, userData);
2093 }
2094
DisposeCurve(ArkUICurveHandle curve)2095 void DisposeCurve(ArkUICurveHandle curve)
2096 {
2097 return ViewAnimate::DisposeCurve(curve);
2098 }
2099
GetAnimationAPI()2100 const ArkUIAnimation* GetAnimationAPI()
2101 {
2102 static const ArkUIAnimation modifier = {
2103 nullptr,
2104 nullptr,
2105 nullptr,
2106 AnimateTo,
2107 KeyframeAnimateTo,
2108 CreateAnimator,
2109 DisposeAnimator,
2110 AnimatorReset,
2111 AnimatorPlay,
2112 AnimatorFinish,
2113 AnimatorPause,
2114 AnimatorCancel,
2115 AnimatorReverse,
2116 CreateCurve,
2117 CreateStepsCurve,
2118 CreateCubicBezierCurve,
2119 CreateSpringCurve,
2120 CreateSpringMotion,
2121 CreateResponsiveSpringMotion,
2122 CreateInterpolatingSpring,
2123 CreateCustomCurve,
2124 DisposeCurve,
2125 };
2126 return &modifier;
2127 }
2128
GetNavigationAPI()2129 const ArkUINavigation* GetNavigationAPI()
2130 {
2131 static const ArkUINavigation modifier = {
2132 nullptr,
2133 nullptr,
2134 GetNavigationId,
2135 GetNavDestinationName,
2136 GetStackLength,
2137 GetNavDesNameByIndex,
2138 GetNavDestinationId,
2139 GetNavDestinationState,
2140 GetNavDestinationIndex,
2141 GetNavDestinationParam,
2142 GetRouterPageIndex,
2143 GetRouterPageName,
2144 GetRouterPagePath,
2145 GetRouterPageState,
2146 GetRouterPageId,
2147 };
2148 return &modifier;
2149 }
2150
GetExtendedAPI()2151 const ArkUIExtendedNodeAPI* GetExtendedAPI()
2152 {
2153 return &impl_extended;
2154 }
2155
CreateArkUIStyledStringDescriptor()2156 ArkUI_StyledString_Descriptor* CreateArkUIStyledStringDescriptor()
2157 {
2158 TAG_LOGI(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "ArkUI_StyledString_Descriptor create");
2159 return new ArkUI_StyledString_Descriptor;
2160 }
2161
DestroyArkUIStyledStringDescriptor(ArkUI_StyledString_Descriptor * descriptor)2162 void DestroyArkUIStyledStringDescriptor(ArkUI_StyledString_Descriptor* descriptor)
2163 {
2164 TAG_LOGI(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "ArkUI_StyledString_Descriptor destroy");
2165 CHECK_NULL_VOID(descriptor);
2166 if (descriptor->html) {
2167 delete descriptor->html;
2168 descriptor->html = nullptr;
2169 }
2170 if (descriptor->spanString) {
2171 auto* spanString = reinterpret_cast<SpanString*>(descriptor->spanString);
2172 delete spanString;
2173 descriptor->spanString = nullptr;
2174 }
2175 delete descriptor;
2176 descriptor = nullptr;
2177 }
2178
UnmarshallStyledStringDescriptor(uint8_t * buffer,size_t bufferSize,ArkUI_StyledString_Descriptor * descriptor)2179 ArkUI_Int32 UnmarshallStyledStringDescriptor(
2180 uint8_t* buffer, size_t bufferSize, ArkUI_StyledString_Descriptor* descriptor)
2181 {
2182 TAG_LOGI(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "UnmarshallStyledStringDescriptor");
2183 CHECK_NULL_RETURN(buffer && descriptor && bufferSize > 0, ARKUI_ERROR_CODE_PARAM_INVALID);
2184 std::vector<uint8_t> vec(buffer, buffer + bufferSize);
2185 SpanString* spanString = new SpanString("");
2186 spanString->DecodeTlvExt(vec, spanString);
2187 descriptor->spanString = reinterpret_cast<void*>(spanString);
2188 return ARKUI_ERROR_CODE_NO_ERROR;
2189 }
2190
MarshallStyledStringDescriptor(uint8_t * buffer,size_t bufferSize,ArkUI_StyledString_Descriptor * descriptor,size_t * resultSize)2191 ArkUI_Int32 MarshallStyledStringDescriptor(
2192 uint8_t* buffer, size_t bufferSize, ArkUI_StyledString_Descriptor* descriptor, size_t* resultSize)
2193 {
2194 TAG_LOGI(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "MarshallStyledStringDescriptor");
2195 CHECK_NULL_RETURN(buffer && resultSize && descriptor, ARKUI_ERROR_CODE_PARAM_INVALID);
2196 CHECK_NULL_RETURN(descriptor->spanString, ARKUI_ERROR_CODE_INVALID_STYLED_STRING);
2197 auto spanStringRawPtr = reinterpret_cast<SpanString*>(descriptor->spanString);
2198 std::vector<uint8_t> tlvData;
2199 spanStringRawPtr->EncodeTlv(tlvData);
2200 *resultSize = tlvData.size();
2201 if (bufferSize < *resultSize) {
2202 return ARKUI_ERROR_CODE_PARAM_INVALID;
2203 }
2204 auto data = tlvData.data();
2205 std::copy(data, data + *resultSize, buffer);
2206 return ARKUI_ERROR_CODE_NO_ERROR;
2207 }
2208
ConvertToHtml(ArkUI_StyledString_Descriptor * descriptor)2209 const char* ConvertToHtml(ArkUI_StyledString_Descriptor* descriptor)
2210 {
2211 TAG_LOGI(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "ConvertToHtml");
2212 CHECK_NULL_RETURN(descriptor && descriptor->spanString, "");
2213 auto spanStringRawPtr = reinterpret_cast<SpanString*>(descriptor->spanString);
2214 auto htmlStr = HtmlUtils::ToHtml(spanStringRawPtr);
2215 char* html = new char[htmlStr.length() + 1];
2216 CHECK_NULL_RETURN(html, "");
2217 std::copy(htmlStr.begin(), htmlStr.end(), html);
2218 html[htmlStr.length()] = '\0';
2219 descriptor->html = html;
2220 return descriptor->html;
2221 }
2222
GetStyledStringAPI()2223 const ArkUIStyledStringAPI* GetStyledStringAPI()
2224 {
2225 static const ArkUIStyledStringAPI impl { CreateArkUIStyledStringDescriptor, DestroyArkUIStyledStringDescriptor,
2226 UnmarshallStyledStringDescriptor, MarshallStyledStringDescriptor, ConvertToHtml };
2227 return &impl;
2228 }
2229
CreateSnapshotOptions()2230 ArkUISnapshotOptions* CreateSnapshotOptions()
2231 {
2232 ArkUISnapshotOptions* snapshotOptions = new ArkUISnapshotOptions();
2233 snapshotOptions->scale = 1.0f;
2234 return snapshotOptions;
2235 }
2236
DestroySnapshotOptions(ArkUISnapshotOptions * snapshotOptions)2237 void DestroySnapshotOptions(ArkUISnapshotOptions* snapshotOptions)
2238 {
2239 if (snapshotOptions != nullptr) {
2240 delete snapshotOptions;
2241 snapshotOptions = nullptr;
2242 }
2243 }
2244
SnapshotOptionsSetScale(ArkUISnapshotOptions * snapshotOptions,ArkUI_Float32 scale)2245 ArkUI_Int32 SnapshotOptionsSetScale(ArkUISnapshotOptions* snapshotOptions, ArkUI_Float32 scale)
2246 {
2247 if (snapshotOptions == nullptr || !OHOS::Ace::GreatNotEqual(scale, 0.0)) {
2248 return ArkUI_ErrorCode::ARKUI_ERROR_CODE_PARAM_INVALID;
2249 }
2250 snapshotOptions->scale = scale;
2251 return ArkUI_ErrorCode::ARKUI_ERROR_CODE_NO_ERROR;
2252 }
2253
GetNodeSnapshot(ArkUINodeHandle node,ArkUISnapshotOptions * snapshotOptions,void * mediaPixel)2254 ArkUI_Int32 GetNodeSnapshot(ArkUINodeHandle node, ArkUISnapshotOptions* snapshotOptions, void* mediaPixel)
2255 {
2256 auto frameNode =
2257 OHOS::Ace::AceType::Claim<OHOS::Ace::NG::FrameNode>(reinterpret_cast<OHOS::Ace::NG::FrameNode*>(node));
2258 auto delegate = EngineHelper::GetCurrentDelegateSafely();
2259 NG::SnapshotOptions options;
2260 options.scale = snapshotOptions != nullptr ? snapshotOptions->scale : 1.0f;
2261 options.waitUntilRenderFinished = true;
2262 auto result = delegate->GetSyncSnapshot(frameNode, options);
2263 *reinterpret_cast<std::shared_ptr<Media::PixelMap>*>(mediaPixel) = result.second;
2264 return result.first;
2265 }
2266
GetComponentSnapshotAPI()2267 const ArkUISnapshotAPI* GetComponentSnapshotAPI()
2268 {
2269 static const ArkUISnapshotAPI impl { CreateSnapshotOptions, DestroySnapshotOptions, SnapshotOptionsSetScale,
2270 GetNodeSnapshot };
2271 return &impl;
2272 }
2273
2274 /* clang-format off */
2275 ArkUIFullNodeAPI impl_full = {
2276 ARKUI_NODE_API_VERSION,
2277 SetCallbackMethod, // CallbackMethod
2278 GetBasicAPI, // BasicAPI
2279 GetArkUINodeModifiers, // NodeModifiers
2280 GetAnimationAPI, // Animation
2281 GetNavigationAPI, // Navigation
2282 GetGraphicsAPI, // Graphics
2283 GetDialogAPI,
2284 GetExtendedAPI, // Extended
2285 NodeAdapter::GetNodeAdapterAPI, // adapter.
2286 DragAdapter::GetDragAdapterAPI, // drag adapter.
2287 GetStyledStringAPI, // StyledStringAPI
2288 GetComponentSnapshotAPI, // SyncSnapshot
2289 };
2290 /* clang-format on */
2291
GetCJUIAnimationAPI()2292 const CJUIAnimation* GetCJUIAnimationAPI()
2293 {
2294 static const CJUIAnimation modifier = {
2295 nullptr,
2296 nullptr,
2297 nullptr,
2298 AnimateTo,
2299 KeyframeAnimateTo,
2300 CreateAnimator,
2301 DisposeAnimator,
2302 AnimatorReset,
2303 AnimatorPlay,
2304 AnimatorFinish,
2305 AnimatorPause,
2306 AnimatorCancel,
2307 AnimatorReverse,
2308 CreateCurve,
2309 CreateStepsCurve,
2310 CreateCubicBezierCurve,
2311 CreateSpringCurve,
2312 CreateSpringMotion,
2313 CreateResponsiveSpringMotion,
2314 CreateInterpolatingSpring,
2315 CreateCustomCurve,
2316 DisposeCurve,
2317 };
2318 return &modifier;
2319 }
2320
GetCJUINavigationAPI()2321 const CJUINavigation* GetCJUINavigationAPI()
2322 {
2323 static const CJUINavigation modifier = {
2324 nullptr,
2325 nullptr,
2326 GetNavigationId,
2327 GetNavDestinationName,
2328 GetStackLength,
2329 GetNavDesNameByIndex,
2330 GetNavDestinationId,
2331 GetNavDestinationState,
2332 GetNavDestinationIndex,
2333 GetNavDestinationParam,
2334 GetRouterPageIndex,
2335 GetRouterPageName,
2336 GetRouterPagePath,
2337 GetRouterPageState,
2338 GetRouterPageId,
2339 };
2340 return &modifier;
2341 }
2342
GetCJUIGraphicsAPI()2343 const CJUIGraphicsAPI* GetCJUIGraphicsAPI()
2344 {
2345 static const CJUIGraphicsAPI api = {
2346 ARKUI_NODE_GRAPHICS_API_VERSION, SetCallbackMethod, GetCanvasAPI, GetPaintAPI, GetFontAPI
2347 };
2348 return &api;
2349 }
2350
GetCJUIDialogAPI()2351 const CJUIDialogAPI* GetCJUIDialogAPI()
2352 {
2353 static const CJUIDialogAPI dialogImpl = {
2354 CreateDialog,
2355 DisposeDialog,
2356 SetDialogContent,
2357 RemoveDialogContent,
2358 SetDialogContentAlignment,
2359 ResetDialogContentAlignment,
2360 SetDialogModalMode,
2361 SetDialogAutoCancel,
2362 SetDialogMask,
2363 SetDialogBackgroundColor,
2364 SetDialogCornerRadius,
2365 SetDialogGridColumnCount,
2366 EnableDialogCustomStyle,
2367 EnableDialogCustomAnimation,
2368 ShowDialog,
2369 CloseDialog,
2370 RegisterOnWillDialogDismiss,
2371 };
2372 return &dialogImpl;
2373 }
2374
GetCJUIExtendedAPI()2375 const CJUIExtendedNodeAPI* GetCJUIExtendedAPI()
2376 {
2377 static CJUIExtendedNodeAPI impl_extended = {
2378 ARKUI_EXTENDED_API_VERSION,
2379
2380 NodeModifier::GetUtilsModifier,
2381 NodeModifier::GetCanvasRenderingContext2DModifier,
2382
2383 SetCallbackMethod,
2384 SetCustomMethodFlag,
2385 GetCustomMethodFlag,
2386 RegisterCustomNodeAsyncEvent,
2387 UnregisterCustomNodeEvent,
2388 RegisterCustomNodeEventReceiver,
2389 SetCustomCallback, // setCustomCallback
2390 MeasureLayoutAndDraw,
2391 MeasureNode,
2392 LayoutNode,
2393 DrawNode,
2394 SetAttachNodePtr,
2395 GetAttachNodePtr,
2396 SetMeasureWidth, // setMeasureWidth
2397 GetMeasureWidth, // getMeasureWidth
2398 SetMeasureHeight, // setMeasureHeight
2399 GetMeasureHeight, // getMeasureHeight
2400 SetX, // setX
2401 SetY, // setY
2402 GetX, // getX
2403 GetY, // getY
2404 GetLayoutConstraint,
2405 SetAlignment,
2406 GetAlignment,
2407 nullptr, // indexerChecker
2408 nullptr, // setRangeUpdater
2409 nullptr, // setLazyItemIndexer
2410 GetPipelineContext,
2411 SetVsyncCallback,
2412 UnblockVsyncWait,
2413 NodeEvent::CheckEvent,
2414 NodeEvent::SendArkUIAsyncEvent,
2415 nullptr, // callContinuation
2416 nullptr, // setChildTotalCount
2417 ShowCrash,
2418 };
2419 return &impl_extended;
2420 }
2421
2422 CJUIFullNodeAPI fullCJUIApi {
2423 SetCallbackMethod,
2424 GetCJUIBasicAPI, // BasicAPI
2425 GetCJUINodeModifiers, // NodeModifiers
2426 GetCJUIAnimationAPI, // Animation
2427 GetCJUINavigationAPI, // Navigation
2428 GetCJUIGraphicsAPI, // Graphics
2429 GetCJUIDialogAPI,
2430 GetCJUIExtendedAPI, // Extended
2431 NodeAdapter::GetCJUINodeAdapterAPI, // adapter.
2432 };
2433 } // namespace
2434
2435 } // namespace OHOS::Ace::NG
2436
2437 extern "C" {
2438
GetCJUIFullNodeAPI()2439 ACE_FORCE_EXPORT CJUIFullNodeAPI* GetCJUIFullNodeAPI()
2440 {
2441 return &OHOS::Ace::NG::fullCJUIApi;
2442 }
2443
GetArkUIAnyFullNodeAPI(int version)2444 ACE_FORCE_EXPORT ArkUIAnyAPI* GetArkUIAnyFullNodeAPI(int version)
2445 {
2446 switch (version) {
2447 case ARKUI_NODE_API_VERSION:
2448 return reinterpret_cast<ArkUIAnyAPI*>(&OHOS::Ace::NG::impl_full);
2449 default: {
2450 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE,
2451 "Requested version %{public}d is not supported, we're version %{public}d", version,
2452 ARKUI_NODE_API_VERSION);
2453 return nullptr;
2454 }
2455 }
2456 }
2457
GetArkUIFullNodeAPI()2458 const ArkUIFullNodeAPI* GetArkUIFullNodeAPI()
2459 {
2460 return &OHOS::Ace::NG::impl_full;
2461 }
2462
SendArkUIAsyncEvent(ArkUINodeEvent * event)2463 void SendArkUIAsyncEvent(ArkUINodeEvent* event)
2464 {
2465 OHOS::Ace::NG::NodeEvent::SendArkUIAsyncEvent(event);
2466 }
2467
SendArkUIAsyncCustomEvent(ArkUICustomNodeEvent * event)2468 void SendArkUIAsyncCustomEvent(ArkUICustomNodeEvent* event)
2469 {
2470 OHOS::Ace::NG::CustomNodeEvent::SendArkUIAsyncEvent(event);
2471 }
2472
GetArkUIAPI(ArkUIAPIVariantKind kind,ArkUI_Int32 version)2473 ACE_FORCE_EXPORT const ArkUIAnyAPI* GetArkUIAPI(ArkUIAPIVariantKind kind, ArkUI_Int32 version)
2474 {
2475 switch (kind) {
2476 case ArkUIAPIVariantKind::BASIC: {
2477 switch (version) {
2478 case ARKUI_BASIC_API_VERSION:
2479 return reinterpret_cast<const ArkUIAnyAPI*>(OHOS::Ace::NG::GetBasicAPI());
2480 default: {
2481 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE,
2482 "Requested basic version %{public}d is not supported, we're version %{public}d\n", version,
2483 ARKUI_BASIC_API_VERSION);
2484
2485 return nullptr;
2486 }
2487 }
2488 }
2489 case ArkUIAPIVariantKind::FULL: {
2490 switch (version) {
2491 case ARKUI_FULL_API_VERSION:
2492 return reinterpret_cast<const ArkUIAnyAPI*>(&OHOS::Ace::NG::impl_full);
2493 default: {
2494 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE,
2495 "Requested full version %{public}d is not supported, we're version %{public}d\n", version,
2496 ARKUI_FULL_API_VERSION);
2497
2498 return nullptr;
2499 }
2500 }
2501 }
2502 case ArkUIAPIVariantKind::GRAPHICS: {
2503 switch (version) {
2504 case ARKUI_NODE_GRAPHICS_API_VERSION:
2505 return reinterpret_cast<const ArkUIAnyAPI*>(OHOS::Ace::NG::GetGraphicsAPI());
2506 default: {
2507 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE,
2508 "Requested graphics version %{public}d is not supported, we're version %{public}d\n", version,
2509 ARKUI_NODE_GRAPHICS_API_VERSION);
2510
2511 return nullptr;
2512 }
2513 }
2514 }
2515 case ArkUIAPIVariantKind::EXTENDED: {
2516 switch (version) {
2517 case ARKUI_EXTENDED_API_VERSION:
2518 return reinterpret_cast<const ArkUIAnyAPI*>(&OHOS::Ace::NG::impl_extended);
2519 default: {
2520 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE,
2521 "Requested extended version %{public}d is not supported, we're version %{public}d\n", version,
2522 ARKUI_EXTENDED_API_VERSION);
2523
2524 return nullptr;
2525 }
2526 }
2527 }
2528 default: {
2529 TAG_LOGE(OHOS::Ace::AceLogTag::ACE_NATIVE_NODE, "API kind %{public}d is not supported\n",
2530 static_cast<int>(kind));
2531
2532 return nullptr;
2533 }
2534 }
2535 }
2536
provideEntryPoint(void)2537 __attribute__((constructor)) static void provideEntryPoint(void)
2538 {
2539 #ifdef WINDOWS_PLATFORM
2540 // mingw has no setenv :(.
2541 static char entryPointString[64];
2542 if (snprintf_s(entryPointString, sizeof entryPointString, sizeof entryPointString - 1,
2543 "__LIBACE_ENTRY_POINT=%llx", static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(&GetArkUIAPI))) < 0) {
2544 return;
2545 }
2546 putenv(entryPointString);
2547 #else
2548 char entryPointString[64];
2549 if (snprintf_s(entryPointString, sizeof entryPointString, sizeof entryPointString - 1,
2550 "%llx", static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(&GetArkUIAPI))) < 0) {
2551 return;
2552 }
2553 setenv("__LIBACE_ENTRY_POINT", entryPointString, 1);
2554 #endif
2555 }
2556 }
2557