1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "native_node_napi.h"
17 
18 #include <cstdint>
19 
20 #include "js_native_api.h"
21 #include "js_native_api_types.h"
22 #include "native_type.h"
23 #include "node/node_extened.h"
24 #include "node/node_model.h"
25 
26 #include "base/error/error_code.h"
27 #include "base/image/pixel_map.h"
28 #include "base/log/log_wrapper.h"
29 #include "base/utils/utils.h"
30 #include "core/components_ng/base/frame_node.h"
31 #include "core/components_ng/base/ui_node.h"
32 
33 extern "C" {
34 
OH_ArkUI_GetNodeHandleFromNapiValue(napi_env env,napi_value value,ArkUI_NodeHandle * handle)35 int32_t OH_ArkUI_GetNodeHandleFromNapiValue(napi_env env, napi_value value, ArkUI_NodeHandle* handle)
36 {
37     bool hasProperty = false;
38     auto result = napi_has_named_property(env, value, "nodePtr_", &hasProperty);
39     const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
40     if (result == napi_ok && hasProperty) {
41         napi_value frameNodePtr = nullptr;
42         auto result = napi_get_named_property(env, value, "nodePtr_", &frameNodePtr);
43         if (result != napi_ok) {
44             LOGE("fail to get nodePtr");
45             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
46         }
47         // BuilderNode case.
48         void* nativePtr = nullptr;
49         result = napi_get_value_external(env, frameNodePtr, &nativePtr);
50         if (result != napi_ok || nativePtr == nullptr) {
51             LOGE("fail to get nodePtr external value");
52             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
53         }
54         auto* uiNodePtr = reinterpret_cast<OHOS::Ace::NG::UINode*>(nativePtr);
55         uiNodePtr->IncRefCount();
56         *handle = new ArkUI_Node({ .type = -1,
57             .uiNodeHandle = reinterpret_cast<ArkUINodeHandle>(nativePtr),
58             .cNode = false,
59             .buildNode = true });
60         if (impl) {
61             impl->getExtendedAPI()->setAttachNodePtr((*handle)->uiNodeHandle, reinterpret_cast<void*>(*handle));
62         }
63         return OHOS::Ace::ERROR_CODE_NO_ERROR;
64     }
65     result = napi_has_named_property(env, value, "builderNode_", &hasProperty);
66     if (result == napi_ok && hasProperty) {
67         // Component Content case.
68         napi_value builderNode = nullptr;
69         auto result = napi_get_named_property(env, value, "builderNode_", &builderNode);
70         if (result != napi_ok) {
71             LOGE("fail to get builderNode");
72             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
73         }
74         napi_value nodePtr = nullptr;
75         result = napi_get_named_property(env, builderNode, "nodePtr_", &nodePtr);
76         if (result != napi_ok) {
77             LOGE("fail to get nodePtr in builderNode");
78             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
79         }
80         void* nativePtr = nullptr;
81         result = napi_get_value_external(env, nodePtr, &nativePtr);
82         if (result != napi_ok) {
83             LOGE("fail to get nodePtr external value in builderNode");
84             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
85         }
86         auto* uiNode = reinterpret_cast<OHOS::Ace::NG::UINode*>(nativePtr);
87         OHOS::Ace::NG::FrameNode* frameNode = OHOS::Ace::AceType::DynamicCast<OHOS::Ace::NG::FrameNode>(uiNode);
88         if (frameNode == nullptr) {
89             LOGE("fail to get frameNode value in builderNode");
90             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
91         }
92         if (frameNode->GetTag() == "BuilderProxyNode") {
93             // need to get the really frameNode.
94             if (!impl) {
95                 return OHOS::Ace::ERROR_CODE_NATIVE_IMPL_LIBRARY_NOT_FOUND;
96             }
97             auto* child = impl->getNodeModifiers()->getFrameNodeModifier()->getChild(
98                 reinterpret_cast<ArkUINodeHandle>(frameNode), 0, true);
99             if (!child) {
100                 LOGE("fail to get child in BuilderProxyNode");
101                 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
102             }
103             frameNode = reinterpret_cast<OHOS::Ace::NG::FrameNode*>(child);
104         }
105         frameNode->IncRefCount();
106         *handle = new ArkUI_Node({ .type = -1,
107             .uiNodeHandle = reinterpret_cast<ArkUINodeHandle>(frameNode),
108             .cNode = false,
109             .buildNode = true });
110         if (impl) {
111             impl->getExtendedAPI()->setAttachNodePtr((*handle)->uiNodeHandle, reinterpret_cast<void*>(*handle));
112         }
113         return OHOS::Ace::ERROR_CODE_NO_ERROR;
114     }
115     return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
116 }
117 
OH_ArkUI_GetContextFromNapiValue(napi_env env,napi_value value,ArkUI_ContextHandle * context)118 int32_t OH_ArkUI_GetContextFromNapiValue(napi_env env, napi_value value, ArkUI_ContextHandle* context)
119 {
120     bool hasProperty = false;
121     auto result = napi_has_named_property(env, value, "instanceId_", &hasProperty);
122     if (result != napi_ok || !hasProperty) {
123         LOGE("fail to get Context value");
124         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
125     }
126 
127     napi_value contextPtr = nullptr;
128     result = napi_get_named_property(env, value, "instanceId_", &contextPtr);
129     if (result != napi_ok) {
130         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
131     }
132 
133     napi_valuetype valuetype;
134     if (napi_typeof(env, contextPtr, &valuetype) != napi_ok) {
135         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
136     }
137     if (valuetype != napi_number) {
138         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
139     }
140     int32_t instanceId = -1;
141     result = napi_get_value_int32(env, contextPtr, &instanceId);
142     if (result != napi_ok) {
143         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
144     }
145     *context = new ArkUI_Context({ .id = instanceId });
146     return OHOS::Ace::ERROR_CODE_NO_ERROR;
147 }
148 
OH_ArkUI_GetNodeContentFromNapiValue(napi_env env,napi_value value,ArkUI_NodeContentHandle * content)149 int32_t OH_ArkUI_GetNodeContentFromNapiValue(napi_env env, napi_value value, ArkUI_NodeContentHandle* content)
150 {
151     bool hasProperty = false;
152     auto result = napi_has_named_property(env, value, "nativePtr_", &hasProperty);
153     if (result != napi_ok || !hasProperty) {
154         LOGE("fail to get native content value");
155         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
156     }
157     napi_value nativeContent = nullptr;
158     result = napi_get_named_property(env, value, "nativePtr_", &nativeContent);
159     if (result != napi_ok) {
160         LOGE("fail to get native content");
161         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
162     }
163     void* nativePtr = nullptr;
164     result = napi_get_value_external(env, nativeContent, &nativePtr);
165     if (result != napi_ok) {
166         LOGE("fail to get native content ptr");
167         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
168     }
169     *content = reinterpret_cast<ArkUI_NodeContentHandle>(nativePtr);
170     return OHOS::Ace::ERROR_CODE_NO_ERROR;
171 }
172 
OH_ArkUI_GetDrawableDescriptorFromNapiValue(napi_env env,napi_value value,ArkUI_DrawableDescriptor ** drawableDescriptor)173 int32_t OH_ArkUI_GetDrawableDescriptorFromNapiValue(
174     napi_env env, napi_value value, ArkUI_DrawableDescriptor** drawableDescriptor)
175 {
176     void* objectNapi = nullptr;
177     napi_unwrap(env, value, &objectNapi);
178     if (!objectNapi) {
179         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
180     }
181     ArkUI_DrawableDescriptor* drawable =
182         new ArkUI_DrawableDescriptor { nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr };
183     auto* descriptor = reinterpret_cast<OHOS::Ace::Napi::DrawableDescriptor*>(objectNapi);
184     if (!descriptor) {
185         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
186     }
187     auto drawableType = descriptor->GetDrawableType();
188     if (drawableType == OHOS::Ace::Napi::DrawableDescriptor::DrawableType::ANIMATED) {
189         auto* animatedDrawable = static_cast<OHOS::Ace::Napi::AnimatedDrawableDescriptor*>(descriptor);
190         if (!animatedDrawable) {
191             return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
192         }
193         int32_t duration = animatedDrawable->GetDuration();
194         int32_t iteration = animatedDrawable->GetIterations();
195         drawable->animatedDrawableDescriptor = std::make_shared<OHOS::Ace::Napi::AnimatedDrawableDescriptor>(
196             animatedDrawable->GetPixelMapList(), duration, iteration);
197         *drawableDescriptor = drawable;
198         return OHOS::Ace::ERROR_CODE_NO_ERROR;
199     }
200     drawable->drawableDescriptor = std::make_shared<OHOS::Ace::Napi::DrawableDescriptor>(descriptor->GetPixelMap());
201     *drawableDescriptor = drawable;
202     return OHOS::Ace::ERROR_CODE_NO_ERROR;
203 }
204 
OH_ArkUI_GetDrawableDescriptorFromResourceNapiValue(napi_env env,napi_value value,ArkUI_DrawableDescriptor ** drawableDescriptor)205 int32_t OH_ArkUI_GetDrawableDescriptorFromResourceNapiValue(
206     napi_env env, napi_value value, ArkUI_DrawableDescriptor** drawableDescriptor)
207 {
208     auto parseApi = reinterpret_cast<void (*)(void*, void*)>(OHOS::Ace::NodeModel::GetParseJsMedia());
209     if (!parseApi) {
210         return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
211     }
212 
213     ArkUI_DrawableDescriptor* drawable =
214         new ArkUI_DrawableDescriptor { nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr };
215     drawable->resource = std::make_shared<ArkUI_Resource>();
216     parseApi(value, drawable->resource.get());
217     *drawableDescriptor = drawable;
218     return OHOS::Ace::ERROR_CODE_NO_ERROR;
219 }
220 
OH_ArkUI_GetNavigationId(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)221 ArkUI_ErrorCode  OH_ArkUI_GetNavigationId(
222     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
223 {
224     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
225     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
226     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
227     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
228     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
229     auto navigationAPI = fullImpl->getNavigation();
230     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
231     auto ret =
232         navigationAPI->getNavigationId(node->uiNodeHandle, buffer, bufferSize, writeLength);
233     return static_cast<ArkUI_ErrorCode>(ret);
234 }
235 
OH_ArkUI_GetNavDestinationName(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)236 ArkUI_ErrorCode OH_ArkUI_GetNavDestinationName(
237     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
238 {
239     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
240     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
241     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
242     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
243     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
244     auto navigationAPI = fullImpl->getNavigation();
245     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
246     auto ret =
247         navigationAPI->getNavDestinationName(node->uiNodeHandle, buffer, bufferSize, writeLength);
248     return static_cast<ArkUI_ErrorCode>(ret);
249 }
250 
OH_ArkUI_GetNavStackLength(ArkUI_NodeHandle node,int32_t * length)251 ArkUI_ErrorCode OH_ArkUI_GetNavStackLength(ArkUI_NodeHandle node, int32_t* length)
252 {
253     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
254     CHECK_NULL_RETURN(length, ARKUI_ERROR_CODE_PARAM_INVALID);
255     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
256     auto stacklength = fullImpl->getNavigation()->getStackLength(node->uiNodeHandle);
257     if (stacklength < 0) {
258         return ARKUI_ERROR_CODE_GET_INFO_FAILED;
259     }
260     *length = stacklength;
261     return ARKUI_ERROR_CODE_NO_ERROR;
262 }
263 
OH_ArkUI_GetNavDestinationNameByIndex(ArkUI_NodeHandle node,int32_t index,char * buffer,int32_t bufferSize,int32_t * writeLength)264 ArkUI_ErrorCode OH_ArkUI_GetNavDestinationNameByIndex(
265     ArkUI_NodeHandle node, int32_t index, char* buffer, int32_t bufferSize, int32_t* writeLength)
266 {
267     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
268     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
269     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
270     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
271     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
272     auto navigationAPI = fullImpl->getNavigation();
273     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
274     auto ret =
275         navigationAPI->getNavDesNameByIndex(node->uiNodeHandle, index, buffer, bufferSize, writeLength);
276     return static_cast<ArkUI_ErrorCode>(ret);
277 }
278 
OH_ArkUI_GetNavDestinationId(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)279 ArkUI_ErrorCode OH_ArkUI_GetNavDestinationId(
280     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
281 {
282     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
283     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
284     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
285     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
286     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
287     auto navigationAPI = fullImpl->getNavigation();
288     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
289     auto ret =
290         navigationAPI->getNavDestinationId(node->uiNodeHandle, buffer, bufferSize, writeLength);
291     return static_cast<ArkUI_ErrorCode>(ret);
292 }
293 
OH_ArkUI_GetNavDestinationState(ArkUI_NodeHandle node,ArkUI_NavDestinationState * state)294 ArkUI_ErrorCode OH_ArkUI_GetNavDestinationState(ArkUI_NodeHandle node, ArkUI_NavDestinationState* state)
295 {
296     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
297     CHECK_NULL_RETURN(state, ARKUI_ERROR_CODE_PARAM_INVALID);
298     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
299     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
300     auto navigationAPI = fullImpl->getNavigation();
301     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
302 
303     auto navDestinationState = navigationAPI->getNavDestinationState(node->uiNodeHandle);
304     if (navDestinationState < 0) {
305         return ARKUI_ERROR_CODE_GET_INFO_FAILED;
306     }
307     *state = static_cast<ArkUI_NavDestinationState>(navDestinationState);
308     return ARKUI_ERROR_CODE_NO_ERROR;
309 }
310 
OH_ArkUI_GetNavDestinationIndex(ArkUI_NodeHandle node,int32_t * index)311 ArkUI_ErrorCode OH_ArkUI_GetNavDestinationIndex(ArkUI_NodeHandle node, int32_t* index)
312 {
313     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
314     CHECK_NULL_RETURN(index, ARKUI_ERROR_CODE_PARAM_INVALID);
315     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
316     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
317     auto navigationAPI = fullImpl->getNavigation();
318     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
319 
320     auto retIndex = navigationAPI->getNavDestinationIndex(node->uiNodeHandle);
321     if (retIndex < 0) {
322         return ARKUI_ERROR_CODE_GET_INFO_FAILED;
323     }
324     *index = retIndex;
325     return ARKUI_ERROR_CODE_NO_ERROR;
326 }
327 
OH_ArkUI_GetNavDestinationParam(ArkUI_NodeHandle node)328 napi_value OH_ArkUI_GetNavDestinationParam(ArkUI_NodeHandle node)
329 {
330     CHECK_NULL_RETURN(node, nullptr);
331     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
332     CHECK_NULL_RETURN(fullImpl, nullptr);
333     auto navigationAPI = fullImpl->getNavigation();
334     CHECK_NULL_RETURN(navigationAPI, nullptr);
335     return reinterpret_cast<napi_value>(navigationAPI->getNavDestinationParam(node->uiNodeHandle));
336 }
337 
OH_ArkUI_GetRouterPageIndex(ArkUI_NodeHandle node,int32_t * index)338 ArkUI_ErrorCode OH_ArkUI_GetRouterPageIndex(ArkUI_NodeHandle node, int32_t* index)
339 {
340     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
341     CHECK_NULL_RETURN(index, ARKUI_ERROR_CODE_PARAM_INVALID);
342     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
343     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
344     auto navigationAPI = fullImpl->getNavigation();
345     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
346 
347     auto retIndex = navigationAPI->getRouterPageIndex(node->uiNodeHandle);
348     if (retIndex < 0) {
349         return ARKUI_ERROR_CODE_GET_INFO_FAILED;
350     }
351     *index = retIndex;
352     return ARKUI_ERROR_CODE_NO_ERROR;
353 }
354 
OH_ArkUI_GetRouterPageName(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)355 ArkUI_ErrorCode OH_ArkUI_GetRouterPageName(
356     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
357 {
358     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
359     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
360     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
361     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
362     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
363     auto navigationAPI = fullImpl->getNavigation();
364     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
365     auto ret =
366         navigationAPI->getRouterPageName(node->uiNodeHandle, buffer, bufferSize, writeLength);
367     return static_cast<ArkUI_ErrorCode>(ret);
368 }
369 
OH_ArkUI_GetRouterPagePath(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)370 ArkUI_ErrorCode OH_ArkUI_GetRouterPagePath(
371     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
372 {
373     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
374     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
375     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
376     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
377     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
378     auto navigationAPI = fullImpl->getNavigation();
379     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
380     auto ret =
381         navigationAPI->getRouterPagePath(node->uiNodeHandle, buffer, bufferSize, writeLength);
382     return static_cast<ArkUI_ErrorCode>(ret);
383 }
384 
OH_ArkUI_GetRouterPageState(ArkUI_NodeHandle node,ArkUI_RouterPageState * state)385 ArkUI_ErrorCode OH_ArkUI_GetRouterPageState(ArkUI_NodeHandle node, ArkUI_RouterPageState* state)
386 {
387     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
388     CHECK_NULL_RETURN(state, ARKUI_ERROR_CODE_PARAM_INVALID);
389     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
390     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
391     auto navigationAPI = fullImpl->getNavigation();
392     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
393 
394     auto routerPageState = navigationAPI->getRouterPageState(node->uiNodeHandle);
395     if (routerPageState < 0) {
396         return ARKUI_ERROR_CODE_GET_INFO_FAILED;
397     }
398     *state = static_cast<ArkUI_RouterPageState>(routerPageState);
399     return ARKUI_ERROR_CODE_NO_ERROR;
400 }
401 
OH_ArkUI_GetRouterPageId(ArkUI_NodeHandle node,char * buffer,int32_t bufferSize,int32_t * writeLength)402 ArkUI_ErrorCode OH_ArkUI_GetRouterPageId(
403     ArkUI_NodeHandle node, char* buffer, int32_t bufferSize, int32_t* writeLength)
404 {
405     CHECK_NULL_RETURN(node, ARKUI_ERROR_CODE_PARAM_INVALID);
406     CHECK_NULL_RETURN(buffer, ARKUI_ERROR_CODE_PARAM_INVALID);
407     CHECK_NULL_RETURN(writeLength, ARKUI_ERROR_CODE_PARAM_INVALID);
408     auto* fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
409     CHECK_NULL_RETURN(fullImpl, ARKUI_ERROR_CODE_GET_INFO_FAILED);
410     auto navigationAPI = fullImpl->getNavigation();
411     CHECK_NULL_RETURN(navigationAPI, ARKUI_ERROR_CODE_GET_INFO_FAILED);
412     auto ret =
413         navigationAPI->getRouterPageId(node->uiNodeHandle, buffer, bufferSize, writeLength);
414     return static_cast<ArkUI_ErrorCode>(ret);
415 }
416 }
417