1 /*
2 * Copyright (C) 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 "napi_util.h"
17
18 #include <codecvt>
19 #include <cstdio>
20 #include <cstring>
21 #include <locale>
22 #include <memory>
23 #include <unordered_map>
24 #include <vector>
25
26 #include "core_service_errors.h"
27 #include "enum_convert_for_js.h"
28 #include "state_registry_errors.h"
29 #include "telephony_log_wrapper.h"
30
31 namespace OHOS {
32 namespace Telephony {
33 static constexpr int32_t MAX_TEXT_LENGTH = 4096;
34 static constexpr const char *JS_ERROR_TELEPHONY_PERMISSION_DENIED_STRING = "Permission denied.";
35 static constexpr const char *JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API_STRING = "Non-system applications use system APIs.";
36 static constexpr const char *JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER_STRING =
37 "Parameter error. The type of parameter should match or the number of parameters must match.";
38 static constexpr const char *JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API_STRING = "The device does not support this API.";
39 static constexpr const char *JS_ERROR_TELEPHONY_SUCCESS_STRING = "Success.";
40 static constexpr const char *JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING = "Invalid parameter value.";
41 static constexpr const char *JS_ERROR_TELEPHONY_SERVICE_ERROR_STRING = "Operation failed. Cannot connect to service.";
42 static constexpr const char *JS_ERROR_TELEPHONY_SYSTEM_ERROR_STRING = "System internal error.";
43 static constexpr const char *JS_ERROR_TELEPHONY_NO_SIM_CARD_STRING = "Do not have sim card.";
44 static constexpr const char *JS_ERROR_TELEPHONY_UNKNOW_ERROR_STRING = "Unknown error code.";
45 static constexpr const char *JS_ERROR_SIM_BASE_ERROR_STRING = "Sim module base error.";
46 static constexpr const char *JS_ERROR_SIM_CARD_IS_NOT_ACTIVE_STRING = "SIM card is not activated.";
47 static constexpr const char *JS_ERROR_SIM_CARD_OPERATION_ERROR_STRING = "SIM card operation error.";
48 static constexpr const char *JS_ERROR_OPERATOR_CONFIG_ERROR_STRING = "Operator config error.";
49 static constexpr const char *JS_ERROR_NETWORK_SEARCH_BASE_ERROR_STRING = "Network search module base error.";
50 static constexpr const char *JS_ERROR_CALL_MANAGER_BASE_ERROR_STRING = "Call manager module base error.";
51 static constexpr const char *JS_ERROR_CELLULAR_CALL_CS_BASE_ERROR_STRING = "Cellular call module cs base error.";
52 static constexpr const char *JS_ERROR_CELLULAR_CALL_IMS_BASE_ERROR_STRING = "Cellular call module ims base error.";
53 static constexpr const char *JS_ERROR_CELLULAR_DATA_BASE_ERROR_STRING = "Cellular data module base error.";
54 static constexpr const char *JS_ERROR_SMS_MMS_BASE_ERROR_STRING = "Sms mms module base error.";
55 static constexpr const char *JS_ERROR_STATE_REGISTRY_BASE_ERROR_STRING = "State registry module base error.";
56 static constexpr const char *JS_ERROR_AIRPLANE_MODE_ON_STRING = "Airplane mode is on.";
57 static constexpr const char *JS_ERROR_NETWORK_NOT_IN_SERVICE = "Network not in service.";
58 static constexpr const char *JS_ERROR_CONFERENCE_EXCEED_LIMIT_STRING = "Conference call is exceed limit.";
59 static constexpr const char *JS_ERROR_CONFERENCE_CALL_IS_NOT_ACTIVE_STRING = "Conference call is not active.";
60 static constexpr const char *JS_ERROR_TELEPHONY_CALL_COUNTS_EXCEED_LIMIT_STRING = "call count exceeds limit";
61 static constexpr const char *JS_ERROR_TELEPHONY_DIAL_IS_BUSY_STRING =
62 "Current on a call, unable to initiate a new call";
63 static constexpr const char *JS_ERROR_ESIM_SUCCESS_STRING = "Success.";
64 static constexpr const char *JS_ERROR_ESIM_SERVICE_ERROR_STRING = "Service connection failed.";
65 static constexpr const char *JS_ERROR_ESIM_SYSTEM_ERROR_STRING = "System internal error.";
66
67 static std::unordered_map<int32_t, const char *> errorMap_ = {
68 { JsErrorCode::JS_ERROR_TELEPHONY_PERMISSION_DENIED, JS_ERROR_TELEPHONY_PERMISSION_DENIED_STRING },
69 { JsErrorCode::JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API, JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API_STRING },
70 { JsErrorCode::JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER, JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER_STRING },
71 { JsErrorCode::JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API, JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API_STRING },
72 { JsErrorCode::JS_ERROR_TELEPHONY_SUCCESS, JS_ERROR_TELEPHONY_SUCCESS_STRING },
73 { JsErrorCode::JS_ERROR_TELEPHONY_ARGUMENT_ERROR, JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING },
74 { JsErrorCode::JS_ERROR_TELEPHONY_SERVICE_ERROR, JS_ERROR_TELEPHONY_SERVICE_ERROR_STRING },
75 { JsErrorCode::JS_ERROR_TELEPHONY_SYSTEM_ERROR, JS_ERROR_TELEPHONY_SYSTEM_ERROR_STRING },
76 { JsErrorCode::JS_ERROR_TELEPHONY_NO_SIM_CARD, JS_ERROR_TELEPHONY_NO_SIM_CARD_STRING },
77 { JsErrorCode::JS_ERROR_TELEPHONY_UNKNOW_ERROR, JS_ERROR_TELEPHONY_UNKNOW_ERROR_STRING },
78 { JsErrorCode::JS_ERROR_SIM_BASE_ERROR, JS_ERROR_SIM_BASE_ERROR_STRING },
79 { JsErrorCode::JS_ERROR_SIM_CARD_IS_NOT_ACTIVE, JS_ERROR_SIM_CARD_IS_NOT_ACTIVE_STRING },
80 { JsErrorCode::JS_ERROR_SIM_CARD_OPERATION_ERROR, JS_ERROR_SIM_CARD_OPERATION_ERROR_STRING },
81 { JsErrorCode::JS_ERROR_OPERATOR_CONFIG_ERROR, JS_ERROR_OPERATOR_CONFIG_ERROR_STRING },
82 { JsErrorCode::JS_ERROR_NETWORK_SEARCH_BASE_ERROR, JS_ERROR_NETWORK_SEARCH_BASE_ERROR_STRING },
83 { JsErrorCode::JS_ERROR_CALL_MANAGER_BASE_ERROR, JS_ERROR_CALL_MANAGER_BASE_ERROR_STRING },
84 { JsErrorCode::JS_ERROR_CELLULAR_CALL_CS_BASE_ERROR, JS_ERROR_CELLULAR_CALL_CS_BASE_ERROR_STRING },
85 { JsErrorCode::JS_ERROR_CELLULAR_CALL_IMS_BASE_ERROR, JS_ERROR_CELLULAR_CALL_IMS_BASE_ERROR_STRING },
86 { JsErrorCode::JS_ERROR_CELLULAR_DATA_BASE_ERROR, JS_ERROR_CELLULAR_DATA_BASE_ERROR_STRING },
87 { JsErrorCode::JS_ERROR_SMS_MMS_BASE_ERROR, JS_ERROR_SMS_MMS_BASE_ERROR_STRING },
88 { JsErrorCode::JS_ERROR_STATE_REGISTRY_BASE_ERROR, JS_ERROR_STATE_REGISTRY_BASE_ERROR_STRING },
89 { JsErrorCode::JS_ERROR_TELEPHONY_AIRPLANE_MODE_ON, JS_ERROR_AIRPLANE_MODE_ON_STRING },
90 { JsErrorCode::JS_ERROR_TELEPHONY_NETWORK_NOT_IN_SERVICE, JS_ERROR_NETWORK_NOT_IN_SERVICE },
91 { JsErrorCode::JS_ERROR_TELEPHONY_CONFERENCE_EXCEED_LIMIT, JS_ERROR_CONFERENCE_EXCEED_LIMIT_STRING },
92 { JsErrorCode::JS_ERROR_TELEPHONY_CONFERENCE_CALL_NOT_ACTIVE, JS_ERROR_CONFERENCE_CALL_IS_NOT_ACTIVE_STRING },
93 { JsErrorCode::JS_ERROR_TELEPHONY_CALL_COUNTS_EXCEED_LIMIT, JS_ERROR_TELEPHONY_CALL_COUNTS_EXCEED_LIMIT_STRING },
94 { JsErrorCode::JS_ERROR_TELEPHONY_DIAL_IS_BUSY, JS_ERROR_TELEPHONY_DIAL_IS_BUSY_STRING },
95 { JsErrorCode::JS_ERROR_ESIM_SUCCESS, JS_ERROR_ESIM_SUCCESS_STRING },
96 { JsErrorCode::JS_ERROR_ESIM_SERVICE_ERROR, JS_ERROR_ESIM_SERVICE_ERROR_STRING },
97 { JsErrorCode::JS_ERROR_ESIM_SYSTEM_ERROR, JS_ERROR_ESIM_SYSTEM_ERROR_STRING },
98 };
99 const std::string ERROR_STRING = "error";
100 const std::u16string ERROR_USTRING = u"error";
101
GetErrorMessage(int32_t errorCode)102 std::string NapiUtil::GetErrorMessage(int32_t errorCode)
103 {
104 std::string result = "";
105 auto iter = errorMap_.find(errorCode);
106 if (iter == errorMap_.end()) {
107 TELEPHONY_LOGE("NapiUtil::GetErrorMessage return null.");
108 return result;
109 }
110 TELEPHONY_LOGD("NapiUtil::GetErrorMessage errorCode %{public}d, message = %{public}s", errorCode, iter->second);
111 result = iter->second;
112 return result;
113 }
114
ToUtf8(std::u16string str16)115 std::string NapiUtil::ToUtf8(std::u16string str16)
116 {
117 if (str16 == ERROR_USTRING) {
118 return ERROR_STRING;
119 }
120 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert(ERROR_STRING);
121 std::string result = convert.to_bytes(str16);
122 return result == ERROR_STRING ? "" : result;
123 }
124
ToUtf16(std::string str)125 std::u16string NapiUtil::ToUtf16(std::string str)
126 {
127 if (str == ERROR_STRING) {
128 return ERROR_USTRING;
129 }
130 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert(ERROR_STRING, ERROR_USTRING);
131 std::u16string result = convert.from_bytes(str);
132 return result == ERROR_USTRING ? u"" : result;
133 }
134
CreateErrorMessage(napi_env env,const std::string & msg,int32_t errorCode)135 napi_value NapiUtil::CreateErrorMessage(napi_env env, const std::string &msg, int32_t errorCode)
136 {
137 napi_value result = nullptr;
138 napi_value message = nullptr;
139 NAPI_CALL(env, napi_create_string_utf8(env, msg.c_str(), msg.length(), &message));
140 napi_value codeValue = nullptr;
141 NAPI_CALL(env, napi_create_int32(env, errorCode, &codeValue));
142 NAPI_CALL(env, napi_create_object(env, &result));
143 NAPI_CALL(env, napi_set_named_property(env, result, "code", codeValue));
144 NAPI_CALL(env, napi_set_named_property(env, result, "message", message));
145 return result;
146 }
147
CreateUndefined(napi_env env)148 napi_value NapiUtil::CreateUndefined(napi_env env)
149 {
150 napi_value result = nullptr;
151 NAPI_CALL(env, napi_get_undefined(env, &result));
152 return result;
153 }
154
MatchValueType(napi_env env,napi_value value,napi_valuetype targetType)155 bool NapiUtil::MatchValueType(napi_env env, napi_value value, napi_valuetype targetType)
156 {
157 napi_valuetype valueType = napi_undefined;
158 NAPI_CALL_BASE(env, napi_typeof(env, value, &valueType), false);
159 return valueType == targetType;
160 }
161
MatchParameters(napi_env env,const napi_value parameters[],std::initializer_list<napi_valuetype> valueTypes)162 bool NapiUtil::MatchParameters(
163 napi_env env, const napi_value parameters[], std::initializer_list<napi_valuetype> valueTypes)
164 {
165 if (parameters == nullptr) {
166 return false;
167 }
168 int i = 0;
169 for (auto beg = valueTypes.begin(); beg != valueTypes.end(); ++beg) {
170 if (!MatchValueType(env, parameters[i], *beg)) {
171 return false;
172 }
173 ++i;
174 }
175 return true;
176 }
177
SetPropertyInt32(napi_env env,napi_value object,const std::string & name,int32_t value)178 void NapiUtil::SetPropertyInt32(napi_env env, napi_value object, const std::string &name, int32_t value)
179 {
180 napi_value propertyValue = nullptr;
181 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, value, &propertyValue));
182 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name.c_str(), propertyValue));
183 }
184
SetPropertyInt64(napi_env env,napi_value object,const std::string & name,int64_t value)185 void NapiUtil::SetPropertyInt64(napi_env env, napi_value object, const std::string &name, int64_t value)
186 {
187 napi_value propertyValue = nullptr;
188 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, value, &propertyValue));
189 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name.c_str(), propertyValue));
190 }
191
SetPropertyStringUtf8(napi_env env,napi_value object,const std::string & name,const std::string & value)192 void NapiUtil::SetPropertyStringUtf8(napi_env env, napi_value object, const std::string &name, const std::string &value)
193 {
194 napi_value propertyValue = nullptr;
195 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, value.c_str(), value.length(), &propertyValue));
196 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name.c_str(), propertyValue));
197 }
198
SetPropertyBoolean(napi_env env,napi_value object,const std::string & name,bool value)199 void NapiUtil::SetPropertyBoolean(napi_env env, napi_value object, const std::string &name, bool value)
200 {
201 napi_value propertyValue = nullptr;
202 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, value, &propertyValue));
203 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name.c_str(), propertyValue));
204 }
205
ToInt32Value(napi_env env,int32_t value)206 napi_value NapiUtil::ToInt32Value(napi_env env, int32_t value)
207 {
208 napi_value staticValue = nullptr;
209 NAPI_CALL(env, napi_create_int32(env, value, &staticValue));
210 return staticValue;
211 }
212
HasNamedProperty(napi_env env,napi_value object,const std::string & propertyName)213 bool NapiUtil::HasNamedProperty(napi_env env, napi_value object, const std::string &propertyName)
214 {
215 bool hasProperty = false;
216 NAPI_CALL_BASE(env, napi_has_named_property(env, object, propertyName.data(), &hasProperty), false);
217 return hasProperty;
218 }
219
HasNamedTypeProperty(napi_env env,napi_value object,napi_valuetype type,const std::string & propertyName)220 bool NapiUtil::HasNamedTypeProperty(
221 napi_env env, napi_value object, napi_valuetype type, const std::string &propertyName)
222 {
223 bool hasProperty = false;
224 NAPI_CALL_BASE(env, napi_has_named_property(env, object, propertyName.data(), &hasProperty), false);
225 if (hasProperty) {
226 napi_value value = nullptr;
227 NAPI_CALL_BASE(env, napi_get_named_property(env, object, propertyName.data(), &value), false);
228 return MatchValueType(env, value, type);
229 }
230 return false;
231 }
232
MatchObjectProperty(napi_env env,napi_value object,std::initializer_list<std::pair<std::string,napi_valuetype>> pairList)233 bool NapiUtil::MatchObjectProperty(
234 napi_env env, napi_value object, std::initializer_list<std::pair<std::string, napi_valuetype>> pairList)
235 {
236 if (object == nullptr) {
237 return false;
238 }
239 for (auto beg = pairList.begin(); beg != pairList.end(); ++beg) {
240 if (!HasNamedTypeProperty(env, object, beg->second, beg->first)) {
241 return false;
242 }
243 }
244 return true;
245 }
246
MatchOptionPropertyType(napi_env env,napi_value object,napi_valuetype type,const std::string & propertyName)247 bool NapiUtil::MatchOptionPropertyType(
248 napi_env env, napi_value object, napi_valuetype type, const std::string &propertyName)
249 {
250 bool hasProperty = false;
251 NAPI_CALL_BASE(env, napi_has_named_property(env, object, propertyName.data(), &hasProperty), false);
252 if (hasProperty) {
253 napi_value value = nullptr;
254 NAPI_CALL_BASE(env, napi_get_named_property(env, object, propertyName.data(), &value), false);
255 return MatchValueType(env, value, type);
256 }
257 return true;
258 }
259
GetStringFromValue(napi_env env,napi_value value)260 std::string NapiUtil::GetStringFromValue(napi_env env, napi_value value)
261 {
262 char msgChars[MAX_TEXT_LENGTH] = {0};
263 size_t msgLength = 0;
264 NAPI_CALL_BASE(env, napi_get_value_string_utf8(env, value, msgChars, MAX_TEXT_LENGTH, &msgLength), "");
265 TELEPHONY_LOGI("msgLength = %{public}zu", msgLength);
266 if (msgLength > 0) {
267 return std::string(msgChars, 0, msgLength);
268 } else {
269 return "";
270 }
271 }
272
GetNamedProperty(napi_env env,napi_value object,const std::string & propertyName)273 napi_value NapiUtil::GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName)
274 {
275 napi_value value = nullptr;
276 bool hasProperty = false;
277 NAPI_CALL(env, napi_has_named_property(env, object, propertyName.data(), &hasProperty));
278 if (hasProperty) {
279 NAPI_CALL(env, napi_get_named_property(env, object, propertyName.data(), &value));
280 }
281 return value;
282 }
283
HandleAsyncWork(napi_env env,BaseContext * baseContext,const std::string & workName,napi_async_execute_callback execute,napi_async_complete_callback complete)284 napi_value NapiUtil::HandleAsyncWork(napi_env env, BaseContext *baseContext, const std::string &workName,
285 napi_async_execute_callback execute, napi_async_complete_callback complete)
286 {
287 TELEPHONY_LOGD("workName = %{public}s", workName.c_str());
288 std::unique_ptr<BaseContext> context(baseContext);
289 if (context == nullptr) {
290 ThrowParameterError(env);
291 return nullptr;
292 }
293 napi_value result = nullptr;
294 if (context->callbackRef == nullptr) {
295 NAPI_CALL(env, napi_create_promise(env, &context->deferred, &result));
296 } else {
297 NAPI_CALL(env, napi_get_undefined(env, &result));
298 }
299 napi_value resource = CreateUndefined(env);
300 napi_value resourceName = nullptr;
301 NAPI_CALL(env, napi_create_string_utf8(env, workName.data(), NAPI_AUTO_LENGTH, &resourceName));
302 NAPI_CALL(env,
303 napi_create_async_work(env, resource, resourceName, execute, complete, (void *)context.get(), &context->work));
304 napi_status queueWorkStatus = napi_queue_async_work_with_qos(env, context->work, napi_qos_default);
305 if (queueWorkStatus == napi_ok) {
306 context.release();
307 } else {
308 std::string errorCode = std::to_string(queueWorkStatus);
309 std::string errorMessage = "error at napi_queue_async_work_with_qos";
310 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
311 }
312 TELEPHONY_LOGD("NapiUtil HandleAsyncWork end");
313 return result;
314 }
315
ReleaseBaseContext(napi_env env,BaseContext * baseContext)316 void NapiUtil::ReleaseBaseContext(napi_env env, BaseContext *baseContext)
317 {
318 if (baseContext == nullptr) {
319 TELEPHONY_LOGE("release baseContext is nullptr");
320 return;
321 }
322 napi_delete_async_work(env, baseContext->work);
323 baseContext->work = nullptr;
324 delete baseContext;
325 baseContext = nullptr;
326 }
327
Handle1ValueCallback(napi_env env,BaseContext * baseContext,napi_value callbackValue)328 void NapiUtil::Handle1ValueCallback(napi_env env, BaseContext *baseContext, napi_value callbackValue)
329 {
330 TELEPHONY_LOGD("Handle1ValueCallback start");
331 if (baseContext == nullptr) {
332 TELEPHONY_LOGE("Handle1ValueCallback baseContext is nullptr");
333 NapiUtil::ThrowParameterError(env);
334 return;
335 }
336 if (baseContext->callbackRef != nullptr) {
337 TELEPHONY_LOGI("start normal callback");
338 napi_value recv = CreateUndefined(env);
339 napi_value callbackFunc = nullptr;
340 if (napi_get_reference_value(env, baseContext->callbackRef, &callbackFunc) != napi_ok) {
341 ReleaseBaseContext(env, baseContext);
342 GET_AND_THROW_LAST_ERROR(env);
343 return;
344 }
345 napi_value callbackValues[] = {callbackValue};
346 napi_value result = nullptr;
347 if (napi_call_function(env, recv, callbackFunc, std::size(callbackValues), callbackValues, &result) !=
348 napi_ok) {
349 ReleaseBaseContext(env, baseContext);
350 GET_AND_THROW_LAST_ERROR(env);
351 return;
352 }
353 if (napi_delete_reference(env, baseContext->callbackRef) != napi_ok) {
354 ReleaseBaseContext(env, baseContext);
355 GET_AND_THROW_LAST_ERROR(env);
356 return;
357 }
358 TELEPHONY_LOGD("normal callback end");
359 } else if (baseContext->deferred != nullptr) {
360 TELEPHONY_LOGD("start promise callback");
361 if (baseContext->resolved) {
362 if (napi_resolve_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
363 ReleaseBaseContext(env, baseContext);
364 GET_AND_THROW_LAST_ERROR(env);
365 return;
366 }
367 TELEPHONY_LOGI("napi_resolve_deferred end");
368 } else {
369 if (napi_reject_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
370 ReleaseBaseContext(env, baseContext);
371 GET_AND_THROW_LAST_ERROR(env);
372 return;
373 }
374 TELEPHONY_LOGI("napi_reject_deferred end");
375 }
376 TELEPHONY_LOGD("promise callback end");
377 }
378 ReleaseBaseContext(env, baseContext);
379 TELEPHONY_LOGD("end");
380 }
381
Handle2ValueCallback(napi_env env,BaseContext * baseContext,napi_value callbackValue)382 void NapiUtil::Handle2ValueCallback(napi_env env, BaseContext *baseContext, napi_value callbackValue)
383 {
384 TELEPHONY_LOGD("Handle2ValueCallback start");
385 if (baseContext == nullptr) {
386 TELEPHONY_LOGI("Handle2ValueCallback serious error baseContext nullptr");
387 ThrowParameterError(env);
388 return;
389 }
390 if (baseContext->callbackRef != nullptr) {
391 TELEPHONY_LOGD("Handle2ValueCallback start normal callback");
392 napi_value recv = CreateUndefined(env);
393 napi_value callbackFunc = nullptr;
394 if (napi_get_reference_value(env, baseContext->callbackRef, &callbackFunc) != napi_ok) {
395 ReleaseBaseContext(env, baseContext);
396 GET_AND_THROW_LAST_ERROR(env);
397 return;
398 }
399 napi_value callbackValues[] = {nullptr, nullptr};
400 callbackValues[0] = baseContext->resolved ? CreateUndefined(env) : callbackValue;
401 callbackValues[1] = baseContext->resolved ? callbackValue : CreateUndefined(env);
402 napi_value result = nullptr;
403 if (napi_call_function(env, recv, callbackFunc, std::size(callbackValues), callbackValues, &result) !=
404 napi_ok) {
405 ReleaseBaseContext(env, baseContext);
406 GET_AND_THROW_LAST_ERROR(env);
407 return;
408 }
409 if (napi_delete_reference(env, baseContext->callbackRef) != napi_ok) {
410 ReleaseBaseContext(env, baseContext);
411 GET_AND_THROW_LAST_ERROR(env);
412 return;
413 }
414 TELEPHONY_LOGD("Handle2ValueCallback normal callback end");
415 } else if (baseContext->deferred != nullptr) {
416 TELEPHONY_LOGD("Handle2ValueCallback start promise callback");
417 if (baseContext->resolved) {
418 if (napi_resolve_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
419 ReleaseBaseContext(env, baseContext);
420 GET_AND_THROW_LAST_ERROR(env);
421 return;
422 }
423 } else {
424 if (napi_reject_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
425 ReleaseBaseContext(env, baseContext);
426 GET_AND_THROW_LAST_ERROR(env);
427 return;
428 }
429 }
430 TELEPHONY_LOGD("Handle2ValueCallback promise callback end");
431 }
432 ReleaseBaseContext(env, baseContext);
433 TELEPHONY_LOGD("Handle2ValueCallback end");
434 }
435
DefineEnumClassByName(napi_env env,napi_value exports,std::string_view enumName,size_t arrSize,const napi_property_descriptor * desc)436 void NapiUtil::DefineEnumClassByName(
437 napi_env env, napi_value exports, std::string_view enumName, size_t arrSize, const napi_property_descriptor *desc)
438 {
439 auto construct = [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; };
440 napi_value result = nullptr;
441 napi_status status =
442 napi_define_class(env, enumName.data(), NAPI_AUTO_LENGTH, construct, nullptr, arrSize, desc, &result);
443 if (status != napi_ok) {
444 TELEPHONY_LOGE("DefineEnumClassByName napi_define_class failed ret = %d", status);
445 }
446 status = napi_set_named_property(env, exports, enumName.data(), result);
447 if (status != napi_ok) {
448 TELEPHONY_LOGE("DefineEnumClassByName napi_set_named_property failed ret = %d", status);
449 }
450 }
451
ConverErrorMessageForJs(int32_t errorCode)452 JsError NapiUtil::ConverErrorMessageForJs(int32_t errorCode)
453 {
454 JsError error = {};
455 if (errorCode == TELEPHONY_ERR_SUCCESS) {
456 error.errorCode = JS_ERROR_TELEPHONY_SUCCESS;
457 error.errorMessage = GetErrorMessage(JS_ERROR_TELEPHONY_SUCCESS);
458 return error;
459 }
460
461 if (CreateParameterErrorMessageForJs(errorCode, error.errorCode)) {
462 error.errorMessage = GetErrorMessage(error.errorCode);
463 return error;
464 }
465
466 if (!CreateCommonErrorMessageForJs(errorCode, error.errorCode) &&
467 !CreateCallErrorMessageForJs(errorCode, error.errorCode) &&
468 !CreateDataErrorMessageForJs(errorCode, error.errorCode) &&
469 !CreateNetworkSearchErrorMessageForJs(errorCode, error.errorCode) &&
470 !CreateVcardErrorMessageForJs(errorCode, error.errorCode) &&
471 !CreateSimErrorMessageForJs(errorCode, error.errorCode) &&
472 !CreateSmsErrorMessageForJs(errorCode, error.errorCode) &&
473 !CreateObserverErrorMessageForJs(errorCode, error.errorCode)) {
474 error.errorCode = JS_ERROR_TELEPHONY_UNKNOW_ERROR;
475 TELEPHONY_LOGE("NapiUtil::ConverErrorMessageForJs errorCode is out of range");
476 }
477 error.errorMessage = GetErrorMessage(error.errorCode);
478 TELEPHONY_LOGI("errorCode from %{public}d to %{public}d", errorCode, error.errorCode);
479 return error;
480 }
481
CreateEsimParameterErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)482 bool NapiUtil::CreateEsimParameterErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
483 {
484 bool flag = true;
485 switch (errorCode) {
486 case ERROR_PARAMETER_COUNTS_INVALID:
487 case ERROR_PARAMETER_TYPE_INVALID:
488 case ERROR_SLOT_ID_INVALID:
489 case napi_status::napi_generic_failure:
490 case napi_status::napi_invalid_arg:
491 jsErrorCode = JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER;
492 break;
493 default:
494 flag = false;
495 break;
496 }
497
498 return flag;
499 }
500
CreateEsimServiceErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)501 bool NapiUtil::CreateEsimServiceErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
502 {
503 bool flag = true;
504
505 switch (errorCode) {
506 case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
507 case TELEPHONY_ERR_WRITE_DATA_FAIL:
508 case TELEPHONY_ERR_WRITE_REPLY_FAIL:
509 case TELEPHONY_ERR_READ_DATA_FAIL:
510 case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
511 jsErrorCode = JS_ERROR_ESIM_SERVICE_ERROR;
512 break;
513 case TELEPHONY_ERR_NOT_SUPPORT_ESIM:
514 jsErrorCode = JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API;
515 break;
516 default:
517 flag = false;
518 break;
519 }
520 return flag;
521 }
522
CreateEsimSystemErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)523 bool NapiUtil::CreateEsimSystemErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
524 {
525 bool flag = true;
526
527 switch (errorCode) {
528 case TELEPHONY_ERR_FAIL:
529 case TELEPHONY_ERR_LOCAL_PTR_NULL:
530 case TELEPHONY_ERR_ESIM_GET_RESULT_TIMEOUT:
531 jsErrorCode = JS_ERROR_ESIM_SYSTEM_ERROR;
532 break;
533 case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
534 jsErrorCode = JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API;
535 break;
536 default:
537 flag = false;
538 break;
539 }
540 return flag;
541 }
542
ConverEsimErrorMessageForJs(int32_t errorCode)543 JsError NapiUtil::ConverEsimErrorMessageForJs(int32_t errorCode)
544 {
545 JsError error = {};
546 if (errorCode == TELEPHONY_ERR_SUCCESS) {
547 error.errorCode = JS_ERROR_ESIM_SUCCESS;
548 error.errorMessage = GetErrorMessage(JS_ERROR_ESIM_SUCCESS);
549 return error;
550 }
551
552 if (CreateEsimParameterErrorMessageForJs(errorCode, error.errorCode)) {
553 error.errorMessage = GetErrorMessage(error.errorCode);
554 return error;
555 }
556
557 if (!CreateEsimServiceErrorMessageForJs(errorCode, error.errorCode) &&
558 !CreateEsimSystemErrorMessageForJs(errorCode, error.errorCode)) {
559 error.errorCode = JS_ERROR_ESIM_SYSTEM_ERROR;
560 TELEPHONY_LOGE("NapiUtil::ConverEsimErrorMessageForJs errorCode is out of range");
561 }
562 error.errorMessage = GetErrorMessage(error.errorCode);
563 TELEPHONY_LOGI("errorCode from %{public}d to %{public}d", errorCode, error.errorCode);
564 return error;
565 }
566
ConverEsimErrorMessageWithPermissionForJs(int32_t errorCode,const std::string & funcName,const std::string & permission)567 JsError NapiUtil::ConverEsimErrorMessageWithPermissionForJs(
568 int32_t errorCode, const std::string &funcName, const std::string &permission)
569 {
570 if (errorCode == TELEPHONY_ERR_PERMISSION_ERR) {
571 JsError error = {};
572 error.errorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
573 error.errorMessage = "BusinessError 201: Permission denied. An attempt was made to " + funcName +
574 " forbidden by permission: " + permission;
575 return error;
576 }
577 return ConverEsimErrorMessageForJs(errorCode);
578 }
579
CreateParameterErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)580 bool NapiUtil::CreateParameterErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
581 {
582 bool flag = true;
583 switch (errorCode) {
584 case ERROR_SERVICE_UNAVAILABLE:
585 case ERROR_NATIVE_API_EXECUTE_FAIL:
586 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
587 break;
588 case ERROR_PARAMETER_COUNTS_INVALID:
589 case ERROR_PARAMETER_TYPE_INVALID:
590 case napi_status::napi_generic_failure:
591 case napi_status::napi_invalid_arg:
592 jsErrorCode = JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER;
593 break;
594 case ERROR_SLOT_ID_INVALID:
595 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
596 break;
597 default:
598 flag = false;
599 break;
600 }
601
602 return flag;
603 }
604
CreateNetworkSearchErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)605 bool NapiUtil::CreateNetworkSearchErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
606 {
607 if ((errorCode < CORE_SERVICE_NETWORK_SEARCH_ERR_OFFSET || errorCode >= CORE_SERVICE_CORE_ERR_OFFSET)) {
608 return false;
609 }
610 bool flag = true;
611 switch (errorCode) {
612 case CORE_SERVICE_SEND_CALLBACK_FAILED:
613 case CORE_SERVICE_RADIO_PROTOCOL_TECH_UNKNOWN:
614 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
615 break;
616 default:
617 flag = false;
618 break;
619 }
620
621 return flag;
622 }
623
CreateVcardErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)624 bool NapiUtil::CreateVcardErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
625 {
626 bool flag = true;
627 switch (errorCode) {
628 case TELEPHONY_ERR_VCARD_FILE_INVALID:
629 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
630 break;
631 default:
632 flag = false;
633 break;
634 }
635
636 return flag;
637 }
638
CreateSimErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)639 bool NapiUtil::CreateSimErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
640 {
641 if ((errorCode < CORE_SERVICE_SIM_ERR_OFFSET || errorCode >= CORE_SERVICE_NETWORK_SEARCH_ERR_OFFSET)) {
642 return false;
643 }
644 bool flag = true;
645 switch (errorCode) {
646 case CORE_SERVICE_SIM_CARD_IS_NOT_ACTIVE:
647 jsErrorCode = JS_ERROR_SIM_CARD_IS_NOT_ACTIVE;
648 break;
649 case CORE_ERR_SIM_CARD_LOAD_FAILED:
650 case CORE_ERR_SIM_CARD_UPDATE_FAILED:
651 jsErrorCode = JS_ERROR_SIM_CARD_OPERATION_ERROR;
652 break;
653 case CORE_ERR_OPERATOR_KEY_NOT_EXIT:
654 case CORE_ERR_OPERATOR_CONF_NOT_EXIT:
655 jsErrorCode = JS_ERROR_OPERATOR_CONFIG_ERROR;
656 break;
657 default:
658 flag = false;
659 break;
660 }
661
662 return flag;
663 }
664
CreateSmsErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)665 bool NapiUtil::CreateSmsErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
666 {
667 if ((errorCode < SMS_MMS_ERR_OFFSET || errorCode >= STATE_REGISTRY_ERR_OFFSET)) {
668 return false;
669 }
670 bool flag = true;
671 switch (errorCode) {
672 case TELEPHONY_SMS_MMS_DECODE_DATA_EMPTY:
673 case TELEPHONY_SMS_MMS_UNKNOWN_SIM_MESSAGE_STATUS:
674 case TELEPHONY_SMS_MMS_MESSAGE_LENGTH_OUT_OF_RANGE:
675 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
676 break;
677 default:
678 flag = false;
679 break;
680 }
681
682 return flag;
683 }
684
CreateObserverErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)685 bool NapiUtil::CreateObserverErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
686 {
687 if ((errorCode < STATE_REGISTRY_ERR_OFFSET || errorCode >= NET_MANAGER_ERR_OFFSET)) {
688 return false;
689 }
690 bool flag = true;
691 switch (errorCode) {
692 case TELEPHONY_STATE_REGISTRY_SLODID_ERROR:
693 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
694 break;
695 case TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED:
696 jsErrorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
697 break;
698 case TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST:
699 case TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST:
700 case TELEPHONY_STATE_REGISTRY_DATA_EXIST:
701 case TELEPHONY_STATE_REGISTRY_NOT_IMPLEMENTED:
702 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
703 break;
704 default:
705 flag = false;
706 break;
707 }
708
709 return flag;
710 }
711
CreateCommonErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)712 bool NapiUtil::CreateCommonErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
713 {
714 if ((errorCode < COMMON_ERR_OFFSET || errorCode >= CALL_ERR_OFFSET)) {
715 return false;
716 }
717 if (CreateCommonArgumentErrorMessageForJs(errorCode, jsErrorCode) ||
718 CreateCommonServiceErrorMessageForJs(errorCode, jsErrorCode) ||
719 CreateCommonSystemErrorMessageForJs(errorCode, jsErrorCode)) {
720 return true;
721 }
722 return false;
723 }
724
CreateCommonArgumentErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)725 bool NapiUtil::CreateCommonArgumentErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
726 {
727 bool flag = true;
728
729 switch (errorCode) {
730 case TELEPHONY_ERR_ARGUMENT_MISMATCH:
731 case TELEPHONY_ERR_ARGUMENT_INVALID:
732 case TELEPHONY_ERR_ARGUMENT_NULL:
733 case TELEPHONY_ERR_SLOTID_INVALID:
734 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
735 break;
736 default:
737 flag = false;
738 break;
739 }
740 return flag;
741 }
742
CreateCommonServiceErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)743 bool NapiUtil::CreateCommonServiceErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
744 {
745 bool flag = true;
746
747 switch (errorCode) {
748 case TELEPHONY_ERR_DESCRIPTOR_MISMATCH:
749 case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
750 case TELEPHONY_ERR_WRITE_DATA_FAIL:
751 case TELEPHONY_ERR_WRITE_REPLY_FAIL:
752 case TELEPHONY_ERR_READ_DATA_FAIL:
753 case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
754 case TELEPHONY_ERR_REGISTER_CALLBACK_FAIL:
755 case TELEPHONY_ERR_CALLBACK_ALREADY_REGISTERED:
756 case TELEPHONY_ERR_UNINIT:
757 case TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL:
758 jsErrorCode = JS_ERROR_TELEPHONY_SERVICE_ERROR;
759 break;
760 default:
761 flag = false;
762 break;
763 }
764 return flag;
765 }
766
CreateCommonSystemErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)767 bool NapiUtil::CreateCommonSystemErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
768 {
769 bool flag = true;
770
771 switch (errorCode) {
772 case TELEPHONY_ERR_FAIL:
773 case TELEPHONY_ERR_MEMCPY_FAIL:
774 case TELEPHONY_ERR_MEMSET_FAIL:
775 case TELEPHONY_ERR_STRCPY_FAIL:
776 case TELEPHONY_ERR_LOCAL_PTR_NULL:
777 case TELEPHONY_ERR_SUBSCRIBE_BROADCAST_FAIL:
778 case TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL:
779 case TELEPHONY_ERR_ADD_DEATH_RECIPIENT_FAIL:
780 case TELEPHONY_ERR_STRTOINT_FAIL:
781 case TELEPHONY_ERR_RIL_CMD_FAIL:
782 case TELEPHONY_ERR_DATABASE_WRITE_FAIL:
783 case TELEPHONY_ERR_DATABASE_READ_FAIL:
784 case TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE:
785 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
786 break;
787 case TELEPHONY_ERR_NO_SIM_CARD:
788 jsErrorCode = JS_ERROR_TELEPHONY_NO_SIM_CARD;
789 break;
790 case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
791 jsErrorCode = JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API;
792 break;
793 case TELEPHONY_ERR_AIRPLANE_MODE_ON:
794 jsErrorCode = JS_ERROR_TELEPHONY_AIRPLANE_MODE_ON;
795 break;
796 case TELEPHONY_ERR_NETWORK_NOT_IN_SERVICE:
797 jsErrorCode = JS_ERROR_TELEPHONY_NETWORK_NOT_IN_SERVICE;
798 break;
799 default:
800 flag = false;
801 break;
802 }
803 return flag;
804 }
805
CreateCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)806 bool NapiUtil::CreateCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
807 {
808 if ((errorCode < CALL_ERR_OFFSET || errorCode >= CELLULAR_DATA_ERR_OFFSET)) {
809 return false;
810 }
811 if (CreateCommonCallErrorMessageForJs(errorCode, jsErrorCode) ||
812 CreateVideoCallErrorMessageForJs(errorCode, jsErrorCode) ||
813 CreateSupplementServiceCallErrorMessageForJs(errorCode, jsErrorCode)) {
814 return true;
815 }
816 return false;
817 }
818
CreateCommonCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)819 bool NapiUtil::CreateCommonCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
820 {
821 bool flag = true;
822
823 switch (errorCode) {
824 case TELEPHONY_CALL_ERR_NUMBER_OUT_OF_RANGE:
825 case TELEPHONY_CALL_ERR_PHONE_NUMBER_EMPTY:
826 case TELEPHONY_CALL_ERR_FORMAT_PHONE_NUMBER_FAILED:
827 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
828 break;
829 case TELEPHONY_CALL_ERR_PARAMETER_OUT_OF_RANGE:
830 case TELEPHONY_CALL_ERR_INVALID_SLOT_ID:
831 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
832 break;
833 case TELEPHONY_CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT:
834 jsErrorCode = JS_ERROR_TELEPHONY_CONFERENCE_EXCEED_LIMIT;
835 break;
836 case TELEPHONY_CALL_ERR_CONFERENCE_CALL_IS_NOT_ACTIVE:
837 jsErrorCode = JS_ERROR_TELEPHONY_CONFERENCE_CALL_NOT_ACTIVE;
838 break;
839 case TELEPHONY_CALL_ERR_CALL_COUNTS_EXCEED_LIMIT:
840 jsErrorCode = JS_ERROR_TELEPHONY_CALL_COUNTS_EXCEED_LIMIT;
841 break;
842 case TELEPHONY_CALL_ERR_CALL_IS_NOT_ACTIVATED:
843 case TELEPHONY_CALL_ERR_ILLEGAL_CALL_OPERATION:
844 case TELEPHONY_CALL_ERR_AUDIO_SETTING_MUTE_FAILED:
845 case TELEPHONY_CALL_ERR_CALL_IS_NOT_ON_HOLDING:
846 case TELEPHONY_CALL_ERR_PHONE_CALLS_TOO_FEW:
847 case TELEPHONY_CALL_ERR_VIDEO_ILLEGAL_CALL_TYPE:
848 case TELEPHONY_CALL_ERR_CONFERENCE_NOT_EXISTS:
849 case TELEPHONY_CALL_ERR_CONFERENCE_SEPERATE_FAILED:
850 case TELEPHONY_CALL_ERR_EMERGENCY_UNSUPPORT_CONFERENCEABLE:
851 case TELEPHONY_CALL_ERR_VOLTE_NOT_SUPPORT:
852 case TELEPHONY_CALL_ERR_VOLTE_PROVISIONING_DISABLED:
853 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
854 break;
855 case TELEPHONY_CALL_ERR_DIAL_IS_BUSY:
856 jsErrorCode = JS_ERROR_TELEPHONY_DIAL_IS_BUSY;
857 break;
858 default:
859 flag = false;
860 break;
861 }
862 return flag;
863 }
864
CreateVideoCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)865 bool NapiUtil::CreateVideoCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
866 {
867 bool flag = true;
868
869 switch (errorCode) {
870 case TELEPHONY_CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE:
871 case TELEPHONY_CALL_ERR_VIDEO_IN_PROGRESS:
872 case TELEPHONY_CALL_ERR_VIDEO_ILLEAGAL_SCENARIO:
873 case TELEPHONY_CALL_ERR_VIDEO_MODE_CHANGE_NOTIFY_FAILED:
874 case TELEPHONY_CALL_ERR_VIDEO_NOT_SUPPORTED:
875 case TELEPHONY_CALL_ERR_SETTING_AUDIO_DEVICE_FAILED:
876 case TELEPHONY_CALL_ERR_VIDEO_INVALID_COORDINATES:
877 case TELEPHONY_CALL_ERR_VIDEO_INVALID_ZOOM:
878 case TELEPHONY_CALL_ERR_VIDEO_INVALID_ROTATION:
879 case TELEPHONY_CALL_ERR_VIDEO_INVALID_CAMERA_ID:
880 case TELEPHONY_CALL_ERR_INVALID_PATH:
881 case TELEPHONY_CALL_ERR_CAMERA_NOT_TURNED_ON:
882 case TELEPHONY_CALL_ERR_INVALID_DIAL_SCENE:
883 case TELEPHONY_CALL_ERR_INVALID_VIDEO_STATE:
884 case TELEPHONY_CALL_ERR_UNKNOW_DIAL_TYPE:
885 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
886 break;
887 default:
888 flag = false;
889 break;
890 }
891 return flag;
892 }
893
CreateSupplementServiceCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)894 bool NapiUtil::CreateSupplementServiceCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
895 {
896 bool flag = true;
897
898 switch (errorCode) {
899 case TELEPHONY_CALL_ERR_INVALID_RESTRICTION_TYPE:
900 case TELEPHONY_CALL_ERR_INVALID_RESTRICTION_MODE:
901 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_TYPE:
902 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_SETTING_TYPE:
903 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
904 break;
905 case TELEPHONY_CALL_ERR_FUNCTION_NOT_SUPPORTED:
906 jsErrorCode = JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API;
907 break;
908 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_TIME:
909 case TELEPHONY_CALL_ERR_NAPI_INTERFACE_FAILED:
910 case TELEPHONY_CALL_ERR_CALLBACK_ALREADY_EXIST:
911 case TELEPHONY_CALL_ERR_RESOURCE_UNAVAILABLE:
912 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
913 break;
914 case TELEPHONY_CALL_ERR_UT_NO_CONNECTION:
915 jsErrorCode = JS_ERROR_CALL_UT_NO_CONNECTION;
916 break;
917 default:
918 flag = false;
919 break;
920 }
921 return flag;
922 }
923
CreateDataErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)924 bool NapiUtil::CreateDataErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
925 {
926 if ((errorCode < CELLULAR_DATA_ERR_OFFSET || errorCode >= SMS_MMS_ERR_OFFSET)) {
927 return false;
928 }
929 bool flag = true;
930
931 switch (errorCode) {
932 case TELEPHONY_CELLULAR_DATA_INVALID_PARAM:
933 jsErrorCode = JS_ERROR_CELLULAR_DATA_BASE_ERROR;
934 break;
935 default:
936 flag = false;
937 break;
938 }
939 return flag;
940 }
941
ConverErrorMessageWithPermissionForJs(int32_t errorCode,const std::string & funcName,const std::string & permission)942 JsError NapiUtil::ConverErrorMessageWithPermissionForJs(
943 int32_t errorCode, const std::string &funcName, const std::string &permission)
944 {
945 if (errorCode == TELEPHONY_ERR_PERMISSION_ERR) {
946 JsError error = {};
947 error.errorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
948 error.errorMessage = "BusinessError 201: Permission denied. An attempt was made to " + funcName +
949 " forbidden by permission: " + permission;
950 return error;
951 }
952 return ConverErrorMessageForJs(errorCode);
953 }
954
CreateError(napi_env env,int32_t err,const std::string & msg)955 napi_value NapiUtil::CreateError(napi_env env, int32_t err, const std::string &msg)
956 {
957 napi_value businessError = nullptr;
958 napi_value errorCode = nullptr;
959 NAPI_CALL(env, napi_create_int32(env, err, &errorCode));
960 napi_value errorMessage = nullptr;
961 NAPI_CALL(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH, &errorMessage));
962 napi_create_error(env, nullptr, errorMessage, &businessError);
963 napi_set_named_property(env, businessError, "code", errorCode);
964 return businessError;
965 }
966
ThrowError(napi_env env,int32_t errorCode,const std::string & message)967 void NapiUtil::ThrowError(napi_env env, int32_t errorCode, const std::string &message)
968 {
969 napi_value error = CreateError(env, errorCode, message);
970 napi_throw(env, error);
971 }
972
ThrowParameterError(napi_env env)973 void NapiUtil::ThrowParameterError(napi_env env)
974 {
975 ThrowError(
976 env, JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER, GetErrorMessage(JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER));
977 }
978 } // namespace Telephony
979 } // namespace OHOS
980