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 "bridge/declarative_frontend/jsview/canvas/js_canvas.h"
17 
18 #include "base/log/ace_scoring_log.h"
19 #include "bridge/common/utils/engine_helper.h"
20 #include "bridge/declarative_frontend/jsview/js_utils.h"
21 #include "bridge/declarative_frontend/jsview/canvas/js_rendering_context_base.h"
22 #include "bridge/declarative_frontend/jsview/models/canvas/canvas_model_impl.h"
23 #include "core/common/container.h"
24 #include "core/components_ng/base/view_stack_model.h"
25 #include "core/components_ng/base/view_stack_processor.h"
26 #include "core/components_ng/pattern/canvas/canvas_model_ng.h"
27 
28 namespace OHOS::Ace {
29 std::unique_ptr<CanvasModel> CanvasModel::instance_ = nullptr;
30 std::mutex CanvasModel::mutex_;
GetInstance()31 CanvasModel* CanvasModel::GetInstance()
32 {
33     if (!instance_) {
34         std::lock_guard<std::mutex> lock(mutex_);
35         if (!instance_) {
36 #ifdef NG_BUILD
37             instance_.reset(new NG::CanvasModelNG());
38 #else
39             if (Container::IsCurrentUseNewPipeline()) {
40                 instance_.reset(new NG::CanvasModelNG());
41             } else {
42                 instance_.reset(new Framework::CanvasModelImpl());
43             }
44 #endif
45         }
46     }
47     return instance_.get();
48 }
49 } // namespace OHOS::Ace
50 namespace OHOS::Ace::Framework {
51 
Create(const JSCallbackInfo & info)52 void JSCanvas::Create(const JSCallbackInfo& info)
53 {
54     auto pattern = CanvasModel::GetInstance()->Create();
55     CHECK_NULL_VOID(pattern);
56     if (info[0]->IsUndefined()) {
57         CanvasModel::GetInstance()->DetachRenderContext();
58     } else if (info[0]->IsObject()) {
59         JSRenderingContextBase* jsContext = JSRef<JSObject>::Cast(info[0])->Unwrap<JSRenderingContextBase>();
60         if (jsContext) {
61             jsContext->SetInstanceId(Container::CurrentId());
62             jsContext->SetCanvasPattern(pattern);
63             jsContext->SetAntiAlias();
64             jsContext->SetDensity();
65         }
66     }
67 
68     if (info.Length() > 1) {
69         auto options = info[1];
70         if (!options->IsObject()) {
71             return;
72         }
73         auto engine = EngineHelper::GetCurrentEngine();
74         CHECK_NULL_VOID(engine);
75         NativeEngine* nativeEngine = engine->GetNativeEngine();
76         CHECK_NULL_VOID(nativeEngine);
77         panda::Local<JsiValue> value = options.Get().GetLocalHandle();
78         JSValueWrapper valueWrapper = value;
79         ScopeRAII scope(reinterpret_cast<napi_env>(nativeEngine));
80         napi_value optionsValue = nativeEngine->ValueToNapiValue(valueWrapper);
81         CanvasModel::GetInstance()->SetImageAIOptions(optionsValue);
82     }
83 }
84 
JSBind(BindingTarget globalObj)85 void JSCanvas::JSBind(BindingTarget globalObj)
86 {
87     JSClass<JSCanvas>::Declare("Canvas");
88     MethodOptions opt = MethodOptions::NONE;
89     JSClass<JSCanvas>::StaticMethod("create", &JSCanvas::Create, opt);
90     JSClass<JSCanvas>::StaticMethod("onReady", &JSCanvas::OnReady);
91     JSClass<JSCanvas>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
92     JSClass<JSCanvas>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
93     JSClass<JSCanvas>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
94     JSClass<JSCanvas>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
95     JSClass<JSCanvas>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
96     JSClass<JSCanvas>::StaticMethod("onHover", &JSInteractableView::JsOnHover);
97     JSClass<JSCanvas>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
98     JSClass<JSCanvas>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
99     JSClass<JSCanvas>::StaticMethod("onClick", &JSInteractableView::JsOnClick);
100     JSClass<JSCanvas>::StaticMethod("enableAnalyzer", &JSCanvas::EnableAnalyzer);
101     JSClass<JSCanvas>::InheritAndBind<JSViewAbstract>(globalObj);
102 }
103 
OnReady(const JSCallbackInfo & info)104 void JSCanvas::OnReady(const JSCallbackInfo& info)
105 {
106     if (info.Length() < 1 || !info[0]->IsFunction()) {
107         return;
108     }
109 
110     RefPtr<JsFunction> jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(info[0]));
111     if (Container::IsCurrentUsePartialUpdate()) {
112         auto targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
113         auto readyEvent = [execCtx = info.GetExecutionContext(), func = std::move(jsFunc), node = targetNode]() {
114             JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
115             ACE_SCORING_EVENT("Canvas.onReady");
116             PipelineContext::SetCallBackNode(node);
117             func->Execute();
118         };
119         CanvasModel::GetInstance()->SetOnReady(std::move(readyEvent));
120     } else {
121         auto targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
122         auto readyEvent = [execCtx = info.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
123                               uint32_t accountableCanvasElement) {
124             JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
125             ACE_SCORING_EVENT("Canvas.onReady");
126             PipelineContext::SetCallBackNode(node);
127             func->Execute();
128         };
129         CanvasModel::GetInstance()->SetOnReady(std::move(readyEvent));
130     }
131 }
132 
EnableAnalyzer(bool enable)133 void JSCanvas::EnableAnalyzer(bool enable)
134 {
135     CanvasModel::GetInstance()->EnableAnalyzer(enable);
136 }
137 } // namespace OHOS::Ace::Framework
138