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 "node_model.h"
17
18
19 #include "event_converter.h"
20 #include "interfaces/native/event/ui_input_event_impl.h"
21 #include "node_extened.h"
22 #include "style_modifier.h"
23
24 #include "base/error/error_code.h"
25 #include "base/utils/utils.h"
26
27 namespace OHOS::Ace::NodeModel {
28 namespace {
29 #if defined(WINDOWS_PLATFORM)
30 #include <windows.h>
31 // Here we need to find module where GetArkUINodeAPI()
32 // function is implemented.
FindModule()33 void* FindModule()
34 {
35 // To find from main exe
36 HMODULE result = nullptr;
37 const char libname[] = "libace_compatible.dll";
38 GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_PIN, libname, &result);
39 if (result) {
40 return result;
41 }
42 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Cannot find module!");
43 return nullptr;
44 }
FindFunction(void * library,const char * name)45 void* FindFunction(void* library, const char* name)
46 {
47 return (void*)GetProcAddress(reinterpret_cast<HMODULE>(library), name);
48 }
49 #else
50 #include <dlfcn.h>
51 void* FindModule()
52 {
53 const char libname[] = "libace_compatible.z.so";
54 void* result = dlopen(libname, RTLD_LAZY | RTLD_LOCAL);
55 if (result) {
56 return result;
57 }
58 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Cannot load libace: %{public}s", dlerror());
59 return nullptr;
60 }
61
62 void* FindFunction(void* library, const char* name)
63 {
64 return dlsym(library, name);
65 }
66 #endif
67
68 ArkUIFullNodeAPI* impl = nullptr;
69
InitialFullNodeImpl(int version)70 bool InitialFullNodeImpl(int version)
71 {
72 if (!impl) {
73 typedef ArkUIAnyAPI* (*GetAPI_t)(int);
74 GetAPI_t getAPI = nullptr;
75 void* module = FindModule();
76 if (module == nullptr) {
77 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "fail to get module");
78 return false;
79 }
80 // Note, that RTLD_DEFAULT is ((void *) 0).
81 getAPI = reinterpret_cast<GetAPI_t>(FindFunction(module, "GetArkUIAnyFullNodeAPI"));
82 if (!getAPI) {
83 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Cannot find GetArkUIAnyFullNodeAPI()");
84 return false;
85 }
86
87 impl = reinterpret_cast<ArkUIFullNodeAPI*>((*getAPI)(version));
88 if (!impl) {
89 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "getAPI() returned null");
90 return false;
91 }
92
93 if (impl->version != version) {
94 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE,
95 "API version mismatch: expected %{public}d, but get the version %{public}d", version, impl->version);
96 return false;
97 }
98 }
99
100 impl->getBasicAPI()->registerNodeAsyncEventReceiver(OHOS::Ace::NodeModel::HandleInnerEvent);
101 impl->getExtendedAPI()->registerCustomNodeAsyncEventReceiver(OHOS::Ace::NodeModel::HandleInnerCustomEvent);
102 return true;
103 }
104 } // namespace
105
GetFullImpl()106 ArkUIFullNodeAPI* GetFullImpl()
107 {
108 return impl;
109 }
110
InitialFullImpl()111 bool InitialFullImpl()
112 {
113 return InitialFullNodeImpl(ARKUI_NODE_API_VERSION);
114 }
115
116 struct InnerEventExtraParam {
117 int32_t targetId;
118 ArkUI_NodeHandle nodePtr;
119 void* userData;
120 };
121
122 struct ExtraData {
123 std::unordered_map<int64_t, InnerEventExtraParam*> eventMap;
124 };
125
126 std::set<ArkUI_NodeHandle> g_nodeSet;
127
IsValidArkUINode(ArkUI_NodeHandle nodePtr)128 bool IsValidArkUINode(ArkUI_NodeHandle nodePtr)
129 {
130 if (!nodePtr || g_nodeSet.count(nodePtr) == 0) {
131 return false;
132 }
133 return true;
134 }
135
CreateNode(ArkUI_NodeType type)136 ArkUI_NodeHandle CreateNode(ArkUI_NodeType type)
137 {
138 static const ArkUINodeType nodes[] = { ARKUI_CUSTOM, ARKUI_TEXT, ARKUI_SPAN, ARKUI_IMAGE_SPAN, ARKUI_IMAGE,
139 ARKUI_TOGGLE, ARKUI_LOADING_PROGRESS, ARKUI_TEXT_INPUT, ARKUI_TEXTAREA, ARKUI_BUTTON, ARKUI_PROGRESS,
140 ARKUI_CHECKBOX, ARKUI_XCOMPONENT, ARKUI_DATE_PICKER, ARKUI_TIME_PICKER, ARKUI_TEXT_PICKER,
141 ARKUI_CALENDAR_PICKER, ARKUI_SLIDER, ARKUI_RADIO, ARKUI_IMAGE_ANIMATOR, ARKUI_XCOMPONENT_TEXTURE,
142 ARKUI_CHECK_BOX_GROUP, ARKUI_STACK, ARKUI_SWIPER, ARKUI_SCROLL, ARKUI_LIST, ARKUI_LIST_ITEM,
143 ARKUI_LIST_ITEM_GROUP, ARKUI_COLUMN, ARKUI_ROW, ARKUI_FLEX, ARKUI_REFRESH, ARKUI_WATER_FLOW, ARKUI_FLOW_ITEM,
144 ARKUI_RELATIVE_CONTAINER, ARKUI_GRID, ARKUI_GRID_ITEM, ARKUI_CUSTOM_SPAN };
145 // already check in entry point.
146 uint32_t nodeType = type < MAX_NODE_SCOPE_NUM ? type : (type - MAX_NODE_SCOPE_NUM + BASIC_COMPONENT_NUM);
147 const auto* impl = GetFullImpl();
148 if (nodeType >= sizeof(nodes) / sizeof(ArkUINodeType)) {
149 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "node type: %{public}d NOT IMPLEMENT", type);
150 return nullptr;
151 }
152
153 ArkUI_Int32 id = ARKUI_AUTO_GENERATE_NODE_ID;
154 auto* uiNode = impl->getBasicAPI()->createNode(nodes[nodeType], id, ARKUI_NODE_FLAG_C);
155 if (!uiNode) {
156 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "node type: %{public}d can not find in full impl", type);
157 return nullptr;
158 }
159 impl->getBasicAPI()->markDirty(uiNode, ARKUI_DIRTY_FLAG_ATTRIBUTE_DIFF);
160 ArkUI_Node* arkUINode = new ArkUI_Node({ type, uiNode, true });
161 impl->getExtendedAPI()->setAttachNodePtr(uiNode, reinterpret_cast<void*>(arkUINode));
162 g_nodeSet.emplace(arkUINode);
163 return arkUINode;
164 }
165
DisposeNativeSource(ArkUI_NodeHandle nativePtr)166 void DisposeNativeSource(ArkUI_NodeHandle nativePtr)
167 {
168 CHECK_NULL_VOID(nativePtr);
169 if (!CheckIsCNode(nativePtr)) {
170 return;
171 }
172 if (nativePtr->customEventListeners) {
173 auto eventListenersSet = reinterpret_cast<std::set<void (*)(ArkUI_NodeCustomEvent*)>*>(
174 nativePtr->customEventListeners);
175 if (eventListenersSet) {
176 eventListenersSet->clear();
177 }
178 delete eventListenersSet;
179 nativePtr->customEventListeners = nullptr;
180 }
181 if (nativePtr->eventListeners) {
182 auto eventListenersSet = reinterpret_cast<std::set<void (*)(ArkUI_NodeEvent*)>*>(
183 nativePtr->eventListeners);
184 if (eventListenersSet) {
185 eventListenersSet->clear();
186 }
187 delete eventListenersSet;
188 nativePtr->eventListeners = nullptr;
189 }
190 if (nativePtr->areaChangeRadio) {
191 delete[] nativePtr->areaChangeRadio->value;
192 delete nativePtr->areaChangeRadio;
193 nativePtr->areaChangeRadio = nullptr;
194 }
195 }
196
DisposeNode(ArkUI_NodeHandle nativePtr)197 void DisposeNode(ArkUI_NodeHandle nativePtr)
198 {
199 CHECK_NULL_VOID(nativePtr);
200 if (!CheckIsCNode(nativePtr)) {
201 return;
202 }
203 // already check in entry point.
204 const auto* impl = GetFullImpl();
205 impl->getBasicAPI()->disposeNode(nativePtr->uiNodeHandle);
206 DisposeNativeSource(nativePtr);
207 g_nodeSet.erase(nativePtr);
208 delete nativePtr;
209 nativePtr = nullptr;
210 }
211
AddChild(ArkUI_NodeHandle parentNode,ArkUI_NodeHandle childNode)212 int32_t AddChild(ArkUI_NodeHandle parentNode, ArkUI_NodeHandle childNode)
213 {
214 CHECK_NULL_RETURN(parentNode, ERROR_CODE_PARAM_INVALID);
215 CHECK_NULL_RETURN(childNode, ERROR_CODE_PARAM_INVALID);
216 if (!CheckIsCNode(parentNode) || !CheckIsCNode(childNode)) {
217 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
218 }
219 // a
220 if (parentNode->type == -1) {
221 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
222 }
223 const auto* impl = GetFullImpl();
224 // already check in entry point.
225 impl->getBasicAPI()->addChild(parentNode->uiNodeHandle, childNode->uiNodeHandle);
226 impl->getBasicAPI()->markDirty(parentNode->uiNodeHandle, ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST);
227 return ERROR_CODE_NO_ERROR;
228 }
229
RemoveChild(ArkUI_NodeHandle parentNode,ArkUI_NodeHandle childNode)230 int32_t RemoveChild(ArkUI_NodeHandle parentNode, ArkUI_NodeHandle childNode)
231 {
232 CHECK_NULL_RETURN(parentNode, ERROR_CODE_PARAM_INVALID);
233 CHECK_NULL_RETURN(childNode, ERROR_CODE_PARAM_INVALID);
234 if (!CheckIsCNode(parentNode) || !CheckIsCNode(childNode)) {
235 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
236 }
237 // already check in entry point.
238 if (parentNode->type == -1) {
239 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
240 }
241 const auto* impl = GetFullImpl();
242 impl->getBasicAPI()->removeChild(parentNode->uiNodeHandle, childNode->uiNodeHandle);
243 impl->getBasicAPI()->markDirty(parentNode->uiNodeHandle, ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST);
244 return ERROR_CODE_NO_ERROR;
245 }
246
InsertChildAfter(ArkUI_NodeHandle parentNode,ArkUI_NodeHandle childNode,ArkUI_NodeHandle siblingNode)247 int32_t InsertChildAfter(ArkUI_NodeHandle parentNode, ArkUI_NodeHandle childNode, ArkUI_NodeHandle siblingNode)
248 {
249 CHECK_NULL_RETURN(parentNode, ERROR_CODE_PARAM_INVALID);
250 CHECK_NULL_RETURN(childNode, ERROR_CODE_PARAM_INVALID);
251 if (!CheckIsCNode(parentNode) || !CheckIsCNode(childNode)) {
252 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
253 }
254 // already check in entry point.
255 if (parentNode->type == -1) {
256 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
257 }
258 const auto* impl = GetFullImpl();
259 impl->getBasicAPI()->insertChildAfter(
260 parentNode->uiNodeHandle, childNode->uiNodeHandle, siblingNode ? siblingNode->uiNodeHandle : nullptr);
261 impl->getBasicAPI()->markDirty(parentNode->uiNodeHandle, ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST);
262 return ERROR_CODE_NO_ERROR;
263 }
264
InsertChildBefore(ArkUI_NodeHandle parentNode,ArkUI_NodeHandle childNode,ArkUI_NodeHandle siblingNode)265 int32_t InsertChildBefore(ArkUI_NodeHandle parentNode, ArkUI_NodeHandle childNode, ArkUI_NodeHandle siblingNode)
266 {
267 CHECK_NULL_RETURN(parentNode, ERROR_CODE_PARAM_INVALID);
268 CHECK_NULL_RETURN(childNode, ERROR_CODE_PARAM_INVALID);
269 if (!CheckIsCNode(parentNode) || !CheckIsCNode(childNode)) {
270 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
271 }
272 // already check in entry point.
273 if (parentNode->type == -1) {
274 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
275 }
276 const auto* impl = GetFullImpl();
277 impl->getBasicAPI()->insertChildBefore(
278 parentNode->uiNodeHandle, childNode->uiNodeHandle, siblingNode ? siblingNode->uiNodeHandle : nullptr);
279 impl->getBasicAPI()->markDirty(parentNode->uiNodeHandle, ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST);
280 return ERROR_CODE_NO_ERROR;
281 }
282
InsertChildAt(ArkUI_NodeHandle parentNode,ArkUI_NodeHandle childNode,int32_t position)283 int32_t InsertChildAt(ArkUI_NodeHandle parentNode, ArkUI_NodeHandle childNode, int32_t position)
284 {
285 CHECK_NULL_RETURN(parentNode, ERROR_CODE_PARAM_INVALID);
286 CHECK_NULL_RETURN(childNode, ERROR_CODE_PARAM_INVALID);
287 if (!CheckIsCNode(parentNode) || !CheckIsCNode(childNode)) {
288 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
289 }
290 // already check in entry point.
291 if (parentNode->type == -1) {
292 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
293 }
294 const auto* impl = GetFullImpl();
295 impl->getBasicAPI()->insertChildAt(parentNode->uiNodeHandle, childNode->uiNodeHandle, position);
296 impl->getBasicAPI()->markDirty(parentNode->uiNodeHandle, ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST);
297 return ERROR_CODE_NO_ERROR;
298 }
299
SetAttribute(ArkUI_NodeHandle node,ArkUI_NodeAttributeType attribute,const char * value)300 void SetAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute, const char* value)
301 {
302 SetNodeAttribute(node, attribute, value);
303 }
304
SetAttribute(ArkUI_NodeHandle node,ArkUI_NodeAttributeType attribute,const ArkUI_AttributeItem * value)305 int32_t SetAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute, const ArkUI_AttributeItem* value)
306 {
307 if (node == nullptr) {
308 return ERROR_CODE_PARAM_INVALID;
309 }
310 if (node->type == -1 && attribute != NODE_LAYOUT_RECT) {
311 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
312 }
313 return SetNodeAttribute(node, attribute, value);
314 }
315
ResetAttribute(ArkUI_NodeHandle node,ArkUI_NodeAttributeType attribute)316 int32_t ResetAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute)
317 {
318 if (node == nullptr) {
319 return ERROR_CODE_PARAM_INVALID;
320 }
321 if (node->type == -1 && attribute != NODE_LAYOUT_RECT) {
322 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
323 }
324 return ResetNodeAttribute(node, attribute);
325 }
326
GetAttribute(ArkUI_NodeHandle node,ArkUI_NodeAttributeType attribute)327 const ArkUI_AttributeItem* GetAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute)
328 {
329 if (node == nullptr) {
330 return nullptr;
331 }
332 return GetNodeAttribute(node, attribute);
333 }
334
RegisterNodeEvent(ArkUI_NodeHandle nodePtr,ArkUI_NodeEventType eventType,int32_t targetId)335 int32_t RegisterNodeEvent(ArkUI_NodeHandle nodePtr, ArkUI_NodeEventType eventType, int32_t targetId)
336 {
337 return RegisterNodeEvent(nodePtr, eventType, targetId, nullptr);
338 }
339
RegisterNodeEvent(ArkUI_NodeHandle nodePtr,ArkUI_NodeEventType eventType,int32_t targetId,void * userData)340 int32_t RegisterNodeEvent(ArkUI_NodeHandle nodePtr, ArkUI_NodeEventType eventType, int32_t targetId, void* userData)
341 {
342 if (nodePtr == nullptr || !CheckIsCNode(nodePtr)) {
343 return ERROR_CODE_PARAM_INVALID;
344 }
345 auto originEventType = ConvertOriginEventType(eventType, nodePtr->type);
346 if (originEventType < 0) {
347 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "event is not supported %{public}d", eventType);
348 return ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED;
349 }
350 // already check in entry point.
351 if (nodePtr->type == -1 && !nodePtr->isBindNative) {
352 return ERROR_CODE_NATIVE_IMPL_BUILDER_NODE_ERROR;
353 }
354 const auto* impl = GetFullImpl();
355 auto* extraParam = new InnerEventExtraParam({ targetId, nodePtr, userData });
356 if (nodePtr->extraData) {
357 auto* extraData = reinterpret_cast<ExtraData*>(nodePtr->extraData);
358 auto result = extraData->eventMap.try_emplace(eventType, extraParam);
359 if (!result.second) {
360 result.first->second->targetId = targetId;
361 result.first->second->userData = userData;
362 delete extraParam;
363 }
364 } else {
365 nodePtr->extraData = new ExtraData();
366 auto* extraData = reinterpret_cast<ExtraData*>(nodePtr->extraData);
367 extraData->eventMap[eventType] = extraParam;
368 }
369 if (eventType == NODE_EVENT_ON_VISIBLE_AREA_CHANGE) {
370 ArkUI_AttributeItem* radio = nodePtr->areaChangeRadio;
371 radio = radio ? radio : static_cast<ArkUI_AttributeItem*>(userData);
372 if (!radio) {
373 return ERROR_CODE_PARAM_INVALID;
374 }
375 ArkUI_Int32 radioLength = radio->size;
376 if (radioLength <= 0) {
377 return ERROR_CODE_PARAM_INVALID;
378 }
379 ArkUI_Float32 radioList[radioLength];
380 for (int i = 0; i < radioLength; ++i) {
381 if (LessNotEqual(radio->value[i].f32, 0.0f) || GreatNotEqual(radio->value[i].f32, 1.0f)) {
382 return ERROR_CODE_PARAM_INVALID;
383 }
384 radioList[i] = radio->value[i].f32;
385 }
386 impl->getNodeModifiers()->getCommonModifier()->setOnVisibleAreaChange(
387 nodePtr->uiNodeHandle, reinterpret_cast<int64_t>(nodePtr), radioList, radioLength);
388 } else if (eventType == NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_EVENT) {
389 auto options = nodePtr->visibleAreaEventOptions;
390 if (!options) {
391 return ERROR_CODE_PARAM_INVALID;
392 }
393 auto visibleAreaEventOptions = reinterpret_cast<ArkUI_VisibleAreaEventOptions*>(options);
394 if (!visibleAreaEventOptions) {
395 return ERROR_CODE_PARAM_INVALID;
396 }
397 ArkUI_Int32 radioLength = static_cast<ArkUI_Int32>(visibleAreaEventOptions->ratios.size());
398 if (radioLength <= 0) {
399 return ERROR_CODE_PARAM_INVALID;
400 }
401 ArkUI_Float32 radioList[radioLength];
402 for (int i = 0; i < radioLength; ++i) {
403 if (LessNotEqual(visibleAreaEventOptions->ratios[i], 0.0f) ||
404 GreatNotEqual(visibleAreaEventOptions->ratios[i], 1.0f)) {
405 return ERROR_CODE_PARAM_INVALID;
406 }
407 radioList[i] = visibleAreaEventOptions->ratios[i];
408 }
409 impl->getNodeModifiers()->getCommonModifier()->setOnVisibleAreaApproximateChange(nodePtr->uiNodeHandle,
410 reinterpret_cast<int64_t>(nodePtr), radioList, radioLength,
411 visibleAreaEventOptions->expectedUpdateInterval);
412 } else {
413 impl->getBasicAPI()->registerNodeAsyncEvent(
414 nodePtr->uiNodeHandle, static_cast<ArkUIEventSubKind>(originEventType), reinterpret_cast<int64_t>(nodePtr));
415 }
416 return ERROR_CODE_NO_ERROR;
417 }
418
UnregisterNodeEvent(ArkUI_NodeHandle nodePtr,ArkUI_NodeEventType eventType)419 void UnregisterNodeEvent(ArkUI_NodeHandle nodePtr, ArkUI_NodeEventType eventType)
420 {
421 if (nodePtr == nullptr || !CheckIsCNode(nodePtr)) {
422 return;
423 }
424 if (!nodePtr->extraData) {
425 return;
426 }
427 if (nodePtr->type == -1 && !nodePtr->isBindNative) {
428 return;
429 }
430 auto* extraData = reinterpret_cast<ExtraData*>(nodePtr->extraData);
431 auto& eventMap = extraData->eventMap;
432 auto innerEventExtraParam = eventMap.find(eventType);
433 if (innerEventExtraParam == eventMap.end()) {
434 return;
435 }
436 delete innerEventExtraParam->second;
437 eventMap.erase(innerEventExtraParam);
438 if (eventMap.empty()) {
439 delete extraData;
440 nodePtr->extraData = nullptr;
441 }
442 auto originEventType = ConvertOriginEventType(eventType, nodePtr->type);
443 if (originEventType < 0) {
444 return;
445 }
446 impl->getBasicAPI()->unRegisterNodeAsyncEvent(
447 nodePtr->uiNodeHandle, static_cast<ArkUIEventSubKind>(originEventType));
448 }
449
450 void (*g_compatibleEventReceiver)(ArkUI_CompatibleNodeEvent* event) = nullptr;
RegisterOnEvent(void (* eventReceiver)(ArkUI_CompatibleNodeEvent * event))451 void RegisterOnEvent(void (*eventReceiver)(ArkUI_CompatibleNodeEvent* event))
452 {
453 g_compatibleEventReceiver = eventReceiver;
454 }
455
456 void (*g_eventReceiver)(ArkUI_NodeEvent* event) = nullptr;
RegisterOnEvent(void (* eventReceiver)(ArkUI_NodeEvent * event))457 void RegisterOnEvent(void (*eventReceiver)(ArkUI_NodeEvent* event))
458 {
459 g_eventReceiver = eventReceiver;
460 }
461
UnregisterOnEvent()462 void UnregisterOnEvent()
463 {
464 g_eventReceiver = nullptr;
465 }
466
HandleTouchEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)467 void HandleTouchEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
468 {
469 uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_TOUCH;
470 uiEvent.eventTypeId = C_TOUCH_EVENT_ID;
471 uiEvent.inputEvent = &(innerEvent->touchEvent);
472 }
473
HandleMouseEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)474 void HandleMouseEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
475 {
476 uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_MOUSE;
477 uiEvent.eventTypeId = C_MOUSE_EVENT_ID;
478 uiEvent.inputEvent = &(innerEvent->mouseEvent);
479 }
480
HandleKeyEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)481 void HandleKeyEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
482 {
483 uiEvent.eventTypeId = C_KEY_EVENT_ID;
484 uiEvent.inputEvent = &(innerEvent->keyEvent);
485 }
486
HandleFocusAxisEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)487 void HandleFocusAxisEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
488 {
489 uiEvent.eventTypeId = C_FOCUS_AXIS_EVENT_ID;
490 uiEvent.inputEvent = &(innerEvent->focusAxisEvent);
491 }
492
HandleAxisEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)493 void HandleAxisEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
494 {
495 uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_AXIS;
496 uiEvent.eventTypeId = C_AXIS_EVENT_ID;
497 uiEvent.inputEvent = &(innerEvent->axisEvent);
498 }
499
HandleHoverEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)500 void HandleHoverEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
501 {
502 uiEvent.eventTypeId = C_HOVER_EVENT_ID;
503 uiEvent.inputEvent = &(innerEvent->hoverEvent);
504 }
505
HandleClickEvent(ArkUI_UIInputEvent & uiEvent,ArkUINodeEvent * innerEvent)506 void HandleClickEvent(ArkUI_UIInputEvent& uiEvent, ArkUINodeEvent* innerEvent)
507 {
508 uiEvent.eventTypeId = C_CLICK_EVENT_ID;
509 uiEvent.inputEvent = &(innerEvent->clickEvent);
510 }
511
HandleInnerNodeEvent(ArkUINodeEvent * innerEvent)512 void HandleInnerNodeEvent(ArkUINodeEvent* innerEvent)
513 {
514 if (!innerEvent) {
515 return;
516 }
517 auto nativeNodeEventType = GetNativeNodeEventType(innerEvent);
518 if (nativeNodeEventType == -1) {
519 return;
520 }
521 auto eventType = static_cast<ArkUI_NodeEventType>(nativeNodeEventType);
522 auto* nodePtr = reinterpret_cast<ArkUI_NodeHandle>(innerEvent->extraParam);
523 auto extraData = reinterpret_cast<ExtraData*>(nodePtr->extraData);
524 if (!extraData) {
525 return;
526 }
527 auto innerEventExtraParam = extraData->eventMap.find(eventType);
528 if (innerEventExtraParam == extraData->eventMap.end()) {
529 return;
530 }
531 ArkUI_NodeEvent event;
532 event.node = nodePtr;
533 event.eventId = innerEventExtraParam->second->targetId;
534 event.userData = innerEventExtraParam->second->userData;
535 if (!g_eventReceiver && !g_compatibleEventReceiver && (!(event.node) ||
536 (event.node && !(event.node->eventListeners)))) {
537 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "event receiver is not register");
538 return;
539 }
540 if ((g_eventReceiver || (event.node && event.node->eventListeners)) && ConvertEvent(innerEvent, &event)) {
541 event.targetId = innerEvent->nodeId;
542 ArkUI_UIInputEvent uiEvent;
543 std::map<ArkUI_NodeEventType, std::function<void(ArkUI_UIInputEvent&, ArkUINodeEvent*)>> eventHandlers = {
544 {NODE_TOUCH_EVENT, HandleTouchEvent},
545 {NODE_ON_TOUCH_INTERCEPT, HandleTouchEvent},
546 {NODE_ON_MOUSE, HandleMouseEvent},
547 {NODE_ON_KEY_EVENT, HandleKeyEvent},
548 {NODE_ON_KEY_PRE_IME, HandleKeyEvent},
549 {NODE_ON_FOCUS_AXIS, HandleFocusAxisEvent},
550 {NODE_DISPATCH_KEY_EVENT, HandleKeyEvent},
551 {NODE_ON_AXIS, HandleAxisEvent},
552 {NODE_ON_CLICK_EVENT, HandleClickEvent},
553 {NODE_ON_HOVER_EVENT, HandleHoverEvent},
554 {NODE_ON_HOVER_MOVE, HandleTouchEvent},
555 };
556
557 auto it = eventHandlers.find(eventType);
558 if (it != eventHandlers.end()) {
559 it->second(uiEvent, innerEvent);
560 event.origin = &uiEvent;
561 } else {
562 event.origin = innerEvent;
563 }
564 HandleNodeEvent(&event);
565 }
566 if (g_compatibleEventReceiver) {
567 ArkUI_CompatibleNodeEvent event;
568 event.node = nodePtr;
569 event.eventId = innerEventExtraParam->second->targetId;
570 if (ConvertEvent(innerEvent, &event)) {
571 g_compatibleEventReceiver(&event);
572 ConvertEventResult(&event, innerEvent);
573 }
574 }
575 }
576
GetNativeNodeEventType(ArkUINodeEvent * innerEvent)577 int32_t GetNativeNodeEventType(ArkUINodeEvent* innerEvent)
578 {
579 int32_t invalidType = -1;
580 auto* nodePtr = reinterpret_cast<ArkUI_NodeHandle>(innerEvent->extraParam);
581 if (!nodePtr || g_nodeSet.count(nodePtr) == 0) {
582 return invalidType;
583 }
584 if (!nodePtr->extraData) {
585 return invalidType;
586 }
587 auto extraData = reinterpret_cast<ExtraData*>(nodePtr->extraData);
588 ArkUIEventSubKind subKind = static_cast<ArkUIEventSubKind>(-1);
589 switch (innerEvent->kind) {
590 case COMPONENT_ASYNC_EVENT:
591 subKind = static_cast<ArkUIEventSubKind>(innerEvent->componentAsyncEvent.subKind);
592 break;
593 case TEXT_INPUT:
594 subKind = static_cast<ArkUIEventSubKind>(innerEvent->textInputEvent.subKind);
595 break;
596 case TOUCH_EVENT:
597 subKind = static_cast<ArkUIEventSubKind>(innerEvent->touchEvent.subKind);
598 break;
599 case MOUSE_INPUT_EVENT:
600 subKind = static_cast<ArkUIEventSubKind>(innerEvent->mouseEvent.subKind);
601 break;
602 case MIXED_EVENT:
603 subKind = static_cast<ArkUIEventSubKind>(innerEvent->mixedEvent.subKind);
604 break;
605 case DRAG_EVENT:
606 subKind = static_cast<ArkUIEventSubKind>(innerEvent->dragEvent.subKind);
607 break;
608 case KEY_INPUT_EVENT:
609 subKind = static_cast<ArkUIEventSubKind>(innerEvent->keyEvent.subKind);
610 break;
611 case FOCUS_AXIS_EVENT:
612 subKind = static_cast<ArkUIEventSubKind>(innerEvent->focusAxisEvent.subKind);
613 break;
614 case TEXT_INPUT_CHANGE:
615 subKind = static_cast<ArkUIEventSubKind>(innerEvent->textChangeEvent.subKind);
616 break;
617 case AXIS_EVENT:
618 subKind = static_cast<ArkUIEventSubKind>(innerEvent->axisEvent.subKind);
619 break;
620 case CLICK_EVENT:
621 subKind = static_cast<ArkUIEventSubKind>(innerEvent->clickEvent.subKind);
622 break;
623 case HOVER_EVENT:
624 subKind = static_cast<ArkUIEventSubKind>(innerEvent->hoverEvent.subKind);
625 break;
626 default:
627 break; /* Empty */
628 }
629 ArkUI_NodeEventType eventType = static_cast<ArkUI_NodeEventType>(ConvertToNodeEventType(subKind));
630 auto innerEventExtraParam = extraData->eventMap.find(eventType);
631 if (innerEventExtraParam == extraData->eventMap.end()) {
632 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "the event of %{public}d is not register", eventType);
633 return invalidType;
634 }
635 return static_cast<int32_t>(eventType);
636 }
637
HandleNodeEvent(ArkUI_NodeEvent * event)638 void HandleNodeEvent(ArkUI_NodeEvent* event)
639 {
640 if (!event) {
641 return;
642 }
643 if (event->node && event->node->eventListeners) {
644 auto eventListenersSet = reinterpret_cast<std::set<void (*)(ArkUI_NodeEvent*)>*>(event->node->eventListeners);
645 TriggerNodeEvent(event, eventListenersSet);
646 }
647 if (g_eventReceiver) {
648 g_eventReceiver(event);
649 }
650 }
651
TriggerNodeEvent(ArkUI_NodeEvent * event,std::set<void (*)(ArkUI_NodeEvent *)> * eventListenersSet)652 void TriggerNodeEvent(ArkUI_NodeEvent* event, std::set<void (*)(ArkUI_NodeEvent*)>* eventListenersSet)
653 {
654 if (!eventListenersSet) {
655 return;
656 }
657 if (eventListenersSet->size() == 1) {
658 auto eventListener = eventListenersSet->begin();
659 (*eventListener)(event);
660 } else if (eventListenersSet->size() > 1) {
661 for (const auto& eventListener : *eventListenersSet) {
662 (*eventListener)(event);
663 if (!IsValidArkUINode(event->node)) {
664 break;
665 }
666 }
667 }
668 }
669
CheckEvent(ArkUI_NodeEvent * event)670 int32_t CheckEvent(ArkUI_NodeEvent* event)
671 {
672 return 0;
673 }
674
SetUserData(ArkUI_NodeHandle node,void * userData)675 int32_t SetUserData(ArkUI_NodeHandle node, void* userData)
676 {
677 if (!node || !CheckIsCNode(node)) {
678 return ERROR_CODE_PARAM_INVALID;
679 }
680 if (!userData) {
681 return ERROR_CODE_PARAM_INVALID;
682 }
683 node->userData = userData;
684 return ERROR_CODE_NO_ERROR;
685 }
686
GetUserData(ArkUI_NodeHandle node)687 void* GetUserData(ArkUI_NodeHandle node)
688 {
689 return node->userData;
690 }
691
SetLengthMetricUnit(ArkUI_NodeHandle nodePtr,ArkUI_LengthMetricUnit unit)692 int32_t SetLengthMetricUnit(ArkUI_NodeHandle nodePtr, ArkUI_LengthMetricUnit unit)
693 {
694 if (!nodePtr || !CheckIsCNode(nodePtr)) {
695 return ERROR_CODE_PARAM_INVALID;
696 }
697 if (!InRegion(static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_DEFAULT),
698 static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_FP), static_cast<int32_t>(unit))) {
699 return ERROR_CODE_PARAM_INVALID;
700 }
701 nodePtr->lengthMetricUnit = unit;
702 return ERROR_CODE_NO_ERROR;
703 }
704
ApplyModifierFinish(ArkUI_NodeHandle nodePtr)705 void ApplyModifierFinish(ArkUI_NodeHandle nodePtr)
706 {
707 // already check in entry point.
708 if (!nodePtr) {
709 return;
710 }
711 const auto* impl = GetFullImpl();
712 impl->getBasicAPI()->applyModifierFinish(nodePtr->uiNodeHandle);
713 }
714
MarkDirty(ArkUI_NodeHandle nodePtr,ArkUI_NodeDirtyFlag dirtyFlag)715 void MarkDirty(ArkUI_NodeHandle nodePtr, ArkUI_NodeDirtyFlag dirtyFlag)
716 {
717 // spanNode inherited from UINode
718 if (!nodePtr || !CheckIsCNode(nodePtr)) {
719 return;
720 }
721 ArkUIDirtyFlag flag = ARKUI_DIRTY_FLAG_MEASURE;
722 switch (dirtyFlag) {
723 case NODE_NEED_MEASURE: {
724 flag = ARKUI_DIRTY_FLAG_MEASURE_SELF_AND_PARENT;
725 break;
726 }
727 case NODE_NEED_LAYOUT: {
728 flag = ARKUI_DIRTY_FLAG_LAYOUT;
729 break;
730 }
731 case NODE_NEED_RENDER: {
732 flag = ARKUI_DIRTY_FLAG_RENDER;
733 break;
734 }
735 default: {
736 flag = ARKUI_DIRTY_FLAG_MEASURE;
737 }
738 }
739 // already check in entry point.
740 const auto* impl = GetFullImpl();
741 impl->getBasicAPI()->markDirty(nodePtr->uiNodeHandle, flag);
742 }
743
AddNodeEventReceiver(ArkUI_NodeHandle nodePtr,void (* eventReceiver)(ArkUI_NodeEvent * event))744 int32_t AddNodeEventReceiver(ArkUI_NodeHandle nodePtr, void (*eventReceiver)(ArkUI_NodeEvent* event))
745 {
746 if (!nodePtr || !eventReceiver || !CheckIsCNode(nodePtr)) {
747 return ERROR_CODE_PARAM_INVALID;
748 }
749 if (!nodePtr->eventListeners) {
750 nodePtr->eventListeners = new std::set<void (*)(ArkUI_NodeEvent*)>();
751 }
752 auto eventListenersSet = reinterpret_cast<std::set<void (*)(ArkUI_NodeEvent*)>*>(nodePtr->eventListeners);
753 if (!eventListenersSet) {
754 return ERROR_CODE_PARAM_INVALID;
755 }
756 eventListenersSet->emplace(eventReceiver);
757 return ERROR_CODE_NO_ERROR;
758 }
759
RemoveNodeEventReceiver(ArkUI_NodeHandle nodePtr,void (* eventReceiver)(ArkUI_NodeEvent * event))760 int32_t RemoveNodeEventReceiver(ArkUI_NodeHandle nodePtr, void (*eventReceiver)(ArkUI_NodeEvent* event))
761 {
762 if (!nodePtr || !eventReceiver || !nodePtr->eventListeners || !CheckIsCNode(nodePtr)) {
763 return ERROR_CODE_PARAM_INVALID;
764 }
765 auto eventListenersSet = reinterpret_cast<std::set<void (*)(ArkUI_NodeEvent*)>*>(nodePtr->eventListeners);
766 if (!eventListenersSet) {
767 return ERROR_CODE_PARAM_INVALID;
768 }
769 eventListenersSet->erase(eventReceiver);
770 if (eventListenersSet->empty()) {
771 delete eventListenersSet;
772 nodePtr->eventListeners = nullptr;
773 }
774 return ERROR_CODE_NO_ERROR;
775 }
776
GetParseJsMedia()777 void* GetParseJsMedia()
778 {
779 void* module = FindModule();
780 if (!module) {
781 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "fail to get module");
782 return nullptr;
783 }
784 void (*parseJsMedia)(void* value, void* resource) = nullptr;
785 parseJsMedia = reinterpret_cast<void (*)(void*, void*)>(
786 FindFunction(module, "OHOS_ACE_ParseJsMedia"));
787 if (!parseJsMedia) {
788 TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Cannot find OHOS_ACE_ParseJsMedia");
789 return nullptr;
790 }
791 return reinterpret_cast<void*>(parseJsMedia);
792 }
793
CheckIsCNode(ArkUI_NodeHandle node)794 bool CheckIsCNode(ArkUI_NodeHandle node)
795 {
796 if (node->cNode || node->buildNode) {
797 return true;
798 }
799 return false;
800 }
801
CheckIsCNodeOrCrossLanguage(ArkUI_NodeHandle node)802 bool CheckIsCNodeOrCrossLanguage(ArkUI_NodeHandle node)
803 {
804 if (node->cNode || node->buildNode) {
805 return true;
806 }
807 const auto* impl = GetFullImpl();
808 CHECK_NULL_RETURN(impl, false);
809 return impl->getNodeModifiers()->getFrameNodeModifier()->getCrossLanguageOptions(node->uiNodeHandle);
810 }
811
GetArkUINode(ArkUINodeHandle node)812 ArkUI_NodeHandle GetArkUINode(ArkUINodeHandle node)
813 {
814 CHECK_NULL_RETURN(node, nullptr);
815 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
816 void* attachNode = impl->getExtendedAPI()->getAttachNodePtr(node);
817 if (attachNode) {
818 return reinterpret_cast<ArkUI_NodeHandle>(attachNode);
819 }
820 ArkUI_Node* arkUINode = new ArkUI_Node({ -1, node, false });
821 arkUINode->type = GetNodeTypeByTag(arkUINode);
822 impl->getExtendedAPI()->setAttachNodePtr((arkUINode)->uiNodeHandle, reinterpret_cast<void*>(arkUINode));
823 return reinterpret_cast<ArkUI_NodeHandle>(arkUINode);
824 }
825
GetNodeTypeByTag(ArkUI_NodeHandle node)826 int32_t GetNodeTypeByTag(ArkUI_NodeHandle node)
827 {
828 if (node == nullptr) {
829 return -1;
830 }
831
832 static const std::unordered_map<std::string, ArkUI_NodeType> nodeTypeMap = {
833 { OHOS::Ace::V2::TEXT_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TEXT },
834 { OHOS::Ace::V2::SPAN_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_SPAN },
835 { OHOS::Ace::V2::IMAGE_SPAN_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_IMAGE_SPAN },
836 { OHOS::Ace::V2::IMAGE_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_IMAGE },
837 { OHOS::Ace::V2::TOGGLE_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TOGGLE },
838 { OHOS::Ace::V2::LOADING_PROGRESS_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_LOADING_PROGRESS },
839 { OHOS::Ace::V2::TEXTINPUT_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TEXT_INPUT },
840 { OHOS::Ace::V2::TEXTAREA_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TEXT_AREA },
841 { OHOS::Ace::V2::BUTTON_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_BUTTON },
842 { OHOS::Ace::V2::PROGRESS_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_PROGRESS },
843 { OHOS::Ace::V2::CHECK_BOX_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_CHECKBOX },
844 { OHOS::Ace::V2::XCOMPONENT_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_XCOMPONENT },
845 { OHOS::Ace::V2::DATE_PICKER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_DATE_PICKER },
846 { OHOS::Ace::V2::TIME_PICKER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TIME_PICKER },
847 { OHOS::Ace::V2::TEXT_PICKER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_TEXT_PICKER },
848 { OHOS::Ace::V2::CALENDAR_PICKER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_CALENDAR_PICKER },
849 { OHOS::Ace::V2::SLIDER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_SLIDER },
850 { OHOS::Ace::V2::RADIO_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_RADIO },
851 { OHOS::Ace::V2::IMAGE_ANIMATOR_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_IMAGE_ANIMATOR },
852 { OHOS::Ace::V2::STACK_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_STACK },
853 { OHOS::Ace::V2::SWIPER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_SWIPER },
854 { OHOS::Ace::V2::SCROLL_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_SCROLL },
855 { OHOS::Ace::V2::LIST_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_LIST },
856 { OHOS::Ace::V2::LIST_ITEM_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_LIST_ITEM },
857 { OHOS::Ace::V2::LIST_ITEM_GROUP_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_LIST_ITEM_GROUP },
858 { OHOS::Ace::V2::COLUMN_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_COLUMN },
859 { OHOS::Ace::V2::ROW_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_ROW },
860 { OHOS::Ace::V2::FLEX_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_FLEX },
861 { OHOS::Ace::V2::REFRESH_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_REFRESH },
862 { OHOS::Ace::V2::WATERFLOW_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_WATER_FLOW },
863 { OHOS::Ace::V2::FLOW_ITEM_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_FLOW_ITEM },
864 { OHOS::Ace::V2::RELATIVE_CONTAINER_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_RELATIVE_CONTAINER },
865 { OHOS::Ace::V2::GRID_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_GRID },
866 { OHOS::Ace::V2::GRID_ITEM_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_GRID_ITEM },
867 { OHOS::Ace::V2::CUSTOM_SPAN_NODE_ETS_TAG, ArkUI_NodeType::ARKUI_NODE_CUSTOM_SPAN },
868 };
869
870 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
871 auto value = impl->getNodeModifiers()->getFrameNodeModifier()->getNodeType(node->uiNodeHandle);
872 auto iter = nodeTypeMap.find(value);
873 if (iter != nodeTypeMap.end()) {
874 return iter->second;
875 }
876 return -1;
877 }
878
RegisterBindNativeNode(ArkUI_NodeHandle node)879 void RegisterBindNativeNode(ArkUI_NodeHandle node)
880 {
881 CHECK_NULL_VOID(node);
882 g_nodeSet.emplace(node);
883 }
884 } // namespace OHOS::Ace::NodeModel
885
886 #ifdef __cplusplus
887 extern "C" {
888 #endif
889
OH_ArkUI_NodeContent_AddNode(ArkUI_NodeContentHandle content,ArkUI_NodeHandle node)890 int32_t OH_ArkUI_NodeContent_AddNode(ArkUI_NodeContentHandle content, ArkUI_NodeHandle node)
891 {
892 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
893 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND);
894 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
895 return impl->getNodeModifiers()->getNodeContentModifier()->addChild(
896 reinterpret_cast<ArkUINodeContentHandle>(content), node->uiNodeHandle);
897 }
898
OH_ArkUI_NodeContent_InsertNode(ArkUI_NodeContentHandle content,ArkUI_NodeHandle node,int32_t position)899 int32_t OH_ArkUI_NodeContent_InsertNode(ArkUI_NodeContentHandle content, ArkUI_NodeHandle node, int32_t position)
900 {
901 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
902 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND);
903 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
904 return impl->getNodeModifiers()->getNodeContentModifier()->insertChild(
905 reinterpret_cast<ArkUINodeContentHandle>(content), node->uiNodeHandle, position);
906 }
907
OH_ArkUI_NodeContent_RemoveNode(ArkUI_NodeContentHandle content,ArkUI_NodeHandle node)908 int32_t OH_ArkUI_NodeContent_RemoveNode(ArkUI_NodeContentHandle content, ArkUI_NodeHandle node)
909 {
910 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
911 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND);
912 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
913 return impl->getNodeModifiers()->getNodeContentModifier()->removeChild(
914 reinterpret_cast<ArkUINodeContentHandle>(content), node->uiNodeHandle);
915 }
916
OH_ArkUI_NodeContent_RegisterCallback(ArkUI_NodeContentHandle content,ArkUI_NodeContentCallback callback)917 int32_t OH_ArkUI_NodeContent_RegisterCallback(ArkUI_NodeContentHandle content, ArkUI_NodeContentCallback callback)
918 {
919 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
920 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND);
921 auto innerCallback = reinterpret_cast<void (*)(ArkUINodeContentEvent* event)>(callback);
922 return impl->getNodeModifiers()->getNodeContentModifier()->registerEvent(
923 reinterpret_cast<ArkUINodeContentHandle>(content), nullptr, innerCallback);
924 }
925
OH_ArkUI_NodeContentEvent_GetEventType(ArkUI_NodeContentEvent * event)926 ArkUI_NodeContentEventType OH_ArkUI_NodeContentEvent_GetEventType(ArkUI_NodeContentEvent* event)
927 {
928 CHECK_NULL_RETURN(event, static_cast<ArkUI_NodeContentEventType>(-1));
929 auto* innerEvent = reinterpret_cast<ArkUINodeContentEvent*>(event);
930 return static_cast<ArkUI_NodeContentEventType>(innerEvent->type);
931 }
932
OH_ArkUI_NodeContentEvent_GetNodeContentHandle(ArkUI_NodeContentEvent * event)933 ArkUI_NodeContentHandle OH_ArkUI_NodeContentEvent_GetNodeContentHandle(ArkUI_NodeContentEvent* event)
934 {
935 CHECK_NULL_RETURN(event, nullptr);
936 auto* innerEvent = reinterpret_cast<ArkUINodeContentEvent*>(event);
937 return reinterpret_cast<ArkUI_NodeContentHandle>(innerEvent->nodeContent);
938 }
939
OH_ArkUI_NodeContent_SetUserData(ArkUI_NodeContentHandle content,void * userData)940 int32_t OH_ArkUI_NodeContent_SetUserData(ArkUI_NodeContentHandle content, void* userData)
941 {
942 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
943 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND);
944 return impl->getNodeModifiers()->getNodeContentModifier()->setUserData(
945 reinterpret_cast<ArkUINodeContentHandle>(content), userData);
946 }
947
OH_ArkUI_NodeContent_GetUserData(ArkUI_NodeContentHandle content)948 void* OH_ArkUI_NodeContent_GetUserData(ArkUI_NodeContentHandle content)
949 {
950 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
951 CHECK_NULL_RETURN(impl, nullptr);
952 return impl->getNodeModifiers()->getNodeContentModifier()->getUserData(
953 reinterpret_cast<ArkUINodeContentHandle>(content));
954 }
955
956 #ifdef __cplusplus
957 };
958 #endif
959