1 /*
2  * Copyright (c) 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 "scan_option_descriptor_helper.h"
17 #include "scan_range_helper.h"
18 #include "napi_scan_utils.h"
19 #include "scan_log.h"
20 
21 namespace OHOS::Scan {
22 static constexpr const char *PARAM_OPTION_NAME = "optionName";
23 static constexpr const char *PARAM_OPTION_TITLE = "optionTitle";
24 static constexpr const char *PARAM_OPTION_DESC = "optionDesc";
25 static constexpr const char *PARAM_OPTION_TYPE = "optionType";
26 static constexpr const char *PARAM_OPTION_UNIT = "optionUnit";
27 static constexpr const char *PARAM_OPTION_SIZE = "optionSize";
28 static constexpr const char *PARAM_OPTION_CAP = "optionCap";
29 static constexpr const char *PARAM_OPTION_CONSTRAINT_TYPE = "optionConstraintType";
30 static constexpr const char *PARAM_OPTION_CONSTRAINT_STRING = "optionConstraintString";
31 static constexpr const char *PARAM_OPTION_CONSTRAINT_NUMBER = "optionConstraintNumber";
32 static constexpr const char *PARAM_OPTION_CONSTRAINT_RANGE = "optionConstraintRange";
33 
MakeJsObject(napi_env env,const ScanOptionDescriptor & desc)34 napi_value ScanOptionDescriptorHelper::MakeJsObject(napi_env env, const ScanOptionDescriptor &desc)
35 {
36     napi_value jsObj = nullptr;
37 
38     napi_create_object(env, &jsObj);
39     NapiScanUtils::SetStringPropertyUtf8(env, jsObj, PARAM_OPTION_NAME, desc.GetOptionName());
40     NapiScanUtils::SetStringPropertyUtf8(env, jsObj, PARAM_OPTION_TITLE, desc.GetOptionTitle());
41     NapiScanUtils::SetStringPropertyUtf8(env, jsObj, PARAM_OPTION_DESC, desc.GetOptionDesc());
42     NapiScanUtils::SetUint32Property(env, jsObj, PARAM_OPTION_TYPE, desc.GetOptionType());
43     NapiScanUtils::SetUint32Property(env, jsObj, PARAM_OPTION_UNIT, desc.GetOptionUnit());
44 
45     NapiScanUtils::SetInt32Property(env, jsObj, PARAM_OPTION_SIZE, desc.GetOptionSize());
46     NapiScanUtils::SetInt32Property(env, jsObj, PARAM_OPTION_CAP, desc.GetOptionCap());
47 
48     NapiScanUtils::SetUint32Property(env, jsObj, PARAM_OPTION_CONSTRAINT_TYPE, desc.GetOptionConstraintType());
49 
50     std::vector<std::string> optionConstraintString;
51     desc.GetOptionConstraintString(optionConstraintString);
52     napi_value arrOptionConstraintString = nullptr;
53     SCAN_CALL(env, napi_create_array(env, &arrOptionConstraintString));
54     uint32_t arrOptionConstraintStringLength = optionConstraintString.size();
55     for (uint32_t i = 0; i < arrOptionConstraintStringLength; i++) {
56         napi_value value = NapiScanUtils::CreateStringUtf8(env, optionConstraintString[i]);
57         SCAN_CALL(env, napi_set_element(env, arrOptionConstraintString, i, value));
58     }
59     SCAN_CALL(env, napi_set_named_property(env, jsObj, PARAM_OPTION_CONSTRAINT_STRING, arrOptionConstraintString));
60 
61     std::vector<int32_t> optionConstraintNumber;
62     desc.GetOptionConstraintNumber(optionConstraintNumber);
63     napi_value arrOptionConstraintNumber = nullptr;
64     SCAN_CALL(env, napi_create_array(env, &arrOptionConstraintNumber));
65     uint32_t arrOptionConstraintNumberLength = optionConstraintNumber.size();
66     for (uint32_t i = 0; i < arrOptionConstraintNumberLength; i++) {
67         napi_value value;
68         SCAN_CALL(env, napi_create_int32(env, optionConstraintNumber[i], &value));
69         SCAN_CALL(env, napi_set_element(env, arrOptionConstraintNumber, i, value));
70     }
71     SCAN_CALL(env, napi_set_named_property(env, jsObj, PARAM_OPTION_CONSTRAINT_NUMBER, arrOptionConstraintNumber));
72 
73     ScanRange optionConstraintRange;
74     desc.GetOptionConstraintRange(optionConstraintRange);
75     napi_value scanRange = ScanRangeHelper::MakeJsObject(env, optionConstraintRange);
76     SCAN_CALL(env, napi_set_named_property(env, jsObj, PARAM_OPTION_CONSTRAINT_RANGE, scanRange));
77 
78     return jsObj;
79 }
80 
GetValueFromJs(napi_env env,napi_value jsValue,std::shared_ptr<ScanOptionDescriptor> & nativeObj)81 napi_value ScanOptionDescriptorHelper::GetValueFromJs(napi_env env, napi_value jsValue,
82                                                       std::shared_ptr<ScanOptionDescriptor> &nativeObj)
83 {
84     std::string optionName = NapiScanUtils::GetStringPropertyUtf8(env, jsValue, PARAM_OPTION_NAME);
85     nativeObj->SetOptionName(optionName);
86 
87     std::string optionTitle = NapiScanUtils::GetStringPropertyUtf8(env, jsValue, PARAM_OPTION_TITLE);
88     nativeObj->SetOptionTitle(optionTitle);
89 
90     std::string optionDesc = NapiScanUtils::GetStringPropertyUtf8(env, jsValue, PARAM_OPTION_DESC);
91     nativeObj->SetOptionDesc(optionDesc);
92 
93     uint32_t optionType = NapiScanUtils::GetUint32Property(env, jsValue, PARAM_OPTION_TYPE);
94     nativeObj->SetOptionType(optionType);
95 
96     uint32_t optionUnit = NapiScanUtils::GetUint32Property(env, jsValue, PARAM_OPTION_UNIT);
97     nativeObj->SetOptionUnit(optionUnit);
98 
99     int32_t optionSize = NapiScanUtils::GetInt32Property(env, jsValue, PARAM_OPTION_SIZE);
100     nativeObj->SetOptionSize(optionSize);
101 
102     int32_t optionCap = NapiScanUtils::GetInt32Property(env, jsValue, PARAM_OPTION_CAP);
103     nativeObj->SetOptionCap(optionCap);
104 
105     uint32_t optionConstraintType = NapiScanUtils::GetUint32Property(env, jsValue, PARAM_OPTION_CONSTRAINT_TYPE);
106     nativeObj->SetOptionConstraintType(optionConstraintType);
107     return nullptr;
108 }
109 
ObjSetOptionConstraintString(napi_env env,napi_value jsValue,std::shared_ptr<ScanOptionDescriptor> & nativeObj)110 napi_value ScanOptionDescriptorHelper::ObjSetOptionConstraintString(napi_env env, napi_value jsValue,
111                                                                     std::shared_ptr<ScanOptionDescriptor> &nativeObj)
112 {
113     napi_value jsOptionConstraintString = NapiScanUtils::GetNamedProperty(env, jsValue, PARAM_OPTION_CONSTRAINT_STRING);
114     bool isArray = false;
115     if (jsOptionConstraintString != nullptr) {
116         std::vector<std::string> optionConstraintString;
117         SCAN_CALL(env, napi_is_array(env, jsOptionConstraintString, &isArray));
118         if (!isArray) {
119             SCAN_HILOGE("Invalid list of option constraint string");
120             return nullptr;
121         }
122         uint32_t arrayLength = 0;
123         SCAN_CALL(env, napi_get_array_length(env, jsOptionConstraintString, &arrayLength));
124         for (uint32_t index = 0; index < arrayLength; index++) {
125             napi_value jsConstraintString;
126             std::string constraintString;
127             SCAN_CALL(env, napi_get_element(env, jsOptionConstraintString, index, &jsConstraintString));
128             constraintString = NapiScanUtils::GetValueString(env, jsConstraintString);
129             optionConstraintString.emplace_back(constraintString);
130         }
131         nativeObj->SetOptionConstraintString(optionConstraintString);
132     }
133     return nullptr;
134 }
135 
ObjSetOptionConstraintNumber(napi_env env,napi_value jsValue,std::shared_ptr<ScanOptionDescriptor> & nativeObj)136 napi_value ScanOptionDescriptorHelper::ObjSetOptionConstraintNumber(napi_env env, napi_value jsValue,
137                                                                     std::shared_ptr<ScanOptionDescriptor> &nativeObj)
138 {
139     napi_value jsOptionConstraintNumber = NapiScanUtils::GetNamedProperty(env, jsValue, PARAM_OPTION_CONSTRAINT_NUMBER);
140     bool isArray = false;
141     if (jsOptionConstraintNumber != nullptr) {
142         std::vector<int32_t> optionConstraintNumber;
143         SCAN_CALL(env, napi_is_array(env, jsOptionConstraintNumber, &isArray));
144         if (!isArray) {
145             SCAN_HILOGE("Invalid list of option constraint number");
146             return nullptr;
147         }
148         uint32_t arrayLength = 0;
149         SCAN_CALL(env, napi_get_array_length(env, jsOptionConstraintNumber, &arrayLength));
150         for (uint32_t index = 0; index < arrayLength; index++) {
151             napi_value jsConstraintNumber;
152             int32_t constraintNumber;
153             SCAN_CALL(env, napi_get_element(env, jsOptionConstraintNumber, index, &jsConstraintNumber));
154             SCAN_CALL(env, napi_get_value_int32(env, jsConstraintNumber, &constraintNumber));
155             optionConstraintNumber.emplace_back(constraintNumber);
156         }
157         nativeObj->SetOptionConstraintNumber(optionConstraintNumber);
158     }
159     return nullptr;
160 }
161 
ObjSetOptionConstraintRange(napi_env env,napi_value jsValue,std::shared_ptr<ScanOptionDescriptor> & nativeObj)162 napi_value ScanOptionDescriptorHelper::ObjSetOptionConstraintRange(napi_env env, napi_value jsValue,
163                                                                    std::shared_ptr<ScanOptionDescriptor> &nativeObj)
164 {
165     auto jsOptionConstraintRange = NapiScanUtils::GetNamedProperty(env, jsValue, PARAM_OPTION_CONSTRAINT_RANGE);
166     if (jsOptionConstraintRange != nullptr) {
167         auto scanRange = ScanRangeHelper::BuildFromJs(env, jsOptionConstraintRange);
168         if (scanRange == nullptr) {
169             SCAN_HILOGE("Failed to get scan range from js");
170             return nullptr;
171         }
172         nativeObj->SetOptionConstraintRange(*scanRange);
173     }
174     return nullptr;
175 }
176 
BuildFromJs(napi_env env,napi_value jsValue)177 std::shared_ptr<ScanOptionDescriptor> ScanOptionDescriptorHelper::BuildFromJs(napi_env env, napi_value jsValue)
178 {
179     auto nativeObj = std::make_shared<ScanOptionDescriptor>();
180 
181     auto names = NapiScanUtils::GetPropertyNames(env, jsValue);
182     for (auto name : names) {
183         SCAN_HILOGD("Property: %{public}s", name.c_str());
184     }
185 
186     GetValueFromJs(env, jsValue, nativeObj);
187     ObjSetOptionConstraintString(env, jsValue, nativeObj);
188     ObjSetOptionConstraintNumber(env, jsValue, nativeObj);
189     ObjSetOptionConstraintRange(env, jsValue, nativeObj);
190     return nativeObj;
191 }
192 }  // namespace OHOS::Scan
193