1 /*
2  * Copyright (c) 2021-2022 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_lazy_foreach.h"
17 
18 #include <functional>
19 #include <set>
20 #include <string>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/memory/referenced.h"
24 #include "base/utils/utils.h"
25 #include "bridge/common/utils/utils.h"
26 #include "bridge/declarative_frontend/engine/js_object_template.h"
27 #include "bridge/declarative_frontend/jsview/js_lazy_foreach_actuator.h"
28 #include "bridge/declarative_frontend/jsview/js_lazy_foreach_builder.h"
29 #ifndef NG_BUILD
30 #include "bridge/declarative_frontend/jsview/js_lazy_foreach_component.h"
31 #endif
32 #include "bridge/declarative_frontend/jsview/js_view.h"
33 #include "bridge/declarative_frontend/jsview/js_view_common_def.h"
34 #include "bridge/declarative_frontend/jsview/models/lazy_for_each_model_impl.h"
35 #include "bridge/declarative_frontend/view_stack_processor.h"
36 #include "core/common/container.h"
37 #include "core/common/container_scope.h"
38 #include "core/components_ng/base/view_stack_model.h"
39 #include "core/components_ng/syntax/lazy_for_each_model.h"
40 #include "core/components_ng/syntax/lazy_for_each_model_ng.h"
41 
42 namespace OHOS::Ace {
GetInstance()43 LazyForEachModel* LazyForEachModel::GetInstance()
44 {
45 #ifdef NG_BUILD
46     static NG::LazyForEachModelNG instance;
47     return &instance;
48 #else
49     if (Container::IsCurrentUseNewPipeline()) {
50         static NG::LazyForEachModelNG instance;
51         return &instance;
52     } else {
53         static Framework::LazyForEachModelImpl instance;
54         return &instance;
55     }
56 #endif
57 }
58 } // namespace OHOS::Ace
59 
60 namespace OHOS::Ace::Framework {
61 
JSBind(BindingTarget globalObj)62 void JSDataChangeListener::JSBind(BindingTarget globalObj)
63 {
64     JSClass<JSDataChangeListener>::Declare("__ohos_ace_inner_JSDataChangeListener__");
65     // API7 onEditChanged deprecated
66     JSClass<JSDataChangeListener>::CustomMethod("onDataReloaded", &JSDataChangeListener::OnDataReloaded);
67     JSClass<JSDataChangeListener>::CustomMethod("onDataReload", &JSDataChangeListener::OnDataReloaded);
68     // API7 onDataAdded deprecated
69     JSClass<JSDataChangeListener>::CustomMethod("onDataAdded", &JSDataChangeListener::OnDataAdded);
70     JSClass<JSDataChangeListener>::CustomMethod("onDataAdd", &JSDataChangeListener::OnDataAdded);
71     // API7 onDataDeleted deprecated
72     JSClass<JSDataChangeListener>::CustomMethod("onDataDeleted", &JSDataChangeListener::OnDataDeleted);
73     JSClass<JSDataChangeListener>::CustomMethod("onDataDelete", &JSDataChangeListener::OnDataDeleted);
74     // API7 onDataChanged deprecated
75     JSClass<JSDataChangeListener>::CustomMethod("onDataChanged", &JSDataChangeListener::OnDataChanged);
76     JSClass<JSDataChangeListener>::CustomMethod("onDataChange", &JSDataChangeListener::OnDataChanged);
77     // API7 onDataMoved deprecated
78     JSClass<JSDataChangeListener>::CustomMethod("onDataMoved", &JSDataChangeListener::OnDataMoved);
79     JSClass<JSDataChangeListener>::CustomMethod("onDataMove", &JSDataChangeListener::OnDataMoved);
80     // temporary interface
81     JSClass<JSDataChangeListener>::CustomMethod("onDataBulkAdded", &JSDataChangeListener::OnDataBulkAdded);
82     JSClass<JSDataChangeListener>::CustomMethod("onDataBulkAdd", &JSDataChangeListener::OnDataBulkAdded);
83     JSClass<JSDataChangeListener>::CustomMethod("onDataBulkDeleted", &JSDataChangeListener::OnDataBulkDeleted);
84     JSClass<JSDataChangeListener>::CustomMethod("onDataBulkDelete", &JSDataChangeListener::OnDataBulkDeleted);
85     // API12 onDatasetChange
86     JSClass<JSDataChangeListener>::CustomMethod("onDatasetChange", &JSDataChangeListener::OnDatasetChange);
87     JSClass<JSDataChangeListener>::Bind(
88         globalObj, &JSDataChangeListener::Constructor, &JSDataChangeListener::Destructor);
89 }
90 
CreateActuator(const std::string & viewId)91 RefPtr<JSLazyForEachActuator> CreateActuator(const std::string& viewId)
92 {
93 #ifdef NG_BUILD
94     return AceType::MakeRefPtr<JSLazyForEachBuilder>();
95 #else
96     if (Container::IsCurrentUseNewPipeline()) {
97         return AceType::MakeRefPtr<JSLazyForEachBuilder>();
98     } else {
99         return AceType::MakeRefPtr<JSLazyForEachComponent>(viewId);
100     }
101 #endif
102 }
103 
104 namespace {
105 
106 enum {
107     PARAM_VIEW_ID = 0,
108     PARAM_PARENT_VIEW,
109     PARAM_DATA_SOURCE,
110     PARAM_ITEM_GENERATOR,
111     PARAM_KEY_GENERATOR,
112     PARAM_UPDATE_CHANGEDNODE,
113 
114     MIN_PARAM_SIZE = PARAM_KEY_GENERATOR,
115     MAX_PARAM_SIZE = 6,
116 };
117 
ParseAndVerifyParams(const JSCallbackInfo & info,JSRef<JSVal> (& params)[MAX_PARAM_SIZE])118 bool ParseAndVerifyParams(const JSCallbackInfo& info, JSRef<JSVal> (&params)[MAX_PARAM_SIZE])
119 {
120     if (info.Length() < MIN_PARAM_SIZE) {
121         return false;
122     }
123 
124     if (!info[PARAM_VIEW_ID]->IsNumber() && !info[PARAM_VIEW_ID]->IsString()) {
125         return false;
126     }
127     if (!info[PARAM_PARENT_VIEW]->IsObject()) {
128         return false;
129     }
130     if (!info[PARAM_DATA_SOURCE]->IsObject()) {
131         return false;
132     }
133     if (!info[PARAM_ITEM_GENERATOR]->IsFunction()) {
134         return false;
135     }
136     if (info.Length() > MIN_PARAM_SIZE &&
137         !(info[PARAM_KEY_GENERATOR]->IsFunction() || info[PARAM_KEY_GENERATOR]->IsUndefined())) {
138         return false;
139     }
140     if (info.Length() > MIN_PARAM_SIZE + 1 && !info[PARAM_UPDATE_CHANGEDNODE]->IsBoolean()) {
141         return false;
142     }
143 
144     for (int32_t idx = PARAM_VIEW_ID; idx < std::min(info.Length(), static_cast<int32_t>(MAX_PARAM_SIZE)); ++idx) {
145         params[idx] = info[idx];
146     }
147     return true;
148 }
149 
150 } // namespace
151 
JSBind(BindingTarget globalObj)152 void JSLazyForEach::JSBind(BindingTarget globalObj)
153 {
154     JSClass<JSLazyForEach>::Declare("LazyForEach");
155     JSClass<JSLazyForEach>::StaticMethod("create", &JSLazyForEach::Create);
156     JSClass<JSLazyForEach>::StaticMethod("createInternal", &JSLazyForEach::Create);
157     JSClass<JSLazyForEach>::StaticMethod("pop", &JSLazyForEach::Pop);
158     JSClass<JSLazyForEach>::StaticMethod("onMove", &JSLazyForEach::OnMove);
159     JSClass<JSLazyForEach>::Bind(globalObj);
160 
161     JSDataChangeListener::JSBind(globalObj);
162 }
163 
Create(const JSCallbackInfo & info)164 void JSLazyForEach::Create(const JSCallbackInfo& info)
165 {
166     JSRef<JSVal> params[MAX_PARAM_SIZE];
167     if (!ParseAndVerifyParams(info, params)) {
168         TAG_LOGW(AceLogTag::ACE_LAZY_FOREACH, "Invalid arguments for LazyForEach");
169         return;
170     }
171     if (!params[PARAM_PARENT_VIEW]->IsObject() || !params[PARAM_DATA_SOURCE]->IsObject()
172         || !params[PARAM_ITEM_GENERATOR]->IsFunction()) {
173             return;
174     }
175     if (!params[PARAM_VIEW_ID]->IsString()) {
176         return;
177     }
178     std::string viewId = ViewStackModel::GetInstance()->ProcessViewId(params[PARAM_VIEW_ID]->ToString());
179 
180     JSRef<JSObject> parentViewObj = JSRef<JSObject>::Cast(params[PARAM_PARENT_VIEW]);
181 
182     // LazyForEach is not in observeComponentCreation, mark isDeleting_ here
183     JSRef<JSVal> isDeleting = parentViewObj->GetProperty("isDeleting_");
184     if (isDeleting->IsBoolean() && isDeleting->ToBoolean()) {
185         return;
186     }
187 
188     JSRef<JSObject> dataSourceObj = JSRef<JSObject>::Cast(params[PARAM_DATA_SOURCE]);
189     JSRef<JSFunc> itemGenerator = JSRef<JSFunc>::Cast(params[PARAM_ITEM_GENERATOR]);
190     ItemKeyGenerator keyGenFunc;
191     bool updateChangedNodeFlag = false;
192 
193     if (params[PARAM_KEY_GENERATOR]->IsUndefined()) {
194         keyGenFunc = [viewId](const JSRef<JSVal>&, size_t index) { return viewId + "-" + std::to_string(index); };
195     } else if (params[PARAM_KEY_GENERATOR]->IsFunction()) {
196         keyGenFunc = [viewId, keyGenerator = JSRef<JSFunc>::Cast(params[PARAM_KEY_GENERATOR])](
197                          const JSRef<JSVal>& jsVal, size_t index) {
198             JSRef<JSVal> params[] = { jsVal, JSRef<JSVal>::Make(ToJSValue(index)) };
199             auto key = keyGenerator->Call(JSRef<JSObject>(), ArraySize(params), params);
200             return viewId + "-" + (key->IsString() || key->IsNumber() ? key->ToString() : std::to_string(index));
201         };
202     }
203 
204     if (!params[PARAM_UPDATE_CHANGEDNODE]->IsUndefined()) {
205         updateChangedNodeFlag = params[PARAM_UPDATE_CHANGEDNODE]->ToBoolean();
206     }
207 
208     const auto& actuator = CreateActuator(viewId);
209     actuator->SetJSExecutionContext(info.GetExecutionContext());
210     actuator->SetParentViewObj(parentViewObj);
211     actuator->SetDataSourceObj(dataSourceObj);
212     actuator->SetItemGenerator(itemGenerator, std::move(keyGenFunc));
213     actuator->SetUpdateChangedNodeFlag(updateChangedNodeFlag);
214     LazyForEachModel::GetInstance()->Create(actuator);
215 }
216 
Pop()217 void JSLazyForEach::Pop()
218 {
219     auto* stack = NG::ViewStackProcessor::GetInstance();
220     if (stack->GetMainFrameNode() && stack->GetMainFrameNode()->GetTag() == V2::TABS_ETS_TAG) {
221         return;
222     }
223     ViewStackModel::GetInstance()->PopContainer();
224 }
225 
OnMove(const JSCallbackInfo & info)226 void JSLazyForEach::OnMove(const JSCallbackInfo& info)
227 {
228     if (info[0]->IsFunction()) {
229         auto onMove = [execCtx = info.GetExecutionContext(), func = JSRef<JSFunc>::Cast(info[0])]
230             (int32_t from, int32_t to) {
231                 auto params = ConvertToJSValues(from, to);
232                 func->Call(JSRef<JSObject>(), params.size(), params.data());
233             };
234         LazyForEachModel::GetInstance()->OnMove(std::move(onMove));
235     } else {
236         LazyForEachModel::GetInstance()->OnMove(nullptr);
237     }
238 }
239 } // namespace OHOS::Ace::Framework
240