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 #include "core/interfaces/native/node/node_xcomponent_modifier.h"
16
17 #include "core/components_ng/pattern/xcomponent/xcomponent_model_ng.h"
18 #include "core/components_ng/pattern/xcomponent/xcomponent_pattern.h"
19 #include "core/components_ng/pattern/xcomponent/xcomponent_pattern_v2.h"
20 #include "core/components_ng/base/view_abstract.h"
21
22 namespace OHOS::Ace::NG {
23 namespace {
24 const uint32_t ERROR_UINT_CODE = -1;
25 thread_local std::string g_strValue;
26
SetXComponentEnableAnalyzer(ArkUINodeHandle node,ArkUI_Bool enable)27 void SetXComponentEnableAnalyzer(ArkUINodeHandle node, ArkUI_Bool enable)
28 {
29 auto* frameNode = reinterpret_cast<FrameNode*>(node);
30 CHECK_NULL_VOID(frameNode);
31 XComponentModelNG::EnableAnalyzer(frameNode, enable);
32 }
33
ResetXComponentEnableAnalyzer(ArkUINodeHandle node)34 void ResetXComponentEnableAnalyzer(ArkUINodeHandle node)
35 {
36 auto* frameNode = reinterpret_cast<FrameNode*>(node);
37 CHECK_NULL_VOID(frameNode);
38 XComponentModelNG::EnableAnalyzer(frameNode, false);
39 }
40
SetXComponentBackgroundColor(ArkUINodeHandle node,uint32_t color)41 void SetXComponentBackgroundColor(ArkUINodeHandle node, uint32_t color)
42 {
43 auto* frameNode = reinterpret_cast<FrameNode*>(node);
44 CHECK_NULL_VOID(frameNode);
45 auto type = XComponentModelNG::GetType(frameNode);
46 if (!XComponentModel::IsBackGroundColorAvailable(type)) {
47 return;
48 }
49 ViewAbstract::SetBackgroundColor(frameNode, Color(color));
50 }
51
SetXComponentBackgroundColorWithColorSpace(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_Int32 colorSpace)52 void SetXComponentBackgroundColorWithColorSpace(
53 ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_Int32 colorSpace)
54 {
55 auto* frameNode = reinterpret_cast<FrameNode*>(node);
56 CHECK_NULL_VOID(frameNode);
57 auto type = XComponentModelNG::GetType(frameNode);
58 if (!XComponentModel::IsBackGroundColorAvailable(type)) {
59 return;
60 }
61 Color backgroundColor { color };
62 if (ColorSpace::DISPLAY_P3 == colorSpace) {
63 backgroundColor.SetColorSpace(ColorSpace::DISPLAY_P3);
64 } else {
65 backgroundColor.SetColorSpace(ColorSpace::SRGB);
66 }
67 ViewAbstract::SetBackgroundColor(frameNode, backgroundColor);
68 }
69
ResetXComponentBackgroundColor(ArkUINodeHandle node)70 void ResetXComponentBackgroundColor(ArkUINodeHandle node)
71 {
72 auto* frameNode = reinterpret_cast<FrameNode*>(node);
73 CHECK_NULL_VOID(frameNode);
74 auto type = XComponentModelNG::GetType(frameNode);
75 if (!XComponentModel::IsBackGroundColorAvailable(type)) {
76 return;
77 }
78 ViewAbstract::SetBackgroundColor(frameNode, (type == XComponentType::SURFACE) ? Color::BLACK : Color::TRANSPARENT);
79 }
80
SetXComponentOpacity(ArkUINodeHandle node,ArkUI_Float32 opacity)81 void SetXComponentOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity)
82 {
83 auto *frameNode = reinterpret_cast<FrameNode *>(node);
84 CHECK_NULL_VOID(frameNode);
85 auto type = XComponentModelNG::GetXComponentType(frameNode);
86 if (type == XComponentType::SURFACE || type == XComponentType::COMPONENT) {
87 return;
88 }
89 if ((LessNotEqual(opacity, 0.0)) || opacity > 1) {
90 opacity = 1.0f;
91 }
92 ViewAbstract::SetOpacity(frameNode, opacity);
93 }
94
ResetXComponentOpacity(ArkUINodeHandle node)95 void ResetXComponentOpacity(ArkUINodeHandle node)
96 {
97 auto* frameNode = reinterpret_cast<FrameNode*>(node);
98 CHECK_NULL_VOID(frameNode);
99 auto type = XComponentModelNG::GetXComponentType(frameNode);
100 if (type == XComponentType::SURFACE || type == XComponentType::COMPONENT) {
101 return;
102 }
103 ViewAbstract::SetOpacity(frameNode, 1.0f);
104 }
105
SetXComponentId(ArkUINodeHandle node,const char * id)106 void SetXComponentId(ArkUINodeHandle node, const char* id)
107 {
108 auto* frameNode = reinterpret_cast<FrameNode*>(node);
109 CHECK_NULL_VOID(frameNode);
110 XComponentModelNG::SetXComponentId(frameNode, id);
111 }
112
SetXComponentType(ArkUINodeHandle node,uint32_t type)113 void SetXComponentType(ArkUINodeHandle node, uint32_t type)
114 {
115 auto* frameNode = reinterpret_cast<FrameNode*>(node);
116 CHECK_NULL_VOID(frameNode);
117 XComponentModelNG::SetXComponentType(frameNode, static_cast<XComponentType>(type));
118 }
119
SetXComponentSurfaceSize(ArkUINodeHandle node,uint32_t width,uint32_t height)120 void SetXComponentSurfaceSize(ArkUINodeHandle node, uint32_t width, uint32_t height)
121 {
122 auto* frameNode = reinterpret_cast<FrameNode*>(node);
123 CHECK_NULL_VOID(frameNode);
124 XComponentModelNG::SetXComponentSurfaceSize(frameNode, width, height);
125 }
126
GetXComponentId(ArkUINodeHandle node)127 ArkUI_CharPtr GetXComponentId(ArkUINodeHandle node)
128 {
129 auto *frameNode = reinterpret_cast<FrameNode *>(node);
130 CHECK_NULL_RETURN(frameNode, "");
131 g_strValue = XComponentModelNG::GetXComponentId(frameNode);
132 return g_strValue.c_str();
133 }
134
GetXComponentType(ArkUINodeHandle node)135 ArkUI_Int32 GetXComponentType(ArkUINodeHandle node)
136 {
137 auto *frameNode = reinterpret_cast<FrameNode *>(node);
138 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
139 return static_cast<ArkUI_Int32>(XComponentModelNG::GetXComponentType(frameNode));
140 }
141
GetXComponentSurfaceWidth(ArkUINodeHandle node)142 ArkUI_Uint32 GetXComponentSurfaceWidth(ArkUINodeHandle node)
143 {
144 auto *frameNode = reinterpret_cast<FrameNode *>(node);
145 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
146 return XComponentModelNG::GetXComponentSurfaceWidth(frameNode);
147 }
148
GetXComponentSurfaceHeight(ArkUINodeHandle node)149 ArkUI_Uint32 GetXComponentSurfaceHeight(ArkUINodeHandle node)
150 {
151 auto *frameNode = reinterpret_cast<FrameNode *>(node);
152 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
153 return XComponentModelNG::GetXComponentSurfaceHeight(frameNode);
154 }
155
GetNativeXComponent(ArkUINodeHandle node)156 void* GetNativeXComponent(ArkUINodeHandle node)
157 {
158 auto *frameNode = reinterpret_cast<FrameNode *>(node);
159 CHECK_NULL_RETURN(frameNode, nullptr);
160 auto xcPattern = frameNode->GetPattern<XComponentPattern>();
161 CHECK_NULL_RETURN(xcPattern, nullptr);
162 if (xcPattern->HasGotSurfaceHolder() || xcPattern->IsNativeXComponentDisabled()) {
163 return nullptr;
164 }
165 auto pair = xcPattern->GetNativeXComponent();
166 xcPattern->SetHasGotNativeXComponent(true);
167 return reinterpret_cast<void*>(pair.second.lock().get());
168 }
169
SetXComponentLibraryname(ArkUINodeHandle node,const char * libraryname)170 void SetXComponentLibraryname(ArkUINodeHandle node, const char* libraryname)
171 {
172 auto* frameNode = reinterpret_cast<FrameNode*>(node);
173 CHECK_NULL_VOID(frameNode);
174 XComponentModelNG::SetXComponentLibraryname(frameNode, libraryname);
175 }
176
SetImageAIOptions(ArkUINodeHandle node,void * options)177 void SetImageAIOptions(ArkUINodeHandle node, void* options)
178 {
179 auto* frameNode = reinterpret_cast<FrameNode*>(node);
180 CHECK_NULL_VOID(frameNode);
181 XComponentModelNG::SetImageAIOptions(frameNode, options);
182 }
183
InitXComponent(ArkUINodeHandle node)184 void InitXComponent(ArkUINodeHandle node)
185 {
186 auto* frameNode = reinterpret_cast<FrameNode*>(node);
187 CHECK_NULL_VOID(frameNode);
188 XComponentModelNG::InitXComponent(frameNode);
189 }
190
SetXComponentEnableSecure(ArkUINodeHandle node,ArkUI_Bool enable)191 void SetXComponentEnableSecure(ArkUINodeHandle node, ArkUI_Bool enable)
192 {
193 auto* frameNode = reinterpret_cast<FrameNode*>(node);
194 CHECK_NULL_VOID(frameNode);
195 XComponentModelNG::EnableSecure(frameNode, enable);
196 }
197
ResetXComponentEnableSecure(ArkUINodeHandle node)198 void ResetXComponentEnableSecure(ArkUINodeHandle node)
199 {
200 auto* frameNode = reinterpret_cast<FrameNode*>(node);
201 CHECK_NULL_VOID(frameNode);
202 XComponentModelNG::EnableSecure(frameNode, false);
203 }
204
SetXComponentHdrBrightness(ArkUINodeHandle node,ArkUI_Float32 hdrBrightness)205 void SetXComponentHdrBrightness(ArkUINodeHandle node, ArkUI_Float32 hdrBrightness)
206 {
207 auto* frameNode = reinterpret_cast<FrameNode*>(node);
208 CHECK_NULL_VOID(frameNode);
209 XComponentModelNG::HdrBrightness(frameNode, hdrBrightness);
210 }
211
ResetXComponentHdrBrightness(ArkUINodeHandle node)212 void ResetXComponentHdrBrightness(ArkUINodeHandle node)
213 {
214 auto* frameNode = reinterpret_cast<FrameNode*>(node);
215 CHECK_NULL_VOID(frameNode);
216 XComponentModelNG::HdrBrightness(frameNode, 1.0f);
217 }
218
SetXComponentEnableTransparentLayer(ArkUINodeHandle node,ArkUI_Bool enable)219 void SetXComponentEnableTransparentLayer(ArkUINodeHandle node, ArkUI_Bool enable)
220 {
221 auto* frameNode = reinterpret_cast<FrameNode*>(node);
222 CHECK_NULL_VOID(frameNode);
223 XComponentModelNG::EnableTransparentLayer(frameNode, enable);
224 }
225
ResetXComponentEnableTransparentLayer(ArkUINodeHandle node)226 void ResetXComponentEnableTransparentLayer(ArkUINodeHandle node)
227 {
228 auto* frameNode = reinterpret_cast<FrameNode*>(node);
229 CHECK_NULL_VOID(frameNode);
230 XComponentModelNG::EnableTransparentLayer(frameNode, false);
231 }
232
SetXComponentRenderFit(ArkUINodeHandle node,ArkUI_Int32 renderFitNumber)233 void SetXComponentRenderFit(ArkUINodeHandle node, ArkUI_Int32 renderFitNumber)
234 {
235 auto* frameNode = reinterpret_cast<FrameNode*>(node);
236 CHECK_NULL_VOID(frameNode);
237 auto renderFit = RenderFit::RESIZE_FILL;
238 if (renderFitNumber >= static_cast<int32_t>(RenderFit::CENTER) &&
239 renderFitNumber <= static_cast<int32_t>(RenderFit::RESIZE_COVER_BOTTOM_RIGHT)) {
240 renderFit = static_cast<RenderFit>(renderFitNumber);
241 }
242 auto type = XComponentModelNG::GetXComponentType(frameNode);
243 if (type == XComponentType::COMPONENT || type == XComponentType::NODE) {
244 return;
245 }
246 if (type == XComponentType::TEXTURE) {
247 ViewAbstract::SetRenderFit(frameNode, renderFit);
248 return;
249 }
250 XComponentModelNG::SetRenderFit(frameNode, renderFit);
251 }
252
ResetXComponentRenderFit(ArkUINodeHandle node)253 void ResetXComponentRenderFit(ArkUINodeHandle node)
254 {
255 auto* frameNode = reinterpret_cast<FrameNode*>(node);
256 CHECK_NULL_VOID(frameNode);
257 auto type = XComponentModelNG::GetXComponentType(frameNode);
258 if (type == XComponentType::COMPONENT || type == XComponentType::NODE) {
259 return;
260 }
261 if (type == XComponentType::TEXTURE) {
262 ViewAbstract::SetRenderFit(frameNode, RenderFit::RESIZE_FILL);
263 return;
264 }
265 XComponentModelNG::SetRenderFit(frameNode, RenderFit::RESIZE_FILL);
266 }
267
GetXComponentRenderFit(ArkUINodeHandle node)268 ArkUI_Int32 GetXComponentRenderFit(ArkUINodeHandle node)
269 {
270 auto* frameNode = reinterpret_cast<FrameNode*>(node);
271 CHECK_NULL_RETURN(frameNode, static_cast<ArkUI_Int32>(RenderFit::RESIZE_FILL));
272 auto type = XComponentModelNG::GetXComponentType(frameNode);
273 if (type == XComponentType::TEXTURE) {
274 return static_cast<ArkUI_Int32>(ViewAbstract::GetRenderFit(frameNode));
275 }
276 return static_cast<ArkUI_Int32>(XComponentModelNG::GetSurfaceRenderFit(frameNode));
277 }
278
SetXComponentSurfaceRect(ArkUINodeHandle node,ArkUI_Int32 offsetX,ArkUI_Int32 offsetY,ArkUI_Int32 surfaceWidth,ArkUI_Int32 surfaceHeight)279 void SetXComponentSurfaceRect(ArkUINodeHandle node, ArkUI_Int32 offsetX,
280 ArkUI_Int32 offsetY, ArkUI_Int32 surfaceWidth, ArkUI_Int32 surfaceHeight)
281 {
282 auto* frameNode = reinterpret_cast<FrameNode*>(node);
283 CHECK_NULL_VOID(frameNode);
284 if (surfaceWidth <= 0 || surfaceHeight <= 0) {
285 return;
286 }
287 XComponentModelNG::SetXComponentSurfaceRect(frameNode, static_cast<float>(offsetX), static_cast<float>(offsetY),
288 static_cast<float>(surfaceWidth), static_cast<float>(surfaceHeight));
289 }
290
GetXComponentSurfaceRect(ArkUINodeHandle node,ArkUI_Int32 & offsetX,ArkUI_Int32 & offsetY,ArkUI_Int32 & surfaceWidth,ArkUI_Int32 & surfaceHeight)291 void GetXComponentSurfaceRect(ArkUINodeHandle node, ArkUI_Int32& offsetX, ArkUI_Int32& offsetY,
292 ArkUI_Int32& surfaceWidth, ArkUI_Int32& surfaceHeight)
293 {
294 float surfaceRectOffsetX = 0.0f;
295 float surfaceRectOffsetY = 0.0f;
296 float surfaceRectWidth = 0.0f;
297 float surfaceRectHeight = 0.0f;
298 auto* frameNode = reinterpret_cast<FrameNode*>(node);
299 CHECK_NULL_VOID(frameNode);
300 XComponentModelNG::GetXComponentSurfaceRect(frameNode, surfaceRectOffsetX, surfaceRectOffsetY,
301 surfaceRectWidth, surfaceRectHeight);
302 offsetX = static_cast<ArkUI_Int32>(surfaceRectOffsetX);
303 offsetY = static_cast<ArkUI_Int32>(surfaceRectOffsetY);
304 surfaceWidth = static_cast<ArkUI_Int32>(surfaceRectWidth);
305 surfaceHeight = static_cast<ArkUI_Int32>(surfaceRectHeight);
306 }
307
ResetXComponentSurfaceRect(ArkUINodeHandle node)308 void ResetXComponentSurfaceRect(ArkUINodeHandle node)
309 {
310 auto* frameNode = reinterpret_cast<FrameNode*>(node);
311 CHECK_NULL_VOID(frameNode);
312 float width = ViewAbstract::GetWidth(frameNode).GetNativeValue(static_cast<DimensionUnit>(0));
313 float height = ViewAbstract::GetHeight(frameNode).GetNativeValue(static_cast<DimensionUnit>(0));
314 XComponentModelNG::SetXComponentSurfaceRect(frameNode, 0.0f, 0.0f, width, height);
315 }
316
GetXComponentEnableAnalyzer(ArkUINodeHandle node)317 ArkUI_Bool GetXComponentEnableAnalyzer(ArkUINodeHandle node)
318 {
319 auto* frameNode = reinterpret_cast<FrameNode*>(node);
320 CHECK_NULL_RETURN(frameNode, false);
321 auto type = XComponentModelNG::GetXComponentType(frameNode);
322 if (type != XComponentType::SURFACE && type != XComponentType::TEXTURE) {
323 return false;
324 }
325 ArkUI_Bool isEnable = XComponentModelNG::GetXComponentEnableAnalyzer(frameNode);
326 return isEnable;
327 }
328
StartImageAnalyzer(ArkUINodeHandle node,void * arkuiNode,void * userData,XComponentAnalyzerCallback callback)329 void StartImageAnalyzer(ArkUINodeHandle node, void* arkuiNode, void* userData,
330 XComponentAnalyzerCallback callback)
331 {
332 auto *frameNode = reinterpret_cast<FrameNode *>(node);
333 CHECK_NULL_VOID(frameNode);
334 auto xcPattern = frameNode->GetPattern<XComponentPattern>();
335 CHECK_NULL_VOID(xcPattern);
336 std::function<void(int32_t)> nativeAnalyzerCallback = [arkuiNode, userData, callback](int32_t statusCode) {
337 if (callback) {
338 callback(arkuiNode, statusCode, userData);
339 }
340 };
341 xcPattern->NativeStartImageAnalyzer(nativeAnalyzerCallback);
342 }
343
StopImageAnalyzer(ArkUINodeHandle node)344 void StopImageAnalyzer(ArkUINodeHandle node)
345 {
346 auto *frameNode = reinterpret_cast<FrameNode *>(node);
347 CHECK_NULL_VOID(frameNode);
348 auto xcPattern = frameNode->GetPattern<XComponentPattern>();
349 CHECK_NULL_VOID(xcPattern);
350 xcPattern->StopImageAnalyzer();
351 }
352
CreateSurfaceHolder(ArkUINodeHandle node)353 void* CreateSurfaceHolder(ArkUINodeHandle node)
354 {
355 auto* frameNode = reinterpret_cast<FrameNode*>(node);
356 CHECK_NULL_RETURN(frameNode, nullptr);
357 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
358 CHECK_NULL_RETURN(xcPattern, nullptr);
359 if (xcPattern->IsCreateSurfaceHolderForbidden()) {
360 return nullptr;
361 }
362 OH_ArkUI_SurfaceHolder* surfaceHolder = xcPattern->GetSurfaceHolder();
363 if (surfaceHolder == nullptr) {
364 surfaceHolder = new OH_ArkUI_SurfaceHolder();
365 xcPattern->SetSurfaceHolder(surfaceHolder);
366 }
367 return reinterpret_cast<void*>(surfaceHolder);
368 }
369
Dispose(ArkUINodeHandle node)370 void Dispose(ArkUINodeHandle node)
371 {
372 auto* frameNode = reinterpret_cast<FrameNode*>(node);
373 CHECK_NULL_VOID(frameNode);
374 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
375 CHECK_NULL_VOID(xcPattern);
376 xcPattern->SetSurfaceHolder(nullptr);
377 }
378
SetAutoInitialize(ArkUINodeHandle node,ArkUI_Bool autoInitialize)379 ArkUI_Int32 SetAutoInitialize(ArkUINodeHandle node, ArkUI_Bool autoInitialize)
380 {
381 auto* frameNode = reinterpret_cast<FrameNode*>(node);
382 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
383 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
384 CHECK_NULL_RETURN(xcPattern, ERROR_CODE_PARAM_INVALID);
385 auto nodeType = xcPattern->GetXComponentNodeType();
386 if (nodeType != XComponentNodeType::TYPE_NODE && nodeType != XComponentNodeType::CNODE) {
387 return ERROR_CODE_PARAM_INVALID;
388 }
389 return xcPattern->SetAutoInitialize(autoInitialize);
390 }
391
Initialize(ArkUINodeHandle node)392 ArkUI_Int32 Initialize(ArkUINodeHandle node)
393 {
394 auto* frameNode = reinterpret_cast<FrameNode*>(node);
395 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
396 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
397 CHECK_NULL_RETURN(xcPattern, ERROR_CODE_PARAM_INVALID);
398 auto nodeType = xcPattern->GetXComponentNodeType();
399 if (nodeType != XComponentNodeType::TYPE_NODE && nodeType != XComponentNodeType::CNODE) {
400 return ERROR_CODE_PARAM_INVALID;
401 }
402 return xcPattern->Initialize();
403 }
404
IsInitialized(ArkUINodeHandle node,ArkUI_Bool * isInitialized)405 ArkUI_Int32 IsInitialized(ArkUINodeHandle node, ArkUI_Bool* isInitialized)
406 {
407 auto* frameNode = reinterpret_cast<FrameNode*>(node);
408 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
409 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
410 CHECK_NULL_RETURN(xcPattern, ERROR_CODE_PARAM_INVALID);
411 auto nodeType = xcPattern->GetXComponentNodeType();
412 if (nodeType != XComponentNodeType::TYPE_NODE && nodeType != XComponentNodeType::CNODE) {
413 return ERROR_CODE_PARAM_INVALID;
414 }
415 bool value;
416 auto res = xcPattern->IsInitialized(value);
417 *isInitialized = value;
418 return res;
419 }
420
Finalize(ArkUINodeHandle node)421 ArkUI_Int32 Finalize(ArkUINodeHandle node)
422 {
423 auto* frameNode = reinterpret_cast<FrameNode*>(node);
424 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
425 auto xcPattern = frameNode->GetPattern<XComponentPatternV2>();
426 CHECK_NULL_RETURN(xcPattern, ERROR_CODE_PARAM_INVALID);
427 auto nodeType = xcPattern->GetXComponentNodeType();
428 if (nodeType != XComponentNodeType::TYPE_NODE && nodeType != XComponentNodeType::CNODE) {
429 return ERROR_CODE_PARAM_INVALID;
430 }
431 return xcPattern->Finalize();
432 }
433
GetXComponentIsBindNative(ArkUINodeHandle node)434 ArkUI_Bool GetXComponentIsBindNative(ArkUINodeHandle node)
435 {
436 auto* frameNode = reinterpret_cast<FrameNode*>(node);
437 CHECK_NULL_RETURN(frameNode, false);
438 auto xcPattern = frameNode->GetPattern<XComponentPattern>();
439 CHECK_NULL_RETURN(xcPattern, false);
440 return static_cast<ArkUI_Bool>(xcPattern->IsBindNative());
441 }
442
SetExpectedFrameRateRange(ArkUINodeHandle node,ArkUI_Int32 min,ArkUI_Int32 max,ArkUI_Int32 expected)443 ArkUI_Int32 SetExpectedFrameRateRange(
444 ArkUINodeHandle node, ArkUI_Int32 min, ArkUI_Int32 max, ArkUI_Int32 expected)
445 {
446 auto* frameNode = reinterpret_cast<FrameNode*>(node);
447 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
448 if (!(min <= max && expected >= min && expected <= max)) {
449 LOGE("Xcomponent Expeted FrameRateRange Error.");
450 return ERROR_CODE_PARAM_INVALID;
451 }
452 return XComponentModelNG::SetExpectedRateRange(frameNode, min, max, expected);
453 }
454
RegisterOnFrameCallback(ArkUINodeHandle node,void (* callback)(void *,uint64_t,uint64_t),void * arkuiNode)455 ArkUI_Int32 RegisterOnFrameCallback(ArkUINodeHandle node,
456 void(*callback)(void*, uint64_t, uint64_t), void* arkuiNode)
457 {
458 auto* frameNode = reinterpret_cast<FrameNode*>(node);
459 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
460 return XComponentModelNG::SetOnFrameCallback(frameNode, callback, arkuiNode);
461 }
462
UnregisterOnFrameCallback(ArkUINodeHandle node)463 ArkUI_Int32 UnregisterOnFrameCallback(ArkUINodeHandle node)
464 {
465 auto* frameNode = reinterpret_cast<FrameNode*>(node);
466 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
467 return XComponentModelNG::UnregisterOnFrameCallback(frameNode);
468 }
469
SetNeedSoftKeyboard(ArkUINodeHandle node,bool needSoftKeyboard)470 ArkUI_Int32 SetNeedSoftKeyboard(ArkUINodeHandle node, bool needSoftKeyboard)
471 {
472 auto* frameNode = reinterpret_cast<FrameNode*>(node);
473 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
474 return XComponentModelNG::SetNeedSoftKeyboard(frameNode, needSoftKeyboard);
475 }
476
CreateAccessibilityProvider(ArkUINodeHandle node)477 void* CreateAccessibilityProvider(ArkUINodeHandle node)
478 {
479 auto* frameNode = reinterpret_cast<FrameNode*>(node);
480 CHECK_NULL_RETURN(frameNode, nullptr);
481 return XComponentModelNG::CreateAccessibilityProvider(frameNode);
482 }
483
DisposeAccessibilityProvider(void * provider)484 void DisposeAccessibilityProvider(void* provider)
485 {
486 XComponentModelNG::DisposeAccessibilityProvider(
487 reinterpret_cast<ArkUI_AccessibilityProvider*>(provider));
488 }
489 } // namespace
490
491 namespace NodeModifier {
GetXComponentModifier()492 const ArkUIXComponentModifier* GetXComponentModifier()
493 {
494 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
495 static const ArkUIXComponentModifier modifier = {
496 .setXComponentEnableAnalyzer = SetXComponentEnableAnalyzer,
497 .resetXComponentEnableAnalyzer = ResetXComponentEnableAnalyzer,
498 .setXComponentBackgroundColor = SetXComponentBackgroundColor,
499 .setXComponentBackgroundColorWithColorSpace = SetXComponentBackgroundColorWithColorSpace,
500 .resetXComponentBackgroundColor = ResetXComponentBackgroundColor,
501 .setXComponentOpacity = SetXComponentOpacity,
502 .resetXComponentOpacity = ResetXComponentOpacity,
503 .setXComponentId = SetXComponentId,
504 .setXComponentType = SetXComponentType,
505 .setXComponentSurfaceSize = SetXComponentSurfaceSize,
506 .getXComponentId = GetXComponentId,
507 .getXComponentType = GetXComponentType,
508 .getXComponentSurfaceWidth = GetXComponentSurfaceWidth,
509 .getXComponentSurfaceHeight = GetXComponentSurfaceHeight,
510 .getNativeXComponent = GetNativeXComponent,
511 .setXComponentLibraryname = SetXComponentLibraryname,
512 .setImageAIOptions = SetImageAIOptions,
513 .initXComponent = InitXComponent,
514 .setXComponentEnableSecure = SetXComponentEnableSecure,
515 .resetXComponentEnableSecure = ResetXComponentEnableSecure,
516 .setXComponentHdrBrightness = SetXComponentHdrBrightness,
517 .resetXComponentHdrBrightness = ResetXComponentHdrBrightness,
518 .setXComponentEnableTransparentLayer = SetXComponentEnableTransparentLayer,
519 .resetXComponentEnableTransparentLayer = ResetXComponentEnableTransparentLayer,
520 .setXComponentRenderFit = SetXComponentRenderFit,
521 .resetXComponentRenderFit = ResetXComponentRenderFit,
522 .getXComponentRenderFit = GetXComponentRenderFit,
523 .setXComponentSurfaceRect = SetXComponentSurfaceRect,
524 .getXComponentSurfaceRect = GetXComponentSurfaceRect,
525 .resetXComponentSurfaceRect = ResetXComponentSurfaceRect,
526 .getXComponentEnableAnalyzer = GetXComponentEnableAnalyzer,
527 .startImageAnalyzer = StartImageAnalyzer,
528 .stopImageAnalyzer = StopImageAnalyzer,
529 .createSurfaceHolder = CreateSurfaceHolder,
530 .dispose = Dispose,
531 .setAutoInitialize = SetAutoInitialize,
532 .initialize = Initialize,
533 .isInitialized = IsInitialized,
534 .finalize = Finalize,
535 .getXComponentIsBindNative = GetXComponentIsBindNative,
536 .setExpectedFrameRateRange = SetExpectedFrameRateRange,
537 .registerOnFrameCallback = RegisterOnFrameCallback,
538 .unregisterOnFrameCallback = UnregisterOnFrameCallback,
539 .setNeedSoftKeyboard = SetNeedSoftKeyboard,
540 .createAccessibilityProvider = CreateAccessibilityProvider,
541 .disposeAccessibilityProvider = DisposeAccessibilityProvider,
542 };
543 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
544
545 return &modifier;
546 }
547
GetCJUIXComponentModifier()548 const CJUIXComponentModifier* GetCJUIXComponentModifier()
549 {
550 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
551 static const CJUIXComponentModifier modifier = {
552 .loadXComponent = nullptr, // loadXComponent
553 .setXComponentOptions = nullptr, // setXComponentOptions
554 .getXComponentSurfaceId = nullptr, // getXComponentSurfaceId
555 .getXComponentController = nullptr, // getXComponentController
556 .setXComponentBackgroundColor = SetXComponentBackgroundColor,
557 .setXComponentBackgroundColorWithColorSpace = SetXComponentBackgroundColorWithColorSpace,
558 .resetXComponentBackgroundColor = ResetXComponentBackgroundColor,
559 .setXComponentOpacity = SetXComponentOpacity,
560 .resetXComponentOpacity = ResetXComponentOpacity,
561 .setXComponentId = SetXComponentId,
562 .setXComponentType = SetXComponentType,
563 .setXComponentSurfaceSize = SetXComponentSurfaceSize,
564 .getXComponentId = GetXComponentId,
565 .getXComponentType = GetXComponentType,
566 .getXComponentSurfaceWidth = GetXComponentSurfaceWidth,
567 .getXComponentSurfaceHeight = GetXComponentSurfaceHeight,
568 .getNativeXComponent = GetNativeXComponent,
569 .setXComponentLibraryname = SetXComponentLibraryname,
570 .setImageAIOptions = SetImageAIOptions,
571 };
572 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
573
574 return &modifier;
575 }
576 } // namespace NodeModifier
577 } // namespace OHOS::Ace::NG
578