1 /*
2  * Copyright (c) 2021-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 "js_rendering_context.h"
17 
18 #include <cstdint>
19 
20 #include "interfaces/inner_api/ace/ai/image_analyzer.h"
21 #include "js_native_api.h"
22 #include "js_native_api_types.h"
23 
24 #include "base/error/error_code.h"
25 #include "base/memory/referenced.h"
26 #include "base/log/ace_scoring_log.h"
27 #include "base/utils/utils.h"
28 #include "bridge/common/utils/engine_helper.h"
29 #include "bridge/declarative_frontend/engine/bindings.h"
30 #include "bridge/declarative_frontend/engine/js_converter.h"
31 #include "bridge/declarative_frontend/engine/js_types.h"
32 #include "bridge/declarative_frontend/jsview/canvas/js_offscreen_rendering_context.h"
33 #include "bridge/declarative_frontend/jsview/js_utils.h"
34 #include "bridge/declarative_frontend/jsview/models/canvas/canvas_rendering_context_2d_model_impl.h"
35 #include "core/common/container_scope.h"
36 #include "core/components_ng/pattern/canvas/canvas_rendering_context_2d_model_ng.h"
37 
38 namespace OHOS::Ace {
39 struct CanvasAsyncCxt {
40     napi_env env = nullptr;
41     napi_deferred deferred = nullptr;
42 };
43 } // namespace OHOS::Ace
44 
45 namespace OHOS::Ace::Framework {
46 
JSRenderingContext()47 JSRenderingContext::JSRenderingContext()
48 {
49 #ifdef NG_BUILD
50     renderingContext2DModel_ = AceType::MakeRefPtr<NG::CanvasRenderingContext2DModelNG>();
51 #else
52     if (Container::IsCurrentUseNewPipeline()) {
53         renderingContext2DModel_ = AceType::MakeRefPtr<NG::CanvasRenderingContext2DModelNG>();
54         auto onAttach = [weakCtx = WeakClaim(this)]() {
55             auto ctx = weakCtx.Upgrade();
56             CHECK_NULL_VOID(ctx);
57             ctx->OnAttachToCanvas();
58         };
59         auto onDetach = [weakCtx = WeakClaim(this)]() {
60             auto ctx = weakCtx.Upgrade();
61             CHECK_NULL_VOID(ctx);
62             ctx->OnDetachFromCanvas();
63         };
64         auto canvasRenderingContext2DModel =
65             AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
66         CHECK_NULL_VOID(canvasRenderingContext2DModel);
67         canvasRenderingContext2DModel->SetOnAttach(onAttach);
68         canvasRenderingContext2DModel->SetOnDetach(onDetach);
69     } else {
70         renderingContext2DModel_ = AceType::MakeRefPtr<Framework::CanvasRenderingContext2DModelImpl>();
71     }
72 #endif
73 }
74 
JSBind(BindingTarget globalObj)75 void JSRenderingContext::JSBind(BindingTarget globalObj)
76 {
77     // Define the class "CanvasRenderingContext2D"
78     JSClass<JSRenderingContext>::Declare("CanvasRenderingContext2D");
79 
80     // Define all properties of the "CanvasRenderingContext2D"
81     JSClass<JSRenderingContext>::CustomProperty(
82         "canvas", &JSRenderingContext::JsGetCanvas, &JSRenderingContext::JsSetCanvas);
83     JSClass<JSRenderingContext>::CustomProperty(
84         "width", &JSRenderingContext::JsGetWidth, &JSRenderingContext::JsSetWidth);
85     JSClass<JSRenderingContext>::CustomProperty(
86         "height", &JSRenderingContext::JsGetHeight, &JSRenderingContext::JsSetHeight);
87     JSClass<JSRenderingContext>::CustomProperty(
88         "filter", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetFilter);
89     JSClass<JSRenderingContext>::CustomProperty(
90         "direction", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetDirection);
91     JSClass<JSRenderingContext>::CustomProperty(
92         "fillStyle", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetFillStyle);
93     JSClass<JSRenderingContext>::CustomProperty(
94         "strokeStyle", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetStrokeStyle);
95     JSClass<JSRenderingContext>::CustomProperty(
96         "lineCap", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetLineCap);
97     JSClass<JSRenderingContext>::CustomProperty(
98         "lineJoin", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetLineJoin);
99     JSClass<JSRenderingContext>::CustomProperty(
100         "miterLimit", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetMiterLimit);
101     JSClass<JSRenderingContext>::CustomProperty(
102         "lineWidth", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetLineWidth);
103     JSClass<JSRenderingContext>::CustomProperty("font", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetFont);
104     JSClass<JSRenderingContext>::CustomProperty(
105         "textAlign", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetTextAlign);
106     JSClass<JSRenderingContext>::CustomProperty(
107         "textBaseline", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetTextBaseline);
108     JSClass<JSRenderingContext>::CustomProperty(
109         "globalAlpha", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetGlobalAlpha);
110     JSClass<JSRenderingContext>::CustomProperty(
111         "globalCompositeOperation", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetGlobalCompositeOperation);
112     JSClass<JSRenderingContext>::CustomProperty(
113         "lineDashOffset", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetLineDashOffset);
114     JSClass<JSRenderingContext>::CustomProperty(
115         "shadowBlur", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetShadowBlur);
116     JSClass<JSRenderingContext>::CustomProperty(
117         "shadowColor", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetShadowColor);
118     JSClass<JSRenderingContext>::CustomProperty(
119         "shadowOffsetX", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetShadowOffsetX);
120     JSClass<JSRenderingContext>::CustomProperty(
121         "shadowOffsetY", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetShadowOffsetY);
122     JSClass<JSRenderingContext>::CustomProperty(
123         "imageSmoothingEnabled", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetImageSmoothingEnabled);
124     JSClass<JSRenderingContext>::CustomProperty(
125         "imageSmoothingQuality", &JSCanvasRenderer::JSGetEmpty, &JSCanvasRenderer::JsSetImageSmoothingQuality);
126 
127     // Define all methods of the "CanvasRenderingContext2D"
128     JSClass<JSRenderingContext>::CustomMethod("toDataURL", &JSCanvasRenderer::JsToDataUrl);
129     JSClass<JSRenderingContext>::CustomMethod("createRadialGradient", &JSCanvasRenderer::JsCreateRadialGradient);
130     JSClass<JSRenderingContext>::CustomMethod("fillRect", &JSCanvasRenderer::JsFillRect);
131     JSClass<JSRenderingContext>::CustomMethod("strokeRect", &JSCanvasRenderer::JsStrokeRect);
132     JSClass<JSRenderingContext>::CustomMethod("clearRect", &JSCanvasRenderer::JsClearRect);
133     JSClass<JSRenderingContext>::CustomMethod("createLinearGradient", &JSCanvasRenderer::JsCreateLinearGradient);
134     JSClass<JSRenderingContext>::CustomMethod("fillText", &JSCanvasRenderer::JsFillText);
135     JSClass<JSRenderingContext>::CustomMethod("strokeText", &JSCanvasRenderer::JsStrokeText);
136     JSClass<JSRenderingContext>::CustomMethod("measureText", &JSCanvasRenderer::JsMeasureText);
137     JSClass<JSRenderingContext>::CustomMethod("moveTo", &JSCanvasRenderer::JsMoveTo);
138     JSClass<JSRenderingContext>::CustomMethod("lineTo", &JSCanvasRenderer::JsLineTo);
139     JSClass<JSRenderingContext>::CustomMethod("bezierCurveTo", &JSCanvasRenderer::JsBezierCurveTo);
140     JSClass<JSRenderingContext>::CustomMethod("quadraticCurveTo", &JSCanvasRenderer::JsQuadraticCurveTo);
141     JSClass<JSRenderingContext>::CustomMethod("arcTo", &JSCanvasRenderer::JsArcTo);
142     JSClass<JSRenderingContext>::CustomMethod("arc", &JSCanvasRenderer::JsArc);
143     JSClass<JSRenderingContext>::CustomMethod("ellipse", &JSCanvasRenderer::JsEllipse);
144     JSClass<JSRenderingContext>::CustomMethod("fill", &JSCanvasRenderer::JsFill);
145     JSClass<JSRenderingContext>::CustomMethod("stroke", &JSCanvasRenderer::JsStroke);
146     JSClass<JSRenderingContext>::CustomMethod("clip", &JSCanvasRenderer::JsClip);
147     JSClass<JSRenderingContext>::CustomMethod("rect", &JSCanvasRenderer::JsRect);
148     JSClass<JSRenderingContext>::CustomMethod("beginPath", &JSCanvasRenderer::JsBeginPath);
149     JSClass<JSRenderingContext>::CustomMethod("closePath", &JSCanvasRenderer::JsClosePath);
150     JSClass<JSRenderingContext>::CustomMethod("restore", &JSCanvasRenderer::JsRestore);
151     JSClass<JSRenderingContext>::CustomMethod("save", &JSCanvasRenderer::JsSave);
152     JSClass<JSRenderingContext>::CustomMethod("rotate", &JSCanvasRenderer::JsRotate);
153     JSClass<JSRenderingContext>::CustomMethod("scale", &JSCanvasRenderer::JsScale);
154     JSClass<JSRenderingContext>::CustomMethod("getTransform", &JSCanvasRenderer::JsGetTransform);
155     JSClass<JSRenderingContext>::CustomMethod("setTransform", &JSCanvasRenderer::JsSetTransform);
156     JSClass<JSRenderingContext>::CustomMethod("resetTransform", &JSCanvasRenderer::JsResetTransform);
157     JSClass<JSRenderingContext>::CustomMethod("transform", &JSCanvasRenderer::JsTransform);
158     JSClass<JSRenderingContext>::CustomMethod("translate", &JSCanvasRenderer::JsTranslate);
159     JSClass<JSRenderingContext>::CustomMethod("setLineDash", &JSCanvasRenderer::JsSetLineDash);
160     JSClass<JSRenderingContext>::CustomMethod("getLineDash", &JSCanvasRenderer::JsGetLineDash);
161     JSClass<JSRenderingContext>::CustomMethod("drawImage", &JSCanvasRenderer::JsDrawImage);
162     JSClass<JSRenderingContext>::CustomMethod("createPattern", &JSCanvasRenderer::JsCreatePattern);
163     JSClass<JSRenderingContext>::CustomMethod("createImageData", &JSCanvasRenderer::JsCreateImageData);
164     JSClass<JSRenderingContext>::CustomMethod("putImageData", &JSCanvasRenderer::JsPutImageData);
165     JSClass<JSRenderingContext>::CustomMethod("getImageData", &JSCanvasRenderer::JsGetImageData);
166     JSClass<JSRenderingContext>::CustomMethod("getJsonData", &JSCanvasRenderer::JsGetJsonData);
167     JSClass<JSRenderingContext>::CustomMethod("getPixelMap", &JSCanvasRenderer::JsGetPixelMap);
168     JSClass<JSRenderingContext>::CustomMethod("setPixelMap", &JSCanvasRenderer::JsSetPixelMap);
169     JSClass<JSRenderingContext>::CustomMethod("drawBitmapMesh", &JSCanvasRenderer::JsDrawBitmapMesh);
170     JSClass<JSRenderingContext>::CustomMethod(
171         "transferFromImageBitmap", &JSRenderingContext::JsTransferFromImageBitmap);
172     JSClass<JSRenderingContext>::CustomMethod("createConicGradient", &JSCanvasRenderer::JsCreateConicGradient);
173     JSClass<JSRenderingContext>::CustomMethod("saveLayer", &JSCanvasRenderer::JsSaveLayer);
174     JSClass<JSRenderingContext>::CustomMethod("restoreLayer", &JSCanvasRenderer::JsRestoreLayer);
175     JSClass<JSRenderingContext>::CustomMethod("reset", &JSCanvasRenderer::JsReset);
176     JSClass<JSRenderingContext>::CustomMethod("startImageAnalyzer", &JSRenderingContext::JsStartImageAnalyzer);
177     JSClass<JSRenderingContext>::CustomMethod("stopImageAnalyzer", &JSRenderingContext::JsStopImageAnalyzer);
178     JSClass<JSRenderingContext>::CustomMethod("on", &JSRenderingContext::JsOn);
179     JSClass<JSRenderingContext>::CustomMethod("off", &JSRenderingContext::JsOff);
180 
181     // Register the "CanvasRenderingContext2D" to the global object of the vm
182     JSClass<JSRenderingContext>::Bind(globalObj, JSRenderingContext::Constructor, JSRenderingContext::Destructor);
183 }
184 
Constructor(const JSCallbackInfo & args)185 void JSRenderingContext::Constructor(const JSCallbackInfo& args)
186 {
187     auto jsRenderContext = Referenced::MakeRefPtr<JSRenderingContext>();
188     jsRenderContext->IncRefCount();
189     args.SetReturnValue(Referenced::RawPtr(jsRenderContext));
190 
191     auto* jsContextSetting = args.UnwrapArg<JSRenderingContextSettings>(0);
192     if (jsContextSetting) {
193         bool anti = jsContextSetting->GetAntialias();
194         jsRenderContext->SetAnti(anti);
195 
196         int32_t unit = 0;
197         if (args.GetInt32Arg(1, unit) && (static_cast<CanvasUnit>(unit) == CanvasUnit::PX)) {
198             jsRenderContext->SetUnit(CanvasUnit::PX);
199         }
200     }
201 }
202 
Destructor(JSRenderingContext * controller)203 void JSRenderingContext::Destructor(JSRenderingContext* controller)
204 {
205     if (controller != nullptr) {
206         controller->DecRefCount();
207     }
208 }
209 
OnAttachToCanvas()210 void JSRenderingContext::OnAttachToCanvas()
211 {
212     ContainerScope scope(instanceId_);
213     for (const auto& iter : attachCallback_) {
214         auto callback = iter.second;
215         if (callback) {
216             callback();
217         }
218     }
219 }
220 
OnDetachFromCanvas()221 void JSRenderingContext::OnDetachFromCanvas()
222 {
223     ContainerScope scope(instanceId_);
224     for (const auto& iter : detachCallback_) {
225         auto callback = iter.second;
226         if (callback) {
227             callback();
228         }
229     }
230 }
231 
JsGetCanvas(const JSCallbackInfo & info)232 void JSRenderingContext::JsGetCanvas(const JSCallbackInfo& info)
233 {
234     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
235     CHECK_NULL_VOID(canvasRenderingContext2DModel);
236     auto nodeId = canvasRenderingContext2DModel->GetId();
237 
238     auto vm = info.GetVm();
239     auto globalObj = JSNApi::GetGlobalObject(vm);
240     auto globalFunc = globalObj->Get(vm, panda::StringRef::NewFromUtf8(vm, "__getFrameNodeByNodeId__"));
241     JsiValue jsiValue(globalFunc);
242     JsiRef<JsiValue> globalFuncRef = JsiRef<JsiValue>::Make(jsiValue);
243     if (!globalFuncRef->IsFunction()) {
244         return;
245     }
246     RefPtr<JsFunction> jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(globalFuncRef));
247     JSRef<JSVal> params[2]; // The count of the function's params is 2.
248     params[0] = JSRef<JSVal>::Make(ToJSValue(instanceId_));
249     params[1] = JSRef<JSVal>::Make(ToJSValue(nodeId));
250     auto returnPtr = jsFunc->ExecuteJS(2, params);
251     info.SetReturnValue(returnPtr);
252     return;
253 }
254 
JsSetCanvas(const JSCallbackInfo & info)255 void JSRenderingContext::JsSetCanvas(const JSCallbackInfo& info)
256 {
257     return;
258 }
259 
JsGetWidth(const JSCallbackInfo & info)260 void JSRenderingContext::JsGetWidth(const JSCallbackInfo& info)
261 {
262     double width = 0.0;
263     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
264     CHECK_NULL_VOID(canvasRenderingContext2DModel);
265     canvasRenderingContext2DModel->GetWidth(width);
266     double density = GetDensity();
267     width /= density;
268     auto returnValue = JSVal(ToJSValue(width));
269     auto returnPtr = JSRef<JSVal>::Make(returnValue);
270     info.SetReturnValue(returnPtr);
271 }
272 
JsSetWidth(const JSCallbackInfo & info)273 void JSRenderingContext::JsSetWidth(const JSCallbackInfo& info)
274 {
275     return;
276 }
277 
JsSetHeight(const JSCallbackInfo & info)278 void JSRenderingContext::JsSetHeight(const JSCallbackInfo& info)
279 {
280     return;
281 }
282 
JsGetHeight(const JSCallbackInfo & info)283 void JSRenderingContext::JsGetHeight(const JSCallbackInfo& info)
284 {
285     double height = 0.0;
286     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
287     CHECK_NULL_VOID(canvasRenderingContext2DModel);
288     canvasRenderingContext2DModel->GetHeight(height);
289     double density = GetDensity();
290     height /= density;
291     auto returnValue = JSVal(ToJSValue(height));
292     auto returnPtr = JSRef<JSVal>::Make(returnValue);
293     info.SetReturnValue(returnPtr);
294 }
295 
JsTransferFromImageBitmap(const JSCallbackInfo & info)296 void JSRenderingContext::JsTransferFromImageBitmap(const JSCallbackInfo& info)
297 {
298     ContainerScope scope(Container::CurrentIdSafely());
299     if (info.Length() == 0) {
300         return;
301     }
302     if (!info[0]->IsObject()) {
303         return;
304     }
305     auto engine = EngineHelper::GetCurrentEngine();
306     CHECK_NULL_VOID(engine);
307     NativeEngine* nativeEngine = engine->GetNativeEngine();
308     napi_env env = reinterpret_cast<napi_env>(nativeEngine);
309     panda::Local<JsiValue> value = info[0].Get().GetLocalHandle();
310     JSValueWrapper valueWrapper = value;
311     napi_value napiValue = nativeEngine->ValueToNapiValue(valueWrapper);
312     void* nativeObj = nullptr;
313     auto status = napi_unwrap(env, napiValue, &nativeObj);
314     if (status != napi_ok) {
315         return;
316     }
317     auto jsImage = (JSRenderImage*)nativeObj;
318     CHECK_NULL_VOID(jsImage);
319     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
320     CHECK_NULL_VOID(canvasRenderingContext2DModel);
321 #ifdef PIXEL_MAP_SUPPORTED
322     auto pixelMap = jsImage->GetPixelMap();
323     CHECK_NULL_VOID(pixelMap);
324     canvasRenderingContext2DModel->TransferFromImageBitmap(pixelMap);
325 #else
326     auto imageData = jsImage->GetImageData();
327     CHECK_NULL_VOID(imageData);
328     canvasRenderingContext2DModel->TransferFromImageBitmap(imageData);
329 #endif
330 }
331 
CreateErrorValue(napi_env env,int32_t errCode,const std::string & errMsg="")332 napi_value CreateErrorValue(napi_env env, int32_t errCode, const std::string& errMsg = "")
333 {
334     napi_value code = nullptr;
335     std::string codeStr = std::to_string(errCode);
336     napi_create_string_utf8(env, codeStr.c_str(), codeStr.length(), &code);
337     napi_value msg = nullptr;
338     napi_create_string_utf8(env, errMsg.c_str(), errMsg.length(), &msg);
339     napi_value error = nullptr;
340     napi_create_error(env, code, msg, &error);
341     return error;
342 }
343 
HandleDeferred(const shared_ptr<CanvasAsyncCxt> & asyncCtx,ImageAnalyzerState state)344 void HandleDeferred(const shared_ptr<CanvasAsyncCxt>& asyncCtx, ImageAnalyzerState state)
345 {
346     auto env = asyncCtx->env;
347     CHECK_NULL_VOID(env);
348     auto deferred = asyncCtx->deferred;
349     CHECK_NULL_VOID(deferred);
350 
351     napi_handle_scope scope = nullptr;
352     auto status = napi_open_handle_scope(env, &scope);
353     if (status != napi_ok) {
354         return;
355     }
356 
357     napi_value result = nullptr;
358     switch (state) {
359         case ImageAnalyzerState::UNSUPPORTED:
360             result = CreateErrorValue(env, ERROR_CODE_AI_ANALYSIS_UNSUPPORTED);
361             napi_reject_deferred(env, deferred, result);
362             break;
363         case ImageAnalyzerState::ONGOING:
364             result = CreateErrorValue(env, ERROR_CODE_AI_ANALYSIS_IS_ONGOING);
365             napi_reject_deferred(env, deferred, result);
366             break;
367         case ImageAnalyzerState::STOPPED:
368             result = CreateErrorValue(env, ERROR_CODE_AI_ANALYSIS_IS_STOPPED);
369             napi_reject_deferred(env, deferred, result);
370             break;
371         case ImageAnalyzerState::FINISHED:
372             napi_get_null(env, &result);
373             napi_resolve_deferred(env, deferred, result);
374             break;
375         default:
376             break;
377     }
378     napi_close_handle_scope(env, scope);
379 }
380 
ReturnPromise(const JSCallbackInfo & info,napi_value result)381 void ReturnPromise(const JSCallbackInfo& info, napi_value result)
382 {
383     CHECK_NULL_VOID(result);
384     auto jsPromise = JsConverter::ConvertNapiValueToJsVal(result);
385     if (!jsPromise->IsObject()) {
386         return;
387     }
388     info.SetReturnValue(JSRef<JSObject>::Cast(jsPromise));
389 }
390 
JsStartImageAnalyzer(const JSCallbackInfo & info)391 void JSRenderingContext::JsStartImageAnalyzer(const JSCallbackInfo& info)
392 {
393     ContainerScope scope(instanceId_);
394     auto engine = EngineHelper::GetCurrentEngine();
395     CHECK_NULL_VOID(engine);
396     NativeEngine* nativeEngine = engine->GetNativeEngine();
397     auto env = reinterpret_cast<napi_env>(nativeEngine);
398 
399     auto asyncCtx = std::make_shared<CanvasAsyncCxt>();
400     asyncCtx->env = env;
401     napi_value promise = nullptr;
402     napi_create_promise(env, &asyncCtx->deferred, &promise);
403     if (info.Length() < 1 || !info[0]->IsObject()) {
404         ReturnPromise(info, promise);
405         return;
406     }
407 
408     ScopeRAII scopeRaii(env);
409     panda::Local<JsiValue> value = info[0].Get().GetLocalHandle();
410     JSValueWrapper valueWrapper = value;
411     napi_value configNativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
412     if (isImageAnalyzing_) {
413         napi_value result = CreateErrorValue(env, ERROR_CODE_AI_ANALYSIS_IS_ONGOING);
414         napi_reject_deferred(env, asyncCtx->deferred, result);
415         ReturnPromise(info, promise);
416         return;
417     }
418 
419     OnAnalyzedCallback onAnalyzed_ = [asyncCtx, weakCtx = WeakClaim(this)](ImageAnalyzerState state) {
420         CHECK_NULL_VOID(asyncCtx);
421         HandleDeferred(asyncCtx, state);
422         auto ctx = weakCtx.Upgrade();
423         CHECK_NULL_VOID(ctx);
424         ctx->isImageAnalyzing_ = false;
425     };
426     isImageAnalyzing_ = true;
427     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
428     CHECK_NULL_VOID(canvasRenderingContext2DModel);
429     canvasRenderingContext2DModel->StartImageAnalyzer(configNativeValue, onAnalyzed_);
430     ReturnPromise(info, promise);
431 }
432 
JsStopImageAnalyzer(const JSCallbackInfo & info)433 void JSRenderingContext::JsStopImageAnalyzer(const JSCallbackInfo& info)
434 {
435     ContainerScope scope(instanceId_);
436     auto canvasRenderingContext2DModel = AceType::DynamicCast<CanvasRenderingContext2DModel>(renderingContext2DModel_);
437     CHECK_NULL_VOID(canvasRenderingContext2DModel);
438     canvasRenderingContext2DModel->StopImageAnalyzer();
439 }
440 
FindCbList(napi_env env,napi_value cb,CanvasCallbackFuncPairList & callbackFuncPairList)441 CanvasCallbackFuncPairList::const_iterator JSRenderingContext::FindCbList(
442     napi_env env, napi_value cb, CanvasCallbackFuncPairList& callbackFuncPairList)
443 {
444     return std::find_if(callbackFuncPairList.begin(), callbackFuncPairList.end(), [env, cb](const auto& item) -> bool {
445         bool result = false;
446         napi_value refItem;
447         napi_get_reference_value(env, item.first, &refItem);
448         napi_strict_equals(env, refItem, cb, &result);
449         return result;
450     });
451 }
452 
AddCallbackToList(napi_env env,napi_value cb,CanvasCallbackType type,const std::function<void ()> && onFunc)453 void JSRenderingContext::AddCallbackToList(
454     napi_env env, napi_value cb, CanvasCallbackType type, const std::function<void()>&& onFunc)
455 {
456     if (type == CanvasCallbackType::ON_ATTACH) {
457         auto iter = FindCbList(env, cb, attachCallback_);
458         if (iter == attachCallback_.end()) {
459             napi_ref ref = nullptr;
460             napi_create_reference(env, cb, 1, &ref);
461             attachCallback_.emplace_back(ref, onFunc);
462         }
463     } else if (type == CanvasCallbackType::ON_DETACH) {
464         auto iter = FindCbList(env, cb, detachCallback_);
465         if (iter == detachCallback_.end()) {
466             napi_ref ref = nullptr;
467             napi_create_reference(env, cb, 1, &ref);
468             detachCallback_.emplace_back(ref, onFunc);
469         }
470     }
471 }
472 
DeleteCallbackFromList(int argc,napi_env env,napi_value cb,CanvasCallbackType type)473 void JSRenderingContext::DeleteCallbackFromList(int argc, napi_env env, napi_value cb, CanvasCallbackType type)
474 {
475     if (argc == 1) {
476         if (type == CanvasCallbackType::ON_ATTACH) {
477             for (const auto& item : attachCallback_) {
478                 napi_delete_reference(env, item.first);
479             }
480             attachCallback_.clear();
481         } else if (type == CanvasCallbackType::ON_DETACH) {
482             for (const auto& item : detachCallback_) {
483                 napi_delete_reference(env, item.first);
484             }
485             detachCallback_.clear();
486         }
487     } else if (argc == 2) { // The count of params is 2.
488         if (type == CanvasCallbackType::ON_ATTACH) {
489             auto iter = FindCbList(env, cb, attachCallback_);
490             if (iter != attachCallback_.end()) {
491                 napi_delete_reference(env, iter->first);
492                 attachCallback_.erase(iter);
493             }
494         } else if (type == CanvasCallbackType::ON_DETACH) {
495             auto iter = FindCbList(env, cb, detachCallback_);
496             if (iter != detachCallback_.end()) {
497                 napi_delete_reference(env, iter->first);
498                 detachCallback_.erase(iter);
499             }
500         }
501     }
502 }
503 
GetCanvasCallbackType(const std::string & strType)504 CanvasCallbackType JSRenderingContext::GetCanvasCallbackType(const std::string& strType)
505 {
506     CanvasCallbackType type = CanvasCallbackType::UNKNOWN;
507     static constexpr char attachType[] = "onAttach";
508     static constexpr char detachType[] = "onDetach";
509     if (strType.compare(attachType) == 0) {
510         type = CanvasCallbackType::ON_ATTACH;
511     } else if (strType.compare(detachType) == 0) {
512         type = CanvasCallbackType::ON_DETACH;
513     }
514     return type;
515 }
516 
JsOn(const JSCallbackInfo & info)517 void JSRenderingContext::JsOn(const JSCallbackInfo& info)
518 {
519     if (!info[0]->IsString() || !info[1]->IsFunction()) {
520         return;
521     }
522     const CanvasCallbackType type = GetCanvasCallbackType(info[0]->ToString());
523     if (type == CanvasCallbackType::UNKNOWN) {
524         JSException::Throw(ERROR_CODE_PARAM_INVALID, "%s", "Input parameter error.");
525         return;
526     }
527     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(info[1]));
528     std::function<void()> onFunc = [execCtx = info.GetExecutionContext(), func = std::move(jsFunc),
529                                        id = instanceId_]() {
530         ContainerScope scope(id);
531         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
532         func->Execute();
533     };
534     ContainerScope scope(instanceId_);
535 #if !defined(PREVIEW)
536     auto engine = std::static_pointer_cast<ArkJSRuntime>(JsiDeclarativeEngineInstance::GetCurrentRuntime());
537 #else
538     auto engine = EngineHelper::GetCurrentEngineSafely();
539 #endif
540     CHECK_NULL_VOID(engine);
541     NativeEngine* nativeEngine = engine->GetNativeEngine();
542     CHECK_NULL_VOID(nativeEngine);
543     auto env = reinterpret_cast<napi_env>(nativeEngine);
544     ScopeRAII scopeNapi(env);
545     panda::Local<JsiValue> value = info[1].Get().GetLocalHandle();
546     JSValueWrapper valueWrapper = value;
547     napi_value cb = nativeEngine->ValueToNapiValue(valueWrapper);
548     napi_handle_scope napiScope = nullptr;
549     napi_open_handle_scope(env, &napiScope);
550     CHECK_NULL_VOID(napiScope);
551 
552     AddCallbackToList(env, cb, type, std::move(onFunc));
553     napi_close_handle_scope(env, napiScope);
554 }
555 
JsOff(const JSCallbackInfo & info)556 void JSRenderingContext::JsOff(const JSCallbackInfo& info)
557 {
558     if (!info[0]->IsString()) {
559         return;
560     }
561     const CanvasCallbackType type = GetCanvasCallbackType(info[0]->ToString());
562     if (type == CanvasCallbackType::UNKNOWN) {
563         JSException::Throw(ERROR_CODE_PARAM_INVALID, "%s", "Input parameter error.");
564         return;
565     }
566     ContainerScope scope(instanceId_);
567 #if !defined(PREVIEW)
568     auto engine = std::static_pointer_cast<ArkJSRuntime>(JsiDeclarativeEngineInstance::GetCurrentRuntime());
569 #else
570     auto engine = EngineHelper::GetCurrentEngineSafely();
571 #endif
572     CHECK_NULL_VOID(engine);
573     NativeEngine* nativeEngine = engine->GetNativeEngine();
574     CHECK_NULL_VOID(nativeEngine);
575     auto env = reinterpret_cast<napi_env>(nativeEngine);
576     ScopeRAII scopeNapi(env);
577     napi_value cb = nullptr;
578     if (info[1]->IsFunction()) {
579         panda::Local<JsiValue> value = info[1].Get().GetLocalHandle();
580         JSValueWrapper valueWrapper = value;
581         cb = nativeEngine->ValueToNapiValue(valueWrapper);
582     }
583 
584     DeleteCallbackFromList(info.Length(), env, cb, type);
585 }
586 } // namespace OHOS::Ace::Framework
587