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 "bridge/cj_frontend/interfaces/cj_ffi/cj_canvas_ffi.h"
17 
18 #include <cinttypes>
19 
20 #include "cj_lambda.h"
21 #include "ffi_remote_data.h"
22 #include "pixel_map_impl.h"
23 
24 #include "bridge/cj_frontend/cppview/canvas_path.h"
25 #include "bridge/cj_frontend/cppview/canvas_renderer.h"
26 #include "bridge/cj_frontend/interfaces/cj_ffi/utils.h"
27 #include "core/common/container.h"
28 #include "core/components_ng/pattern/canvas/canvas_model.h"
29 
30 using namespace OHOS;
31 using namespace OHOS::Ace;
32 using namespace OHOS::FFI;
33 using namespace OHOS::Ace::Framework;
34 
35 namespace {
36 enum class CanvasImageType { COORDINATES_ONLY = 0, COORDINATES_AND_SIZE, COORDINATES_AND_SIZE_WITH_SOURCE };
37 const std::vector<LineCapStyle> LINE_CAP_STYLE_LIST = { LineCapStyle::BUTT, LineCapStyle::ROUND, LineCapStyle::SQUARE };
38 const std::vector<LineJoinStyle> LINE_JOIN_STYLE_LIST = { LineJoinStyle::MITER, LineJoinStyle::ROUND,
39     LineJoinStyle::BEVEL };
40 const std::vector<FontStyle> FONT_STYLE_LIST = { FontStyle::NORMAL, FontStyle::ITALIC };
41 const std::vector<TextAlign> TEXT_ALIGN_LIST = { TextAlign::LEFT, TextAlign::RIGHT, TextAlign::CENTER,
42     TextAlign::JUSTIFY, TextAlign::START, TextAlign::END };
43 const std::vector<TextBaseline> TEXT_BASELINE_LIST = { TextBaseline::ALPHABETIC, TextBaseline::IDEOGRAPHIC,
44     TextBaseline::TOP, TextBaseline::BOTTOM, TextBaseline::MIDDLE, TextBaseline::HANGING };
45 const std::vector<CompositeOperation> COMPOSITE_OPERATION_LIST = { CompositeOperation::SOURCE_OVER,
46     CompositeOperation::SOURCE_ATOP, CompositeOperation::SOURCE_IN, CompositeOperation::SOURCE_OUT,
47     CompositeOperation::DESTINATION_OVER, CompositeOperation::DESTINATION_ATOP, CompositeOperation::DESTINATION_IN,
48     CompositeOperation::DESTINATION_OUT, CompositeOperation::LIGHTER, CompositeOperation::COPY,
49     CompositeOperation::XOR };
50 const std::vector<CanvasImageType> CANVAS_IMAGE_TYPE_LIST = { CanvasImageType::COORDINATES_ONLY,
51     CanvasImageType::COORDINATES_AND_SIZE, CanvasImageType::COORDINATES_AND_SIZE_WITH_SOURCE };
52 
GetRectParam(double x,double y,double width,double height)53 Rect GetRectParam(double x, double y, double width, double height)
54 {
55     x = PipelineBase::Vp2PxWithCurrentDensity(x);
56     y = PipelineBase::Vp2PxWithCurrentDensity(y);
57     width = PipelineBase::Vp2PxWithCurrentDensity(width);
58     height = PipelineBase::Vp2PxWithCurrentDensity(height);
59     Rect rect = Rect(x, y, width, height);
60     return rect;
61 }
62 
GetBezierCurveParam(double cp1x,double cp1y,double cp2x,double cp2y,double x,double y)63 BezierCurveParam GetBezierCurveParam(double cp1x, double cp1y, double cp2x, double cp2y, double x, double y)
64 {
65     BezierCurveParam param;
66     param.cp1x = PipelineBase::Vp2PxWithCurrentDensity(cp1x);
67     param.cp1y = PipelineBase::Vp2PxWithCurrentDensity(cp1y);
68     param.cp2x = PipelineBase::Vp2PxWithCurrentDensity(cp2x);
69     param.cp2y = PipelineBase::Vp2PxWithCurrentDensity(cp2y);
70     param.x = PipelineBase::Vp2PxWithCurrentDensity(x);
71     param.y = PipelineBase::Vp2PxWithCurrentDensity(y);
72     return param;
73 }
74 
GetQuadraticCurveParam(double cpx,double cpy,double x,double y)75 QuadraticCurveParam GetQuadraticCurveParam(double cpx, double cpy, double x, double y)
76 {
77     QuadraticCurveParam param;
78     param.cpx = PipelineBase::Vp2PxWithCurrentDensity(cpx);
79     param.cpy = PipelineBase::Vp2PxWithCurrentDensity(cpy);
80     param.x = PipelineBase::Vp2PxWithCurrentDensity(x);
81     param.y = PipelineBase::Vp2PxWithCurrentDensity(y);
82     return param;
83 }
84 
GetArcParam(double x,double y,double radius,double startAngle,double endAngle,bool anticlockwise)85 ArcParam GetArcParam(double x, double y, double radius, double startAngle, double endAngle, bool anticlockwise)
86 {
87     ArcParam param;
88     param.x = PipelineBase::Vp2PxWithCurrentDensity(x);
89     param.y = PipelineBase::Vp2PxWithCurrentDensity(y);
90     param.radius = PipelineBase::Vp2PxWithCurrentDensity(radius);
91     param.startAngle = startAngle;
92     param.endAngle = endAngle;
93     param.anticlockwise = anticlockwise;
94     return param;
95 }
96 
GetArcToParam(double x1,double y1,double x2,double y2,double radius)97 ArcToParam GetArcToParam(double x1, double y1, double x2, double y2, double radius)
98 {
99     ArcToParam param;
100     param.x1 = PipelineBase::Vp2PxWithCurrentDensity(x1);
101     param.y1 = PipelineBase::Vp2PxWithCurrentDensity(y1);
102     param.x2 = PipelineBase::Vp2PxWithCurrentDensity(x2);
103     param.y2 = PipelineBase::Vp2PxWithCurrentDensity(y2);
104     param.radius = PipelineBase::Vp2PxWithCurrentDensity(radius);
105     return param;
106 }
107 
GetEllipseParam(double x,double y,double radiusX,double radiusY,double rotation,double startAngle,double endAngle,bool anticlockwise)108 EllipseParam GetEllipseParam(double x, double y, double radiusX, double radiusY, double rotation, double startAngle,
109     double endAngle, bool anticlockwise)
110 {
111     EllipseParam param;
112     param.x = PipelineBase::Vp2PxWithCurrentDensity(x);
113     param.y = PipelineBase::Vp2PxWithCurrentDensity(y);
114     param.radiusX = PipelineBase::Vp2PxWithCurrentDensity(radiusX);
115     param.radiusY = PipelineBase::Vp2PxWithCurrentDensity(radiusY);
116     param.rotation = rotation;
117     param.startAngle = startAngle;
118     param.endAngle = endAngle;
119     param.anticlockwise = anticlockwise;
120     return param;
121 }
122 
GetTransformParam(double scaleX,double scaleY,double skewX,double skewY,double translateX,double translateY)123 TransformParam GetTransformParam(
124     double scaleX, double scaleY, double skewX, double skewY, double translateX, double translateY)
125 {
126     TransformParam param;
127     param.scaleX = scaleX;
128     param.scaleY = scaleY;
129     param.skewX = skewX;
130     param.skewY = skewY;
131     param.translateX = PipelineBase::Vp2PxWithCurrentDensity(translateX);
132     param.translateY = PipelineBase::Vp2PxWithCurrentDensity(translateY);
133     return param;
134 }
135 } // namespace
136 
137 extern "C" {
FfiOHOSAceFrameworkCanvasCreate(int64_t contextId)138 void FfiOHOSAceFrameworkCanvasCreate(int64_t contextId)
139 {
140     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
141     if (context == nullptr) {
142         return;
143     }
144 
145     auto pattern = CanvasModel::GetInstance()->Create();
146     context->SetCanvasPattern(pattern);
147     context->SetAntiAlias();
148 }
149 
FfiOHOSAceFrameworkCanvasOnReady(void (* callback)())150 void FfiOHOSAceFrameworkCanvasOnReady(void (*callback)())
151 {
152     auto targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
153     auto readyEvent = [lambda = CJLambda::Create(callback), node = targetNode] {
154         PipelineContext::SetCallBackNode(node);
155         lambda();
156     };
157     CanvasModel::GetInstance()->SetOnReady(std::move(readyEvent));
158 }
159 
FfiOHOSAceFrameworkRenderingContextCtor(bool antialias)160 int64_t FfiOHOSAceFrameworkRenderingContextCtor(bool antialias)
161 {
162     auto context = FFIData::Create<NativeCanvasRenderer>(antialias);
163     if (context == nullptr) {
164         return FFI_ERROR_CODE;
165     }
166     return context->GetID();
167 }
168 
FfiOHOSAceFrameworkRenderingContextSetFillStyle(int64_t contextId,uint32_t colorValue)169 void FfiOHOSAceFrameworkRenderingContextSetFillStyle(int64_t contextId, uint32_t colorValue)
170 {
171     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
172     if (context != nullptr) {
173         context->SetFillStyle(Color(colorValue));
174     } else {
175         LOGE("canvas fillStyle error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
176     }
177 }
178 
FfiOHOSAceFrameworkRenderingContextSetFillStyleByGradient(int64_t contextId,int64_t gradientId)179 void FfiOHOSAceFrameworkRenderingContextSetFillStyleByGradient(int64_t contextId, int64_t gradientId)
180 {
181     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
182     if (context == nullptr) {
183         return;
184     }
185     auto nativeCanvasGradient = FFIData::GetData<NativeCanvasGradient>(gradientId);
186     if (nativeCanvasGradient == nullptr) {
187         return;
188     }
189     context->SetFillStyle(nativeCanvasGradient);
190 }
191 
FfiOHOSAceFrameworkRenderingContextSetLineWidth(int64_t contextId,double lineWidth)192 void FfiOHOSAceFrameworkRenderingContextSetLineWidth(int64_t contextId, double lineWidth)
193 {
194     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
195     if (context != nullptr) {
196         lineWidth = PipelineBase::Vp2PxWithCurrentDensity(lineWidth);
197         context->SetLineWidth(lineWidth);
198     } else {
199         LOGE("canvas lineWidth error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
200     }
201 }
202 
FfiOHOSAceFrameworkRenderingContextSetStrokeStyle(int64_t contextId,uint32_t color)203 void FfiOHOSAceFrameworkRenderingContextSetStrokeStyle(int64_t contextId, uint32_t color)
204 {
205     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
206     if (context != nullptr) {
207         context->SetStrokeStyle(Color(color));
208     } else {
209         LOGE("canvas strokeStyle error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
210     }
211 }
212 
FfiOHOSAceFrameworkRenderingContextSetStrokeStyleByGradient(int64_t contextId,int64_t gradientId)213 void FfiOHOSAceFrameworkRenderingContextSetStrokeStyleByGradient(int64_t contextId, int64_t gradientId)
214 {
215     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
216     if (context == nullptr) {
217         return;
218     }
219     auto nativeCanvasGradient = FFIData::GetData<NativeCanvasGradient>(gradientId);
220     if (nativeCanvasGradient == nullptr) {
221         return;
222     }
223     context->SetStrokeStyle(nativeCanvasGradient);
224 }
225 
FfiOHOSAceFrameworkRenderingContextSetLineCap(int64_t contextId,int32_t lineCap)226 void FfiOHOSAceFrameworkRenderingContextSetLineCap(int64_t contextId, int32_t lineCap)
227 {
228     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(lineCap, LINE_CAP_STYLE_LIST.size())) {
229         return;
230     }
231     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
232     if (context != nullptr) {
233         context->SetLineCap(LINE_CAP_STYLE_LIST[lineCap]);
234     } else {
235         LOGE("canvas lineCap error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
236     }
237 }
238 
FfiOHOSAceFrameworkRenderingContextSetLineJoin(int64_t contextId,int32_t lineJoin)239 void FfiOHOSAceFrameworkRenderingContextSetLineJoin(int64_t contextId, int32_t lineJoin)
240 {
241     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(lineJoin, LINE_JOIN_STYLE_LIST.size())) {
242         return;
243     }
244     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
245     if (context != nullptr) {
246         context->SetLineJoin(LINE_JOIN_STYLE_LIST[lineJoin]);
247     } else {
248         LOGE("canvas lineJoin error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
249     }
250 }
251 
FfiOHOSAceFrameworkRenderingContextSetMiterLimit(int64_t contextId,double limit)252 void FfiOHOSAceFrameworkRenderingContextSetMiterLimit(int64_t contextId, double limit)
253 {
254     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
255     if (context != nullptr) {
256         limit = PipelineBase::Vp2PxWithCurrentDensity(limit);
257         context->SetMiterLimit(limit);
258     } else {
259         LOGE("canvas miterLimit error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
260     }
261 }
262 
FfiOHOSAceFrameworkRenderingContextSetFont(int64_t contextId,int32_t style,const char * weight,double size,int32_t sizeUnit,const char * family)263 void FfiOHOSAceFrameworkRenderingContextSetFont(
264     int64_t contextId, int32_t style, const char* weight, double size, int32_t sizeUnit, const char* family)
265 {
266     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(style, FONT_STYLE_LIST.size())) {
267         return;
268     }
269     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
270     if (context != nullptr) {
271         context->SetFont(FONT_STYLE_LIST[style], weight, Dimension(size, static_cast<DimensionUnit>(sizeUnit)), family);
272     } else {
273         LOGE("canvas font error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
274     }
275 }
276 
FfiOHOSAceFrameworkRenderingContextSetTextAlign(int64_t contextId,int32_t align)277 void FfiOHOSAceFrameworkRenderingContextSetTextAlign(int64_t contextId, int32_t align)
278 {
279     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(align, TEXT_ALIGN_LIST.size())) {
280         return;
281     }
282     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
283     if (context != nullptr) {
284         context->SetTextAlign(TEXT_ALIGN_LIST[align]);
285     } else {
286         LOGE("canvas textAlign error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
287     }
288 }
289 
FfiOHOSAceFrameworkRenderingContextSetTextBaseline(int64_t contextId,int32_t baseline)290 void FfiOHOSAceFrameworkRenderingContextSetTextBaseline(int64_t contextId, int32_t baseline)
291 {
292     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(baseline, TEXT_BASELINE_LIST.size())) {
293         return;
294     }
295     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
296     if (context != nullptr) {
297         context->SetTextBaseline(TEXT_BASELINE_LIST[baseline]);
298     } else {
299         LOGE("canvas textBaseline error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
300     }
301 }
302 
FfiOHOSAceFrameworkRenderingContextSetGlobalAlpha(int64_t contextId,double alpha)303 void FfiOHOSAceFrameworkRenderingContextSetGlobalAlpha(int64_t contextId, double alpha)
304 {
305     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
306     if (context != nullptr) {
307         context->SetGlobalAlpha(alpha);
308     } else {
309         LOGE("canvas globalAlpha error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
310     }
311 }
312 
FfiOHOSAceFrameworkRenderingContextSetLineDash(int64_t contextId,VectorDoublePtr lineDashArr)313 void FfiOHOSAceFrameworkRenderingContextSetLineDash(int64_t contextId, VectorDoublePtr lineDashArr)
314 {
315     auto actualVec = reinterpret_cast<std::vector<double>*>(lineDashArr);
316     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
317     if (context != nullptr) {
318         context->SetLineDash(*actualVec);
319     } else {
320         LOGE("canvas lineDash error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
321     }
322 }
323 
FfiOHOSAceFrameworkRenderingContextSetLineDashOffset(int64_t contextId,double lineDashOffset)324 void FfiOHOSAceFrameworkRenderingContextSetLineDashOffset(int64_t contextId, double lineDashOffset)
325 {
326     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
327     if (context != nullptr) {
328         lineDashOffset = PipelineBase::Vp2PxWithCurrentDensity(lineDashOffset);
329         context->SetLineDashOffset(lineDashOffset);
330     } else {
331         LOGE("canvas lineDashOffset error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
332     }
333 }
334 
FfiOHOSAceFrameworkRenderingContextSetGlobalCompositeOperation(int64_t contextId,int32_t type)335 void FfiOHOSAceFrameworkRenderingContextSetGlobalCompositeOperation(int64_t contextId, int32_t type)
336 {
337     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(type, COMPOSITE_OPERATION_LIST.size())) {
338         return;
339     }
340     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
341     if (context != nullptr) {
342         context->SetGlobalCompositeOperation(COMPOSITE_OPERATION_LIST[type]);
343     } else {
344         LOGE("canvas globalCompositeOperation error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64,
345             contextId);
346     }
347 }
348 
FfiOHOSAceFrameworkRenderingContextSetShadowBlur(int64_t contextId,double blur)349 void FfiOHOSAceFrameworkRenderingContextSetShadowBlur(int64_t contextId, double blur)
350 {
351     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
352     if (context != nullptr) {
353         context->SetShadowBlur(blur);
354     } else {
355         LOGE("canvas shadowBlur error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
356     }
357 }
358 
FfiOHOSAceFrameworkRenderingContextSetShadowColor(int64_t contextId,uint32_t color)359 void FfiOHOSAceFrameworkRenderingContextSetShadowColor(int64_t contextId, uint32_t color)
360 {
361     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
362     if (context != nullptr) {
363         context->SetShadowColor(Color(color));
364     } else {
365         LOGE("canvas shadowColor error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
366     }
367 }
368 
FfiOHOSAceFrameworkRenderingContextSetShadowOffsetX(int64_t contextId,double offsetX)369 void FfiOHOSAceFrameworkRenderingContextSetShadowOffsetX(int64_t contextId, double offsetX)
370 {
371     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
372     if (context != nullptr) {
373         offsetX = PipelineBase::Vp2PxWithCurrentDensity(offsetX);
374         context->SetShadowOffsetX(offsetX);
375     } else {
376         LOGE("canvas shadowOffsetX error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
377     }
378 }
379 
FfiOHOSAceFrameworkRenderingContextSetShadowOffsetY(int64_t contextId,double offsetY)380 void FfiOHOSAceFrameworkRenderingContextSetShadowOffsetY(int64_t contextId, double offsetY)
381 {
382     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
383     if (context != nullptr) {
384         offsetY = PipelineBase::Vp2PxWithCurrentDensity(offsetY);
385         context->SetShadowOffsetY(offsetY);
386     } else {
387         LOGE("canvas shadowOffsetY error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
388     }
389 }
390 
FfiOHOSAceFrameworkRenderingContextSetImageSmoothingEnabled(int64_t contextId,bool enabled)391 void FfiOHOSAceFrameworkRenderingContextSetImageSmoothingEnabled(int64_t contextId, bool enabled)
392 {
393     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
394     if (context != nullptr) {
395         context->SetImageSmoothingEnabled(enabled);
396     } else {
397         LOGE("canvas imageSmoothingEnabled error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
398     }
399 }
400 
FfiOHOSAceFrameworkRenderingContextSetImageSmoothingQuality(int64_t contextId,const char * quality)401 void FfiOHOSAceFrameworkRenderingContextSetImageSmoothingQuality(int64_t contextId, const char* quality)
402 {
403     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
404     if (context != nullptr) {
405         context->SetImageSmoothingQuality(quality);
406     } else {
407         LOGE("canvas imageSmoothingQuality error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
408     }
409 }
410 
FfiOHOSAceFrameworkRenderingContextFillRect(int64_t contextId,double x,double y,double width,double height)411 void FfiOHOSAceFrameworkRenderingContextFillRect(int64_t contextId, double x, double y, double width, double height)
412 {
413     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
414     if (context != nullptr) {
415         auto rect = GetRectParam(x, y, width, height);
416         context->FillRect(rect);
417     } else {
418         LOGE("canvas fillRect error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
419     }
420 }
421 
FfiOHOSAceFrameworkRenderingContextStrokeRect(int64_t contextId,double x,double y,double width,double height)422 void FfiOHOSAceFrameworkRenderingContextStrokeRect(int64_t contextId, double x, double y, double width, double height)
423 {
424     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
425     if (context != nullptr) {
426         auto rect = GetRectParam(x, y, width, height);
427         context->StrokeRect(rect);
428     } else {
429         LOGE("canvas strokeRect error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
430     }
431 }
432 
FfiOHOSAceFrameworkRenderingContextClearRect(int64_t contextId,double x,double y,double width,double height)433 void FfiOHOSAceFrameworkRenderingContextClearRect(int64_t contextId, double x, double y, double width, double height)
434 {
435     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
436     if (context != nullptr) {
437         auto rect = GetRectParam(x, y, width, height);
438         context->ClearRect(rect);
439     } else {
440         LOGE("canvas clearRect error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
441     }
442 }
443 
FfiOHOSAceFrameworkRenderingContextFillText(int64_t contextId,double x,double y,const char * text)444 void FfiOHOSAceFrameworkRenderingContextFillText(int64_t contextId, double x, double y, const char* text)
445 {
446     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
447     if (context != nullptr) {
448         x = PipelineBase::Vp2PxWithCurrentDensity(x);
449         y = PipelineBase::Vp2PxWithCurrentDensity(y);
450         context->FillText(x, y, text);
451     } else {
452         LOGE("canvas fillText error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
453     }
454 }
455 
FfiOHOSAceFrameworkRenderingContextStrokeText(int64_t contextId,double x,double y,const char * text)456 void FfiOHOSAceFrameworkRenderingContextStrokeText(int64_t contextId, double x, double y, const char* text)
457 {
458     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
459     if (context != nullptr) {
460         x = PipelineBase::Vp2PxWithCurrentDensity(x);
461         y = PipelineBase::Vp2PxWithCurrentDensity(y);
462         context->StrokeText(x, y, text);
463     } else {
464         LOGE("canvas strokeText error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
465     }
466 }
467 
FfiOHOSAceFrameworkRenderingContextMeasureText(int64_t contextId,const char * text)468 CTextMetrics FfiOHOSAceFrameworkRenderingContextMeasureText(int64_t contextId, const char* text)
469 {
470     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
471     CTextMetrics textMetrics;
472     if (context != nullptr) {
473         auto metrics = context->MeasureText(text);
474         textMetrics.height = metrics.height;
475         textMetrics.width = metrics.width;
476     } else {
477         LOGE("canvas measureText error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
478     }
479     return textMetrics;
480 }
481 
FfiOHOSAceFrameworkRenderingContextStroke(int64_t contextId)482 void FfiOHOSAceFrameworkRenderingContextStroke(int64_t contextId)
483 {
484     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
485     if (context != nullptr) {
486         context->Stroke();
487     } else {
488         LOGE("canvas stroke error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
489     }
490 }
491 
FfiOHOSAceFrameworkRenderingContextStrokeWithPath(int64_t contextId,int64_t pathId)492 void FfiOHOSAceFrameworkRenderingContextStrokeWithPath(int64_t contextId, int64_t pathId)
493 {
494     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
495     if (context == nullptr) {
496         return;
497     }
498     auto path2d = FFIData::GetData<NativeCanvasPath>(pathId);
499     if (path2d == nullptr) {
500         return;
501     }
502     context->Stroke(path2d);
503 }
504 
FfiOHOSAceFrameworkRenderingContextBeginPath(int64_t contextId)505 void FfiOHOSAceFrameworkRenderingContextBeginPath(int64_t contextId)
506 {
507     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
508     if (context != nullptr) {
509         context->BeginPath();
510     } else {
511         LOGE("canvas beginPath error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
512     }
513 }
514 
FfiOHOSAceFrameworkRenderingContextMoveTo(int64_t contextId,double x,double y)515 void FfiOHOSAceFrameworkRenderingContextMoveTo(int64_t contextId, double x, double y)
516 {
517     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
518     if (context != nullptr) {
519         x = PipelineBase::Vp2PxWithCurrentDensity(x);
520         y = PipelineBase::Vp2PxWithCurrentDensity(y);
521         context->MoveTo(x, y);
522     } else {
523         LOGE("canvas moveTo error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
524     }
525 }
526 
FfiOHOSAceFrameworkRenderingContextLineTo(int64_t contextId,double x,double y)527 void FfiOHOSAceFrameworkRenderingContextLineTo(int64_t contextId, double x, double y)
528 {
529     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
530     if (context != nullptr) {
531         x = PipelineBase::Vp2PxWithCurrentDensity(x);
532         y = PipelineBase::Vp2PxWithCurrentDensity(y);
533         context->LineTo(x, y);
534     } else {
535         LOGE("canvas lineTo error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
536     }
537 }
538 
FfiOHOSAceFrameworkRenderingContextClosePath(int64_t contextId)539 void FfiOHOSAceFrameworkRenderingContextClosePath(int64_t contextId)
540 {
541     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
542     if (context != nullptr) {
543         context->ClosePath();
544     } else {
545         LOGE("canvas closePath error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
546     }
547 }
548 
FfiOHOSAceFrameworkRenderingContextBezierCurveTo(int64_t contextId,double cp1x,double cp1y,double cp2x,double cp2y,double x,double y)549 void FfiOHOSAceFrameworkRenderingContextBezierCurveTo(
550     int64_t contextId, double cp1x, double cp1y, double cp2x, double cp2y, double x, double y)
551 {
552     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
553     if (context != nullptr) {
554         auto bezierCurveParam = GetBezierCurveParam(cp1x, cp1y, cp2x, cp2y, x, y);
555         context->BezierCurveTo(bezierCurveParam);
556     } else {
557         LOGE("canvas bezierCurveTo error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
558     }
559 }
560 
FfiOHOSAceFrameworkRenderingContextQuadraticCurveTo(int64_t contextId,double cpx,double cpy,double x,double y)561 void FfiOHOSAceFrameworkRenderingContextQuadraticCurveTo(int64_t contextId, double cpx, double cpy, double x, double y)
562 {
563     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
564     if (context != nullptr) {
565         auto quadraticCurveParam = GetQuadraticCurveParam(cpx, cpy, x, y);
566         context->QuadraticCurveTo(quadraticCurveParam);
567     } else {
568         LOGE("canvas quadraticCurveTo error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
569     }
570 }
571 
FfiOHOSAceFrameworkRenderingContextArc(int64_t contextId,double x,double y,double radius,double startAngle,double endAngle,bool anticlockwise)572 void FfiOHOSAceFrameworkRenderingContextArc(
573     int64_t contextId, double x, double y, double radius, double startAngle, double endAngle, bool anticlockwise)
574 {
575     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
576     if (context != nullptr) {
577         auto arcParam = GetArcParam(x, y, radius, startAngle, endAngle, anticlockwise);
578         context->Arc(arcParam);
579     } else {
580         LOGE("canvas arc error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
581     }
582 }
583 
FfiOHOSAceFrameworkRenderingContextArcTo(int64_t contextId,double x1,double y1,double x2,double y2,double radius)584 void FfiOHOSAceFrameworkRenderingContextArcTo(
585     int64_t contextId, double x1, double y1, double x2, double y2, double radius)
586 {
587     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
588     if (context != nullptr) {
589         auto arcToParam = GetArcToParam(x1, y1, x2, y2, radius);
590         context->ArcTo(arcToParam);
591     } else {
592         LOGE("canvas arcTo error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
593     }
594 }
595 
FfiOHOSAceFrameworkRenderingContextEllipse(int64_t contextId,double x,double y,double radiusX,double radiusY,double rotation,double startAngle,double endAngle,bool anticlockwise)596 void FfiOHOSAceFrameworkRenderingContextEllipse(int64_t contextId, double x, double y, double radiusX, double radiusY,
597     double rotation, double startAngle, double endAngle, bool anticlockwise)
598 {
599     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
600     if (context != nullptr) {
601         auto arcParam = GetEllipseParam(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
602         context->Ellipse(arcParam);
603     } else {
604         LOGE("canvas ellipse error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
605     }
606 }
607 
FfiOHOSAceFrameworkRenderingContextRect(int64_t contextId,double x,double y,double width,double height)608 void FfiOHOSAceFrameworkRenderingContextRect(int64_t contextId, double x, double y, double width, double height)
609 {
610     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
611     if (context != nullptr) {
612         auto rect = GetRectParam(x, y, width, height);
613         context->NormalRect(rect);
614     } else {
615         LOGE("canvas normalRect error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
616     }
617 }
618 
FfiOHOSAceFrameworkRenderingContextFill(int64_t contextId)619 void FfiOHOSAceFrameworkRenderingContextFill(int64_t contextId)
620 {
621     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
622     if (context != nullptr) {
623         context->Fill();
624     } else {
625         LOGE("canvas fill error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
626     }
627 }
628 
FfiOHOSAceFrameworkRenderingContextClip(int64_t contextId)629 void FfiOHOSAceFrameworkRenderingContextClip(int64_t contextId)
630 {
631     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
632     if (context != nullptr) {
633         context->Clip();
634     } else {
635         LOGE("canvas clip error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
636     }
637 }
638 
FfiOHOSAceFrameworkRenderingContextRotate(int64_t contextId,double angle)639 void FfiOHOSAceFrameworkRenderingContextRotate(int64_t contextId, double angle)
640 {
641     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
642     if (context != nullptr) {
643         context->Rotate(angle);
644     } else {
645         LOGE("canvas rotate error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
646     }
647 }
648 
FfiOHOSAceFrameworkRenderingContextScale(int64_t contextId,double x,double y)649 void FfiOHOSAceFrameworkRenderingContextScale(int64_t contextId, double x, double y)
650 {
651     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
652     if (context != nullptr) {
653         context->Scale(x, y);
654     } else {
655         LOGE("canvas scale error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
656     }
657 }
658 
FfiOHOSAceFrameworkRenderingContextTransform(int64_t contextId,double scaleX,double scaleY,double skewX,double skewY,double translateX,double translateY)659 void FfiOHOSAceFrameworkRenderingContextTransform(
660     int64_t contextId, double scaleX, double scaleY, double skewX, double skewY, double translateX, double translateY)
661 {
662     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
663     if (context != nullptr) {
664         auto transformParam = GetTransformParam(scaleX, scaleY, skewX, skewY, translateX, translateY);
665         context->Transform(transformParam);
666     } else {
667         LOGE("canvas transform error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
668     }
669 }
670 
FfiOHOSAceFrameworkRenderingContextSetTransform(int64_t contextId,double scaleX,double scaleY,double skewX,double skewY,double translateX,double translateY)671 void FfiOHOSAceFrameworkRenderingContextSetTransform(
672     int64_t contextId, double scaleX, double scaleY, double skewX, double skewY, double translateX, double translateY)
673 {
674     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
675     if (context != nullptr) {
676         auto transformParam = GetTransformParam(scaleX, scaleY, skewX, skewY, translateX, translateY);
677         context->SetTransform(transformParam);
678     } else {
679         LOGE("canvas setTransform error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
680     }
681 }
682 
FfiOHOSAceFrameworkRenderingContextTranslate(int64_t contextId,double x,double y)683 void FfiOHOSAceFrameworkRenderingContextTranslate(int64_t contextId, double x, double y)
684 {
685     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
686     if (context != nullptr) {
687         x = PipelineBase::Vp2PxWithCurrentDensity(x);
688         y = PipelineBase::Vp2PxWithCurrentDensity(y);
689         context->Translate(x, y);
690     } else {
691         LOGE("canvas translate error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
692     }
693 }
694 
FfiOHOSAceFrameworkRenderingContextRestore(int64_t contextId)695 void FfiOHOSAceFrameworkRenderingContextRestore(int64_t contextId)
696 {
697     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
698     if (context != nullptr) {
699         context->Restore();
700     } else {
701         LOGE("canvas restore error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
702     }
703 }
704 
FfiOHOSAceFrameworkRenderingContextSave(int64_t contextId)705 void FfiOHOSAceFrameworkRenderingContextSave(int64_t contextId)
706 {
707     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
708     if (context != nullptr) {
709         context->Save();
710     } else {
711         LOGE("canvas save error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
712     }
713 }
714 
FfiOHOSAceFrameworkRenderingContextCreateLinearGradient(int64_t contextId,double x0,double y0,double x1,double y1)715 int64_t FfiOHOSAceFrameworkRenderingContextCreateLinearGradient(
716     int64_t contextId, double x0, double y0, double x1, double y1)
717 {
718     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
719     if (context != nullptr) {
720         x0 = PipelineBase::Vp2PxWithCurrentDensity(x0);
721         y0 = PipelineBase::Vp2PxWithCurrentDensity(y0);
722         x1 = PipelineBase::Vp2PxWithCurrentDensity(x1);
723         y1 = PipelineBase::Vp2PxWithCurrentDensity(y1);
724         return context->CreateLinearGradient(x0, y0, x1, y1);
725     } else {
726         LOGE("canvas createLinearGradient error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
727         return 0;
728     }
729 }
730 
FfiOHOSAceFrameworkRenderingContextCreateRadialGradient(int64_t contextId,double x0,double y0,double r0,double x1,double y1,double r1)731 int64_t FfiOHOSAceFrameworkRenderingContextCreateRadialGradient(
732     int64_t contextId, double x0, double y0, double r0, double x1, double y1, double r1)
733 {
734     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
735     if (context != nullptr) {
736         x0 = PipelineBase::Vp2PxWithCurrentDensity(x0);
737         y0 = PipelineBase::Vp2PxWithCurrentDensity(y0);
738         r0 = PipelineBase::Vp2PxWithCurrentDensity(r0);
739         x1 = PipelineBase::Vp2PxWithCurrentDensity(x1);
740         y1 = PipelineBase::Vp2PxWithCurrentDensity(y1);
741         r1 = PipelineBase::Vp2PxWithCurrentDensity(r1);
742         return context->CreateRadialGradient(x0, y0, r0, x1, y1, r1);
743     } else {
744         LOGE("canvas createRadialGradient error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
745         return 0;
746     }
747 }
748 
FfiOHOSAceFrameworkRenderingContextDrawImage(int64_t contextId,const char * src,NativeImageInfo imageInfo)749 void FfiOHOSAceFrameworkRenderingContextDrawImage(int64_t contextId, const char* src, NativeImageInfo imageInfo)
750 {
751     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(imageInfo.flag, CANVAS_IMAGE_TYPE_LIST.size())) {
752         return;
753     }
754     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
755     if (context == nullptr) {
756         return;
757     }
758     CanvasImage image { .flag = imageInfo.flag,
759         .sx = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sx),
760         .sy = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sy),
761         .sWidth = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sWidth),
762         .sHeight = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sHeight),
763         .dx = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dx),
764         .dy = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dy),
765         .dWidth = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dWidth),
766         .dHeight = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dHeight),
767         .src = src };
768     context->DrawImage(image);
769 }
770 
FfiOHOSAceFrameworkRenderingContextDrawImageWithPixelMap(int64_t contextId,int64_t pixelMapId,NativeImageInfo imageInfo)771 void FfiOHOSAceFrameworkRenderingContextDrawImageWithPixelMap(
772     int64_t contextId, int64_t pixelMapId, NativeImageInfo imageInfo)
773 {
774     if (!OHOS::Ace::Framework::Utils::CheckParamsValid(imageInfo.flag, CANVAS_IMAGE_TYPE_LIST.size())) {
775         LOGE("canvas imageInfo type error, invalid value for ImageInfoType");
776         return;
777     }
778     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
779     if (context == nullptr) {
780         LOGE("canvas drawImage error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
781         return;
782     }
783     auto instance = FFIData::GetData<OHOS::Media::PixelMapImpl>(pixelMapId);
784     if (instance == nullptr) {
785         LOGE("canvas drawImage error, Cannot get PixelMapProxy by id: %{public}" PRId64, pixelMapId);
786         return;
787     }
788     auto pixMap = instance->GetRealPixelMap();
789     if (pixMap == nullptr) {
790         LOGE("canvas drawImage error, Cannot get pixMap in PixelMapProxy");
791         return;
792     }
793     auto pixMapOhos = PixelMap::CreatePixelMap(&pixMap);
794     if (pixMapOhos == nullptr) {
795         LOGE("canvas drawImage error, Cannot create PixelMapOhos by pixMap");
796         return;
797     }
798     CanvasImage image { .flag = imageInfo.flag,
799         .sx = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sx),
800         .sy = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sy),
801         .sWidth = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sWidth),
802         .sHeight = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.sHeight),
803         .dx = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dx),
804         .dy = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dy),
805         .dWidth = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dWidth),
806         .dHeight = PipelineBase::Vp2PxWithCurrentDensity(imageInfo.dHeight) };
807     context->DrawImage(pixMapOhos, image);
808 }
809 
FfiOHOSAceFrameworkRenderingContextGetPixelMap(int64_t contextId,double left,double top,double width,double height)810 int64_t FfiOHOSAceFrameworkRenderingContextGetPixelMap(
811     int64_t contextId, double left, double top, double width, double height)
812 {
813     auto context = FFIData::GetData<NativeCanvasRenderer>(contextId);
814     if (context == nullptr) {
815         LOGE("canvas drawImage error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
816         return 0;
817     }
818 
819     left = PipelineBase::Vp2PxWithCurrentDensity(left);
820     top = PipelineBase::Vp2PxWithCurrentDensity(top);
821     width = PipelineBase::Vp2PxWithCurrentDensity(width);
822     height = PipelineBase::Vp2PxWithCurrentDensity(height);
823     return context->GetPixelMap(left, top, width, height);
824 }
825 
FfiOHOSAceFrameworkCanvasGradientAddColorStop(int64_t contextId,double offset,uint32_t color)826 void FfiOHOSAceFrameworkCanvasGradientAddColorStop(int64_t contextId, double offset, uint32_t color)
827 {
828     auto context = FFIData::GetData<NativeCanvasGradient>(contextId);
829     if (context != nullptr) {
830         context->AddColorStop(offset, Color(color));
831     } else {
832         LOGE("canvasGradient addColorStop error, Cannot get NativeCanvasRenderer by id: %{public}" PRId64, contextId);
833     }
834 }
835 
836 // Canvas Path2d
FfiOHOSAceFrameworkCanvasPathCtor()837 int64_t FfiOHOSAceFrameworkCanvasPathCtor()
838 {
839     auto path2d = FFIData::Create<NativeCanvasPath>();
840     return path2d->GetID();
841 }
842 
FfiOHOSAceFrameworkCanvasPathCtorWithPath(const char * path)843 int64_t FfiOHOSAceFrameworkCanvasPathCtorWithPath(const char* path)
844 {
845     auto path2d = FFIData::Create<NativeCanvasPath>(path);
846     return path2d->GetID();
847 }
848 
FfiOHOSAceFrameworkCanvasPathAddPath(int64_t selfId,int64_t pathId)849 void FfiOHOSAceFrameworkCanvasPathAddPath(int64_t selfId, int64_t pathId)
850 {
851     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
852     if (path2d == nullptr) {
853         return;
854     }
855     auto addPath = FFIData::GetData<NativeCanvasPath>(pathId);
856     if (addPath == nullptr) {
857         return;
858     }
859     path2d->AddPath(addPath);
860 }
861 
FfiOHOSAceFrameworkCanvasPathSetTransform(int64_t selfId,TransformParams params)862 void FfiOHOSAceFrameworkCanvasPathSetTransform(int64_t selfId, TransformParams params)
863 {
864     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
865     if (path2d != nullptr) {
866         double translateX = PipelineBase::Vp2PxWithCurrentDensity(params.translateX);
867         double translateY = PipelineBase::Vp2PxWithCurrentDensity(params.translateY);
868         path2d->SetTransform(params.scaleX, params.skewX, params.skewY, params.scaleY, translateX, translateY);
869     } else {
870         LOGE("canvas path2D setTransform error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
871     }
872 }
873 
FfiOHOSAceFrameworkCanvasPathMoveTo(int64_t selfId,double x,double y)874 void FfiOHOSAceFrameworkCanvasPathMoveTo(int64_t selfId, double x, double y)
875 {
876     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
877     if (path2d != nullptr) {
878         x = PipelineBase::Vp2PxWithCurrentDensity(x);
879         y = PipelineBase::Vp2PxWithCurrentDensity(y);
880         path2d->MoveTo(x, y);
881     } else {
882         LOGE("canvas path2D moveTo error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
883     }
884 }
885 
FfiOHOSAceFrameworkCanvasPathLineTo(int64_t selfId,double x,double y)886 void FfiOHOSAceFrameworkCanvasPathLineTo(int64_t selfId, double x, double y)
887 {
888     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
889     if (path2d != nullptr) {
890         x = PipelineBase::Vp2PxWithCurrentDensity(x);
891         y = PipelineBase::Vp2PxWithCurrentDensity(y);
892         path2d->LineTo(x, y);
893     } else {
894         LOGE("canvas path2D lineTo error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
895     }
896 }
897 
FfiOHOSAceFrameworkCanvasPathArc(int64_t selfId,ArcParams params,bool anticlockwise)898 void FfiOHOSAceFrameworkCanvasPathArc(int64_t selfId, ArcParams params, bool anticlockwise)
899 {
900     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
901     if (path2d != nullptr) {
902         double x = PipelineBase::Vp2PxWithCurrentDensity(params.x);
903         double y = PipelineBase::Vp2PxWithCurrentDensity(params.y);
904         double radius = PipelineBase::Vp2PxWithCurrentDensity(params.radius);
905         path2d->Arc(x, y, radius, params.startAngle, params.endAngle, anticlockwise);
906     } else {
907         LOGE("canvas path2D arc error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
908     }
909 }
910 
FfiOHOSAceFrameworkCanvasPathArcTo(int64_t selfId,ArcToParams params)911 void FfiOHOSAceFrameworkCanvasPathArcTo(int64_t selfId, ArcToParams params)
912 {
913     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
914     if (path2d != nullptr) {
915         double x1 = PipelineBase::Vp2PxWithCurrentDensity(params.x1);
916         double y1 = PipelineBase::Vp2PxWithCurrentDensity(params.y1);
917         double x2 = PipelineBase::Vp2PxWithCurrentDensity(params.x2);
918         double y2 = PipelineBase::Vp2PxWithCurrentDensity(params.y2);
919         double radius = PipelineBase::Vp2PxWithCurrentDensity(params.radius);
920         path2d->ArcTo(x1, y1, x2, y2, radius);
921     } else {
922         LOGE("canvas path2D arcTo error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
923     }
924 }
925 
FfiOHOSAceFrameworkCanvasPathQuadraticCurveTo(int64_t selfId,QuadraticCurveToParams params)926 void FfiOHOSAceFrameworkCanvasPathQuadraticCurveTo(int64_t selfId, QuadraticCurveToParams params)
927 {
928     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
929     if (path2d != nullptr) {
930         double cpx = PipelineBase::Vp2PxWithCurrentDensity(params.cpx);
931         double cpy = PipelineBase::Vp2PxWithCurrentDensity(params.cpy);
932         double x = PipelineBase::Vp2PxWithCurrentDensity(params.x);
933         double y = PipelineBase::Vp2PxWithCurrentDensity(params.y);
934         path2d->QuadraticCurveTo(cpx, cpy, x, y);
935     } else {
936         LOGE("canvas path2D quadraticCurveTo error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
937     }
938 }
939 
FfiOHOSAceFrameworkCanvasPathBezierCurveTo(int64_t selfId,BezierCurveToParams params)940 void FfiOHOSAceFrameworkCanvasPathBezierCurveTo(int64_t selfId, BezierCurveToParams params)
941 {
942     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
943     if (path2d != nullptr) {
944         double cp1x = PipelineBase::Vp2PxWithCurrentDensity(params.cp1x);
945         double cp1y = PipelineBase::Vp2PxWithCurrentDensity(params.cp1y);
946         double cp2x = PipelineBase::Vp2PxWithCurrentDensity(params.cp2x);
947         double cp2y = PipelineBase::Vp2PxWithCurrentDensity(params.cp2y);
948         double x = PipelineBase::Vp2PxWithCurrentDensity(params.x);
949         double y = PipelineBase::Vp2PxWithCurrentDensity(params.y);
950         path2d->BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
951     } else {
952         LOGE("canvas path2D bezierCurveTo error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
953     }
954 }
955 
FfiOHOSAceFrameworkCanvasPathEllipse(int64_t selfId,EllipseParams params,bool anticlockwise)956 void FfiOHOSAceFrameworkCanvasPathEllipse(int64_t selfId, EllipseParams params, bool anticlockwise)
957 {
958     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
959     if (path2d != nullptr) {
960         double x = PipelineBase::Vp2PxWithCurrentDensity(params.x);
961         double y = PipelineBase::Vp2PxWithCurrentDensity(params.y);
962         double radiusX = PipelineBase::Vp2PxWithCurrentDensity(params.radiusX);
963         double radiusY = PipelineBase::Vp2PxWithCurrentDensity(params.radiusY);
964         path2d->Ellipse(x, y, radiusX, radiusY, params.rotation, params.startAngle, params.endAngle, anticlockwise);
965     } else {
966         LOGE("canvas path2D ellipse error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
967     }
968 }
969 
FfiOHOSAceFrameworkCanvasPathRect(int64_t selfId,RectParams params)970 void FfiOHOSAceFrameworkCanvasPathRect(int64_t selfId, RectParams params)
971 {
972     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
973     if (path2d != nullptr) {
974         double x = PipelineBase::Vp2PxWithCurrentDensity(params.x);
975         double y = PipelineBase::Vp2PxWithCurrentDensity(params.y);
976         double width = PipelineBase::Vp2PxWithCurrentDensity(params.width);
977         double height = PipelineBase::Vp2PxWithCurrentDensity(params.height);
978         path2d->Rect(x, y, width, height);
979     } else {
980         LOGE("canvas path2D rect error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
981     }
982 }
983 
FfiOHOSAceFrameworkCanvasPathClosePath(int64_t selfId)984 void FfiOHOSAceFrameworkCanvasPathClosePath(int64_t selfId)
985 {
986     auto path2d = FFIData::GetData<NativeCanvasPath>(selfId);
987     if (path2d != nullptr) {
988         path2d->ClosePath();
989     } else {
990         LOGE("canvas path2D closePath error, Cannot get NativeCanvasPath by id: %{public}" PRId64, selfId);
991     }
992 }
993 }
994