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 #include "frameworks/bridge/declarative_frontend/jsview/js_refresh.h"
17 
18 #include <cstdint>
19 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
20 #include "interfaces/inner_api/ui_session/ui_session_manager.h"
21 #endif
22 
23 #include "base/log/ace_scoring_log.h"
24 #include "bridge/declarative_frontend/jsview/js_refresh.h"
25 #include "bridge/declarative_frontend/jsview/js_view_common_def.h"
26 #include "bridge/declarative_frontend/jsview/models/refresh_model_impl.h"
27 #include "core/components/refresh/refresh_theme.h"
28 #include "core/components_ng/base/view_stack_processor.h"
29 #include "core/components_ng/pattern/refresh/refresh_model_ng.h"
30 
31 namespace OHOS::Ace {
32 namespace {
33 constexpr int32_t DEFAULT_FRICTION = 62;
34 constexpr int32_t MAX_FRICTION = 100;
35 } // namespace
36 std::unique_ptr<RefreshModel> RefreshModel::instance_ = nullptr;
37 std::mutex RefreshModel::mutex_;
38 
GetInstance()39 RefreshModel* RefreshModel::GetInstance()
40 {
41     if (!instance_) {
42         std::lock_guard<std::mutex> lock(mutex_);
43         if (!instance_) {
44 #ifdef NG_BUILD
45             instance_.reset(new NG::RefreshModelNG());
46 #else
47             if (Container::IsCurrentUseNewPipeline()) {
48                 instance_.reset(new NG::RefreshModelNG());
49             } else {
50                 instance_.reset(new Framework::RefreshModelImpl());
51             }
52 #endif
53         }
54     }
55     return instance_.get();
56 }
57 
58 } // namespace OHOS::Ace
59 
60 namespace OHOS::Ace::Framework {
61 
ParseRefreshingObject(const JSCallbackInfo & info,const JSRef<JSObject> & refreshing)62 void ParseRefreshingObject(const JSCallbackInfo& info, const JSRef<JSObject>& refreshing)
63 {
64     JSRef<JSVal> changeEventVal = refreshing->GetProperty("changeEvent");
65     CHECK_NULL_VOID(changeEventVal->IsFunction());
66 
67     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(changeEventVal));
68     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
69     auto changeEvent = [execCtx = info.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
70                            const std::string& param) {
71         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
72         if (param != "true" && param != "false") {
73             return;
74         }
75         bool newValue = StringToBool(param);
76         ACE_SCORING_EVENT("Refresh.ChangeEvent");
77         PipelineContext::SetCallBackNode(node);
78         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(newValue));
79         func->ExecuteJS(1, &newJSVal);
80     };
81     RefreshModel::GetInstance()->SetChangeEvent(std::move(changeEvent));
82 }
83 
SetPullToRefresh(const JSCallbackInfo & info)84 void JSRefresh::SetPullToRefresh(const JSCallbackInfo& info)
85 {
86     bool pullToRefresh = true;
87     if (info[0]->IsBoolean()) {
88         pullToRefresh = info[0]->ToBoolean();
89     }
90     RefreshModel::GetInstance()->SetPullToRefresh(pullToRefresh);
91 }
92 
JSBind(BindingTarget globalObj)93 void JSRefresh::JSBind(BindingTarget globalObj)
94 {
95     JSClass<JSRefresh>::Declare("Refresh");
96     MethodOptions opt = MethodOptions::NONE;
97     JSClass<JSRefresh>::StaticMethod("create", &JSRefresh::Create, opt);
98     JSClass<JSRefresh>::StaticMethod("refreshOffset", &JSRefresh::JsRefreshOffset);
99     JSClass<JSRefresh>::StaticMethod("pullToRefresh", &JSRefresh::SetPullToRefresh, opt);
100     JSClass<JSRefresh>::StaticMethod("onStateChange", &JSRefresh::OnStateChange);
101     JSClass<JSRefresh>::StaticMethod("onRefreshing", &JSRefresh::OnRefreshing);
102     JSClass<JSRefresh>::StaticMethod("onOffsetChange", &JSRefresh::OnOffsetChange);
103     JSClass<JSRefresh>::StaticMethod("pullDownRatio", &JSRefresh::SetPullDownRatio);
104     JSClass<JSRefresh>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
105     JSClass<JSRefresh>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
106     JSClass<JSRefresh>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
107     JSClass<JSRefresh>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
108     JSClass<JSRefresh>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
109     JSClass<JSRefresh>::InheritAndBind<JSContainerBase>(globalObj);
110 }
111 
SetPullDownRatio(const JSCallbackInfo & info)112 void JSRefresh::SetPullDownRatio(const JSCallbackInfo& info)
113 {
114     if (info.Length() < 1) {
115         return;
116     }
117 
118     auto args = info[0];
119     std::optional<float> pulldownRatio = std::nullopt;
120     if (!args->IsNumber() || std::isnan(args->ToNumber<float>())) {
121         RefreshModel::GetInstance()->SetPullDownRatio(pulldownRatio);
122         return;
123     }
124     pulldownRatio = std::clamp(args->ToNumber<float>(), 0.f, 1.f);
125     RefreshModel::GetInstance()->SetPullDownRatio(pulldownRatio);
126 }
127 
JsRefreshOffset(const JSCallbackInfo & info)128 void JSRefresh::JsRefreshOffset(const JSCallbackInfo& info)
129 {
130     if (info.Length() < 1) {
131         return;
132     }
133     JsRefreshOffset(info[0]);
134 }
135 
JsRefreshOffset(const JSRef<JSVal> & jsVal)136 void JSRefresh::JsRefreshOffset(const JSRef<JSVal>& jsVal)
137 {
138     CalcDimension value(0.0f);
139     if (!ParseJsDimensionVpNG(jsVal, value)) {
140         value.SetValue(0.0f);
141     }
142     RefreshModel::GetInstance()->SetRefreshOffset(value);
143 }
144 
Create(const JSCallbackInfo & info)145 void JSRefresh::Create(const JSCallbackInfo& info)
146 {
147     if (!info[0]->IsObject()) {
148         return;
149     }
150     RefPtr<RefreshTheme> theme = GetTheme<RefreshTheme>();
151     if (!theme) {
152         return;
153     }
154     auto paramObject = JSRef<JSObject>::Cast(info[0]);
155     auto refreshing = paramObject->GetProperty("refreshing");
156     auto jsOffset = paramObject->GetProperty("offset");
157     auto friction = paramObject->GetProperty("friction");
158     auto promptText = paramObject->GetProperty("promptText");
159     RefreshModel::GetInstance()->Create();
160 
161     if (refreshing->IsBoolean()) {
162         RefreshModel::GetInstance()->SetRefreshing(refreshing->ToBoolean());
163     } else if (refreshing->IsObject()) {
164         JSRef<JSObject> refreshingObj = JSRef<JSObject>::Cast(refreshing);
165         ParseRefreshingObject(info, refreshingObj);
166         RefreshModel::GetInstance()->SetRefreshing(refreshingObj->GetProperty("value")->ToBoolean());
167     } else {
168         RefreshModel::GetInstance()->SetRefreshing(false);
169     }
170     CalcDimension offset;
171     if (ParseJsDimensionVp(jsOffset, offset)) {
172         if (LessNotEqual(offset.Value(), 0.0) || offset.Unit() == DimensionUnit::PERCENT) {
173             RefreshModel::GetInstance()->SetRefreshDistance(theme->GetRefreshDistance());
174         } else {
175             RefreshModel::GetInstance()->SetIndicatorOffset(offset);
176         }
177     }
178     ParsFrictionData(friction);
179     if (!ParseRefreshingContent(paramObject)) {
180         bool isCustomBuilderExist = ParseCustomBuilder(info);
181         RefreshModel::GetInstance()->SetIsCustomBuilderExist(isCustomBuilderExist);
182     }
183 
184     std::string loadingStr = "";
185     if (ParseJsString(promptText, loadingStr)) {
186         RefreshModel::GetInstance()->SetLoadingText(loadingStr);
187     } else {
188         RefreshModel::GetInstance()->ResetLoadingText();
189     }
190 }
191 
ParseRefreshingContent(const JSRef<JSObject> & paramObject)192 bool JSRefresh::ParseRefreshingContent(const JSRef<JSObject>& paramObject)
193 {
194     JSRef<JSVal> contentParam = paramObject->GetProperty("refreshingContent");
195     if (!contentParam->IsObject()) {
196         return false;
197     }
198     JSRef<JSObject> contentObject = JSRef<JSObject>::Cast(contentParam);
199     JSRef<JSVal> builderNodeParam = contentObject->GetProperty("builderNode_");
200     if (!builderNodeParam->IsObject()) {
201         return false;
202     }
203     JSRef<JSObject> builderNodeObject = JSRef<JSObject>::Cast(builderNodeParam);
204     JSRef<JSVal> nodeptr = builderNodeObject->GetProperty("nodePtr_");
205     if (nodeptr.IsEmpty()) {
206         return false;
207     }
208     const auto* vm = nodeptr->GetEcmaVM();
209     auto* node = nodeptr->GetLocalHandle()->ToNativePointer(vm)->Value();
210     auto* frameNode = reinterpret_cast<NG::FrameNode*>(node);
211     CHECK_NULL_RETURN(frameNode, false);
212     RefPtr<NG::FrameNode> refPtrFrameNode = AceType::Claim(frameNode);
213     RefreshModel::GetInstance()->SetCustomBuilder(refPtrFrameNode);
214     RefreshModel::GetInstance()->SetIsCustomBuilderExist(false);
215     return true;
216 }
217 
ParseCustomBuilder(const JSCallbackInfo & info)218 bool JSRefresh::ParseCustomBuilder(const JSCallbackInfo& info)
219 {
220     if (!info[0]->IsObject()) {
221         return false;
222     }
223     auto paramObject = JSRef<JSObject>::Cast(info[0]);
224     auto builder = paramObject->GetProperty("builder");
225     RefPtr<NG::UINode> customNode;
226     if (builder->IsFunction()) {
227         {
228             NG::ScopedViewStackProcessor builderViewStackProcessor;
229             JsFunction Jsfunc(info.This(), JSRef<JSFunc>::Cast(builder));
230             Jsfunc.Execute();
231             customNode = NG::ViewStackProcessor::GetInstance()->Finish();
232         }
233         RefreshModel::GetInstance()->SetCustomBuilder(customNode);
234         return true;
235     } else {
236         RefreshModel::GetInstance()->SetCustomBuilder(customNode);
237         return false;
238     }
239 }
240 
OnStateChange(const JSCallbackInfo & args)241 void JSRefresh::OnStateChange(const JSCallbackInfo& args)
242 {
243     if (!args[0]->IsFunction()) {
244         return;
245     }
246     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
247     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
248     auto onStateChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
249                              const int32_t& value) {
250         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
251         ACE_SCORING_EVENT("Refresh.OnStateChange");
252         PipelineContext::SetCallBackNode(node);
253         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(value));
254         func->ExecuteJS(1, &newJSVal);
255 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
256         UiSessionManager::GetInstance().ReportComponentChangeEvent("event", "Refresh.OnStateChange");
257 #endif
258     };
259     RefreshModel::GetInstance()->SetOnStateChange(std::move(onStateChange));
260 }
261 
OnRefreshing(const JSCallbackInfo & args)262 void JSRefresh::OnRefreshing(const JSCallbackInfo& args)
263 {
264     if (!args[0]->IsFunction()) {
265         return;
266     }
267     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
268     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
269     auto onRefreshing = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode]() {
270         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
271         ACE_SCORING_EVENT("Refresh.OnRefreshing");
272         PipelineContext::SetCallBackNode(node);
273         auto newJSVal = JSRef<JSVal>::Make();
274         func->ExecuteJS(1, &newJSVal);
275     };
276     RefreshModel::GetInstance()->SetOnRefreshing(std::move(onRefreshing));
277 }
278 
OnOffsetChange(const JSCallbackInfo & args)279 void JSRefresh::OnOffsetChange(const JSCallbackInfo& args)
280 {
281     if (!args[0]->IsFunction()) {
282         RefreshModel::GetInstance()->ResetOnOffsetChange();
283         return;
284     }
285     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
286     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
287     auto offsetChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
288                                 const float& value) {
289         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
290         ACE_SCORING_EVENT("Refresh.OnOffsetChange");
291         PipelineContext::SetCallBackNode(node);
292         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(value));
293         func->ExecuteJS(1, &newJSVal);
294     };
295     RefreshModel::GetInstance()->SetOnOffsetChange(std::move(offsetChange));
296 }
297 
ParsFrictionData(const JsiRef<JsiValue> & friction)298 void JSRefresh::ParsFrictionData(const JsiRef<JsiValue>& friction)
299 {
300     int32_t frictionNumber = DEFAULT_FRICTION;
301     if (friction->IsString()) {
302         frictionNumber = StringUtils::StringToInt(friction->ToString());
303         if ((frictionNumber == 0 && friction->ToString() != "0") || frictionNumber < 0 ||
304             frictionNumber > MAX_FRICTION) {
305             frictionNumber = DEFAULT_FRICTION;
306         }
307     } else if (friction->IsNumber()) {
308         frictionNumber = friction->ToNumber<int32_t>();
309         if (frictionNumber < 0 || frictionNumber > MAX_FRICTION) {
310             frictionNumber = DEFAULT_FRICTION;
311         }
312     }
313     RefreshModel::GetInstance()->SetFriction(frictionNumber);
314 }
315 } // namespace OHOS::Ace::Framework
316