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
Get64StringFromValue(napi_env env,napi_value value)273 std::string NapiUtil::Get64StringFromValue(napi_env env, napi_value value)
274 {
275 auto msgChars = std::make_unique<char[]>(MAX_TEXT_LENGTH);
276 size_t strLength = 0;
277 napi_get_value_string_utf8(env, value, msgChars.get(), MAX_TEXT_LENGTH, &strLength);
278 if (strLength > 0) {
279 return std::string(msgChars.get(), strLength);
280 } else {
281 return "";
282 }
283 }
284
285 // 将 JavaScript 数组转换为 std::vector<int32_t>
ConvertToArrayFromValue(napi_env env,napi_value arrayValue,std::vector<int32_t> & result)286 void NapiUtil::ConvertToArrayFromValue(napi_env env, napi_value arrayValue, std::vector<int32_t>& result)
287 {
288 result.clear();
289 bool isArray;
290 napi_is_array(env, arrayValue, &isArray);
291
292 if (!isArray) {
293 ThrowParameterError(env);
294 return;
295 }
296
297 uint32_t length;
298 napi_get_array_length(env, arrayValue, &length);
299 result.resize(length);
300
301 for (uint32_t i = 0; i < length; i++) {
302 napi_value element;
303 napi_get_element(env, arrayValue, i, &element);
304 int32_t value;
305 napi_status status = napi_get_value_int32(env, element, &value);
306 if (status != napi_ok) {
307 result.clear();
308 ThrowParameterError(env);
309 return;
310 }
311 result[i] = value;
312 }
313 }
314
GetNamedProperty(napi_env env,napi_value object,const std::string & propertyName)315 napi_value NapiUtil::GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName)
316 {
317 napi_value value = nullptr;
318 bool hasProperty = false;
319 NAPI_CALL(env, napi_has_named_property(env, object, propertyName.data(), &hasProperty));
320 if (hasProperty) {
321 NAPI_CALL(env, napi_get_named_property(env, object, propertyName.data(), &value));
322 }
323 return value;
324 }
325
HandleAsyncWork(napi_env env,BaseContext * baseContext,const std::string & workName,napi_async_execute_callback execute,napi_async_complete_callback complete)326 napi_value NapiUtil::HandleAsyncWork(napi_env env, BaseContext *baseContext, const std::string &workName,
327 napi_async_execute_callback execute, napi_async_complete_callback complete)
328 {
329 TELEPHONY_LOGD("workName = %{public}s", workName.c_str());
330 std::unique_ptr<BaseContext> context(baseContext);
331 if (context == nullptr) {
332 ThrowParameterError(env);
333 return nullptr;
334 }
335 napi_value result = nullptr;
336 if (context->callbackRef == nullptr) {
337 NAPI_CALL(env, napi_create_promise(env, &context->deferred, &result));
338 } else {
339 NAPI_CALL(env, napi_get_undefined(env, &result));
340 }
341 napi_value resource = CreateUndefined(env);
342 napi_value resourceName = nullptr;
343 NAPI_CALL(env, napi_create_string_utf8(env, workName.data(), NAPI_AUTO_LENGTH, &resourceName));
344 NAPI_CALL(env,
345 napi_create_async_work(env, resource, resourceName, execute, complete, (void *)context.get(), &context->work));
346 napi_status queueWorkStatus = napi_queue_async_work_with_qos(env, context->work, napi_qos_default);
347 if (queueWorkStatus == napi_ok) {
348 context.release();
349 } else {
350 std::string errorCode = std::to_string(queueWorkStatus);
351 std::string errorMessage = "error at napi_queue_async_work_with_qos";
352 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
353 }
354 TELEPHONY_LOGD("NapiUtil HandleAsyncWork end");
355 return result;
356 }
357
ReleaseBaseContext(napi_env env,BaseContext * baseContext)358 void NapiUtil::ReleaseBaseContext(napi_env env, BaseContext *baseContext)
359 {
360 if (baseContext == nullptr) {
361 TELEPHONY_LOGE("release baseContext is nullptr");
362 return;
363 }
364 napi_delete_async_work(env, baseContext->work);
365 baseContext->work = nullptr;
366 delete baseContext;
367 baseContext = nullptr;
368 }
369
Handle1ValueCallback(napi_env env,BaseContext * baseContext,napi_value callbackValue)370 void NapiUtil::Handle1ValueCallback(napi_env env, BaseContext *baseContext, napi_value callbackValue)
371 {
372 TELEPHONY_LOGD("Handle1ValueCallback start");
373 if (baseContext == nullptr) {
374 TELEPHONY_LOGE("Handle1ValueCallback baseContext is nullptr");
375 NapiUtil::ThrowParameterError(env);
376 return;
377 }
378 if (baseContext->callbackRef != nullptr) {
379 TELEPHONY_LOGI("start normal callback");
380 napi_value recv = CreateUndefined(env);
381 napi_value callbackFunc = nullptr;
382 if (napi_get_reference_value(env, baseContext->callbackRef, &callbackFunc) != napi_ok) {
383 ReleaseBaseContext(env, baseContext);
384 GET_AND_THROW_LAST_ERROR(env);
385 return;
386 }
387 napi_value callbackValues[] = {callbackValue};
388 napi_value result = nullptr;
389 if (napi_call_function(env, recv, callbackFunc, std::size(callbackValues), callbackValues, &result) !=
390 napi_ok) {
391 ReleaseBaseContext(env, baseContext);
392 GET_AND_THROW_LAST_ERROR(env);
393 return;
394 }
395 if (napi_delete_reference(env, baseContext->callbackRef) != napi_ok) {
396 ReleaseBaseContext(env, baseContext);
397 GET_AND_THROW_LAST_ERROR(env);
398 return;
399 }
400 TELEPHONY_LOGD("normal callback end");
401 } else if (baseContext->deferred != nullptr) {
402 TELEPHONY_LOGD("start promise callback");
403 if (baseContext->resolved) {
404 if (napi_resolve_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
405 ReleaseBaseContext(env, baseContext);
406 GET_AND_THROW_LAST_ERROR(env);
407 return;
408 }
409 TELEPHONY_LOGI("napi_resolve_deferred end");
410 } else {
411 if (napi_reject_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
412 ReleaseBaseContext(env, baseContext);
413 GET_AND_THROW_LAST_ERROR(env);
414 return;
415 }
416 TELEPHONY_LOGI("napi_reject_deferred end");
417 }
418 TELEPHONY_LOGD("promise callback end");
419 }
420 ReleaseBaseContext(env, baseContext);
421 TELEPHONY_LOGD("end");
422 }
423
Handle2ValueCallback(napi_env env,BaseContext * baseContext,napi_value callbackValue)424 void NapiUtil::Handle2ValueCallback(napi_env env, BaseContext *baseContext, napi_value callbackValue)
425 {
426 TELEPHONY_LOGD("Handle2ValueCallback start");
427 if (baseContext == nullptr) {
428 TELEPHONY_LOGI("Handle2ValueCallback serious error baseContext nullptr");
429 ThrowParameterError(env);
430 return;
431 }
432 if (baseContext->callbackRef != nullptr) {
433 TELEPHONY_LOGD("Handle2ValueCallback start normal callback");
434 napi_value recv = CreateUndefined(env);
435 napi_value callbackFunc = nullptr;
436 if (napi_get_reference_value(env, baseContext->callbackRef, &callbackFunc) != napi_ok) {
437 ReleaseBaseContext(env, baseContext);
438 GET_AND_THROW_LAST_ERROR(env);
439 return;
440 }
441 napi_value callbackValues[] = {nullptr, nullptr};
442 callbackValues[0] = baseContext->resolved ? CreateUndefined(env) : callbackValue;
443 callbackValues[1] = baseContext->resolved ? callbackValue : CreateUndefined(env);
444 napi_value result = nullptr;
445 if (napi_call_function(env, recv, callbackFunc, std::size(callbackValues), callbackValues, &result) !=
446 napi_ok) {
447 ReleaseBaseContext(env, baseContext);
448 GET_AND_THROW_LAST_ERROR(env);
449 return;
450 }
451 if (napi_delete_reference(env, baseContext->callbackRef) != napi_ok) {
452 ReleaseBaseContext(env, baseContext);
453 GET_AND_THROW_LAST_ERROR(env);
454 return;
455 }
456 TELEPHONY_LOGD("Handle2ValueCallback normal callback end");
457 } else if (baseContext->deferred != nullptr) {
458 TELEPHONY_LOGD("Handle2ValueCallback start promise callback");
459 if (baseContext->resolved) {
460 if (napi_resolve_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
461 ReleaseBaseContext(env, baseContext);
462 GET_AND_THROW_LAST_ERROR(env);
463 return;
464 }
465 } else {
466 if (napi_reject_deferred(env, baseContext->deferred, callbackValue) != napi_ok) {
467 ReleaseBaseContext(env, baseContext);
468 GET_AND_THROW_LAST_ERROR(env);
469 return;
470 }
471 }
472 TELEPHONY_LOGD("Handle2ValueCallback promise callback end");
473 }
474 ReleaseBaseContext(env, baseContext);
475 TELEPHONY_LOGD("Handle2ValueCallback end");
476 }
477
DefineEnumClassByName(napi_env env,napi_value exports,std::string_view enumName,size_t arrSize,const napi_property_descriptor * desc)478 void NapiUtil::DefineEnumClassByName(
479 napi_env env, napi_value exports, std::string_view enumName, size_t arrSize, const napi_property_descriptor *desc)
480 {
481 auto construct = [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; };
482 napi_value result = nullptr;
483 napi_status status =
484 napi_define_class(env, enumName.data(), NAPI_AUTO_LENGTH, construct, nullptr, arrSize, desc, &result);
485 if (status != napi_ok) {
486 TELEPHONY_LOGE("DefineEnumClassByName napi_define_class failed ret = %d", status);
487 }
488 status = napi_set_named_property(env, exports, enumName.data(), result);
489 if (status != napi_ok) {
490 TELEPHONY_LOGE("DefineEnumClassByName napi_set_named_property failed ret = %d", status);
491 }
492 }
493
ConverErrorMessageForJs(int32_t errorCode)494 JsError NapiUtil::ConverErrorMessageForJs(int32_t errorCode)
495 {
496 JsError error = {};
497 if (errorCode == TELEPHONY_ERR_SUCCESS) {
498 error.errorCode = JS_ERROR_TELEPHONY_SUCCESS;
499 error.errorMessage = GetErrorMessage(JS_ERROR_TELEPHONY_SUCCESS);
500 return error;
501 }
502
503 if (CreateParameterErrorMessageForJs(errorCode, error.errorCode)) {
504 error.errorMessage = GetErrorMessage(error.errorCode);
505 return error;
506 }
507
508 if (!CreateCommonErrorMessageForJs(errorCode, error.errorCode) &&
509 !CreateCallErrorMessageForJs(errorCode, error.errorCode) &&
510 !CreateDataErrorMessageForJs(errorCode, error.errorCode) &&
511 !CreateNetworkSearchErrorMessageForJs(errorCode, error.errorCode) &&
512 !CreateVcardErrorMessageForJs(errorCode, error.errorCode) &&
513 !CreateSimErrorMessageForJs(errorCode, error.errorCode) &&
514 !CreateSmsErrorMessageForJs(errorCode, error.errorCode) &&
515 !CreateObserverErrorMessageForJs(errorCode, error.errorCode)) {
516 error.errorCode = JS_ERROR_TELEPHONY_UNKNOW_ERROR;
517 TELEPHONY_LOGE("NapiUtil::ConverErrorMessageForJs errorCode is out of range");
518 }
519 error.errorMessage = GetErrorMessage(error.errorCode);
520 TELEPHONY_LOGI("errorCode from %{public}d to %{public}d", errorCode, error.errorCode);
521 return error;
522 }
523
CreateEsimParameterErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)524 bool NapiUtil::CreateEsimParameterErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
525 {
526 bool flag = true;
527 switch (errorCode) {
528 case ERROR_PARAMETER_COUNTS_INVALID:
529 case ERROR_PARAMETER_TYPE_INVALID:
530 case ERROR_SLOT_ID_INVALID:
531 case napi_status::napi_generic_failure:
532 case napi_status::napi_invalid_arg:
533 jsErrorCode = JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER;
534 break;
535 default:
536 flag = false;
537 break;
538 }
539
540 return flag;
541 }
542
CreateEsimServiceErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)543 bool NapiUtil::CreateEsimServiceErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
544 {
545 bool flag = true;
546
547 switch (errorCode) {
548 case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
549 case TELEPHONY_ERR_WRITE_DATA_FAIL:
550 case TELEPHONY_ERR_WRITE_REPLY_FAIL:
551 case TELEPHONY_ERR_READ_DATA_FAIL:
552 case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
553 jsErrorCode = JS_ERROR_ESIM_SERVICE_ERROR;
554 break;
555 case TELEPHONY_ERR_NOT_SUPPORT_ESIM:
556 jsErrorCode = JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API;
557 break;
558 default:
559 flag = false;
560 break;
561 }
562 return flag;
563 }
564
CreateEsimSystemErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)565 bool NapiUtil::CreateEsimSystemErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
566 {
567 bool flag = true;
568
569 switch (errorCode) {
570 case TELEPHONY_ERR_FAIL:
571 case TELEPHONY_ERR_LOCAL_PTR_NULL:
572 case TELEPHONY_ERR_ESIM_GET_RESULT_TIMEOUT:
573 jsErrorCode = JS_ERROR_ESIM_SYSTEM_ERROR;
574 break;
575 case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
576 jsErrorCode = JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API;
577 break;
578 default:
579 flag = false;
580 break;
581 }
582 return flag;
583 }
584
ConverEsimErrorMessageForJs(int32_t errorCode)585 JsError NapiUtil::ConverEsimErrorMessageForJs(int32_t errorCode)
586 {
587 JsError error = {};
588 if (errorCode == TELEPHONY_ERR_SUCCESS) {
589 error.errorCode = JS_ERROR_ESIM_SUCCESS;
590 error.errorMessage = GetErrorMessage(JS_ERROR_ESIM_SUCCESS);
591 return error;
592 }
593
594 if (CreateEsimParameterErrorMessageForJs(errorCode, error.errorCode)) {
595 error.errorMessage = GetErrorMessage(error.errorCode);
596 return error;
597 }
598
599 if (!CreateEsimServiceErrorMessageForJs(errorCode, error.errorCode) &&
600 !CreateEsimSystemErrorMessageForJs(errorCode, error.errorCode)) {
601 error.errorCode = JS_ERROR_ESIM_SYSTEM_ERROR;
602 TELEPHONY_LOGE("NapiUtil::ConverEsimErrorMessageForJs errorCode is out of range");
603 }
604 error.errorMessage = GetErrorMessage(error.errorCode);
605 TELEPHONY_LOGI("errorCode from %{public}d to %{public}d", errorCode, error.errorCode);
606 return error;
607 }
608
ConverEsimErrorMessageWithPermissionForJs(int32_t errorCode,const std::string & funcName,const std::string & permission)609 JsError NapiUtil::ConverEsimErrorMessageWithPermissionForJs(
610 int32_t errorCode, const std::string &funcName, const std::string &permission)
611 {
612 if (errorCode == TELEPHONY_ERR_PERMISSION_ERR) {
613 JsError error = {};
614 error.errorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
615 error.errorMessage = "BusinessError 201: Permission denied. An attempt was made to " + funcName +
616 " forbidden by permission: " + permission;
617 return error;
618 }
619 return ConverEsimErrorMessageForJs(errorCode);
620 }
621
CreateParameterErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)622 bool NapiUtil::CreateParameterErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
623 {
624 bool flag = true;
625 switch (errorCode) {
626 case ERROR_SERVICE_UNAVAILABLE:
627 case ERROR_NATIVE_API_EXECUTE_FAIL:
628 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
629 break;
630 case ERROR_PARAMETER_COUNTS_INVALID:
631 case ERROR_PARAMETER_TYPE_INVALID:
632 case napi_status::napi_generic_failure:
633 case napi_status::napi_invalid_arg:
634 jsErrorCode = JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER;
635 break;
636 case ERROR_SLOT_ID_INVALID:
637 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
638 break;
639 default:
640 flag = false;
641 break;
642 }
643
644 return flag;
645 }
646
CreateNetworkSearchErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)647 bool NapiUtil::CreateNetworkSearchErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
648 {
649 if ((errorCode < CORE_SERVICE_NETWORK_SEARCH_ERR_OFFSET || errorCode >= CORE_SERVICE_CORE_ERR_OFFSET)) {
650 return false;
651 }
652 bool flag = true;
653 switch (errorCode) {
654 case CORE_SERVICE_SEND_CALLBACK_FAILED:
655 case CORE_SERVICE_RADIO_PROTOCOL_TECH_UNKNOWN:
656 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
657 break;
658 default:
659 flag = false;
660 break;
661 }
662
663 return flag;
664 }
665
CreateVcardErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)666 bool NapiUtil::CreateVcardErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
667 {
668 bool flag = true;
669 switch (errorCode) {
670 case TELEPHONY_ERR_VCARD_FILE_INVALID:
671 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
672 break;
673 default:
674 flag = false;
675 break;
676 }
677
678 return flag;
679 }
680
CreateSimErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)681 bool NapiUtil::CreateSimErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
682 {
683 if ((errorCode < CORE_SERVICE_SIM_ERR_OFFSET || errorCode >= CORE_SERVICE_NETWORK_SEARCH_ERR_OFFSET)) {
684 return false;
685 }
686 bool flag = true;
687 switch (errorCode) {
688 case CORE_SERVICE_SIM_CARD_IS_NOT_ACTIVE:
689 jsErrorCode = JS_ERROR_SIM_CARD_IS_NOT_ACTIVE;
690 break;
691 case CORE_ERR_SIM_CARD_LOAD_FAILED:
692 case CORE_ERR_SIM_CARD_UPDATE_FAILED:
693 jsErrorCode = JS_ERROR_SIM_CARD_OPERATION_ERROR;
694 break;
695 case CORE_ERR_OPERATOR_KEY_NOT_EXIT:
696 case CORE_ERR_OPERATOR_CONF_NOT_EXIT:
697 jsErrorCode = JS_ERROR_OPERATOR_CONFIG_ERROR;
698 break;
699 default:
700 flag = false;
701 break;
702 }
703
704 return flag;
705 }
706
CreateSmsErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)707 bool NapiUtil::CreateSmsErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
708 {
709 if ((errorCode < SMS_MMS_ERR_OFFSET || errorCode >= STATE_REGISTRY_ERR_OFFSET)) {
710 return false;
711 }
712 bool flag = true;
713 switch (errorCode) {
714 case TELEPHONY_SMS_MMS_DECODE_DATA_EMPTY:
715 case TELEPHONY_SMS_MMS_UNKNOWN_SIM_MESSAGE_STATUS:
716 case TELEPHONY_SMS_MMS_MESSAGE_LENGTH_OUT_OF_RANGE:
717 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
718 break;
719 default:
720 flag = false;
721 break;
722 }
723
724 return flag;
725 }
726
CreateObserverErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)727 bool NapiUtil::CreateObserverErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
728 {
729 if ((errorCode < STATE_REGISTRY_ERR_OFFSET || errorCode >= NET_MANAGER_ERR_OFFSET)) {
730 return false;
731 }
732 bool flag = true;
733 switch (errorCode) {
734 case TELEPHONY_STATE_REGISTRY_SLODID_ERROR:
735 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
736 break;
737 case TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED:
738 jsErrorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
739 break;
740 case TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST:
741 case TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST:
742 case TELEPHONY_STATE_REGISTRY_DATA_EXIST:
743 case TELEPHONY_STATE_REGISTRY_NOT_IMPLEMENTED:
744 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
745 break;
746 default:
747 flag = false;
748 break;
749 }
750
751 return flag;
752 }
753
CreateCommonErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)754 bool NapiUtil::CreateCommonErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
755 {
756 if ((errorCode < COMMON_ERR_OFFSET || errorCode >= CALL_ERR_OFFSET)) {
757 return false;
758 }
759 if (CreateCommonArgumentErrorMessageForJs(errorCode, jsErrorCode) ||
760 CreateCommonServiceErrorMessageForJs(errorCode, jsErrorCode) ||
761 CreateCommonSystemErrorMessageForJs(errorCode, jsErrorCode)) {
762 return true;
763 }
764 return false;
765 }
766
CreateCommonArgumentErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)767 bool NapiUtil::CreateCommonArgumentErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
768 {
769 bool flag = true;
770
771 switch (errorCode) {
772 case TELEPHONY_ERR_ARGUMENT_MISMATCH:
773 case TELEPHONY_ERR_ARGUMENT_INVALID:
774 case TELEPHONY_ERR_ARGUMENT_NULL:
775 case TELEPHONY_ERR_SLOTID_INVALID:
776 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
777 break;
778 default:
779 flag = false;
780 break;
781 }
782 return flag;
783 }
784
CreateCommonServiceErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)785 bool NapiUtil::CreateCommonServiceErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
786 {
787 bool flag = true;
788
789 switch (errorCode) {
790 case TELEPHONY_ERR_DESCRIPTOR_MISMATCH:
791 case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
792 case TELEPHONY_ERR_WRITE_DATA_FAIL:
793 case TELEPHONY_ERR_WRITE_REPLY_FAIL:
794 case TELEPHONY_ERR_READ_DATA_FAIL:
795 case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
796 case TELEPHONY_ERR_REGISTER_CALLBACK_FAIL:
797 case TELEPHONY_ERR_CALLBACK_ALREADY_REGISTERED:
798 case TELEPHONY_ERR_UNINIT:
799 case TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL:
800 jsErrorCode = JS_ERROR_TELEPHONY_SERVICE_ERROR;
801 break;
802 default:
803 flag = false;
804 break;
805 }
806 return flag;
807 }
808
CreateCommonSystemErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)809 bool NapiUtil::CreateCommonSystemErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
810 {
811 bool flag = true;
812
813 switch (errorCode) {
814 case TELEPHONY_ERR_FAIL:
815 case TELEPHONY_ERR_MEMCPY_FAIL:
816 case TELEPHONY_ERR_MEMSET_FAIL:
817 case TELEPHONY_ERR_STRCPY_FAIL:
818 case TELEPHONY_ERR_LOCAL_PTR_NULL:
819 case TELEPHONY_ERR_SUBSCRIBE_BROADCAST_FAIL:
820 case TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL:
821 case TELEPHONY_ERR_ADD_DEATH_RECIPIENT_FAIL:
822 case TELEPHONY_ERR_STRTOINT_FAIL:
823 case TELEPHONY_ERR_RIL_CMD_FAIL:
824 case TELEPHONY_ERR_DATABASE_WRITE_FAIL:
825 case TELEPHONY_ERR_DATABASE_READ_FAIL:
826 case TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE:
827 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
828 break;
829 case TELEPHONY_ERR_NO_SIM_CARD:
830 jsErrorCode = JS_ERROR_TELEPHONY_NO_SIM_CARD;
831 break;
832 case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
833 jsErrorCode = JS_ERROR_ILLEGAL_USE_OF_SYSTEM_API;
834 break;
835 case TELEPHONY_ERR_AIRPLANE_MODE_ON:
836 jsErrorCode = JS_ERROR_TELEPHONY_AIRPLANE_MODE_ON;
837 break;
838 case TELEPHONY_ERR_NETWORK_NOT_IN_SERVICE:
839 jsErrorCode = JS_ERROR_TELEPHONY_NETWORK_NOT_IN_SERVICE;
840 break;
841 case TELEPHONY_ERR_POLICY_DISABLED:
842 jsErrorCode = JS_ERROR_TELEPHONY_POLICY_DISABLED;
843 break;
844 default:
845 flag = false;
846 break;
847 }
848 return flag;
849 }
850
CreateCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)851 bool NapiUtil::CreateCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
852 {
853 if ((errorCode < CALL_ERR_OFFSET || errorCode >= CELLULAR_DATA_ERR_OFFSET)) {
854 return false;
855 }
856 if (CreateCommonCallErrorMessageForJs(errorCode, jsErrorCode) ||
857 CreateVideoCallErrorMessageForJs(errorCode, jsErrorCode) ||
858 CreateSupplementServiceCallErrorMessageForJs(errorCode, jsErrorCode)) {
859 return true;
860 }
861 return false;
862 }
863
CreateCommonCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)864 bool NapiUtil::CreateCommonCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
865 {
866 bool flag = true;
867
868 switch (errorCode) {
869 case TELEPHONY_CALL_ERR_NUMBER_OUT_OF_RANGE:
870 case TELEPHONY_CALL_ERR_PHONE_NUMBER_EMPTY:
871 case TELEPHONY_CALL_ERR_FORMAT_PHONE_NUMBER_FAILED:
872 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
873 break;
874 case TELEPHONY_CALL_ERR_PARAMETER_OUT_OF_RANGE:
875 case TELEPHONY_CALL_ERR_INVALID_SLOT_ID:
876 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
877 break;
878 case TELEPHONY_CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT:
879 jsErrorCode = JS_ERROR_TELEPHONY_CONFERENCE_EXCEED_LIMIT;
880 break;
881 case TELEPHONY_CALL_ERR_CONFERENCE_CALL_IS_NOT_ACTIVE:
882 jsErrorCode = JS_ERROR_TELEPHONY_CONFERENCE_CALL_NOT_ACTIVE;
883 break;
884 case TELEPHONY_CALL_ERR_CALL_COUNTS_EXCEED_LIMIT:
885 jsErrorCode = JS_ERROR_TELEPHONY_CALL_COUNTS_EXCEED_LIMIT;
886 break;
887 case TELEPHONY_CALL_ERR_CALL_IS_NOT_ACTIVATED:
888 case TELEPHONY_CALL_ERR_ILLEGAL_CALL_OPERATION:
889 case TELEPHONY_CALL_ERR_AUDIO_SETTING_MUTE_FAILED:
890 case TELEPHONY_CALL_ERR_CALL_IS_NOT_ON_HOLDING:
891 case TELEPHONY_CALL_ERR_PHONE_CALLS_TOO_FEW:
892 case TELEPHONY_CALL_ERR_VIDEO_ILLEGAL_CALL_TYPE:
893 case TELEPHONY_CALL_ERR_CONFERENCE_NOT_EXISTS:
894 case TELEPHONY_CALL_ERR_CONFERENCE_SEPERATE_FAILED:
895 case TELEPHONY_CALL_ERR_EMERGENCY_UNSUPPORT_CONFERENCEABLE:
896 case TELEPHONY_CALL_ERR_VOLTE_NOT_SUPPORT:
897 case TELEPHONY_CALL_ERR_VOLTE_PROVISIONING_DISABLED:
898 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
899 break;
900 case TELEPHONY_CALL_ERR_DIAL_IS_BUSY:
901 jsErrorCode = JS_ERROR_TELEPHONY_DIAL_IS_BUSY;
902 break;
903 default:
904 flag = false;
905 break;
906 }
907 return flag;
908 }
909
CreateVideoCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)910 bool NapiUtil::CreateVideoCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
911 {
912 bool flag = true;
913
914 switch (errorCode) {
915 case TELEPHONY_CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE:
916 case TELEPHONY_CALL_ERR_VIDEO_IN_PROGRESS:
917 case TELEPHONY_CALL_ERR_VIDEO_ILLEAGAL_SCENARIO:
918 case TELEPHONY_CALL_ERR_VIDEO_MODE_CHANGE_NOTIFY_FAILED:
919 case TELEPHONY_CALL_ERR_VIDEO_NOT_SUPPORTED:
920 case TELEPHONY_CALL_ERR_SETTING_AUDIO_DEVICE_FAILED:
921 case TELEPHONY_CALL_ERR_VIDEO_INVALID_COORDINATES:
922 case TELEPHONY_CALL_ERR_VIDEO_INVALID_ZOOM:
923 case TELEPHONY_CALL_ERR_VIDEO_INVALID_ROTATION:
924 case TELEPHONY_CALL_ERR_VIDEO_INVALID_CAMERA_ID:
925 case TELEPHONY_CALL_ERR_INVALID_PATH:
926 case TELEPHONY_CALL_ERR_CAMERA_NOT_TURNED_ON:
927 case TELEPHONY_CALL_ERR_INVALID_DIAL_SCENE:
928 case TELEPHONY_CALL_ERR_INVALID_VIDEO_STATE:
929 case TELEPHONY_CALL_ERR_UNKNOW_DIAL_TYPE:
930 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
931 break;
932 default:
933 flag = false;
934 break;
935 }
936 return flag;
937 }
938
CreateSupplementServiceCallErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)939 bool NapiUtil::CreateSupplementServiceCallErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
940 {
941 bool flag = true;
942
943 switch (errorCode) {
944 case TELEPHONY_CALL_ERR_INVALID_RESTRICTION_TYPE:
945 case TELEPHONY_CALL_ERR_INVALID_RESTRICTION_MODE:
946 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_TYPE:
947 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_SETTING_TYPE:
948 jsErrorCode = JS_ERROR_TELEPHONY_ARGUMENT_ERROR;
949 break;
950 case TELEPHONY_CALL_ERR_FUNCTION_NOT_SUPPORTED:
951 jsErrorCode = JS_ERROR_DEVICE_NOT_SUPPORT_THIS_API;
952 break;
953 case TELEPHONY_CALL_ERR_INVALID_TRANSFER_TIME:
954 case TELEPHONY_CALL_ERR_NAPI_INTERFACE_FAILED:
955 case TELEPHONY_CALL_ERR_CALLBACK_ALREADY_EXIST:
956 case TELEPHONY_CALL_ERR_RESOURCE_UNAVAILABLE:
957 jsErrorCode = JS_ERROR_TELEPHONY_SYSTEM_ERROR;
958 break;
959 case TELEPHONY_CALL_ERR_UT_NO_CONNECTION:
960 jsErrorCode = JS_ERROR_CALL_UT_NO_CONNECTION;
961 break;
962 default:
963 flag = false;
964 break;
965 }
966 return flag;
967 }
968
CreateDataErrorMessageForJs(int32_t errorCode,JsErrorCode & jsErrorCode)969 bool NapiUtil::CreateDataErrorMessageForJs(int32_t errorCode, JsErrorCode &jsErrorCode)
970 {
971 if ((errorCode < CELLULAR_DATA_ERR_OFFSET || errorCode >= SMS_MMS_ERR_OFFSET)) {
972 return false;
973 }
974 bool flag = true;
975
976 switch (errorCode) {
977 case TELEPHONY_CELLULAR_DATA_INVALID_PARAM:
978 jsErrorCode = JS_ERROR_CELLULAR_DATA_BASE_ERROR;
979 break;
980 default:
981 flag = false;
982 break;
983 }
984 return flag;
985 }
986
ConverErrorMessageWithPermissionForJs(int32_t errorCode,const std::string & funcName,const std::string & permission)987 JsError NapiUtil::ConverErrorMessageWithPermissionForJs(
988 int32_t errorCode, const std::string &funcName, const std::string &permission)
989 {
990 if (errorCode == TELEPHONY_ERR_PERMISSION_ERR) {
991 JsError error = {};
992 error.errorCode = JS_ERROR_TELEPHONY_PERMISSION_DENIED;
993 error.errorMessage = "BusinessError 201: Permission denied. An attempt was made to " + funcName +
994 " forbidden by permission: " + permission;
995 return error;
996 }
997 return ConverErrorMessageForJs(errorCode);
998 }
999
CreateError(napi_env env,int32_t err,const std::string & msg)1000 napi_value NapiUtil::CreateError(napi_env env, int32_t err, const std::string &msg)
1001 {
1002 napi_value businessError = nullptr;
1003 napi_value errorCode = nullptr;
1004 NAPI_CALL(env, napi_create_int32(env, err, &errorCode));
1005 napi_value errorMessage = nullptr;
1006 NAPI_CALL(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH, &errorMessage));
1007 napi_create_error(env, nullptr, errorMessage, &businessError);
1008 napi_set_named_property(env, businessError, "code", errorCode);
1009 return businessError;
1010 }
1011
ThrowError(napi_env env,int32_t errorCode,const std::string & message)1012 void NapiUtil::ThrowError(napi_env env, int32_t errorCode, const std::string &message)
1013 {
1014 napi_value error = CreateError(env, errorCode, message);
1015 napi_throw(env, error);
1016 }
1017
ThrowParameterError(napi_env env)1018 void NapiUtil::ThrowParameterError(napi_env env)
1019 {
1020 ThrowError(
1021 env, JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER, GetErrorMessage(JS_ERROR_TELEPHONY_INVALID_INPUT_PARAMETER));
1022 }
1023 } // namespace Telephony
1024 } // namespace OHOS
1025