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/view_model.h"
17
18 #include <optional>
19
20 #include "base/log/log_wrapper.h"
21 #include "base/memory/ace_type.h"
22 #include "base/utils/utils.h"
23 #include "core/components_ng/base/frame_node.h"
24 #include "core/components_ng/base/group_node.h"
25 #include "core/components_ng/base/ui_node.h"
26 #include "core/components_ng/pattern/badge/badge_model_ng.h"
27 #include "core/components_ng/pattern/calendar_picker/calendar_picker_model_ng.h"
28 #include "core/components_ng/pattern/common_view/common_view_model_ng.h"
29 #include "core/components_ng/pattern/canvas/canvas_model_ng.h"
30 #include "core/components_ng/pattern/linear_layout/column_model_ng.h"
31 #include "core/components_ng/pattern/linear_layout/row_model_ng.h"
32 #include "core/components_ng/pattern/list/list_model_ng.h"
33 #include "core/components_ng/pattern/list/list_item_model_ng.h"
34 #include "core/components_ng/pattern/list/list_item_group_model_ng.h"
35 #include "core/components_ng/pattern/marquee/marquee_model_ng.h"
36 #include "core/components_ng/pattern/navigation/navigation_model_ng.h"
37 #include "core/components_ng/pattern/picker/datepicker_model_ng.h"
38 #include "core/components_ng/pattern/qrcode/qrcode_model_ng.h"
39 #include "core/components_ng/pattern/scroll/scroll_model_ng.h"
40 #include "core/components_ng/pattern/shape/circle_model_ng.h"
41 #include "core/components_ng/pattern/stack/stack_model_ng.h"
42 #include "core/components_ng/pattern/tabs/tab_content_model_ng.h"
43 #include "core/components_ng/pattern/tabs/tabs_model_ng.h"
44 #include "core/components_ng/pattern/text/span/span_object.h"
45 #include "core/components_ng/pattern/text_clock/text_clock_model_ng.h"
46 #include "core/components_ng/pattern/text_field/text_field_model_ng.h"
47 #include "core/components_ng/pattern/text/image_span_view.h"
48 #include "core/components_ng/pattern/text/text_model_ng.h"
49 #include "core/components_ng/pattern/text/span_model_ng.h"
50 #include "core/components_ng/pattern/symbol/symbol_model_ng.h"
51 #include "core/components_ng/pattern/text_picker/textpicker_model_ng.h"
52 #include "core/components_ng/pattern/texttimer/text_timer_model_ng.h"
53 #include "core/components_ng/pattern/time_picker/timepicker_model_ng.h"
54 #include "core/components_ng/pattern/toggle/toggle_model_ng.h"
55 #include "core/components_ng/pattern/image/image_model_ng.h"
56 #include "core/components_ng/pattern/list/list_model_ng.h"
57 #include "core/components_ng/pattern/loading_progress/loading_progress_model_ng.h"
58 #include "core/components_ng/pattern/swiper/swiper_model_ng.h"
59 #include "core/components_ng/pattern/button/button_model_ng.h"
60 #include "core/components_ng/pattern/progress/progress_model_ng.h"
61 #include "core/components_ng/pattern/checkbox/checkbox_model_ng.h"
62 #include "core/components_ng/pattern/linear_layout/column_model_ng.h"
63 #include "core/components_ng/pattern/linear_layout/row_model_ng.h"
64 #include "core/components_ng/pattern/flex/flex_model_ng.h"
65 #include "core/components_ng/pattern/refresh/refresh_model_ng.h"
66 #include "core/components_ng/pattern/xcomponent/xcomponent_model_ng.h"
67 #include "core/components_ng/pattern/slider/slider_model_ng.h"
68 #include "core/components_ng/pattern/waterflow/water_flow_model_ng.h"
69 #include "core/components_ng/pattern/waterflow/water_flow_item_model_ng.h"
70 #include "core/components_ng/pattern/relative_container/relative_container_model_ng.h"
71 #include "core/components_ng/pattern/grid/grid_model_ng.h"
72 #include "core/components_ng/pattern/grid/grid_item_model_ng.h"
73 #include "core/components_ng/pattern/grid_col/grid_col_model_ng.h"
74 #include "core/components_ng/pattern/grid_row/grid_row_model_ng.h"
75 #include "core/components_ng/pattern/blank/blank_model_ng.h"
76 #include "core/components_ng/pattern/custom_frame_node/custom_pattern.h"
77 #include "core/components_ng/pattern/divider/divider_model_ng.h"
78 #include "core/components_ng/pattern/indexer/indexer_model_ng.h"
79 #include "core/components_ng/pattern/search/search_model_ng.h"
80 #include "core/components_ng/pattern/radio/radio_model_ng.h"
81 #include "core/components_ng/pattern/image_animator/image_animator_model_ng.h"
82 #include "core/components_ng/pattern/select/select_model_ng.h"
83 #include "core/interfaces/native/node/node_api.h"
84 #include "core/pipeline/base/element_register.h"
85
86 namespace OHOS::Ace::NG::ViewModel {
87
88 ArkUIAPICallbackMethod* callbacks = nullptr;
89
createTextNode(ArkUI_Int32 nodeId)90 void* createTextNode(ArkUI_Int32 nodeId)
91 {
92 auto frameNode = TextModelNG::CreateFrameNode(nodeId, "");
93 CHECK_NULL_RETURN(frameNode, nullptr);
94 frameNode->IncRefCount();
95 return AceType::RawPtr(frameNode);
96 }
97
createSymbolNode(ArkUI_Int32 nodeId)98 void* createSymbolNode(ArkUI_Int32 nodeId)
99 {
100 auto frameNode = SymbolModelNG::CreateFrameNode(nodeId);
101 CHECK_NULL_RETURN(frameNode, nullptr);
102 frameNode->IncRefCount();
103 return AceType::RawPtr(frameNode);
104 }
105
createSpanNode(ArkUI_Int32 nodeId)106 void* createSpanNode(ArkUI_Int32 nodeId)
107 {
108 auto spanNode = SpanModelNG::CreateSpanNode(nodeId, "");
109 CHECK_NULL_RETURN(spanNode, nullptr);
110 spanNode->IncRefCount();
111 return AceType::RawPtr(spanNode);
112 }
113
createImageSpanNode(ArkUI_Int32 nodeId)114 void* createImageSpanNode(ArkUI_Int32 nodeId)
115 {
116 auto imageSpanNode = ImageSpanView::CreateFrameNode(nodeId);
117 CHECK_NULL_RETURN(imageSpanNode, nullptr);
118 imageSpanNode->IncRefCount();
119 return AceType::RawPtr(imageSpanNode);
120 }
121
createImageNode(ArkUI_Int32 nodeId)122 void* createImageNode(ArkUI_Int32 nodeId)
123 {
124 RefPtr<PixelMap> pixmap = nullptr;
125 auto frameNode = ImageModelNG::CreateFrameNode(nodeId, "", pixmap, "", "", false);
126 CHECK_NULL_RETURN(frameNode, nullptr);
127 frameNode->IncRefCount();
128 return AceType::RawPtr(frameNode);
129 }
130
createToggleNode(ArkUI_Int32 nodeId)131 void* createToggleNode(ArkUI_Int32 nodeId)
132 {
133 auto frameNode = ToggleModelNG::CreateFrameNode(nodeId, NG::ToggleType::SWITCH, false);
134 CHECK_NULL_RETURN(frameNode, nullptr);
135 frameNode->IncRefCount();
136 return AceType::RawPtr(frameNode);
137 }
138
createLoadingProgress(ArkUI_Int32 nodeId)139 void* createLoadingProgress(ArkUI_Int32 nodeId)
140 {
141 auto frameNode = LoadingProgressModelNG::CreateFrameNode(nodeId);
142 CHECK_NULL_RETURN(frameNode, nullptr);
143 frameNode->IncRefCount();
144 return AceType::RawPtr(frameNode);
145 }
146
createTextInputNode(ArkUI_Int32 nodeId)147 void* createTextInputNode(ArkUI_Int32 nodeId)
148 {
149 auto frameNode = TextFieldModelNG::CreateFrameNode(nodeId, "", "", false);
150 CHECK_NULL_RETURN(frameNode, nullptr);
151 frameNode->IncRefCount();
152 return AceType::RawPtr(frameNode);
153 }
154
createStackNode(ArkUI_Int32 nodeId)155 void* createStackNode(ArkUI_Int32 nodeId)
156 {
157 auto frameNode = StackModelNG::CreateFrameNode(nodeId);
158 CHECK_NULL_RETURN(frameNode, nullptr);
159 frameNode->IncRefCount();
160 return AceType::RawPtr(frameNode);
161 }
162
createScrollNode(ArkUI_Int32 nodeId)163 void* createScrollNode(ArkUI_Int32 nodeId)
164 {
165 auto frameNode = ScrollModelNG::CreateFrameNode(nodeId);
166 CHECK_NULL_RETURN(frameNode, nullptr);
167 frameNode->IncRefCount();
168 return AceType::RawPtr(frameNode);
169 }
170
createListNode(ArkUI_Int32 nodeId)171 void* createListNode(ArkUI_Int32 nodeId)
172 {
173 auto frameNode = ListModelNG::CreateFrameNode(nodeId);
174 CHECK_NULL_RETURN(frameNode, nullptr);
175 frameNode->IncRefCount();
176 return AceType::RawPtr(frameNode);
177 }
178
createSwiperNode(ArkUI_Int32 nodeId)179 void* createSwiperNode(ArkUI_Int32 nodeId)
180 {
181 auto frameNode = SwiperModelNG::CreateFrameNode(nodeId);
182 CHECK_NULL_RETURN(frameNode, nullptr);
183 frameNode->IncRefCount();
184 return AceType::RawPtr(frameNode);
185 }
186
createTextAreaNode(ArkUI_Int32 nodeId)187 void* createTextAreaNode(ArkUI_Int32 nodeId)
188 {
189 auto frameNode = TextFieldModelNG::CreateFrameNode(nodeId, "", "", true);
190 CHECK_NULL_RETURN(frameNode, nullptr);
191 frameNode->IncRefCount();
192 return AceType::RawPtr(frameNode);
193 }
194
createButtonNode(ArkUI_Int32 nodeId)195 void* createButtonNode(ArkUI_Int32 nodeId)
196 {
197 auto frameNode = ButtonModelNG::CreateFrameNode(nodeId);
198 CHECK_NULL_RETURN(frameNode, nullptr);
199 frameNode->IncRefCount();
200 return AceType::RawPtr(frameNode);
201 }
202
createProgressNode(ArkUI_Int32 nodeId)203 void* createProgressNode(ArkUI_Int32 nodeId)
204 {
205 auto frameNode = ProgressModelNG::CreateFrameNode(nodeId, 0, 100, NG::ProgressType::LINEAR);
206 CHECK_NULL_RETURN(frameNode, nullptr);
207 frameNode->IncRefCount();
208 return AceType::RawPtr(frameNode);
209 }
210
createCheckBoxNode(ArkUI_Int32 nodeId)211 void* createCheckBoxNode(ArkUI_Int32 nodeId)
212 {
213 auto frameNode = CheckBoxModelNG::CreateFrameNode(nodeId);
214 CHECK_NULL_RETURN(frameNode, nullptr);
215 frameNode->IncRefCount();
216 return AceType::RawPtr(frameNode);
217 }
218
createColumnNode(ArkUI_Int32 nodeId)219 void* createColumnNode(ArkUI_Int32 nodeId)
220 {
221 auto frameNode = ColumnModelNG::CreateFrameNode(nodeId);
222 CHECK_NULL_RETURN(frameNode, nullptr);
223 frameNode->IncRefCount();
224 return AceType::RawPtr(frameNode);
225 }
226
createRowNode(ArkUI_Int32 nodeId)227 void* createRowNode(ArkUI_Int32 nodeId)
228 {
229 auto frameNode = RowModelNG::CreateFrameNode(nodeId);
230 CHECK_NULL_RETURN(frameNode, nullptr);
231 frameNode->IncRefCount();
232 return AceType::RawPtr(frameNode);
233 }
234
createFlexNode(ArkUI_Int32 nodeId)235 void* createFlexNode(ArkUI_Int32 nodeId)
236 {
237 auto frameNode = FlexModelNG::CreateFrameNode(nodeId);
238 CHECK_NULL_RETURN(frameNode, nullptr);
239 frameNode->IncRefCount();
240 return AceType::RawPtr(frameNode);
241 }
242
createListItemNode(ArkUI_Int32 nodeId)243 void* createListItemNode(ArkUI_Int32 nodeId)
244 {
245 auto frameNode = ListItemModelNG::CreateFrameNode(nodeId);
246 CHECK_NULL_RETURN(frameNode, nullptr);
247 frameNode->IncRefCount();
248 return AceType::RawPtr(frameNode);
249 }
250
createRefreshNode(ArkUI_Int32 nodeId)251 void* createRefreshNode(ArkUI_Int32 nodeId)
252 {
253 auto frameNode = RefreshModelNG::CreateFrameNode(nodeId);
254 CHECK_NULL_RETURN(frameNode, nullptr);
255 frameNode->IncRefCount();
256 return AceType::RawPtr(frameNode);
257 }
258
createRootNode(ArkUI_Int32 nodeId)259 void* createRootNode(ArkUI_Int32 nodeId)
260 {
261 auto container = Container::Current();
262 CHECK_NULL_RETURN(container, nullptr);
263 RefPtr<PipelineBase> pipeline;
264 pipeline = container->GetPipelineContext();
265 CHECK_NULL_RETURN(pipeline, nullptr);
266 auto context = AceType::DynamicCast<NG::PipelineContext>(pipeline);
267 CHECK_NULL_RETURN(context, nullptr);
268 auto stageManager = context->GetStageManager();
269 CHECK_NULL_RETURN(stageManager, nullptr);
270 auto stageNode = stageManager->GetStageNode();
271 TAG_LOGD(AceLogTag::ACE_NATIVE_NODE, "createRootNode: stageNode %{public}p", AceType::RawPtr(stageNode));
272 return AceType::RawPtr(stageNode);
273 }
274
createComponentRootNode(ArkUI_Int32 nodeId)275 void* createComponentRootNode(ArkUI_Int32 nodeId)
276 {
277 auto frameNode = CommonViewModelNG::CreateFrameNode(nodeId);
278 CHECK_NULL_RETURN(frameNode, nullptr);
279 frameNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
280 frameNode->IncRefCount();
281 TAG_LOGD(AceLogTag::ACE_NATIVE_NODE, "createComponentRootNode: frameNode %{public}p", AceType::RawPtr(frameNode));
282 return AceType::RawPtr(frameNode);
283 }
284
285 #ifdef XCOMPONENT_SUPPORTED
createXComponentNode(ArkUI_Int32 nodeId)286 void* createXComponentNode(ArkUI_Int32 nodeId)
287 {
288 auto frameNode = XComponentModelNG::CreateFrameNode(nodeId, "", XComponentType::SURFACE, "");
289 frameNode->IncRefCount();
290 return AceType::RawPtr(frameNode);
291 }
292
createXComponentNodeWithParams(ArkUI_Int32 nodeId,const ArkUI_Params & params)293 void* createXComponentNodeWithParams(ArkUI_Int32 nodeId, const ArkUI_Params& params)
294 {
295 ArkUI_XComponent_Params* xcParams = (ArkUI_XComponent_Params*)(¶ms);
296 CHECK_NULL_RETURN(xcParams, nullptr);
297 auto frameNode = XComponentModelNG::CreateTypeNode(nodeId, xcParams);
298 frameNode->IncRefCount();
299 return AceType::RawPtr(frameNode);
300 }
301 #endif
302
createListItemGroupNode(ArkUI_Int32 nodeId)303 void* createListItemGroupNode(ArkUI_Int32 nodeId)
304 {
305 auto frameNode = ListItemGroupModelNG::CreateFrameNode(nodeId);
306 CHECK_NULL_RETURN(frameNode, nullptr);
307 frameNode->IncRefCount();
308 return AceType::RawPtr(frameNode);
309 }
310
createSliderNode(ArkUI_Int32 nodeId)311 void* createSliderNode(ArkUI_Int32 nodeId)
312 {
313 auto frameNode = SliderModelNG::CreateFrameNode(nodeId);
314 CHECK_NULL_RETURN(frameNode, nullptr);
315 frameNode->IncRefCount();
316 return AceType::RawPtr(frameNode);
317 }
318
createCanvasNode(ArkUI_Int32 nodeId)319 void* createCanvasNode(ArkUI_Int32 nodeId)
320 {
321 auto frameNode = CanvasModelNG::CreateFrameNode(nodeId);
322 frameNode->IncRefCount();
323 return AceType::RawPtr(frameNode);
324 }
325
createDatePickerNode(ArkUI_Int32 nodeId)326 void* createDatePickerNode(ArkUI_Int32 nodeId)
327 {
328 auto frameNode = DatePickerModelNG::CreateFrameNode(nodeId);
329 CHECK_NULL_RETURN(frameNode, nullptr);
330 frameNode->IncRefCount();
331 return AceType::RawPtr(frameNode);
332 }
333
createTimePickerNode(ArkUI_Int32 nodeId)334 void* createTimePickerNode(ArkUI_Int32 nodeId)
335 {
336 auto frameNode = TimePickerModelNG::CreateFrameNode(nodeId);
337 CHECK_NULL_RETURN(frameNode, nullptr);
338 frameNode->IncRefCount();
339 return AceType::RawPtr(frameNode);
340 }
341
createTextPickerNode(ArkUI_Int32 nodeId)342 void* createTextPickerNode(ArkUI_Int32 nodeId)
343 {
344 auto frameNode = TextPickerModelNG::CreateFrameNode(nodeId);
345 CHECK_NULL_RETURN(frameNode, nullptr);
346 frameNode->IncRefCount();
347 return AceType::RawPtr(frameNode);
348 }
349
createCalendarPickerNode(ArkUI_Int32 nodeId)350 void* createCalendarPickerNode(ArkUI_Int32 nodeId)
351 {
352 auto frameNode = CalendarPickerModelNG::CreateFrameNode(nodeId);
353 CHECK_NULL_RETURN(frameNode, nullptr);
354 frameNode->IncRefCount();
355 return AceType::RawPtr(frameNode);
356 }
357
createCustomNode(ArkUI_Int32 nodeId)358 void* createCustomNode(ArkUI_Int32 nodeId)
359 {
360 auto frameNode = FrameNode::CreateFrameNode("Custom", nodeId, AceType::MakeRefPtr<CustomPattern>());
361 CHECK_NULL_RETURN(frameNode, nullptr);
362 frameNode->IncRefCount();
363 return AceType::RawPtr(frameNode);
364 }
365
createNavigationNode(ArkUI_Int32 nodeId)366 void* createNavigationNode(ArkUI_Int32 nodeId)
367 {
368 auto frameNode = NavigationModelNG::CreateFrameNode(nodeId);
369 frameNode->IncRefCount();
370 return AceType::RawPtr(frameNode);
371 }
372
createWaterFlowNode(ArkUI_Int32 nodeId)373 void* createWaterFlowNode(ArkUI_Int32 nodeId)
374 {
375 auto frameNode = WaterFlowModelNG::CreateFrameNode(nodeId);
376 CHECK_NULL_RETURN(frameNode, nullptr);
377 frameNode->IncRefCount();
378 return AceType::RawPtr(frameNode);
379 }
380
createFlowItemNode(ArkUI_Int32 nodeId)381 void* createFlowItemNode(ArkUI_Int32 nodeId)
382 {
383 auto frameNode = WaterFlowItemModelNG::CreateFrameNode(nodeId);
384 CHECK_NULL_RETURN(frameNode, nullptr);
385 frameNode->IncRefCount();
386 return AceType::RawPtr(frameNode);
387 }
388
createRelativeContainerNode(ArkUI_Int32 nodeId)389 void* createRelativeContainerNode(ArkUI_Int32 nodeId)
390 {
391 auto frameNode = RelativeContainerModelNG::CreateFrameNode(nodeId);
392 CHECK_NULL_RETURN(frameNode, nullptr);
393 frameNode->IncRefCount();
394 return AceType::RawPtr(frameNode);
395 }
396
createGridNode(ArkUI_Int32 nodeId)397 void* createGridNode(ArkUI_Int32 nodeId)
398 {
399 auto frameNode = GridModelNG::CreateFrameNode(nodeId);
400 CHECK_NULL_RETURN(frameNode, nullptr);
401 frameNode->IncRefCount();
402 return AceType::RawPtr(frameNode);
403 }
404
createTabsNode(ArkUI_Int32 nodeId)405 void* createTabsNode(ArkUI_Int32 nodeId)
406 {
407 auto frameNode = TabsModelNG::CreateFrameNode(nodeId);
408 frameNode->IncRefCount();
409 return AceType::RawPtr(frameNode);
410 }
411
createGridItemNode(ArkUI_Int32 nodeId)412 void* createGridItemNode(ArkUI_Int32 nodeId)
413 {
414 auto frameNode = GridItemModelNG::CreateFrameNode(nodeId);
415 CHECK_NULL_RETURN(frameNode, nullptr);
416 frameNode->IncRefCount();
417 return AceType::RawPtr(frameNode);
418 }
419
createRadioNode(ArkUI_Int32 nodeId)420 void* createRadioNode(ArkUI_Int32 nodeId)
421 {
422 auto frameNode = RadioModelNG::CreateFrameNode(nodeId);
423 CHECK_NULL_RETURN(frameNode, nullptr);
424 frameNode->IncRefCount();
425 return AceType::RawPtr(frameNode);
426 }
427
createBlankNode(ArkUI_Int32 nodeId)428 void* createBlankNode(ArkUI_Int32 nodeId)
429 {
430 auto frameNode = BlankModelNG::CreateFrameNode(nodeId);
431 CHECK_NULL_RETURN(frameNode, nullptr);
432 frameNode->IncRefCount();
433 return AceType::RawPtr(frameNode);
434 }
435
createDividerNode(ArkUI_Int32 nodeId)436 void* createDividerNode(ArkUI_Int32 nodeId)
437 {
438 auto frameNode = DividerModelNG::CreateFrameNode(nodeId);
439 CHECK_NULL_RETURN(frameNode, nullptr);
440 frameNode->IncRefCount();
441 return AceType::RawPtr(frameNode);
442 }
443
createSearchNode(ArkUI_Int32 nodeId)444 void* createSearchNode(ArkUI_Int32 nodeId)
445 {
446 auto frameNode = SearchModelNG::CreateFrameNode(nodeId);
447 CHECK_NULL_RETURN(frameNode, nullptr);
448 frameNode->IncRefCount();
449 return AceType::RawPtr(frameNode);
450 }
451
createGridRowNode(ArkUI_Int32 nodeId)452 void* createGridRowNode(ArkUI_Int32 nodeId)
453 {
454 auto frameNode = GridRowModelNG::CreateFrameNode(nodeId);
455 CHECK_NULL_RETURN(frameNode, nullptr);
456 frameNode->IncRefCount();
457 return AceType::RawPtr(frameNode);
458 }
459
createGridColNode(ArkUI_Int32 nodeId)460 void* createGridColNode(ArkUI_Int32 nodeId)
461 {
462 auto frameNode = GridColModelNG::CreateFrameNode(nodeId);
463 CHECK_NULL_RETURN(frameNode, nullptr);
464 frameNode->IncRefCount();
465 return AceType::RawPtr(frameNode);
466 }
467
createCircleNode(ArkUI_Int32 nodeId)468 void* createCircleNode(ArkUI_Int32 nodeId)
469 {
470 auto frameNode = CircleModelNG::CreateFrameNode(nodeId);
471 CHECK_NULL_RETURN(frameNode, nullptr);
472 frameNode->IncRefCount();
473 return AceType::RawPtr(frameNode);
474 }
475
createTabContentNode(ArkUI_Int32 nodeId)476 void* createTabContentNode(ArkUI_Int32 nodeId)
477 {
478 auto frameNode = TabContentModelNG::CreateFrameNode(nodeId);
479 CHECK_NULL_RETURN(frameNode, nullptr);
480 frameNode->IncRefCount();
481 return AceType::RawPtr(frameNode);
482 }
483
createImageAnimatorNode(ArkUI_Int32 nodeId)484 void* createImageAnimatorNode(ArkUI_Int32 nodeId)
485 {
486 auto frameNode = ImageAnimatorModelNG::CreateFrameNode(nodeId);
487 frameNode->IncRefCount();
488 return AceType::RawPtr(frameNode);
489 }
490
createAlphabetIndexerNode(ArkUI_Int32 nodeId)491 void* createAlphabetIndexerNode(ArkUI_Int32 nodeId)
492 {
493 auto frameNode = IndexerModelNG::CreateFrameNode(nodeId);
494 frameNode->IncRefCount();
495 return AceType::RawPtr(frameNode);
496 }
497
createSelectNode(ArkUI_Int32 nodeId)498 void* createSelectNode(ArkUI_Int32 nodeId)
499 {
500 auto frameNode = SelectModelNG::CreateFrameNode(nodeId);
501 frameNode->IncRefCount();
502 return AceType::RawPtr(frameNode);
503 }
504
createCustomSpanNode(ArkUI_Int32 nodeId)505 void* createCustomSpanNode(ArkUI_Int32 nodeId)
506 {
507 auto customSpanNode = CustomSpanNode::CreateFrameNode(nodeId);
508 CHECK_NULL_RETURN(customSpanNode, nullptr);
509 customSpanNode->IncRefCount();
510 return AceType::RawPtr(customSpanNode);
511 }
512
createMarqueeNode(ArkUI_Int32 nodeId)513 void* createMarqueeNode(ArkUI_Int32 nodeId)
514 {
515 auto frameNode = MarqueeModelNG::CreateFrameNode(nodeId);
516 CHECK_NULL_RETURN(frameNode, nullptr);
517 frameNode->IncRefCount();
518 return AceType::RawPtr(frameNode);
519 }
520
createTextClockNode(ArkUI_Int32 nodeId)521 void* createTextClockNode(ArkUI_Int32 nodeId)
522 {
523 auto frameNode = TextClockModelNG::CreateFrameNode(nodeId);
524 CHECK_NULL_RETURN(frameNode, nullptr);
525 frameNode->IncRefCount();
526 return AceType::RawPtr(frameNode);
527 }
528
createQRcodeNode(ArkUI_Int32 nodeId)529 void* createQRcodeNode(ArkUI_Int32 nodeId)
530 {
531 auto frameNode = QRCodeModelNG::CreateFrameNode(nodeId);
532 CHECK_NULL_RETURN(frameNode, nullptr);
533 frameNode->IncRefCount();
534 return AceType::RawPtr(frameNode);
535 }
536
createBadgeNode(ArkUI_Int32 nodeId)537 void* createBadgeNode(ArkUI_Int32 nodeId)
538 {
539 auto frameNode = BadgeModelNG::CreateFrameNode(nodeId);
540 CHECK_NULL_RETURN(frameNode, nullptr);
541 frameNode->IncRefCount();
542 return AceType::RawPtr(frameNode);
543 }
544
createTextTimerNode(ArkUI_Int32 nodeId)545 void* createTextTimerNode(ArkUI_Int32 nodeId)
546 {
547 auto frameNode = TextTimerModelNG::CreateFrameNode(nodeId);
548 CHECK_NULL_RETURN(frameNode, nullptr);
549 frameNode->IncRefCount();
550 return AceType::RawPtr(frameNode);
551 }
552
553 using createArkUIFrameNode = void*(ArkUI_Int32 nodeId);
554
555 static createArkUIFrameNode* createArkUIFrameNodes[] = {
556 nullptr,
557 createTextNode,
558 createSpanNode,
559 createImageSpanNode,
560 createImageNode,
561 createToggleNode,
562 createLoadingProgress,
563 createTextInputNode,
564 createStackNode,
565 createScrollNode,
566 createListNode,
567 createSwiperNode,
568 createTextAreaNode,
569 createButtonNode,
570 createProgressNode,
571 createCheckBoxNode,
572 createColumnNode,
573 createRowNode,
574 createFlexNode,
575 createListItemNode,
576 createTabsNode,
577 nullptr,
578 nullptr,
579 createSliderNode,
580 createCanvasNode,
581 createRadioNode, // Radio
582 createGridNode,
583 #ifdef XCOMPONENT_SUPPORTED
584 createXComponentNode,
585 #else
586 nullptr,
587 #endif
588 nullptr,
589 createRefreshNode,
590 createRootNode,
591 createComponentRootNode,
592 createListItemGroupNode,
593 createDatePickerNode,
594 createTimePickerNode,
595 createTextPickerNode,
596 createCalendarPickerNode,
597 createGridItemNode,
598 createCustomNode,
599 createWaterFlowNode,
600 createFlowItemNode,
601 createRelativeContainerNode,
602 createBlankNode,
603 createDividerNode,
604 createSearchNode,
605 createGridRowNode,
606 createGridColNode,
607 createImageAnimatorNode,
608 createCircleNode,
609 createTabContentNode,
610 createAlphabetIndexerNode,
611 createSelectNode,
612 createNavigationNode,
613 createCustomSpanNode,
614 createSymbolNode,
615 createMarqueeNode,
616 createQRcodeNode,
617 createBadgeNode,
618 createTextClockNode,
619 createTextTimerNode,
620 };
621
CreateNode(ArkUINodeType tag,ArkUI_Int32 nodeId)622 void* CreateNode(ArkUINodeType tag, ArkUI_Int32 nodeId)
623 {
624 if (tag >= sizeof(createArkUIFrameNodes) / sizeof(createArkUIFrameNode*)) {
625 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "fail to create %{public}d type of node", tag);
626 return nullptr;
627 }
628 CHECK_NULL_RETURN(createArkUIFrameNodes[tag], nullptr);
629 if (nodeId == ARKUI_AUTO_GENERATE_NODE_ID) {
630 nodeId = ElementRegister::GetInstance()->MakeUniqueId();
631 }
632 return createArkUIFrameNodes[tag](nodeId);
633 }
634
CreateNodeWithParams(ArkUINodeType tag,ArkUI_Int32 nodeId,const ArkUI_Params & params)635 void* CreateNodeWithParams(ArkUINodeType tag, ArkUI_Int32 nodeId, const ArkUI_Params& params)
636 {
637 if (tag >= sizeof(createArkUIFrameNodes) / sizeof(createArkUIFrameNode*)) {
638 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "fail to create %{public}d type of node", tag);
639 return nullptr;
640 }
641 CHECK_NULL_RETURN(createArkUIFrameNodes[tag], nullptr);
642 if (nodeId == ARKUI_AUTO_GENERATE_NODE_ID) {
643 nodeId = ElementRegister::GetInstance()->MakeUniqueId();
644 }
645 #ifdef XCOMPONENT_SUPPORTED
646 if (tag == ArkUINodeType::ARKUI_XCOMPONENT) {
647 return createXComponentNodeWithParams(nodeId, params);
648 }
649 #endif
650 return createArkUIFrameNodes[tag](nodeId);
651 }
652
GetName(void * nativePtr)653 ArkUI_CharPtr GetName(void* nativePtr)
654 {
655 CHECK_NULL_RETURN(nativePtr, nullptr);
656 auto* frameNode = reinterpret_cast<UINode*>(nativePtr);
657 return frameNode->GetTag().c_str();
658 }
659
DisposeNode(void * nativePtr)660 void DisposeNode(void* nativePtr)
661 {
662 CHECK_NULL_VOID(nativePtr);
663 auto* uiNode = reinterpret_cast<UINode*>(nativePtr);
664 auto* frameNode = AceType::DynamicCast<FrameNode>(uiNode);
665 if (frameNode) {
666 frameNode->SetExtensionHandler(nullptr);
667 }
668 uiNode->DecRefCount();
669 }
670
AddChild(void * parentNode,void * childNode)671 void AddChild(void* parentNode, void* childNode)
672 {
673 CHECK_NULL_VOID(parentNode);
674 CHECK_NULL_VOID(childNode);
675 auto* parent = reinterpret_cast<UINode*>(parentNode);
676 auto* child = reinterpret_cast<UINode*>(childNode);
677 parent->AddChild(AceType::Claim(child));
678 auto* frameNode = AceType::DynamicCast<FrameNode>(child);
679 if (frameNode) {
680 frameNode->OnMountToParentDone();
681 }
682 }
683
RemoveChild(void * parentNode,void * childNode)684 void RemoveChild(void* parentNode, void* childNode)
685 {
686 CHECK_NULL_VOID(parentNode);
687 CHECK_NULL_VOID(childNode);
688 auto* parent = reinterpret_cast<UINode*>(parentNode);
689 auto* child = reinterpret_cast<UINode*>(childNode);
690 child->MarkRemoving();
691 parent->RemoveChild(AceType::Claim(child), true);
692 }
693
InsertChildAt(void * parentNode,void * childNode,int32_t position)694 void InsertChildAt(void* parentNode, void* childNode, int32_t position)
695 {
696 CHECK_NULL_VOID(parentNode);
697 CHECK_NULL_VOID(childNode);
698 auto* parent = reinterpret_cast<UINode*>(parentNode);
699 auto* child = reinterpret_cast<UINode*>(childNode);
700 parent->AddChild(AceType::Claim(child), position);
701 auto* frameNode = AceType::DynamicCast<FrameNode>(child);
702 if (frameNode) {
703 frameNode->OnMountToParentDone();
704 }
705 }
706
InsertChildAfter(void * parentNode,void * childNode,void * siblingNode)707 void InsertChildAfter(void* parentNode, void* childNode, void* siblingNode)
708 {
709 CHECK_NULL_VOID(parentNode);
710 CHECK_NULL_VOID(childNode);
711 auto* parent = reinterpret_cast<UINode*>(parentNode);
712 auto* child = reinterpret_cast<UINode*>(childNode);
713
714 if (AceType::InstanceOf<GroupNode>(parent)) {
715 auto* groupNode = AceType::DynamicCast<GroupNode>(parent);
716 groupNode->AddChildToGroup(AceType::Claim(child));
717 parent->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
718 return;
719 }
720 auto* sibling = reinterpret_cast<UINode*>(siblingNode);
721 if (sibling) {
722 parent->AddChildAfter(AceType::Claim(child), AceType::Claim(sibling));
723 } else {
724 parent->AddChild(AceType::Claim(child));
725 }
726 auto* frameNode = AceType::DynamicCast<FrameNode>(child);
727 if (frameNode) {
728 frameNode->OnMountToParentDone();
729 }
730 }
731
InsertChildBefore(void * parentNode,void * childNode,void * siblingNode)732 void InsertChildBefore(void* parentNode, void* childNode, void* siblingNode)
733 {
734 CHECK_NULL_VOID(parentNode);
735 CHECK_NULL_VOID(childNode);
736 auto* parent = reinterpret_cast<UINode*>(parentNode);
737 auto* child = reinterpret_cast<UINode*>(childNode);
738
739 if (AceType::InstanceOf<GroupNode>(parent)) {
740 auto* groupNode = AceType::DynamicCast<GroupNode>(parent);
741 groupNode->AddChildToGroup(AceType::Claim(child));
742 parent->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
743 return;
744 }
745 auto* sibling = reinterpret_cast<UINode*>(siblingNode);
746 if (sibling) {
747 parent->AddChildBefore(AceType::Claim(child), AceType::Claim(sibling));
748 } else {
749 parent->AddChild(AceType::Claim(child));
750 }
751 auto* frameNode = AceType::DynamicCast<FrameNode>(child);
752 if (frameNode) {
753 frameNode->OnMountToParentDone();
754 }
755 }
756
RegisterCompanion(void * node,int peerId,ArkUI_Int32 flags)757 void RegisterCompanion(void* node, int peerId, ArkUI_Int32 flags)
758 {
759 if (flags == ArkUIAPINodeFlags::NONE) {
760 return;
761 }
762 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(node));
763 if (frameNode) {
764 // create extension and set to frameNode extension holder.
765 auto companion = AceType::MakeRefPtr<ExtensionCompanionNode>(peerId, flags, node);
766 frameNode->SetExtensionHandler(companion);
767 }
768 }
769
GetCompanion(void * nodePtr)770 ExtensionCompanionNode* GetCompanion(void* nodePtr)
771 {
772 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
773 if (frameNode) {
774 return AceType::DynamicCast<ExtensionCompanionNode>(frameNode->GetExtensionHandler());
775 }
776 return nullptr;
777 }
778
SetCustomCallback(ArkUIVMContext context,void * nodePtr,ArkUI_Int32 callback)779 void SetCustomCallback(ArkUIVMContext context, void* nodePtr, ArkUI_Int32 callback)
780 {
781 auto* node = GetCompanion(nodePtr);
782 CHECK_NULL_VOID(node);
783 node->SetCallbackId(context, callback);
784 }
785
SetCallbackMethod(ArkUIAPICallbackMethod * method)786 void SetCallbackMethod(ArkUIAPICallbackMethod* method)
787 {
788 callbacks = method;
789 }
790
GetCallbackMethod()791 ArkUIAPICallbackMethod* GetCallbackMethod()
792 {
793 return callbacks;
794 }
795
MeasureNode(ArkUIVMContext context,ArkUINodeHandle nodePtr,ArkUI_Float32 * data)796 ArkUI_Int32 MeasureNode(ArkUIVMContext context, ArkUINodeHandle nodePtr, ArkUI_Float32* data)
797 {
798 // call frameNode measure.
799 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
800 if (frameNode) {
801 std::optional<LayoutConstraintF> constraint = std::make_optional<LayoutConstraintF>();
802 //minWidth
803 constraint->minSize.SetWidth(data[0]);
804 //minHeight
805 constraint->minSize.SetHeight(data[1]);
806 //maxWidth
807 constraint->maxSize.SetWidth(data[2]);
808 //maxHeight
809 constraint->maxSize.SetHeight(data[3]);
810 //minWidth == maxWidth
811 if (data[0] == data[2]) {
812 constraint->selfIdealSize.SetWidth(data[0]);
813 }
814 //minHeight == maxHeight
815 if (data[1] == data[3]) {
816 constraint->selfIdealSize.SetHeight(data[1]);
817 }
818 //percentReferenceWidth
819 constraint->percentReference.SetWidth(data[4]);
820 //percentReferenceHeight
821 constraint->percentReference.SetHeight(data[5]);
822 frameNode->SetActive(true);
823 frameNode->Measure(constraint);
824 }
825 return 0;
826 }
827
LayoutNode(ArkUIVMContext context,ArkUINodeHandle nodePtr,ArkUI_Float32 (* data)[2])828 ArkUI_Int32 LayoutNode(ArkUIVMContext context, ArkUINodeHandle nodePtr, ArkUI_Float32 (*data)[2])
829 {
830 // call frameNode layout.
831 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
832 if (frameNode) {
833 frameNode->SetActive(true);
834 frameNode->GetGeometryNode()->SetMarginFrameOffsetX((*data)[0]);
835 frameNode->GetGeometryNode()->SetMarginFrameOffsetY((*data)[1]);
836 frameNode->Layout();
837 }
838 return 0;
839 }
840
DrawNode(ArkUIVMContext context,ArkUINodeHandle nodePtr,ArkUI_Float32 * data)841 ArkUI_Int32 DrawNode(ArkUIVMContext context, ArkUINodeHandle nodePtr, ArkUI_Float32* data)
842 {
843 // rsnode draw by data, no need to directly call.
844 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
845 if (frameNode) {
846 frameNode->SetActive(true);
847 auto task = frameNode->CreateRenderTask();
848 if (task) {
849 (*task)();
850 }
851 }
852 return 0;
853 }
854
SetAttachNodePtr(ArkUINodeHandle nodePtr,void * attachNode)855 void SetAttachNodePtr(ArkUINodeHandle nodePtr, void* attachNode)
856 {
857 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
858 if (frameNode) {
859 frameNode->SetExternalData(attachNode);
860 }
861 }
862
GetAttachNodePtr(ArkUINodeHandle nodePtr)863 void* GetAttachNodePtr(ArkUINodeHandle nodePtr)
864 {
865 auto* frameNode = AceType::DynamicCast<FrameNode>(reinterpret_cast<UINode*>(nodePtr));
866 CHECK_NULL_RETURN(frameNode, nullptr);
867 return frameNode->GetExternalData();
868 }
869
IsBuilderNode(void * nodePtr)870 ArkUI_Bool IsBuilderNode(void* nodePtr)
871 {
872 CHECK_NULL_RETURN(nodePtr, false);
873 auto* node = reinterpret_cast<UINode*>(nodePtr);
874 return static_cast<ArkUI_Int32>(node->GetNodeStatus()) != 0 ;
875 }
876 } // namespace OHOS::Ace::NG::ViewModel
877