1 /*
2  * Copyright (c) 2021-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 
16 #ifndef FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_FUNCTION_H
17 #define FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_FUNCTION_H
18 
19 #include <functional>
20 
21 #include "base/memory/ace_type.h"
22 #include "base/utils/macros.h"
23 #include "bridge/declarative_frontend/engine/js_types.h"
24 #include "frameworks/bridge/declarative_frontend/engine/bindings.h"
25 #include "frameworks/bridge/declarative_frontend/engine/js_execution_scope_defines.h"
26 #include "frameworks/bridge/declarative_frontend/engine/js_ref_ptr.h"
27 #if defined(XCOMPONENT_SUPPORTED)
28 #include "frameworks/bridge/declarative_frontend/jsview/js_xcomponent_controller.h"
29 #endif
30 
31 namespace OHOS::Ace::Framework {
32 
33 class ACE_EXPORT JsFunctionBase : public virtual AceType {
34     DECLARE_ACE_TYPE(JsFunctionBase, AceType);
35 
36 public:
Execute()37     virtual void Execute()
38     {
39         ExecuteJS();
40     }
41 
42     void Execute(const JSRef<JSObject>& jsParamsObject);
43     void Execute(const std::vector<std::string>& keys, const std::string& param);
44     void ExecuteNew(const std::vector<std::string>& keys, const std::string& param);
45 
ExecuteJS(int argc)46     virtual JSRef<JSVal> ExecuteJS(int argc)
47     {
48         return ExecuteJS(argc, nullptr);
49     }
ExecuteJS(JSRef<JSVal> * argv)50     virtual JSRef<JSVal> ExecuteJS(JSRef<JSVal>* argv)
51     {
52         return ExecuteJS(0, argv);
53     }
ExecuteJS()54     virtual JSRef<JSVal> ExecuteJS()
55     {
56         return ExecuteJS(0, nullptr);
57     }
58     // Empty realization in JsFunctionBase
ExecuteJS(int argc,JSRef<JSVal> * argv)59     virtual JSRef<JSVal> ExecuteJS(int argc, JSRef<JSVal>* argv)
60     {
61         JSRef<JSObject> eventInfo = JSRef<JSObject>::New();
62         return JSRef<JSVal>::Cast(eventInfo);
63     }
64 
65 protected:
66     JSWeak<JSVal> jsThis_;
67 
68 private:
69     void ExecuteInternal(const std::unique_ptr<JsonValue>& value, const std::string& key,
70     const JSRef<JSObject>& eventInfo);
71 };
72 
73 class ACE_EXPORT JsFunction : public virtual JsFunctionBase {
74     DECLARE_ACE_TYPE(JsFunction, JsFunctionBase);
75 
76 public:
77     explicit JsFunction(const JSRef<JSFunc>& jsFunction);
78     JsFunction(const JSRef<JSObject>& jsObject, const JSRef<JSFunc>& jsFunction);
79     ~JsFunction() override;
80 
ExecuteJS(int argc)81     JSRef<JSVal> ExecuteJS(int argc) override
82     {
83         return ExecuteJS(argc, nullptr);
84     }
ExecuteJS(JSRef<JSVal> * argv)85     JSRef<JSVal> ExecuteJS(JSRef<JSVal>* argv) override
86     {
87         return ExecuteJS(0, argv);
88     }
ExecuteJS()89     JSRef<JSVal> ExecuteJS() override
90     {
91         return ExecuteJS(0, nullptr);
92     }
93     JSRef<JSVal> ExecuteJS(int argc, JSRef<JSVal>* argv) override;
94 
95 protected:
96     JSRef<JSFunc> jsFunction_;
97 };
98 
99 class ACE_EXPORT JsWeakFunction : public virtual JsFunctionBase {
100     DECLARE_ACE_TYPE(JsWeakFunction, JsFunctionBase);
101 
102 public:
103     explicit JsWeakFunction(const JSRef<JSFunc>& jsFunction);
104     JsWeakFunction(const JSRef<JSObject>& jsObject, const JSRef<JSFunc>& jsFunction);
105     ~JsWeakFunction() override = default;
106 
ExecuteJS(int argc)107     JSRef<JSVal> ExecuteJS(int argc) override
108     {
109         return ExecuteJS(argc, nullptr);
110     }
ExecuteJS(JSRef<JSVal> * argv)111     JSRef<JSVal> ExecuteJS(JSRef<JSVal>* argv) override
112     {
113         return ExecuteJS(0, argv);
114     }
ExecuteJS()115     JSRef<JSVal> ExecuteJS() override
116     {
117         return ExecuteJS(0, nullptr);
118     }
119     JSRef<JSVal> ExecuteJS(int argc, JSRef<JSVal>* argv) override;
120 
121 protected:
122     JSWeak<JSFunc> jsWeakFunction_;
123 };
124 
125 template<class T, int32_t ARGC = 0>
126 class ACE_EXPORT JsCitedEventFunction : public JsFunction {
127     DECLARE_ACE_TYPE(JsCitedEventFunction, JsFunction);
128 
129 public:
130     using ParseFunc = std::function<JSRef<JSVal>(T&)>;
131     JsCitedEventFunction() = delete;
JsCitedEventFunction(const JSRef<JSFunc> & jsFunction,ParseFunc parser)132     JsCitedEventFunction(const JSRef<JSFunc>& jsFunction, ParseFunc parser)
133         : JsFunction(JSRef<JSObject>(), jsFunction), parser_(parser)
134     {}
135     ~JsCitedEventFunction() override = default;
136 
Execute()137     void Execute() override
138     {
139         JsFunction::ExecuteJS();
140     }
141 
Execute(T & eventInfo)142     void Execute(T& eventInfo)
143     {
144         JSRef<JSVal> param;
145         if (parser_) {
146             param = parser_(eventInfo);
147         }
148         JsFunction::ExecuteJS(ARGC, &param);
149     }
150 
Execute(const std::string & val,T & eventInfo)151     void Execute(const std::string& val, T& eventInfo)
152     {
153         JSRef<JSVal> jsVal = JSRef<JSVal>::Make(ToJSValue(val));
154         JSRef<JSVal> itemInfo;
155         if (parser_) {
156             itemInfo = parser_(eventInfo);
157         }
158         JSRef<JSVal> params[] = { jsVal, itemInfo };
159         JsFunction::ExecuteJS(ARGC, params);
160     }
161 
162 private:
163     ParseFunc parser_;
164 };
165 
166 template<class T, int32_t ARGC = 0>
167 class ACE_EXPORT JsCommonEventFunction : public JsFunction {
168     DECLARE_ACE_TYPE(JsCommonEventFunction, JsFunction);
169 
170 public:
171     JsCommonEventFunction() = delete;
JsCommonEventFunction(const JSRef<JSFunc> & jsFunction)172     JsCommonEventFunction(const JSRef<JSFunc>& jsFunction)
173         : JsFunction(JSRef<JSObject>(), jsFunction)
174     {}
175     ~JsCommonEventFunction() override = default;
176 
Execute()177     void Execute() override
178     {
179         JsFunction::ExecuteJS();
180     }
181 
Execute(JSRef<JSVal> * argv)182     void Execute(JSRef<JSVal>* argv)
183     {
184         JsFunction::ExecuteJS(ARGC, argv);
185     }
186 };
187 
188 template<class T, int32_t ARGC = 0>
189 class ACE_EXPORT JsEventFunction : public JsFunction {
190     DECLARE_ACE_TYPE(JsEventFunction, JsFunction);
191 
192 public:
193     using ParseFunc = std::function<JSRef<JSVal>(const T&)>;
194     JsEventFunction() = delete;
JsEventFunction(const JSRef<JSFunc> & jsFunction,ParseFunc parser)195     JsEventFunction(const JSRef<JSFunc>& jsFunction, ParseFunc parser)
196         : JsFunction(JSRef<JSObject>(), jsFunction), parser_(parser)
197     {}
198     ~JsEventFunction() override = default;
199 
Execute()200     void Execute() override
201     {
202         JsFunction::ExecuteJS();
203     }
204 
Execute(const T & eventInfo)205     void Execute(const T& eventInfo)
206     {
207         JSRef<JSVal> param;
208         if (parser_) {
209             param = parser_(eventInfo);
210         }
211         JsFunction::ExecuteJS(ARGC, &param);
212     }
213 
ExecuteWithValue(const T & eventInfo)214     JSRef<JSVal> ExecuteWithValue(const T& eventInfo)
215     {
216         JSRef<JSVal> param;
217         if (parser_) {
218             param = parser_(eventInfo);
219         }
220         return JsFunction::ExecuteJS(ARGC, &param);
221     }
222 
223 private:
224     ParseFunc parser_;
225 };
226 
227 JSRef<JSObject> CreateEventTargetObject(const BaseEventInfo& info);
228 
229 } // namespace OHOS::Ace::Framework
230 
231 #endif // FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_FUNCTION_H
232