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     RefreshModel::GetInstance()->SetProgressColor(theme->GetProgressColor());
161 
162     if (refreshing->IsBoolean()) {
163         RefreshModel::GetInstance()->SetRefreshing(refreshing->ToBoolean());
164     } else if (refreshing->IsObject()) {
165         JSRef<JSObject> refreshingObj = JSRef<JSObject>::Cast(refreshing);
166         ParseRefreshingObject(info, refreshingObj);
167         RefreshModel::GetInstance()->SetRefreshing(refreshingObj->GetProperty("value")->ToBoolean());
168     } else {
169         RefreshModel::GetInstance()->SetRefreshing(false);
170     }
171     CalcDimension offset;
172     if (ParseJsDimensionVp(jsOffset, offset)) {
173         if (LessNotEqual(offset.Value(), 0.0) || offset.Unit() == DimensionUnit::PERCENT) {
174             RefreshModel::GetInstance()->SetRefreshDistance(theme->GetRefreshDistance());
175         } else {
176             RefreshModel::GetInstance()->SetIndicatorOffset(offset);
177         }
178     }
179     ParsFrictionData(friction);
180     if (!ParseRefreshingContent(paramObject)) {
181         bool isCustomBuilderExist = ParseCustomBuilder(info);
182         RefreshModel::GetInstance()->SetIsCustomBuilderExist(isCustomBuilderExist);
183     }
184 
185     std::string loadingStr = "";
186     if (ParseJsString(promptText, loadingStr)) {
187         RefreshModel::GetInstance()->SetLoadingText(loadingStr);
188     } else {
189         RefreshModel::GetInstance()->ResetLoadingText();
190     }
191 }
192 
ParseRefreshingContent(const JSRef<JSObject>& paramObject)193 bool JSRefresh::ParseRefreshingContent(const JSRef<JSObject>& paramObject)
194 {
195     JSRef<JSVal> contentParam = paramObject->GetProperty("refreshingContent");
196     if (!contentParam->IsObject()) {
197         return false;
198     }
199     JSRef<JSObject> contentObject = JSRef<JSObject>::Cast(contentParam);
200     JSRef<JSVal> builderNodeParam = contentObject->GetProperty("builderNode_");
201     if (!builderNodeParam->IsObject()) {
202         return false;
203     }
204     JSRef<JSObject> builderNodeObject = JSRef<JSObject>::Cast(builderNodeParam);
205     JSRef<JSVal> nodeptr = builderNodeObject->GetProperty("nodePtr_");
206     if (nodeptr.IsEmpty()) {
207         return false;
208     }
209     const auto* vm = nodeptr->GetEcmaVM();
210     auto* node = nodeptr->GetLocalHandle()->ToNativePointer(vm)->Value();
211     auto* frameNode = reinterpret_cast<NG::FrameNode*>(node);
212     CHECK_NULL_RETURN(frameNode, false);
213     RefPtr<NG::FrameNode> refPtrFrameNode = AceType::Claim(frameNode);
214     RefreshModel::GetInstance()->SetCustomBuilder(refPtrFrameNode);
215     RefreshModel::GetInstance()->SetIsCustomBuilderExist(false);
216     return true;
217 }
218 
ParseCustomBuilder(const JSCallbackInfo& info)219 bool JSRefresh::ParseCustomBuilder(const JSCallbackInfo& info)
220 {
221     if (!info[0]->IsObject()) {
222         return false;
223     }
224     auto paramObject = JSRef<JSObject>::Cast(info[0]);
225     auto builder = paramObject->GetProperty("builder");
226     RefPtr<NG::UINode> customNode;
227     if (builder->IsFunction()) {
228         {
229             NG::ScopedViewStackProcessor builderViewStackProcessor;
230             JsFunction Jsfunc(info.This(), JSRef<JSFunc>::Cast(builder));
231             Jsfunc.Execute();
232             customNode = NG::ViewStackProcessor::GetInstance()->Finish();
233         }
234         RefreshModel::GetInstance()->SetCustomBuilder(customNode);
235         return true;
236     } else {
237         RefreshModel::GetInstance()->SetCustomBuilder(customNode);
238         return false;
239     }
240 }
241 
OnStateChange(const JSCallbackInfo& args)242 void JSRefresh::OnStateChange(const JSCallbackInfo& args)
243 {
244     if (!args[0]->IsFunction()) {
245         return;
246     }
247     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
248     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
249     auto onStateChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
250                              const int32_t& value) {
251         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
252         ACE_SCORING_EVENT("Refresh.OnStateChange");
253         PipelineContext::SetCallBackNode(node);
254         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(value));
255         func->ExecuteJS(1, &newJSVal);
256 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
257         UiSessionManager::GetInstance().ReportComponentChangeEvent("event", "Refresh.OnStateChange");
258 #endif
259     };
260     RefreshModel::GetInstance()->SetOnStateChange(std::move(onStateChange));
261 }
262 
OnRefreshing(const JSCallbackInfo& args)263 void JSRefresh::OnRefreshing(const JSCallbackInfo& args)
264 {
265     if (!args[0]->IsFunction()) {
266         return;
267     }
268     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
269     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
270     auto onRefreshing = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode]() {
271         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
272         ACE_SCORING_EVENT("Refresh.OnRefreshing");
273         PipelineContext::SetCallBackNode(node);
274         auto newJSVal = JSRef<JSVal>::Make();
275         func->ExecuteJS(1, &newJSVal);
276     };
277     RefreshModel::GetInstance()->SetOnRefreshing(std::move(onRefreshing));
278 }
279 
OnOffsetChange(const JSCallbackInfo& args)280 void JSRefresh::OnOffsetChange(const JSCallbackInfo& args)
281 {
282     if (!args[0]->IsFunction()) {
283         RefreshModel::GetInstance()->ResetOnOffsetChange();
284         return;
285     }
286     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
287     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
288     auto offsetChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
289                                 const float& value) {
290         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
291         ACE_SCORING_EVENT("Refresh.OnOffsetChange");
292         PipelineContext::SetCallBackNode(node);
293         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(value));
294         func->ExecuteJS(1, &newJSVal);
295     };
296     RefreshModel::GetInstance()->SetOnOffsetChange(std::move(offsetChange));
297 }
298 
ParsFrictionData(const JsiRef<JsiValue>& friction)299 void JSRefresh::ParsFrictionData(const JsiRef<JsiValue>& friction)
300 {
301     int32_t frictionNumber = DEFAULT_FRICTION;
302     if (friction->IsString()) {
303         frictionNumber = StringUtils::StringToInt(friction->ToString());
304         if ((frictionNumber == 0 && friction->ToString() != "0") || frictionNumber < 0 ||
305             frictionNumber > MAX_FRICTION) {
306             frictionNumber = DEFAULT_FRICTION;
307         }
308     } else if (friction->IsNumber()) {
309         frictionNumber = friction->ToNumber<int32_t>();
310         if (frictionNumber < 0 || frictionNumber > MAX_FRICTION) {
311             frictionNumber = DEFAULT_FRICTION;
312         }
313     }
314     RefreshModel::GetInstance()->SetFriction(frictionNumber);
315 }
316 } // namespace OHOS::Ace::Framework
317