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_radio.h"
17
18 #include "interfaces/inner_api/ui_session/ui_session_manager.h"
19
20 #include "base/log/ace_scoring_log.h"
21 #include "bridge/declarative_frontend/ark_theme/theme_apply/js_radio_theme.h"
22 #include "bridge/declarative_frontend/engine/jsi/js_ui_index.h"
23 #include "bridge/declarative_frontend/jsview/js_interactable_view.h"
24 #include "bridge/declarative_frontend/jsview/js_view_common_def.h"
25 #include "bridge/declarative_frontend/jsview/models/radio_model_impl.h"
26 #include "core/components/checkable/checkable_theme.h"
27 #include "core/components_ng/base/view_abstract.h"
28 #include "core/components_ng/base/view_stack_model.h"
29 #include "core/components_ng/base/view_stack_processor.h"
30 #include "core/components_ng/pattern/radio/radio_model_ng.h"
31 #include "core/components_ng/pattern/radio/radio_pattern.h"
32
33 namespace OHOS::Ace {
34
35 enum class RadioIndicatorType {
36 TICK = 0,
37 DOT,
38 CUSTOM,
39 };
40
GetInstance()41 RadioModel* RadioModel::GetInstance()
42 {
43 #ifdef NG_BUILD
44 static NG::RadioModelNG instance;
45 return &instance;
46 #else
47 if (Container::IsCurrentUseNewPipeline()) {
48 static NG::RadioModelNG instance;
49 return &instance;
50 } else {
51 static Framework::RadioModelImpl instance;
52 return &instance;
53 }
54 #endif
55 }
56
57 } // namespace OHOS::Ace
58 namespace OHOS::Ace::Framework {
Create(const JSCallbackInfo & info)59 void JSRadio::Create(const JSCallbackInfo& info)
60 {
61 if (info.Length() < 1) {
62 return;
63 }
64
65 std::optional<std::string> value;
66 std::optional<std::string> group;
67 std::optional<int32_t> indicator;
68 std::function<void()> customBuilderFunc = nullptr;
69 if ((info.Length() >= 1) && info[0]->IsObject()) {
70 auto paramObject = JSRef<JSObject>::Cast(info[0]);
71 auto valueTemp = paramObject->GetProperty("value");
72 auto groupTemp = paramObject->GetProperty("group");
73 auto indicatorTemp = paramObject->GetProperty("indicatorType");
74 auto builderObject = paramObject->GetProperty("indicatorBuilder");
75 if (valueTemp->IsString()) {
76 value = valueTemp->ToString();
77 } else {
78 value = "";
79 }
80 if (groupTemp->IsString()) {
81 group = groupTemp->ToString();
82 } else {
83 group = "";
84 }
85 indicator = indicatorTemp->ToNumber<int32_t>();
86 ParseIndicator(info, indicator, customBuilderFunc, builderObject);
87 }
88 RadioModel::GetInstance()->Create(value, group, indicator);
89 if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
90 RadioModel::GetInstance()->SetBuilder(std::move(customBuilderFunc));
91 }
92 JSRadioTheme::ApplyTheme();
93 }
94
ParseIndicator(const JSCallbackInfo & info,std::optional<int32_t> & indicator,std::function<void ()> & customBuilderFunc,JSRef<JSVal> & builderObject)95 void JSRadio::ParseIndicator(const JSCallbackInfo& info, std::optional<int32_t>& indicator,
96 std::function<void()>& customBuilderFunc, JSRef<JSVal>& builderObject)
97 {
98 if (indicator.value() == static_cast<int32_t>(RadioIndicatorType::CUSTOM)) {
99 if (builderObject->IsFunction()) {
100 auto builderFunc = AceType::MakeRefPtr<JsFunction>(info.This(), JSRef<JSFunc>::Cast(builderObject));
101 CHECK_NULL_VOID(builderFunc);
102 auto targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
103 customBuilderFunc = [execCtx = info.GetExecutionContext(), func = std::move(builderFunc),
104 node = targetNode]() {
105 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
106 ACE_SCORING_EVENT("Radio.builder");
107 PipelineContext::SetCallBackNode(node);
108 func->Execute();
109 };
110 } else {
111 indicator = static_cast<int32_t>(RadioIndicatorType::TICK);
112 }
113 }
114 }
115
JSBind(BindingTarget globalObj)116 void JSRadio::JSBind(BindingTarget globalObj)
117 {
118 JSClass<JSRadio>::Declare("Radio");
119
120 JSClass<JSRadio>::StaticMethod("create", &JSRadio::Create);
121 JSClass<JSRadio>::StaticMethod("checked", &JSRadio::Checked);
122 JSClass<JSRadio>::StaticMethod("size", &JSRadio::JsSize);
123 JSClass<JSRadio>::StaticMethod("padding", &JSRadio::JsPadding);
124 JSClass<JSRadio>::StaticMethod("radioStyle", &JSRadio::JsRadioStyle);
125 JSClass<JSRadio>::StaticMethod("responseRegion", &JSRadio::JsResponseRegion);
126 JSClass<JSRadio>::StaticMethod("hoverEffect", &JSRadio::JsHoverEffect);
127 JSClass<JSRadio>::StaticMethod("onChange", &JSRadio::OnChange);
128 JSClass<JSRadio>::StaticMethod("onClick", &JSRadio::JsOnClick);
129 JSClass<JSRadio>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
130 JSClass<JSRadio>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
131 JSClass<JSRadio>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
132 JSClass<JSRadio>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
133 JSClass<JSRadio>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
134 JSClass<JSRadio>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
135 JSClass<JSRadio>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
136 JSClass<JSRadio>::InheritAndBind<JSViewAbstract>(globalObj);
137 }
138
ParseCheckedObject(const JSCallbackInfo & args,const JSRef<JSVal> & changeEventVal)139 void ParseCheckedObject(const JSCallbackInfo& args, const JSRef<JSVal>& changeEventVal)
140 {
141 CHECK_NULL_VOID(changeEventVal->IsFunction());
142
143 auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(changeEventVal));
144 WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
145 auto onChecked = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](bool check) {
146 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
147 ACE_SCORING_EVENT("Radio.onChangeEvent");
148 PipelineContext::SetCallBackNode(node);
149 auto newJSVal = JSRef<JSVal>::Make(ToJSValue(check));
150 func->ExecuteJS(1, &newJSVal);
151 };
152 RadioModel::GetInstance()->SetOnChangeEvent(std::move(onChecked));
153 }
154
Checked(const JSCallbackInfo & info)155 void JSRadio::Checked(const JSCallbackInfo& info)
156 {
157 if (info.Length() < 1 || info.Length() > 2) {
158 return;
159 }
160 bool checked = false;
161 JSRef<JSVal> changeEventVal;
162 auto checkedVal = info[0];
163 if (checkedVal->IsObject()) {
164 JSRef<JSObject> obj = JSRef<JSObject>::Cast(checkedVal);
165 checkedVal = obj->GetProperty("value");
166 changeEventVal = obj->GetProperty("$value");
167 } else if (info.Length() > 1) {
168 changeEventVal = info[1];
169 }
170
171 if (checkedVal->IsBoolean()) {
172 checked = checkedVal->ToBoolean();
173 }
174
175 RadioModel::GetInstance()->SetChecked(checked);
176
177 if (changeEventVal->IsFunction()) {
178 ParseCheckedObject(info, changeEventVal);
179 }
180 }
181
JsSize(const JSCallbackInfo & info)182 void JSRadio::JsSize(const JSCallbackInfo& info)
183 {
184 if (!info[0]->IsObject()) {
185 JSViewAbstract::JsWidth(JSVal::Undefined());
186 JSViewAbstract::JsHeight(JSVal::Undefined());
187 return;
188 }
189 JSRef<JSObject> sizeObj = JSRef<JSObject>::Cast(info[0]);
190 JSViewAbstract::JsWidth(sizeObj->GetProperty(static_cast<int32_t>(ArkUIIndex::WIDTH)));
191 JSViewAbstract::JsHeight(sizeObj->GetProperty(static_cast<int32_t>(ArkUIIndex::HEIGHT)));
192 }
193
JsPadding(const JSCallbackInfo & info)194 void JSRadio::JsPadding(const JSCallbackInfo& info)
195 {
196 if (info.Length() < 1) {
197 return;
198 }
199 NG::PaddingPropertyF oldPadding = GetOldPadding(info);
200 NG::PaddingProperty newPadding = GetNewPadding(info);
201 RadioModel::GetInstance()->SetPadding(oldPadding, newPadding);
202 }
203
GetOldPadding(const JSCallbackInfo & info)204 NG::PaddingPropertyF JSRadio::GetOldPadding(const JSCallbackInfo& info)
205 {
206 NG::PaddingPropertyF padding({ 0.0f, 0.0f, 0.0f, 0.0f });
207 if (info[0]->IsObject()) {
208 JSRef<JSObject> jsObj = JSRef<JSObject>::Cast(info[0]);
209 if (jsObj->HasProperty(static_cast<int32_t>(ArkUIIndex::TOP)) ||
210 jsObj->HasProperty(static_cast<int32_t>(ArkUIIndex::BOTTOM)) ||
211 jsObj->HasProperty(static_cast<int32_t>(ArkUIIndex::LEFT)) ||
212 jsObj->HasProperty(static_cast<int32_t>(ArkUIIndex::RIGHT))) {
213 CalcDimension topDimen = CalcDimension(0.0, DimensionUnit::VP);
214 CalcDimension leftDimen = CalcDimension(0.0, DimensionUnit::VP);
215 CalcDimension rightDimen = CalcDimension(0.0, DimensionUnit::VP);
216 CalcDimension bottomDimen = CalcDimension(0.0, DimensionUnit::VP);
217 ParseJsDimensionVp(jsObj->GetProperty(static_cast<int32_t>(ArkUIIndex::TOP)), topDimen);
218 ParseJsDimensionVp(jsObj->GetProperty(static_cast<int32_t>(ArkUIIndex::LEFT)), leftDimen);
219 ParseJsDimensionVp(jsObj->GetProperty(static_cast<int32_t>(ArkUIIndex::RIGHT)), rightDimen);
220 ParseJsDimensionVp(jsObj->GetProperty(static_cast<int32_t>(ArkUIIndex::BOTTOM)), bottomDimen);
221 if (leftDimen == 0.0_vp) {
222 leftDimen = rightDimen;
223 }
224 if (topDimen == 0.0_vp) {
225 topDimen = bottomDimen;
226 }
227 if (leftDimen == 0.0_vp) {
228 leftDimen = topDimen;
229 }
230
231 padding.left = leftDimen.ConvertToPx();
232 padding.right = rightDimen.ConvertToPx();
233 padding.top = topDimen.ConvertToPx();
234 padding.bottom = bottomDimen.ConvertToPx();
235 return padding;
236 }
237 }
238
239 CalcDimension length;
240 if (!ParseJsDimensionVp(info[0], length)) {
241 return padding;
242 }
243
244 padding.left = length.ConvertToPx();
245 padding.right = length.ConvertToPx();
246 padding.top = length.ConvertToPx();
247 padding.bottom = length.ConvertToPx();
248 return padding;
249 }
250
GetNewPadding(const JSCallbackInfo & info)251 NG::PaddingProperty JSRadio::GetNewPadding(const JSCallbackInfo& info)
252 {
253 NG::PaddingProperty padding({ NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp),
254 NG::CalcLength(0.0_vp), std::nullopt, std::nullopt });
255 if (info[0]->IsObject()) {
256 JSRef<JSObject> paddingObj = JSRef<JSObject>::Cast(info[0]);
257 CommonCalcDimension commonCalcDimension;
258 JSViewAbstract::ParseCommonMarginOrPaddingCorner(paddingObj, commonCalcDimension);
259 if (commonCalcDimension.left.has_value() || commonCalcDimension.right.has_value() ||
260 commonCalcDimension.top.has_value() || commonCalcDimension.bottom.has_value()) {
261 return GetPadding(commonCalcDimension.top, commonCalcDimension.bottom, commonCalcDimension.left,
262 commonCalcDimension.right);
263 }
264 }
265 CalcDimension length;
266 if (!ParseJsDimensionVp(info[0], length)) {
267 length.Reset();
268 }
269
270 padding.SetEdges(NG::CalcLength(length.IsNonNegative() ? length : CalcDimension()));
271 return padding;
272 }
273
GetPadding(const std::optional<CalcDimension> & top,const std::optional<CalcDimension> & bottom,const std::optional<CalcDimension> & left,const std::optional<CalcDimension> & right)274 NG::PaddingProperty JSRadio::GetPadding(const std::optional<CalcDimension>& top,
275 const std::optional<CalcDimension>& bottom, const std::optional<CalcDimension>& left,
276 const std::optional<CalcDimension>& right)
277 {
278 NG::PaddingProperty padding({ NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp),
279 NG::CalcLength(0.0_vp), std::nullopt, std::nullopt });
280 if (left.has_value() && left.value().IsNonNegative()) {
281 padding.left = NG::CalcLength(left.value());
282 }
283 if (right.has_value() && right.value().IsNonNegative()) {
284 padding.right = NG::CalcLength(right.value());
285 }
286 if (top.has_value() && top.value().IsNonNegative()) {
287 padding.top = NG::CalcLength(top.value());
288 }
289 if (bottom.has_value() && bottom.value().IsNonNegative()) {
290 padding.bottom = NG::CalcLength(bottom.value());
291 }
292 return padding;
293 }
294
JsRadioStyle(const JSCallbackInfo & info)295 void JSRadio::JsRadioStyle(const JSCallbackInfo& info)
296 {
297 auto theme = GetTheme<RadioTheme>();
298 if (!info[0]->IsObject()) {
299 RadioModel::GetInstance()->SetCheckedBackgroundColor(theme->GetActiveColor());
300 RadioModel::GetInstance()->SetUncheckedBorderColor(theme->GetInactiveColor());
301 RadioModel::GetInstance()->SetIndicatorColor(theme->GetPointColor());
302 return;
303 }
304 JSRef<JSObject> obj = JSRef<JSObject>::Cast(info[0]);
305 JSRef<JSVal> checkedBackgroundColor = obj->GetProperty("checkedBackgroundColor");
306 JSRef<JSVal> uncheckedBorderColor = obj->GetProperty("uncheckedBorderColor");
307 JSRef<JSVal> indicatorColor = obj->GetProperty("indicatorColor");
308 Color checkedBackgroundColorVal;
309 if (!ParseJsColor(checkedBackgroundColor, checkedBackgroundColorVal)) {
310 if (!JSRadioTheme::ObtainCheckedBackgroundColor(checkedBackgroundColorVal)) {
311 checkedBackgroundColorVal = theme->GetActiveColor();
312 }
313 }
314 RadioModel::GetInstance()->SetCheckedBackgroundColor(checkedBackgroundColorVal);
315 Color uncheckedBorderColorVal;
316 if (!ParseJsColor(uncheckedBorderColor, uncheckedBorderColorVal)) {
317 if (!JSRadioTheme::ObtainUncheckedBorderColor(uncheckedBorderColorVal)) {
318 uncheckedBorderColorVal = theme->GetInactiveColor();
319 }
320 } else {
321 auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
322 CHECK_NULL_VOID(frameNode);
323 auto pattern = frameNode->GetPattern<NG::RadioPattern>();
324 CHECK_NULL_VOID(pattern);
325 pattern->SetIsUserSetUncheckBorderColor(true);
326 }
327 RadioModel::GetInstance()->SetUncheckedBorderColor(uncheckedBorderColorVal);
328 Color indicatorColorVal;
329 if (!ParseJsColor(indicatorColor, indicatorColorVal)) {
330 if (!JSRadioTheme::ObtainIndicatorColor(indicatorColorVal)) {
331 indicatorColorVal = theme->GetPointColor();
332 }
333 }
334 RadioModel::GetInstance()->SetIndicatorColor(indicatorColorVal);
335 }
336
JsResponseRegion(const JSCallbackInfo & info)337 void JSRadio::JsResponseRegion(const JSCallbackInfo& info)
338 {
339 if (info.Length() < 1) {
340 return;
341 }
342
343 std::vector<DimensionRect> result;
344 if (!JSViewAbstract::ParseJsResponseRegionArray(info[0], result)) {
345 return;
346 }
347
348 RadioModel::GetInstance()->SetResponseRegion(result);
349 }
350
OnChange(const JSCallbackInfo & args)351 void JSRadio::OnChange(const JSCallbackInfo& args)
352 {
353 if (!args[0]->IsFunction()) {
354 return;
355 }
356 auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(args[0]));
357 WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
358 auto onChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](bool check) {
359 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
360 ACE_SCORING_EVENT("Radio.onChange");
361 PipelineContext::SetCallBackNode(node);
362 auto newJSVal = JSRef<JSVal>::Make(ToJSValue(check));
363 func->ExecuteJS(1, &newJSVal);
364 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Radio.onChange");
365 };
366 RadioModel::GetInstance()->SetOnChange(std::move(onChange));
367 args.ReturnSelf();
368 }
369
JsOnClick(const JSCallbackInfo & args)370 void JSRadio::JsOnClick(const JSCallbackInfo& args)
371 {
372 if (Container::IsCurrentUseNewPipeline()) {
373 JSViewAbstract::JsOnClick(args);
374 return;
375 }
376 if (!args[0]->IsFunction()) {
377 return;
378 }
379 RadioModel::GetInstance()->SetOnClickEvent(
380 JsEventCallback<void()>(args.GetExecutionContext(), JSRef<JSFunc>::Cast(args[0])));
381
382 args.ReturnSelf();
383 }
384
JsHoverEffect(const JSCallbackInfo & info)385 void JSRadio::JsHoverEffect(const JSCallbackInfo& info)
386 {
387 if (info[0]->IsNumber()) {
388 RadioModel::GetInstance()->SetHoverEffect(static_cast<HoverEffectType>(info[0]->ToNumber<int32_t>()));
389 }
390 }
391 } // namespace OHOS::Ace::Framework
392