1 /*
2 * Copyright (c) 2020-2021 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 "picker_view_component.h"
17 #include "ace_log.h"
18 #include "ace_mem_base.h"
19 #include "key_parser.h"
20 #include "keys.h"
21 #include "product_adapter.h"
22 #include "ui_font.h"
23 #ifdef FEATURE_EXTRA_TEXT_X_SUPPORT
24 #include "ui_picker_x.h"
25 #define UIPickerTypeWrapper UIPickerX
26 #else
27 #define UIPickerTypeWrapper UIPicker
28 #endif // FEATURE_EXTRA_TEXT_X_SUPPORT
29
30 namespace OHOS {
31 namespace ACELite {
32 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
OnDatePickerStoped(UIDatePicker & picker)33 void DatePickerListener::OnDatePickerStoped(UIDatePicker &picker)
34 {
35 if (!jerry_value_is_function(dateCallback_)) {
36 HILOG_ERROR(HILOG_MODULE_ACE, "DatePickerListener: callback type invalid!");
37 return;
38 }
39 uint32_t year = (picker.GetSelectYear() == nullptr) ? 0 : strtol(picker.GetSelectYear(), nullptr, DEC);
40 uint32_t month = (picker.GetSelectMonth() == nullptr) ? 0 : strtol(picker.GetSelectMonth(), nullptr, DEC);
41 uint32_t day = (picker.GetSelectDay() == nullptr) ? 0 : strtol(picker.GetSelectDay(), nullptr, DEC);
42
43 jerry_value_t arg = jerry_create_object();
44 JerrySetNumberProperty(arg, DATE_PICKER_YEAR, year);
45 JerrySetNumberProperty(arg, DATE_PICKER_MONTH, month);
46 JerrySetNumberProperty(arg, DATE_PICKER_DAY, day);
47 CallJSFunctionAutoRelease(dateCallback_, UNDEFINED, &arg, 1);
48 jerry_release_value(arg);
49 }
50 #endif // FEATURE_COMPONENT_DATE_PICKER
51
OnPickerStoped(UIPicker & picker)52 void TextPickerListener::OnPickerStoped(UIPicker &picker)
53 {
54 if (!jerry_value_is_function(textCallback_)) {
55 HILOG_ERROR(HILOG_MODULE_ACE, "TextPickerListener: callback type invalid!");
56 return;
57 }
58 uint16_t index = picker.GetSelected();
59 jerry_value_t arg = jerry_create_object();
60 JerrySetStringProperty(arg, TEXT_PICKER_NEW_VALUE, pTextArray_[index]);
61 JerrySetNumberProperty(arg, TEXT_PICKER_NEW_SELECTED, index);
62 CallJSFunctionAutoRelease(textCallback_, UNDEFINED, &arg, 1);
63 jerry_release_value(arg);
64 }
65
OnTimePickerStoped(UITimePicker & picker)66 void TimePickerListener::OnTimePickerStoped(UITimePicker &picker)
67 {
68 if (!jerry_value_is_function(timeCallback_)) {
69 HILOG_ERROR(HILOG_MODULE_ACE, "TimePickerListener: callback type invalid!");
70 return;
71 }
72 uint32_t hour = (picker.GetSelectHour() == nullptr) ? 0 : strtol(picker.GetSelectHour(), nullptr, DEC);
73 uint32_t minute = (picker.GetSelectMinute() == nullptr) ? 0 : strtol(picker.GetSelectMinute(), nullptr, DEC);
74
75 jerry_value_t arg = jerry_create_object();
76 JerrySetNumberProperty(arg, TIME_PICKER_HOUR, hour);
77 JerrySetNumberProperty(arg, TIME_PICKER_MINUTE, minute);
78 CallJSFunctionAutoRelease(timeCallback_, UNDEFINED, &arg, 1);
79 jerry_release_value(arg);
80 }
81
PickerViewComponent(jerry_value_t options,jerry_value_t children,AppStyleManager * styleManager)82 PickerViewComponent::PickerViewComponent(jerry_value_t options, jerry_value_t children, AppStyleManager *styleManager)
83 : Component(options, children, styleManager),
84 options_(options),
85 pickerType_(PickerType::TEXT),
86 pickerView_(nullptr),
87 color_(Color::Gray()),
88 fontSize_(DEFAULT_FONT_SIZE),
89 fontFamily_(nullptr),
90 selectedColor_(Color::White()),
91 selectedFontSize_(PICKER_SELECTED_FONT_SIZE),
92 selectedFontFamily_(nullptr),
93 textSelected_(0),
94 pTextArray_(nullptr),
95 textArraySize_(0),
96 textPickerListener_(nullptr),
97 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
98 dateSelected_(nullptr),
99 dateStart_(nullptr),
100 dateEnd_(nullptr),
101 datePickerListener_(nullptr),
102 #endif // FEATURE_COMPONENT_DATE_PICKER
103 timePickerListener_(nullptr),
104 timeSelected_(nullptr)
105 {
106 SetComponentName(K_PICKER_VIEW);
107 fontSize_ = ProductAdapter::GetDefaultFontSize();
108 #if (FEATURE_ROTATION_API == 1)
109 RegisterNamedFunction(FUNC_ROTATION_NAME, HandleRotationRequest);
110 #endif // FEATURE_ROTATION_API
111 }
112
CreateNativeViews()113 bool PickerViewComponent::CreateNativeViews()
114 {
115 bool result = false;
116 pickerType_ = GetPickerType();
117 switch (pickerType_) {
118 case PickerType::TEXT: {
119 result = CreateTextPicker();
120 break;
121 }
122 case PickerType::TIME: {
123 result = CreateTimePicker();
124 break;
125 }
126 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
127 case PickerType::DATE: {
128 result = CreateDatePicker();
129 break;
130 }
131 #endif // FEATURE_COMPONENT_DATE_PICKER
132 case PickerType::UNKNOWN: {
133 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: picker view type invalid!");
134 break;
135 }
136 default:
137 break;
138 }
139
140 if (pickerView_ == nullptr) {
141 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create native view failed!");
142 result = false;
143 }
144 if (result) {
145 result = (CopyFontFamily(fontFamily_, ProductAdapter::GetDefaultFontFamilyName())) &&
146 (CopyFontFamily(selectedFontFamily_, ProductAdapter::GetDefaultFontFamilyName()));
147 }
148 return result;
149 }
150
CreateTextPicker()151 bool PickerViewComponent::CreateTextPicker()
152 {
153 UIPickerTypeWrapper *uiPicker = new UIPickerTypeWrapper();
154 if (uiPicker == nullptr) {
155 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create text picker failed!");
156 return false;
157 }
158 uiPicker->SetLoopState(true);
159 textPickerListener_ = new TextPickerListener();
160 if (textPickerListener_ == nullptr) {
161 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create text picker listener failed!");
162 delete uiPicker;
163 uiPicker = nullptr;
164 return false;
165 }
166 uiPicker->SetItemHeight(PICKER_ITEM_HEIGHT);
167 pickerView_ = static_cast<UIView *>(uiPicker);
168 return true;
169 }
170
CreateTimePicker()171 bool PickerViewComponent::CreateTimePicker()
172 {
173 UITimePicker *uiTimePicker = new UITimePicker();
174 if (uiTimePicker == nullptr) {
175 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create time picker failed");
176 return false;
177 }
178 uiTimePicker->SetLoopState(uiTimePicker->PICKER_HOUR, true);
179 uiTimePicker->SetLoopState(uiTimePicker->PICKER_MIN, true);
180 uiTimePicker->SetLoopState(uiTimePicker->PICKER_SEC, true);
181 timePickerListener_ = new TimePickerListener();
182 if (timePickerListener_ == nullptr) {
183 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create time picker listener failed");
184 delete uiTimePicker;
185 uiTimePicker = nullptr;
186 return false;
187 }
188 uiTimePicker->SetItemHeight(PICKER_ITEM_HEIGHT);
189 pickerView_ = static_cast<UIView *>(uiTimePicker);
190 return true;
191 }
192
193 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
CreateDatePicker()194 bool PickerViewComponent::CreateDatePicker()
195 {
196 UIDatePicker *uiDatePicker = new UIDatePicker();
197 if (uiDatePicker == nullptr) {
198 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create date picker failed");
199 return false;
200 }
201 datePickerListener_ = new DatePickerListener();
202 if (datePickerListener_ == nullptr) {
203 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: create date picker failed");
204 delete uiDatePicker;
205 uiDatePicker = nullptr;
206 return false;
207 }
208 uiDatePicker->SetItemHeight(PICKER_ITEM_HEIGHT);
209 pickerView_ = static_cast<UIView *>(uiDatePicker);
210 return true;
211 }
212 #endif // FEATURE_COMPONENT_DATE_PICKER
213
ReleaseTextRange()214 void PickerViewComponent::ReleaseTextRange()
215 {
216 // free text picker resources
217 if ((textArraySize_ > 0) && pTextArray_) {
218 for (uint16_t index = 0; index < textArraySize_; index++) {
219 if (pTextArray_[index]) {
220 ace_free(pTextArray_[index]);
221 pTextArray_[index] = nullptr;
222 }
223 }
224 delete[] pTextArray_;
225 pTextArray_ = nullptr;
226 }
227 }
ReleaseNativeViews()228 void PickerViewComponent::ReleaseNativeViews()
229 {
230 if (pickerView_ != nullptr) {
231 delete pickerView_;
232 pickerView_ = nullptr;
233 }
234
235 ReleaseTextRange();
236
237 if (textPickerListener_ != nullptr) {
238 delete textPickerListener_;
239 textPickerListener_ = nullptr;
240 }
241
242 // free time picker resources
243 if (timePickerListener_ != nullptr) {
244 delete timePickerListener_;
245 timePickerListener_ = nullptr;
246 }
247 ACE_FREE(timeSelected_);
248 ACE_FREE(fontFamily_);
249 ACE_FREE(selectedFontFamily_);
250
251 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
252 // free date picker resources
253 if (datePickerListener_ != nullptr) {
254 delete datePickerListener_;
255 datePickerListener_ = nullptr;
256 }
257 ACE_FREE(dateSelected_);
258 ACE_FREE(dateStart_);
259 ACE_FREE(dateEnd_);
260 #endif // FEATURE_COMPONENT_DATE_PICKER
261 }
262
GetComponentRootView() const263 inline UIView *PickerViewComponent::GetComponentRootView() const
264 {
265 return pickerView_;
266 }
267
PostRender()268 void PickerViewComponent::PostRender()
269 {
270 if (pickerView_ == nullptr) {
271 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: no native view for post render!");
272 return;
273 }
274
275 UpdatePickerStyles();
276 UpdatePickerAttrs();
277 }
278
PostUpdate(uint16_t attrKeyId)279 void PickerViewComponent::PostUpdate(uint16_t attrKeyId)
280 {
281 if (pickerView_ == nullptr) {
282 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: post update failed!");
283 return;
284 }
285
286 switch (attrKeyId) {
287 case K_SELECTED:
288 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
289 case K_START:
290 case K_END:
291 #endif // FEATURE_COMPONENT_DATE_PICKER
292 UpdatePickerAttrs();
293 break;
294 case K_COLOR:
295 case K_FONT_SIZE:
296 case K_FONT_FAMILY:
297 case K_SELECTED_COLOR:
298 case K_SELECTED_FONT_SIZE:
299 case K_SELECTED_FONT_FAMILY:
300 UpdatePickerStyles();
301 break;
302 default:
303 break;
304 }
305 }
306
UpdatePickerStyles() const307 void PickerViewComponent::UpdatePickerStyles() const
308 {
309 if (pickerView_ == nullptr) {
310 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: update picker styles failed!");
311 return;
312 }
313 if ((fontFamily_ == nullptr) || (fontSize_ == 0) || (selectedFontFamily_ == nullptr) || (selectedFontSize_ == 0)) {
314 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: font family or size invalid!");
315 return;
316 }
317 UIFont *font = UIFont::GetInstance();
318 if (font == nullptr) {
319 return;
320 }
321
322 switch (pickerType_) {
323 case PickerType::TEXT: {
324 UIPicker *textPicker = reinterpret_cast<UIPicker *>(pickerView_);
325 textPicker->SetBackgroundFont(fontFamily_, fontSize_);
326 textPicker->SetHighlightFont(selectedFontFamily_, selectedFontSize_);
327 textPicker->SetTextColor(color_, selectedColor_);
328 break;
329 }
330 case PickerType::TIME: {
331 UITimePicker *timePicker = reinterpret_cast<UITimePicker *>(pickerView_);
332 timePicker->SetBackgroundFont(fontFamily_, fontSize_);
333 timePicker->SetHighlightFont(selectedFontFamily_, selectedFontSize_);
334 timePicker->SetTextColor(color_, selectedColor_);
335 break;
336 }
337 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
338 case PickerType::DATE: {
339 uint8_t fontId = font->GetFontId(fontFamily_, fontSize_);
340 uint8_t selectedFontId = font->GetFontId(selectedFontFamily_, selectedFontSize_);
341 UIDatePicker *datePicker = reinterpret_cast<UIDatePicker *>(pickerView_);
342 datePicker->SetTextStyle(fontId, selectedFontId, color_, selectedColor_);
343 break;
344 }
345 #endif // FEATURE_COMPONENT_DATE_PICKER
346 default:
347 break;
348 }
349 }
350
UpdatePickerAttrs() const351 void PickerViewComponent::UpdatePickerAttrs() const
352 {
353 if (pickerView_ == nullptr) {
354 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: update picker attributes failed!");
355 return;
356 }
357 switch (pickerType_) {
358 case PickerType::TEXT: {
359 UIPicker *textPicker = reinterpret_cast<UIPicker *>(pickerView_);
360 textPicker->SetSelected(textSelected_);
361 break;
362 }
363 case PickerType::TIME: {
364 UITimePicker *timePicker = reinterpret_cast<UITimePicker *>(pickerView_);
365 if (timeSelected_ != nullptr) {
366 timePicker->SetSelected(timeSelected_);
367 }
368 break;
369 }
370 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
371 case PickerType::DATE: {
372 UIDatePicker *datePicker = reinterpret_cast<UIDatePicker *>(pickerView_);
373 if (dateStart_ != nullptr) {
374 datePicker->SetStart(dateStart_);
375 }
376 if (dateEnd_ != nullptr) {
377 datePicker->SetEnd(dateEnd_);
378 }
379 if (dateSelected_ != nullptr) {
380 datePicker->SetSelected(dateSelected_);
381 }
382 break;
383 }
384 #endif // FEATURE_COMPONENT_DATE_PICKER
385 default:
386 break;
387 }
388 }
389
SetPrivateAttribute(uint16_t attrKeyId,jerry_value_t attrValue)390 bool PickerViewComponent::SetPrivateAttribute(uint16_t attrKeyId, jerry_value_t attrValue)
391 {
392 bool result = true;
393 switch (attrKeyId) {
394 case K_SELECTED: {
395 result = SetPickerSelected(attrValue);
396 break;
397 }
398 case K_RANGE: {
399 if (pickerType_ == PickerType::TEXT) {
400 result = SetTextPickerRange(attrValue);
401 }
402 break;
403 }
404 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
405 case K_START: {
406 if (pickerType_ == PickerType::DATE) {
407 ACE_FREE(dateStart_);
408 dateStart_ = MallocStringOf(attrValue);
409 }
410 break;
411 }
412 case K_END: {
413 if (pickerType_ == PickerType::DATE) {
414 ACE_FREE(dateEnd_);
415 dateEnd_ = MallocStringOf(attrValue);
416 }
417 break;
418 }
419 #endif // FEATURE_COMPONENT_DATE_PICKER
420 default:
421 result = false;
422 break;
423 }
424 return result;
425 }
426
ApplyPrivateStyle(const AppStyleItem * styleItem)427 bool PickerViewComponent::ApplyPrivateStyle(const AppStyleItem *styleItem)
428 {
429 uint16_t styleNameId = GetStylePropNameId(styleItem);
430 if (!KeyParser::IsKeyValid(styleNameId)) {
431 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: apply private style failed!");
432 return false;
433 }
434 uint32_t color = 0;
435 uint8_t alpha = OPA_OPAQUE;
436 switch (styleNameId) {
437 case K_COLOR:
438 if (!GetStyleColorValue(styleItem, color, alpha)) {
439 return false;
440 }
441 color_ = GetRGBColor(color);
442 break;
443 case K_FONT_SIZE:
444 fontSize_ = GetStylePixelValue(styleItem);
445 break;
446 case K_FONT_FAMILY:
447 CopyFontFamily(fontFamily_, GetStyleStrValue(styleItem));
448 break;
449 case K_SELECTED_COLOR:
450 if (!GetStyleColorValue(styleItem, color, alpha)) {
451 return false;
452 }
453 selectedColor_ = GetRGBColor(color);
454 break;
455 case K_SELECTED_FONT_SIZE:
456 selectedFontSize_ = GetStylePixelValue(styleItem);
457 break;
458 case K_SELECTED_FONT_FAMILY:
459 CopyFontFamily(selectedFontFamily_, GetStyleStrValue(styleItem));
460 break;
461 default:
462 return false;
463 }
464 return true;
465 }
466
RegisterPrivateEventListener(uint16_t eventTypeId,jerry_value_t funcValue,bool isStopPropagation)467 bool PickerViewComponent::RegisterPrivateEventListener(uint16_t eventTypeId,
468 jerry_value_t funcValue,
469 bool isStopPropagation)
470 {
471 bool result = false;
472 switch (eventTypeId) {
473 case K_CHANGE: {
474 SetPickerListener(funcValue);
475 result = true;
476 break;
477 }
478 default:
479 break;
480 }
481 return result;
482 }
483
GetStringAttrByName(const char * const name,uint16_t & length) const484 char *PickerViewComponent::GetStringAttrByName(const char * const name, uint16_t &length) const
485 {
486 if (jerry_value_is_undefined(options_)) {
487 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: options undefined!");
488 return nullptr;
489 }
490
491 char *strValue = nullptr;
492 jerry_value_t attrsPropValue = jerryx_get_property_str(options_, ATTR_ATTRS);
493 if (!jerry_value_is_undefined(attrsPropValue)) {
494 strValue = JerryMallocStringProperty(attrsPropValue, name, length);
495 }
496 jerry_release_value(attrsPropValue);
497 return strValue;
498 }
499
GetPickerType() const500 PickerViewComponent::PickerType PickerViewComponent::GetPickerType() const
501 {
502 uint16_t length = 0;
503 char *typeStr = GetStringAttrByName(ATTR_TYPE, length);
504 if (typeStr == nullptr) {
505 return PickerType::TEXT;
506 }
507
508 PickerType type = PickerType::UNKNOWN;
509 uint16_t typeId = KeyParser::ParseKeyId(typeStr, length);
510 switch (typeId) {
511 case K_TEXT:
512 type = PickerType::TEXT;
513 break;
514 case K_TIME:
515 type = PickerType::TIME;
516 break;
517 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
518 case K_DATE:
519 type = PickerType::DATE;
520 break;
521 #endif // FEATURE_COMPONENT_DATE_PICKER
522 default:
523 type = PickerType::UNKNOWN;
524 break;
525 }
526 ace_free(typeStr);
527 typeStr = nullptr;
528 return type;
529 }
530
SetPickerSelected(jerry_value_t selectedValue)531 bool PickerViewComponent::SetPickerSelected(jerry_value_t selectedValue)
532 {
533 switch (pickerType_) {
534 case PickerType::TEXT: {
535 textSelected_ = IntegerOf(selectedValue);
536 break;
537 }
538 case PickerType::TIME: {
539 ACE_FREE(timeSelected_);
540 timeSelected_ = MallocStringOf(selectedValue);
541 break;
542 }
543 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
544 case PickerType::DATE: {
545 ACE_FREE(dateSelected_);
546 dateSelected_ = MallocStringOf(selectedValue);
547 break;
548 }
549 #endif // FEATURE_COMPONENT_DATE_PICKER
550 default:
551 break;
552 }
553 return true;
554 }
555
SetPickerListener(jerry_value_t funcValue) const556 void PickerViewComponent::SetPickerListener(jerry_value_t funcValue) const
557 {
558 switch (pickerType_) {
559 case PickerType::TEXT: {
560 if (textPickerListener_ != nullptr) {
561 UIPicker *textPicker = reinterpret_cast<UIPicker *>(pickerView_);
562 textPickerListener_->SetTextCallback(funcValue);
563 textPicker->RegisterSelectedListener(textPickerListener_);
564 }
565 break;
566 }
567 case PickerType::TIME: {
568 if (timePickerListener_ != nullptr) {
569 UITimePicker *timePicker = reinterpret_cast<UITimePicker *>(pickerView_);
570 timePickerListener_->SetTimeCallback(funcValue);
571 timePicker->RegisterSelectedListener(timePickerListener_);
572 }
573 break;
574 }
575 #if (FEATURE_COMPONENT_DATE_PICKER == 1)
576 case PickerType::DATE: {
577 if (datePickerListener_ != nullptr) {
578 UIDatePicker *datePicker = reinterpret_cast<UIDatePicker *>(pickerView_);
579 datePickerListener_->SetDateCallback(funcValue);
580 datePicker->RegisterSelectedListener(datePickerListener_);
581 }
582 break;
583 }
584 #endif // FEATURE_COMPONENT_DATE_PICKER
585 default:
586 break;
587 }
588 }
589
SetTextPickerRange(jerry_value_t rangeValue)590 bool PickerViewComponent::SetTextPickerRange(jerry_value_t rangeValue)
591 {
592 textArraySize_ = jerry_get_array_length(rangeValue);
593 if (textArraySize_ == 0) {
594 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: text picker range invalid!");
595 return false;
596 }
597
598 ReleaseTextRange();
599
600 pTextArray_ = new char *[textArraySize_];
601 if (pTextArray_ == nullptr) {
602 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: allocate memory for dynamic array failed!");
603 return false;
604 }
605
606 for (uint16_t index = 0; index < textArraySize_; index++) {
607 jerry_value_t element = jerry_get_property_by_index(rangeValue, index);
608 char *elementStr = MallocStringOf(element);
609 jerry_release_value(element);
610 if (elementStr == nullptr) {
611 HILOG_ERROR(HILOG_MODULE_ACE, "PickerViewComponent: text picker range contents invalid!");
612 textArraySize_ = index;
613 return false;
614 }
615 pTextArray_[index] = elementStr;
616 }
617 UIPicker *textPicker = reinterpret_cast<UIPicker *>(pickerView_);
618 if (textPickerListener_ != nullptr) {
619 textPickerListener_->SetTextRange(pTextArray_); // call SetTextRange before SetValues!
620 }
621 textPicker->SetValues(const_cast<const char **>(pTextArray_), textArraySize_);
622 // can not loop when pickerview has one child
623 if (textArraySize_ == 1) {
624 textPicker->SetLoopState(false);
625 } else {
626 textPicker->SetLoopState(true);
627 }
628 return true;
629 }
630 } // namespace ACELite
631 } // namespace OHOS
632