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/image_animator_modifier.h"
16
17 #include "core/components_ng/pattern/image_animator/image_animator_model_ng.h"
18
19 namespace OHOS::Ace::NG {
20 constexpr int32_t DEFAULT_DURATION = 1000; // ms
21 constexpr int32_t DEFAULT_ITERATION = 1;
22 constexpr FillMode DEFAULT_FILL_MODE = FillMode::FORWARDS;
23 constexpr uint32_t DEFAULT_ITERATIONS = 1;
24 constexpr int32_t IMAGES_LENGTH = 4;
25 constexpr int32_t DEFAULT_STATE = 0;
26
27 namespace ImageAnimatorModifier {
ParseImage(CalcDimension * dimension,int32_t dimensionLength,const ArkUIImagePropertiesStruct * image)28 void ParseImage(CalcDimension* dimension, int32_t dimensionLength, const ArkUIImagePropertiesStruct* image)
29 {
30 for (int32_t i = 0; i < dimensionLength; i++) {
31 if (image->unit[i] == static_cast<int8_t>(DimensionUnit::CALC)) {
32 dimension[i].SetUnit(DimensionUnit::CALC);
33 dimension[i].SetValue(0.0);
34 dimension[i].SetCalcValue(std::string(image->calc[i]));
35 } else {
36 dimension[i].SetUnit(static_cast<DimensionUnit>(image->unit[i]));
37 dimension[i].SetValue(image->number[i]);
38 }
39 }
40 }
41
SetState(ArkUINodeHandle node,int32_t state)42 void SetState(ArkUINodeHandle node, int32_t state)
43 {
44 auto* frameNode = reinterpret_cast<FrameNode*>(node);
45 CHECK_NULL_VOID(frameNode);
46
47 int32_t value = state;
48 if (value < static_cast<int32_t>(Animator::Status::IDLE) ||
49 value > static_cast<int32_t>(Animator::Status::STOPPED)) {
50 value = static_cast<int32_t>(Animator::Status::IDLE);
51 }
52
53 ImageAnimatorModelNG::SetState(frameNode, value);
54 }
55
ResetState(ArkUINodeHandle node)56 void ResetState(ArkUINodeHandle node)
57 {
58 auto* frameNode = reinterpret_cast<FrameNode*>(node);
59 CHECK_NULL_VOID(frameNode);
60 ImageAnimatorModelNG::SetState(frameNode, static_cast<int32_t>(Animator::Status::IDLE));
61 }
62
SetDuration(ArkUINodeHandle node,int32_t duration)63 void SetDuration(ArkUINodeHandle node, int32_t duration)
64 {
65 auto* frameNode = reinterpret_cast<FrameNode*>(node);
66 CHECK_NULL_VOID(frameNode);
67 if (duration < 0) {
68 duration = DEFAULT_DURATION;
69 }
70 ImageAnimatorModelNG::SetDuration(frameNode, duration);
71 }
72
SetFixedSize(ArkUINodeHandle node,uint32_t fixedSize)73 void SetFixedSize(ArkUINodeHandle node, uint32_t fixedSize)
74 {
75 auto* frameNode = reinterpret_cast<FrameNode*>(node);
76 CHECK_NULL_VOID(frameNode);
77
78 ImageAnimatorModelNG::SetFixedSize(frameNode, static_cast<bool>(fixedSize));
79 }
80
ResetFixedSize(ArkUINodeHandle node)81 void ResetFixedSize(ArkUINodeHandle node)
82 {
83 auto* frameNode = reinterpret_cast<FrameNode*>(node);
84 CHECK_NULL_VOID(frameNode);
85
86 ImageAnimatorModelNG::SetFixedSize(frameNode, true);
87 }
88
SetFillMode(ArkUINodeHandle node,int32_t fillMode)89 void SetFillMode(ArkUINodeHandle node, int32_t fillMode)
90 {
91 auto* frameNode = reinterpret_cast<FrameNode*>(node);
92 CHECK_NULL_VOID(frameNode);
93
94 int32_t value = fillMode;
95 if (value < static_cast<int32_t>(FillMode::NONE) || value > static_cast<int32_t>(FillMode::BOTH)) {
96 value = static_cast<int32_t>(DEFAULT_FILL_MODE);
97 }
98
99 ImageAnimatorModelNG::SetFillMode(frameNode, value);
100 }
101
ResetFillMode(ArkUINodeHandle node)102 void ResetFillMode(ArkUINodeHandle node)
103 {
104 auto* frameNode = reinterpret_cast<FrameNode*>(node);
105 CHECK_NULL_VOID(frameNode);
106 ImageAnimatorModelNG::SetFillMode(frameNode, static_cast<int32_t>(DEFAULT_FILL_MODE));
107 }
108
SetReverse(ArkUINodeHandle node,uint32_t value)109 void SetReverse(ArkUINodeHandle node, uint32_t value)
110 {
111 auto* frameNode = reinterpret_cast<FrameNode*>(node);
112 CHECK_NULL_VOID(frameNode);
113 ImageAnimatorModelNG::SetIsReverse(frameNode, static_cast<bool>(value));
114 }
115
ResetReverse(ArkUINodeHandle node)116 void ResetReverse(ArkUINodeHandle node)
117 {
118 auto* frameNode = reinterpret_cast<FrameNode*>(node);
119 CHECK_NULL_VOID(frameNode);
120 ImageAnimatorModelNG::SetIsReverse(frameNode, false);
121 }
122
SetImages(ArkUINodeHandle node,struct ArkUIImagePropertiesStruct * images,int32_t length)123 void SetImages(ArkUINodeHandle node, struct ArkUIImagePropertiesStruct* images, int32_t length)
124 {
125 auto* frameNode = reinterpret_cast<FrameNode*>(node);
126 CHECK_NULL_VOID(frameNode);
127 if (length == 0) {
128 ImageAnimatorModelNG::SetImages(frameNode, std::vector<ImageProperties>());
129 return;
130 }
131 CHECK_NULL_VOID(images);
132 if (length <= 0) {
133 return;
134 }
135 std::vector<ImageProperties> imageList;
136 for (int32_t i = 0; i < length; i++) {
137 ArkUIImagePropertiesStruct* image = images + i;
138 CHECK_NULL_VOID(image);
139 CalcDimension dimension[IMAGES_LENGTH];
140 ParseImage(dimension, IMAGES_LENGTH, image);
141 ImageProperties property { std::string(image->src), nullptr, "", "", dimension[0], dimension[1], dimension[2],
142 dimension[3], image->duration };
143 imageList.emplace_back(property);
144 }
145 ImageAnimatorModelNG::SetImages(frameNode, imageList);
146 }
147
ResetImages(ArkUINodeHandle node)148 void ResetImages(ArkUINodeHandle node)
149 {
150 auto* frameNode = reinterpret_cast<FrameNode*>(node);
151 CHECK_NULL_VOID(frameNode);
152 ImageAnimatorModelNG::SetImages(frameNode, std::vector<ImageProperties>());
153 }
154
SetImageAnimatorIteration(ArkUINodeHandle node,int32_t value)155 void SetImageAnimatorIteration(ArkUINodeHandle node, int32_t value)
156 {
157 auto* frameNode = reinterpret_cast<FrameNode*>(node);
158 CHECK_NULL_VOID(frameNode);
159
160 int32_t iteration = value;
161 if (iteration < -1) {
162 iteration = DEFAULT_ITERATIONS;
163 }
164
165 ImageAnimatorModelNG::SetIteration(frameNode, iteration);
166 }
167
ResetImageAnimatorIteration(ArkUINodeHandle node)168 void ResetImageAnimatorIteration(ArkUINodeHandle node)
169 {
170 auto* frameNode = reinterpret_cast<FrameNode*>(node);
171 CHECK_NULL_VOID(frameNode);
172 ImageAnimatorModelNG::SetIteration(frameNode, DEFAULT_ITERATION);
173 }
174
SetAutoMonitorInvisibleArea(ArkUINodeHandle node,ArkUI_Bool value)175 void SetAutoMonitorInvisibleArea(ArkUINodeHandle node, ArkUI_Bool value)
176 {
177 auto* frameNode = reinterpret_cast<FrameNode*>(node);
178 CHECK_NULL_VOID(frameNode);
179 ImageAnimatorModelNG::SetAutoMonitorInvisibleArea(frameNode, value);
180 }
181
SetImageAnimatorSrc(ArkUINodeHandle node,ArkUIImageFrameInfo * imageInfos,ArkUI_Int32 size)182 void SetImageAnimatorSrc(ArkUINodeHandle node, ArkUIImageFrameInfo* imageInfos, ArkUI_Int32 size)
183 {
184 auto* frameNode = reinterpret_cast<FrameNode*>(node);
185 CHECK_NULL_VOID(frameNode);
186 if (size <= 0) {
187 ImageAnimatorModelNG::SetImages(frameNode, std::vector<ImageProperties>());
188 return;
189 }
190 CHECK_NULL_VOID(imageInfos);
191 std::vector<ImageProperties> imageList;
192 for (int32_t i = 0; i < size; i++) {
193 ArkUIImageFrameInfo* image = imageInfos + i;
194 CHECK_NULL_VOID(image);
195 ImageProperties property;
196 auto pixelmap = PixelMap::GetFromDrawable(image->drawable);
197 if (pixelmap) {
198 property.pixelMap = pixelmap;
199 } else {
200 property.src = std::string(image->src);
201 }
202 property.width = CalcDimension(static_cast<double>(image->width), static_cast<DimensionUnit>(image->unit));
203 property.height = CalcDimension(static_cast<double>(image->height), static_cast<DimensionUnit>(image->unit));
204 property.top = CalcDimension(static_cast<double>(image->top), static_cast<DimensionUnit>(image->unit));
205 property.left = CalcDimension(static_cast<double>(image->left), static_cast<DimensionUnit>(image->unit));
206 property.duration = image->duration;
207 imageList.emplace_back(property);
208 }
209 ImageAnimatorModelNG::SetImages(frameNode, imageList);
210 }
211
ResetDuration(ArkUINodeHandle node)212 void ResetDuration(ArkUINodeHandle node)
213 {
214 auto* frameNode = reinterpret_cast<FrameNode*>(node);
215 CHECK_NULL_VOID(frameNode);
216 ImageAnimatorModelNG::SetDuration(frameNode, DEFAULT_DURATION);
217 }
218
GetIsReverse(ArkUINodeHandle node)219 ArkUI_Bool GetIsReverse(ArkUINodeHandle node)
220 {
221 auto* frameNode = reinterpret_cast<FrameNode*>(node);
222 CHECK_NULL_RETURN(frameNode, false);
223 return static_cast<ArkUI_Bool>(ImageAnimatorModelNG::IsReverse(frameNode));
224 }
225
GetDuration(ArkUINodeHandle node)226 int32_t GetDuration(ArkUINodeHandle node)
227 {
228 auto* frameNode = reinterpret_cast<FrameNode*>(node);
229 CHECK_NULL_RETURN(frameNode, DEFAULT_DURATION);
230 return ImageAnimatorModelNG::GetDuration(frameNode);
231 }
232
GetState(ArkUINodeHandle node)233 int32_t GetState(ArkUINodeHandle node)
234 {
235 auto* frameNode = reinterpret_cast<FrameNode*>(node);
236 CHECK_NULL_RETURN(frameNode, DEFAULT_STATE);
237 return ImageAnimatorModelNG::GetState(frameNode);
238 }
239
GetIsFixedSize(ArkUINodeHandle node)240 ArkUI_Bool GetIsFixedSize(ArkUINodeHandle node)
241 {
242 auto* frameNode = reinterpret_cast<FrameNode*>(node);
243 CHECK_NULL_RETURN(frameNode, true);
244 return static_cast<ArkUI_Bool>(ImageAnimatorModelNG::IsFixedSize(frameNode));
245 }
246
GetFillMode(ArkUINodeHandle node)247 int32_t GetFillMode(ArkUINodeHandle node)
248 {
249 auto* frameNode = reinterpret_cast<FrameNode*>(node);
250 CHECK_NULL_RETURN(frameNode, static_cast<int32_t>(DEFAULT_FILL_MODE));
251 return ImageAnimatorModelNG::GetFillMode(frameNode);
252 }
253
GetIteration(ArkUINodeHandle node)254 int32_t GetIteration(ArkUINodeHandle node)
255 {
256 auto* frameNode = reinterpret_cast<FrameNode*>(node);
257 CHECK_NULL_RETURN(frameNode, DEFAULT_ITERATION);
258 return ImageAnimatorModelNG::GetIteration(frameNode);
259 }
260
GetImagesSize(ArkUINodeHandle node)261 int32_t GetImagesSize(ArkUINodeHandle node)
262 {
263 auto* frameNode = reinterpret_cast<FrameNode*>(node);
264 CHECK_NULL_RETURN(frameNode, 0);
265 return ImageAnimatorModelNG::GetImagesSize(frameNode);
266 }
267
SetImageAnimatorOnStart(ArkUINodeHandle node,void * callback)268 void SetImageAnimatorOnStart(ArkUINodeHandle node, void* callback)
269 {
270 auto* frameNode = reinterpret_cast<FrameNode*>(node);
271 CHECK_NULL_VOID(frameNode);
272 if (callback) {
273 auto onStart = reinterpret_cast<std::function<void()>*>(callback);
274 ImageAnimatorModelNG::SetOnStart(frameNode, std::move(*onStart));
275 } else {
276 ImageAnimatorModelNG::SetOnStart(frameNode, nullptr);
277 }
278 }
279
ResetImageAnimatorOnStart(ArkUINodeHandle node)280 void ResetImageAnimatorOnStart(ArkUINodeHandle node)
281 {
282 auto* frameNode = reinterpret_cast<FrameNode*>(node);
283 CHECK_NULL_VOID(frameNode);
284 ImageAnimatorModelNG::SetOnStart(frameNode, nullptr);
285 }
SetImageAnimatorOnPause(ArkUINodeHandle node,void * callback)286 void SetImageAnimatorOnPause(ArkUINodeHandle node, void* callback)
287 {
288 auto* frameNode = reinterpret_cast<FrameNode*>(node);
289 CHECK_NULL_VOID(frameNode);
290 if (callback) {
291 auto onPause = reinterpret_cast<std::function<void()>*>(callback);
292 ImageAnimatorModelNG::SetOnPause(frameNode, std::move(*onPause));
293 } else {
294 ImageAnimatorModelNG::SetOnPause(frameNode, nullptr);
295 }
296 }
297
ResetImageAnimatorOnPause(ArkUINodeHandle node)298 void ResetImageAnimatorOnPause(ArkUINodeHandle node)
299 {
300 auto* frameNode = reinterpret_cast<FrameNode*>(node);
301 CHECK_NULL_VOID(frameNode);
302 ImageAnimatorModelNG::SetOnPause(frameNode, nullptr);
303 }
304
SetImageAnimatorOnRepeat(ArkUINodeHandle node,void * callback)305 void SetImageAnimatorOnRepeat(ArkUINodeHandle node, void* callback)
306 {
307 auto* frameNode = reinterpret_cast<FrameNode*>(node);
308 CHECK_NULL_VOID(frameNode);
309 if (callback) {
310 auto onRepeat = reinterpret_cast<std::function<void()>*>(callback);
311 ImageAnimatorModelNG::SetOnRepeat(frameNode, std::move(*onRepeat));
312 } else {
313 ImageAnimatorModelNG::SetOnRepeat(frameNode, nullptr);
314 }
315 }
316
ResetImageAnimatorOnRepeat(ArkUINodeHandle node)317 void ResetImageAnimatorOnRepeat(ArkUINodeHandle node)
318 {
319 auto* frameNode = reinterpret_cast<FrameNode*>(node);
320 CHECK_NULL_VOID(frameNode);
321 ImageAnimatorModelNG::SetOnRepeat(frameNode, nullptr);
322 }
323
SetImageAnimatorOnCancel(ArkUINodeHandle node,void * callback)324 void SetImageAnimatorOnCancel(ArkUINodeHandle node, void* callback)
325 {
326 auto* frameNode = reinterpret_cast<FrameNode*>(node);
327 CHECK_NULL_VOID(frameNode);
328 if (callback) {
329 auto onCancel = reinterpret_cast<std::function<void()>*>(callback);
330 ImageAnimatorModelNG::SetOnCancel(frameNode, std::move(*onCancel));
331 } else {
332 ImageAnimatorModelNG::SetOnCancel(frameNode, nullptr);
333 }
334 }
335
ResetImageAnimatorOnCancel(ArkUINodeHandle node)336 void ResetImageAnimatorOnCancel(ArkUINodeHandle node)
337 {
338 auto* frameNode = reinterpret_cast<FrameNode*>(node);
339 CHECK_NULL_VOID(frameNode);
340 ImageAnimatorModelNG::SetOnCancel(frameNode, nullptr);
341 }
342
SetImageAnimatorOnFinish(ArkUINodeHandle node,void * callback)343 void SetImageAnimatorOnFinish(ArkUINodeHandle node, void* callback)
344 {
345 auto* frameNode = reinterpret_cast<FrameNode*>(node);
346 CHECK_NULL_VOID(frameNode);
347 if (callback) {
348 auto onFinish = reinterpret_cast<std::function<void()>*>(callback);
349 ImageAnimatorModelNG::SetOnFinish(frameNode, std::move(*onFinish));
350 } else {
351 ImageAnimatorModelNG::SetOnFinish(frameNode, nullptr);
352 }
353 }
354
ResetImageAnimatorOnFinish(ArkUINodeHandle node)355 void ResetImageAnimatorOnFinish(ArkUINodeHandle node)
356 {
357 auto* frameNode = reinterpret_cast<FrameNode*>(node);
358 CHECK_NULL_VOID(frameNode);
359 ImageAnimatorModelNG::SetOnFinish(frameNode, nullptr);
360 }
361 } // namespace ImageAnimatorModifier
362
363 namespace NodeModifier {
GetImageAnimatorModifier()364 const ArkUIImageAnimatorModifier* GetImageAnimatorModifier()
365 {
366 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
367 static const ArkUIImageAnimatorModifier modifier = {
368 .setState = ImageAnimatorModifier::SetState,
369 .resetState = ImageAnimatorModifier::ResetState,
370 .setDuration = ImageAnimatorModifier::SetDuration,
371 .setFixedSize = ImageAnimatorModifier::SetFixedSize,
372 .resetFixedSize = ImageAnimatorModifier::ResetFixedSize,
373 .setFillMode = ImageAnimatorModifier::SetFillMode,
374 .resetFillMode = ImageAnimatorModifier::ResetFillMode,
375 .setReverse = ImageAnimatorModifier::SetReverse,
376 .resetReverse = ImageAnimatorModifier::ResetReverse,
377 .setImages = ImageAnimatorModifier::SetImages,
378 .resetImages = ImageAnimatorModifier::ResetImages,
379 .setImageAnimatorIteration = ImageAnimatorModifier::SetImageAnimatorIteration,
380 .resetImageAnimatorIteration = ImageAnimatorModifier::ResetImageAnimatorIteration,
381 .setAutoMonitorInvisibleArea = ImageAnimatorModifier::SetAutoMonitorInvisibleArea,
382 .setImageAnimatorSrc = ImageAnimatorModifier::SetImageAnimatorSrc,
383 .resetDuration = ImageAnimatorModifier::ResetDuration,
384 .getIsReverse = ImageAnimatorModifier::GetIsReverse,
385 .getDuration = ImageAnimatorModifier::GetDuration,
386 .getState = ImageAnimatorModifier::GetState,
387 .getFixedSize = ImageAnimatorModifier::GetIsFixedSize,
388 .getFillMode = ImageAnimatorModifier::GetFillMode,
389 .getIteration = ImageAnimatorModifier::GetIteration,
390 .getImagesSize = ImageAnimatorModifier::GetImagesSize,
391 .setImageAnimatorOnStart = ImageAnimatorModifier::SetImageAnimatorOnStart,
392 .resetImageAnimatorOnStart = ImageAnimatorModifier::ResetImageAnimatorOnStart,
393 .setImageAnimatorOnPause = ImageAnimatorModifier::SetImageAnimatorOnPause,
394 .resetImageAnimatorOnPause = ImageAnimatorModifier::ResetImageAnimatorOnPause,
395 .setImageAnimatorOnRepeat = ImageAnimatorModifier::SetImageAnimatorOnRepeat,
396 .resetImageAnimatorOnRepeat = ImageAnimatorModifier::ResetImageAnimatorOnRepeat,
397 .setImageAnimatorOnCancel = ImageAnimatorModifier::SetImageAnimatorOnCancel,
398 .resetImageAnimatorOnCancel = ImageAnimatorModifier::ResetImageAnimatorOnCancel,
399 .setImageAnimatorOnFinish = ImageAnimatorModifier::SetImageAnimatorOnFinish,
400 .resetImageAnimatorOnFinish = ImageAnimatorModifier::ResetImageAnimatorOnFinish,
401 };
402 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
403
404 return &modifier;
405 }
406
GetCJUIImageAnimatorModifier()407 const CJUIImageAnimatorModifier* GetCJUIImageAnimatorModifier()
408 {
409 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
410 static const CJUIImageAnimatorModifier modifier = {
411 .setState = ImageAnimatorModifier::SetState,
412 .resetState = ImageAnimatorModifier::ResetState,
413 .setDuration = ImageAnimatorModifier::SetDuration,
414 .setFixedSize = ImageAnimatorModifier::SetFixedSize,
415 .resetFixedSize = ImageAnimatorModifier::ResetFixedSize,
416 .setFillMode = ImageAnimatorModifier::SetFillMode,
417 .resetFillMode = ImageAnimatorModifier::ResetFillMode,
418 .setReverse = ImageAnimatorModifier::SetReverse,
419 .resetReverse = ImageAnimatorModifier::ResetReverse,
420 .setImages = ImageAnimatorModifier::SetImages,
421 .resetImages = ImageAnimatorModifier::ResetImages,
422 .setImageAnimatorIteration = ImageAnimatorModifier::SetImageAnimatorIteration,
423 .resetImageAnimatorIteration = ImageAnimatorModifier::ResetImageAnimatorIteration,
424 .setImageAnimatorSrc = ImageAnimatorModifier::SetImageAnimatorSrc,
425 .resetDuration = ImageAnimatorModifier::ResetDuration,
426 .getIsReverse = ImageAnimatorModifier::GetIsReverse,
427 .getDuration = ImageAnimatorModifier::GetDuration,
428 .getState = ImageAnimatorModifier::GetState,
429 .getFixedSize = ImageAnimatorModifier::GetIsFixedSize,
430 .getFillMode = ImageAnimatorModifier::GetFillMode,
431 .getIteration = ImageAnimatorModifier::GetIteration,
432 .getImagesSize = ImageAnimatorModifier::GetImagesSize,
433 };
434 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
435
436 return &modifier;
437 }
438
SetImageAnimatorOnStart(ArkUINodeHandle node,void * extraParam)439 void SetImageAnimatorOnStart(ArkUINodeHandle node, void* extraParam)
440 {
441 auto* frameNode = reinterpret_cast<FrameNode*>(node);
442 CHECK_NULL_VOID(frameNode);
443 auto onEvent = [node, extraParam]() {
444 ArkUINodeEvent event;
445 event.kind = COMPONENT_ASYNC_EVENT;
446 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
447 event.componentAsyncEvent.subKind = ON_IMAGE_ANIMATOR_ON_START;
448 SendArkUISyncEvent(&event);
449 };
450 ImageAnimatorModelNG::SetOnStart(frameNode, std::move(onEvent));
451 }
452
SetImageAnimatorOnPause(ArkUINodeHandle node,void * extraParam)453 void SetImageAnimatorOnPause(ArkUINodeHandle node, void* extraParam)
454 {
455 auto* frameNode = reinterpret_cast<FrameNode*>(node);
456 CHECK_NULL_VOID(frameNode);
457 auto onEvent = [node, extraParam]() {
458 ArkUINodeEvent event;
459 event.kind = COMPONENT_ASYNC_EVENT;
460 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
461 event.componentAsyncEvent.subKind = ON_IMAGE_ANIMATOR_ON_PAUSE;
462 SendArkUISyncEvent(&event);
463 };
464 ImageAnimatorModelNG::SetOnPause(frameNode, std::move(onEvent));
465 }
466
SetImageAnimatorOnRepeat(ArkUINodeHandle node,void * extraParam)467 void SetImageAnimatorOnRepeat(ArkUINodeHandle node, void* extraParam)
468 {
469 auto* frameNode = reinterpret_cast<FrameNode*>(node);
470 CHECK_NULL_VOID(frameNode);
471 auto onEvent = [node, extraParam]() {
472 ArkUINodeEvent event;
473 event.kind = COMPONENT_ASYNC_EVENT;
474 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
475 event.componentAsyncEvent.subKind = ON_IMAGE_ANIMATOR_ON_REPEAT;
476 SendArkUISyncEvent(&event);
477 };
478 ImageAnimatorModelNG::SetOnRepeat(frameNode, std::move(onEvent));
479 }
480
SetImageAnimatorOnCancel(ArkUINodeHandle node,void * extraParam)481 void SetImageAnimatorOnCancel(ArkUINodeHandle node, void* extraParam)
482 {
483 auto* frameNode = reinterpret_cast<FrameNode*>(node);
484 CHECK_NULL_VOID(frameNode);
485 auto onEvent = [node, extraParam]() {
486 ArkUINodeEvent event;
487 event.kind = COMPONENT_ASYNC_EVENT;
488 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
489 event.componentAsyncEvent.subKind = ON_IMAGE_ANIMATOR_ON_CANCEL;
490 SendArkUISyncEvent(&event);
491 };
492 ImageAnimatorModelNG::SetOnCancel(frameNode, std::move(onEvent));
493 }
494
SetImageAnimatorOnFinish(ArkUINodeHandle node,void * extraParam)495 void SetImageAnimatorOnFinish(ArkUINodeHandle node, void* extraParam)
496 {
497 auto* frameNode = reinterpret_cast<FrameNode*>(node);
498 CHECK_NULL_VOID(frameNode);
499 auto onEvent = [node, extraParam]() {
500 ArkUINodeEvent event;
501 event.kind = COMPONENT_ASYNC_EVENT;
502 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
503 event.componentAsyncEvent.subKind = ON_IMAGE_ANIMATOR_ON_FINISH;
504 SendArkUISyncEvent(&event);
505 };
506 ImageAnimatorModelNG::SetOnFinish(frameNode, std::move(onEvent));
507 }
508
ResetImageAnimatorOnStart(ArkUINodeHandle node)509 void ResetImageAnimatorOnStart(ArkUINodeHandle node)
510 {
511 auto* frameNode = reinterpret_cast<FrameNode*>(node);
512 CHECK_NULL_VOID(frameNode);
513 ImageAnimatorModelNG::SetOnStart(frameNode, nullptr);
514 }
ResetImageAnimatorOnPause(ArkUINodeHandle node)515 void ResetImageAnimatorOnPause(ArkUINodeHandle node)
516 {
517 auto* frameNode = reinterpret_cast<FrameNode*>(node);
518 CHECK_NULL_VOID(frameNode);
519 ImageAnimatorModelNG::SetOnPause(frameNode, nullptr);
520 }
ResetImageAnimatorOnRepeat(ArkUINodeHandle node)521 void ResetImageAnimatorOnRepeat(ArkUINodeHandle node)
522 {
523 auto* frameNode = reinterpret_cast<FrameNode*>(node);
524 CHECK_NULL_VOID(frameNode);
525 ImageAnimatorModelNG::SetOnRepeat(frameNode, nullptr);
526 }
ResetImageAnimatorOnCancel(ArkUINodeHandle node)527 void ResetImageAnimatorOnCancel(ArkUINodeHandle node)
528 {
529 auto* frameNode = reinterpret_cast<FrameNode*>(node);
530 CHECK_NULL_VOID(frameNode);
531 ImageAnimatorModelNG::SetOnCancel(frameNode, nullptr);
532 }
ResetImageAnimatorOnFinish(ArkUINodeHandle node)533 void ResetImageAnimatorOnFinish(ArkUINodeHandle node)
534 {
535 auto* frameNode = reinterpret_cast<FrameNode*>(node);
536 CHECK_NULL_VOID(frameNode);
537 ImageAnimatorModelNG::SetOnFinish(frameNode, nullptr);
538 }
539 }
540 } // namespace OHOS::Ace::NG
541