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 "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
GetInstance()28 PatternLockModel* PatternLockModel::GetInstance()
29 {
30 if (!instance_) {
31 #ifdef NG_BUILD
32 instance_.reset(new NG::PatternLockModelNG());
33 #else
34 if (Container::IsCurrentUseNewPipeline()) {
35 instance_.reset(new NG::PatternLockModelNG());
36 } else {
37 instance_.reset(new Framework::PatternLockModelImpl());
38 }
39 #endif
40 }
41 return instance_.get();
42 }
43
44 } // namespace OHOS::Ace
45
46 namespace OHOS::Ace::Framework {
ChoosePointToJSValue(std::vector<int> input)47 JSRef<JSArray> JSPatternLock::ChoosePointToJSValue(std::vector<int> input)
48 {
49 JSRef<JSArray> arr = JSRef<JSArray>::New();
50 for (size_t i = 0; i < input.size(); i++) {
51 arr->SetValueAt(i, ConvertToJSValue(input[i]));
52 }
53 return arr;
54 }
Create(const JSCallbackInfo & info)55 void JSPatternLock::Create(const JSCallbackInfo& info)
56 {
57 auto controller = PatternLockModel::GetInstance()->Create();
58
59 if (info.Length() > 0 && info[0]->IsObject()) {
60 auto* jsController = JSRef<JSObject>::Cast(info[0])->Unwrap<JSPatternLockController>();
61 if (jsController) {
62 jsController->SetController(controller);
63 }
64 }
65 }
JSBind(BindingTarget globalObj)66 void JSPatternLock::JSBind(BindingTarget globalObj)
67 {
68 JSClass<JSPatternLock>::Declare("PatternLock");
69 MethodOptions opt = MethodOptions::NONE;
70 JSClass<JSPatternLock>::StaticMethod("create", &JSPatternLock::Create, opt);
71 JSClass<JSPatternLock>::StaticMethod("onPatternComplete", &JSPatternLock::SetPatternComplete);
72 JSClass<JSPatternLock>::StaticMethod("regularColor", &JSPatternLock::SetRegularColor, MethodOptions::NONE);
73 JSClass<JSPatternLock>::StaticMethod("selectedColor", &JSPatternLock::SetSelectedColor, MethodOptions::NONE);
74 JSClass<JSPatternLock>::StaticMethod("activeColor", &JSPatternLock::SetActiveColor, MethodOptions::NONE);
75 JSClass<JSPatternLock>::StaticMethod("pathColor", &JSPatternLock::SetPathColor, MethodOptions::NONE);
76 JSClass<JSPatternLock>::StaticMethod("pathStrokeWidth", &JSPatternLock::SetPathStrokeWidth);
77 JSClass<JSPatternLock>::StaticMethod("circleRadius", &JSPatternLock::SetCircleRadius, MethodOptions::NONE);
78 JSClass<JSPatternLock>::StaticMethod("sideLength", &JSPatternLock::SetSideLength, MethodOptions::NONE);
79 JSClass<JSPatternLock>::StaticMethod("autoReset", &JSPatternLock::SetAutoReset, MethodOptions::NONE);
80 JSClass<JSPatternLock>::Inherit<JSViewAbstract>();
81 JSClass<JSPatternLock>::Bind(globalObj);
82 }
SetDefaultTheme(OHOS::Ace::RefPtr<OHOS::Ace::V2::PatternLockComponent> & patternLock)83 void JSPatternLock::SetDefaultTheme(OHOS::Ace::RefPtr<OHOS::Ace::V2::PatternLockComponent>& patternLock)
84 {
85 auto lockTheme = GetTheme<V2::PatternLockTheme>();
86 if (!lockTheme) {
87 LOGE("Get PatternLock theme error");
88 return;
89 }
90 patternLock->SetRegularColor(lockTheme->GetRegularColor());
91 patternLock->SetSelectedColor(lockTheme->GetSelectedColor());
92 patternLock->SetActiveColor(lockTheme->GetActiveColor());
93 patternLock->SetPathColor(lockTheme->GetPathColor());
94 }
95
SetPatternComplete(const JSCallbackInfo & args)96 void JSPatternLock::SetPatternComplete(const JSCallbackInfo& args)
97 {
98 if (!args[0]->IsFunction()) {
99 return;
100 }
101
102 auto onComplete = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])](
103 const BaseEventInfo* event) {
104 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
105 const auto* eventInfo = TypeInfoHelper::DynamicCast<V2::PatternCompleteEvent>(event);
106 CHECK_NULL_VOID(eventInfo);
107 JSRef<JSVal> params[] = { ChoosePointToJSValue(eventInfo->GetInput()) };
108 func->Call(JSRef<JSObject>(), ArraySize(params), params);
109 };
110
111 PatternLockModel::GetInstance()->SetPatternComplete(std::move(onComplete));
112 }
SetSelectedColor(const JSCallbackInfo & info)113 void JSPatternLock::SetSelectedColor(const JSCallbackInfo& info)
114 {
115 if (info.Length() < 1) {
116 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
117 return;
118 }
119 Color selectedColor;
120 if (!ParseJsColor(info[0], selectedColor)) {
121 return;
122 }
123
124 PatternLockModel::GetInstance()->SetSelectedColor(selectedColor);
125 }
SetAutoReset(const JSCallbackInfo & info)126 void JSPatternLock::SetAutoReset(const JSCallbackInfo& info)
127 {
128 if (info.Length() < 1) {
129 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
130 return;
131 }
132 if (!info[0]->IsBoolean()) {
133 LOGE("arg is not bool.");
134 PatternLockModel::GetInstance()->SetAutoReset(true);
135 return;
136 }
137 PatternLockModel::GetInstance()->SetAutoReset(info[0]->ToBoolean());
138 }
139
SetPathColor(const JSCallbackInfo & info)140 void JSPatternLock::SetPathColor(const JSCallbackInfo& info)
141 {
142 if (info.Length() < 1) {
143 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
144 return;
145 }
146 Color pathColor;
147 if (!ParseJsColor(info[0], pathColor)) {
148 return;
149 }
150
151 PatternLockModel::GetInstance()->SetPathColor(pathColor);
152 }
SetActiveColor(const JSCallbackInfo & info)153 void JSPatternLock::SetActiveColor(const JSCallbackInfo& info)
154 {
155 if (info.Length() < 1) {
156 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
157 return;
158 }
159 Color activeColor;
160 if (!ParseJsColor(info[0], activeColor)) {
161 return;
162 }
163
164 PatternLockModel::GetInstance()->SetActiveColor(activeColor);
165 }
SetRegularColor(const JSCallbackInfo & info)166 void JSPatternLock::SetRegularColor(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 regularColor;
173 if (!ParseJsColor(info[0], regularColor)) {
174 return;
175 }
176
177 PatternLockModel::GetInstance()->SetRegularColor(regularColor);
178 }
SetCircleRadius(const JSCallbackInfo & info)179 void JSPatternLock::SetCircleRadius(const JSCallbackInfo& info)
180 {
181 if (info.Length() < 1) {
182 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
183 return;
184 }
185 Dimension radius;
186 if (!ParseJsDimensionVp(info[0], radius)) {
187 return;
188 }
189
190 PatternLockModel::GetInstance()->SetCircleRadius(radius);
191 }
SetSideLength(const JSCallbackInfo & info)192 void JSPatternLock::SetSideLength(const JSCallbackInfo& info)
193 {
194 if (info.Length() < 1) {
195 LOGE("The argv is wrong, it is supposed to have at least 1 argument");
196 return;
197 }
198 Dimension sideLength;
199 if (!ParseJsDimensionVp(info[0], sideLength)) {
200 return;
201 }
202 JSViewAbstract::JsWidth(info);
203 JSViewAbstract::JsHeight(info);
204
205 PatternLockModel::GetInstance()->SetSideLength(sideLength);
206 }
SetPathStrokeWidth(const JSCallbackInfo & info)207 void JSPatternLock::SetPathStrokeWidth(const JSCallbackInfo& info)
208 {
209 if (info.Length() < 1) {
210 LOGE("The arg is wrong, it is supposed to have at least 1 argument");
211 return;
212 }
213 Dimension lineWidth;
214 if (!ParseJsDimensionVp(info[0], lineWidth)) {
215 return;
216 }
217
218 PatternLockModel::GetInstance()->SetStrokeWidth(lineWidth);
219 }
JSBind(BindingTarget globalObj)220 void JSPatternLockController::JSBind(BindingTarget globalObj)
221 {
222 JSClass<JSPatternLockController>::Declare("PatternLockController");
223 JSClass<JSPatternLockController>::CustomMethod("reset", &JSPatternLockController::Reset);
224 JSClass<JSPatternLockController>::Bind(
225 globalObj, JSPatternLockController::Constructor, JSPatternLockController::Destructor);
226 }
Reset(const JSCallbackInfo & args)227 void JSPatternLockController::Reset(const JSCallbackInfo& args)
228 {
229 if (controller_) {
230 controller_->Reset();
231 }
232 }
Constructor(const JSCallbackInfo & args)233 void JSPatternLockController::Constructor(const JSCallbackInfo& args)
234 {
235 auto controller = Referenced::MakeRefPtr<JSPatternLockController>();
236 controller->IncRefCount();
237 args.SetReturnValue(Referenced::RawPtr(controller));
238 }
Destructor(JSPatternLockController * controller)239 void JSPatternLockController::Destructor(JSPatternLockController* controller)
240 {
241 if (controller != nullptr) {
242 controller->DecRefCount();
243 }
244 }
245 } // namespace OHOS::Ace::Framework