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 "bridge/declarative_frontend/jsview/js_pattern_lock.h"
17
18 #include "base/log/ace_trace.h"
19 #include "bridge/declarative_frontend/jsview/models/patternlock_model_impl.h"
20 #include "bridge/declarative_frontend/view_stack_processor.h"
21 #include "core/components_ng/pattern/patternlock/patternlock_model_ng.h"
22 #include "core/components_v2/pattern_lock/pattern_lock_component.h"
23
24 namespace OHOS::Ace {
25
26 std::unique_ptr<PatternLockModel> PatternLockModel::instance_ = nullptr;
27 std::mutex PatternLockModel::mutex_;
28 const std::vector<V2::PatternLockChallengeResult> CHALLENGE_RESULT = { V2::PatternLockChallengeResult::CORRECT,
29 V2::PatternLockChallengeResult::WRONG };
30
GetInstance()31 PatternLockModel* PatternLockModel::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::PatternLockModelNG());
38 #else
39 if (Container::IsCurrentUseNewPipeline()) {
40 instance_.reset(new NG::PatternLockModelNG());
41 } else {
42 instance_.reset(new Framework::PatternLockModelImpl());
43 }
44 #endif
45 }
46 }
47 return instance_.get();
48 }
49
50 } // namespace OHOS::Ace
51
52 namespace OHOS::Ace::Framework {
ChoosePointToJSValue(std::vector<int> input)53 JSRef<JSArray> JSPatternLock::ChoosePointToJSValue(std::vector<int> input)
54 {
55 JSRef<JSArray> arr = JSRef<JSArray>::New();
56 for (size_t i = 0; i < input.size(); i++) {
57 arr->SetValueAt(i, ConvertToJSValue(input[i]));
58 }
59 return arr;
60 }
Create(const JSCallbackInfo & info)61 void JSPatternLock::Create(const JSCallbackInfo& info)
62 {
63 auto controller = PatternLockModel::GetInstance()->Create();
64
65 if (info.Length() > 0 && info[0]->IsObject()) {
66 auto* jsController = JSRef<JSObject>::Cast(info[0])->Unwrap<JSPatternLockController>();
67 if (jsController) {
68 jsController->SetController(controller);
69 }
70 }
71 }
JSBind(BindingTarget globalObj)72 void JSPatternLock::JSBind(BindingTarget globalObj)
73 {
74 JSClass<JSPatternLock>::Declare("PatternLock");
75 MethodOptions opt = MethodOptions::NONE;
76 JSClass<JSPatternLock>::StaticMethod("create", &JSPatternLock::Create, opt);
77 JSClass<JSPatternLock>::StaticMethod("onPatternComplete", &JSPatternLock::SetPatternComplete);
78 JSClass<JSPatternLock>::StaticMethod("regularColor", &JSPatternLock::SetRegularColor, MethodOptions::NONE);
79 JSClass<JSPatternLock>::StaticMethod("selectedColor", &JSPatternLock::SetSelectedColor, MethodOptions::NONE);
80 JSClass<JSPatternLock>::StaticMethod("activeColor", &JSPatternLock::SetActiveColor, MethodOptions::NONE);
81 JSClass<JSPatternLock>::StaticMethod("pathColor", &JSPatternLock::SetPathColor, MethodOptions::NONE);
82 JSClass<JSPatternLock>::StaticMethod("pathStrokeWidth", &JSPatternLock::SetPathStrokeWidth);
83 JSClass<JSPatternLock>::StaticMethod("circleRadius", &JSPatternLock::SetCircleRadius, MethodOptions::NONE);
84 JSClass<JSPatternLock>::StaticMethod("sideLength", &JSPatternLock::SetSideLength, MethodOptions::NONE);
85 JSClass<JSPatternLock>::StaticMethod("autoReset", &JSPatternLock::SetAutoReset, MethodOptions::NONE);
86 JSClass<JSPatternLock>::StaticMethod("onDotConnected", &JSPatternLock::SetDotConnected);
87 JSClass<JSPatternLock>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
88 JSClass<JSPatternLock>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
89 JSClass<JSPatternLock>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
90 JSClass<JSPatternLock>::InheritAndBind<JSViewAbstract>(globalObj);
91 }
SetDefaultTheme(OHOS::Ace::RefPtr<OHOS::Ace::V2::PatternLockComponent> & patternLock)92 void JSPatternLock::SetDefaultTheme(OHOS::Ace::RefPtr<OHOS::Ace::V2::PatternLockComponent>& patternLock)
93 {
94 auto lockTheme = GetTheme<V2::PatternLockTheme>();
95 if (!lockTheme) {
96 LOGE("Get PatternLock theme error");
97 return;
98 }
99 patternLock->SetRegularColor(lockTheme->GetRegularColor());
100 patternLock->SetSelectedColor(lockTheme->GetSelectedColor());
101 patternLock->SetActiveColor(lockTheme->GetActiveColor());
102 patternLock->SetPathColor(lockTheme->GetPathColor());
103 }
104
SetPatternComplete(const JSCallbackInfo & args)105 void JSPatternLock::SetPatternComplete(const JSCallbackInfo& args)
106 {
107 if (!args[0]->IsFunction()) {
108 return;
109 }
110
111 auto onComplete = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])](
112 const BaseEventInfo* event) {
113 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
114 const auto* eventInfo = TypeInfoHelper::DynamicCast<V2::PatternCompleteEvent>(event);
115 CHECK_NULL_VOID(eventInfo);
116 JSRef<JSVal> params[] = { ChoosePointToJSValue(eventInfo->GetInput()) };
117 func->Call(JSRef<JSObject>(), ArraySize(params), params);
118 };
119
120 PatternLockModel::GetInstance()->SetPatternComplete(std::move(onComplete));
121 }
SetSelectedColor(const JSCallbackInfo & info)122 void JSPatternLock::SetSelectedColor(const JSCallbackInfo& info)
123 {
124 if (info.Length() < 1) {
125 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
126 return;
127 }
128 Color selectedColor;
129 if (!ParseJsColor(info[0], selectedColor)) {
130 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
131 CHECK_NULL_VOID(patternLockTheme);
132 selectedColor = patternLockTheme->GetSelectedColor();
133 }
134
135 PatternLockModel::GetInstance()->SetSelectedColor(selectedColor);
136 }
SetAutoReset(const JSCallbackInfo & info)137 void JSPatternLock::SetAutoReset(const JSCallbackInfo& info)
138 {
139 if (info.Length() < 1) {
140 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
141 return;
142 }
143 if (!info[0]->IsBoolean()) {
144 LOGE("arg is not bool.");
145 PatternLockModel::GetInstance()->SetAutoReset(true);
146 return;
147 }
148 PatternLockModel::GetInstance()->SetAutoReset(info[0]->ToBoolean());
149 }
150
SetPathColor(const JSCallbackInfo & info)151 void JSPatternLock::SetPathColor(const JSCallbackInfo& info)
152 {
153 if (info.Length() < 1) {
154 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
155 return;
156 }
157 Color pathColor;
158 if (!ParseJsColor(info[0], pathColor)) {
159 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
160 CHECK_NULL_VOID(patternLockTheme);
161 pathColor = patternLockTheme->GetPathColor();
162 }
163
164 PatternLockModel::GetInstance()->SetPathColor(pathColor);
165 }
SetActiveColor(const JSCallbackInfo & info)166 void JSPatternLock::SetActiveColor(const JSCallbackInfo& info)
167 {
168 if (info.Length() < 1) {
169 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
170 return;
171 }
172 Color activeColor;
173 if (!ParseJsColor(info[0], activeColor)) {
174 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
175 CHECK_NULL_VOID(patternLockTheme);
176 activeColor = patternLockTheme->GetActiveColor();
177 }
178
179 PatternLockModel::GetInstance()->SetActiveColor(activeColor);
180 }
SetRegularColor(const JSCallbackInfo & info)181 void JSPatternLock::SetRegularColor(const JSCallbackInfo& info)
182 {
183 if (info.Length() < 1) {
184 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
185 return;
186 }
187 Color regularColor;
188 if (!ParseJsColor(info[0], regularColor)) {
189 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
190 CHECK_NULL_VOID(patternLockTheme);
191 regularColor = patternLockTheme->GetRegularColor();
192 }
193
194 PatternLockModel::GetInstance()->SetRegularColor(regularColor);
195 }
SetCircleRadius(const JSCallbackInfo & info)196 void JSPatternLock::SetCircleRadius(const JSCallbackInfo& info)
197 {
198 if (info.Length() < 1) {
199 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
200 return;
201 }
202 auto pipeline = PipelineBase::GetCurrentContext();
203 CHECK_NULL_VOID(pipeline);
204 CalcDimension radius;
205 if (pipeline->GetMinPlatformVersion() < static_cast<int32_t>(PlatformVersion::VERSION_TEN)) {
206 if (!ParseJsDimensionVp(info[0], radius)) {
207 return;
208 }
209 if (radius.IsNonNegative()) {
210 PatternLockModel::GetInstance()->SetCircleRadius(radius);
211 }
212 } else {
213 if (!ParseJsDimensionVp(info[0], radius) || radius.IsNonPositive()) {
214 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
215 CHECK_NULL_VOID(patternLockTheme);
216 radius = patternLockTheme->GetCircleRadius();
217 }
218 PatternLockModel::GetInstance()->SetCircleRadius(radius);
219 }
220 }
SetSideLength(const JSCallbackInfo & info)221 void JSPatternLock::SetSideLength(const JSCallbackInfo& info)
222 {
223 if (info.Length() < 1) {
224 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
225 return;
226 }
227 CalcDimension sideLength;
228 if (!ParseJsDimensionVp(info[0], sideLength)) {
229 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
230 CHECK_NULL_VOID(patternLockTheme);
231 sideLength = patternLockTheme->GetSideLength();
232 }
233
234 PatternLockModel::GetInstance()->SetSideLength(sideLength);
235 }
SetPathStrokeWidth(const JSCallbackInfo & info)236 void JSPatternLock::SetPathStrokeWidth(const JSCallbackInfo& info)
237 {
238 if (info.Length() < 1) {
239 LOGE("The arg is wrong, it is supposed to have at least 1 argument");
240 return;
241 }
242 CalcDimension lineWidth;
243 if (!ParseJsDimensionVp(info[0], lineWidth)) {
244 RefPtr<V2::PatternLockTheme> patternLockTheme = GetTheme<V2::PatternLockTheme>();
245 CHECK_NULL_VOID(patternLockTheme);
246 lineWidth = patternLockTheme->GetPathStrokeWidth();
247 }
248
249 PatternLockModel::GetInstance()->SetStrokeWidth(lineWidth);
250 }
SetDotConnected(const JSCallbackInfo & args)251 void JSPatternLock::SetDotConnected(const JSCallbackInfo& args)
252 {
253 if (!args[0]->IsFunction()) {
254 return;
255 }
256
257 auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
258 auto onConnected = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc)](int32_t code) {
259 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
260
261 JSRef<JSVal> newJSVal = JSRef<JSVal>::Make(ToJSValue(code));
262 func->ExecuteJS(1, &newJSVal);
263 };
264
265 PatternLockModel::GetInstance()->SetDotConnected(std::move(onConnected));
266 }
JSBind(BindingTarget globalObj)267 void JSPatternLockController::JSBind(BindingTarget globalObj)
268 {
269 JSClass<JSPatternLockController>::Declare("PatternLockController");
270 JSClass<JSPatternLockController>::CustomMethod("reset", &JSPatternLockController::Reset);
271 JSClass<JSPatternLockController>::CustomMethod("setChallengeResult", &JSPatternLockController::SetChallengeResult);
272 JSClass<JSPatternLockController>::Bind(
273 globalObj, JSPatternLockController::Constructor, JSPatternLockController::Destructor);
274 }
Reset(const JSCallbackInfo & args)275 void JSPatternLockController::Reset(const JSCallbackInfo& args)
276 {
277 if (controller_) {
278 controller_->Reset();
279 }
280 }
SetChallengeResult(const JSCallbackInfo & args)281 void JSPatternLockController::SetChallengeResult(const JSCallbackInfo& args)
282 {
283 if (controller_) {
284 if (!args[0]->IsNumber()) {
285 return;
286 }
287 int32_t value = args[0]->ToNumber<int32_t>();
288 if (value >= 1 && value <= static_cast<int32_t>(CHALLENGE_RESULT.size())) {
289 controller_->SetChallengeResult(CHALLENGE_RESULT[value - 1]);
290 }
291 }
292 }
Constructor(const JSCallbackInfo & args)293 void JSPatternLockController::Constructor(const JSCallbackInfo& args)
294 {
295 auto controller = Referenced::MakeRefPtr<JSPatternLockController>();
296 controller->IncRefCount();
297 args.SetReturnValue(Referenced::RawPtr(controller));
298 }
Destructor(JSPatternLockController * controller)299 void JSPatternLockController::Destructor(JSPatternLockController* controller)
300 {
301 if (controller != nullptr) {
302 controller->DecRefCount();
303 }
304 }
305 } // namespace OHOS::Ace::Framework
306