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_sim.h"
17
18 #include <memory>
19 #include <string>
20 #include <string_view>
21
22 #include "core_service_client.h"
23 #include "napi_parameter_util.h"
24 #include "napi_sim_type.h"
25 #include "napi_util.h"
26 #include "network_state.h"
27 #include "sim_state_type.h"
28 #include "telephony_log_wrapper.h"
29 #include "telephony_permission.h"
30
31 namespace OHOS {
32 namespace Telephony {
33 namespace {
34 constexpr const char *CHINA_TELECOM_CARD = "china_telecom_card";
35 constexpr const char *JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING = "Invalid parameter value.";
36 std::mutex mtx;
37 const int32_t PARAMETER_COUNT_ZERO = 0;
38 const int32_t PARAMETER_COUNT_ONE = 1;
39 const int32_t PARAMETER_COUNT_TWO = 2;
40 struct AsyncPara {
41 std::string funcName = "";
42 napi_env env = nullptr;
43 napi_callback_info info = nullptr;
44 napi_async_execute_callback execute = nullptr;
45 napi_async_complete_callback complete = nullptr;
46 };
47 struct PermissionPara {
48 std::string func = "";
49 std::string permission = "";
50 };
51
IsValidSlotId(int32_t slotId)52 static inline bool IsValidSlotId(int32_t slotId)
53 {
54 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
55 }
56
IsValidSlotIdEx(int32_t slotId)57 static inline bool IsValidSlotIdEx(int32_t slotId)
58 {
59 // One more slot for VSim.
60 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT + 1));
61 }
62
IsValidSlotIdForDefault(int32_t slotId)63 static inline bool IsValidSlotIdForDefault(int32_t slotId)
64 {
65 return ((slotId >= DEFAULT_SIM_SLOT_ID_REMOVE) && (slotId < SIM_SLOT_COUNT));
66 }
67
68 template<typename T, napi_async_execute_callback exec, napi_async_complete_callback complete>
NapiCreateAsyncWork(napi_env env,napi_callback_info info,std::string_view funcName)69 napi_value NapiCreateAsyncWork(napi_env env, napi_callback_info info, std::string_view funcName)
70 {
71 size_t argc = 2;
72 napi_value argv[] {nullptr, nullptr};
73 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
74
75 std::unique_ptr<AsyncContext<T>> asyncContext = std::make_unique<AsyncContext<T>>();
76 BaseContext &context = asyncContext->context;
77 auto inParaTp = std::make_tuple(&asyncContext->slotId, &context.callbackRef);
78 std::optional<NapiError> errCode = MatchParameters(env, argv, argc, inParaTp);
79 if (errCode.has_value()) {
80 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
81 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
82 return nullptr;
83 }
84
85 napi_value result = nullptr;
86 if (context.callbackRef == nullptr) {
87 NAPI_CALL(env, napi_create_promise(env, &context.deferred, &result));
88 } else {
89 NAPI_CALL(env, napi_get_undefined(env, &result));
90 }
91
92 napi_value resourceName = nullptr;
93 NAPI_CALL(env, napi_create_string_utf8(env, funcName.data(), funcName.length(), &resourceName));
94 AsyncContext<T> *pContext = asyncContext.release();
95 NAPI_CALL(env,
96 napi_create_async_work(
97 env, nullptr, resourceName, exec, complete, static_cast<void *>(pContext), &context.work));
98 if (napi_queue_async_work_with_qos(env, context.work, napi_qos_default) != napi_ok) {
99 delete pContext;
100 result = nullptr;
101 }
102 return result;
103 }
104
105 template<typename AsyncContextType, typename... Ts>
NapiCreateAsyncWork2(const AsyncPara & para,AsyncContextType * asyncContext,std::tuple<Ts...> & theTuple)106 napi_value NapiCreateAsyncWork2(const AsyncPara ¶, AsyncContextType *asyncContext, std::tuple<Ts...> &theTuple)
107 {
108 napi_env env = para.env;
109 BaseContext &context = asyncContext->asyncContext.context;
110
111 size_t argc = sizeof...(Ts);
112 napi_value argv[sizeof...(Ts)] {nullptr};
113 NAPI_CALL(env, napi_get_cb_info(env, para.info, &argc, argv, nullptr, nullptr));
114
115 std::optional<NapiError> errCode = MatchParameters(env, argv, argc, theTuple);
116 if (errCode.has_value()) {
117 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
118 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
119 delete asyncContext;
120 asyncContext = nullptr;
121 return nullptr;
122 }
123
124 napi_value result = nullptr;
125 if (context.callbackRef == nullptr) {
126 NAPI_CALL(env, napi_create_promise(env, &context.deferred, &result));
127 } else {
128 NAPI_CALL(env, napi_get_undefined(env, &result));
129 }
130
131 napi_value resourceName = nullptr;
132 NAPI_CALL(env, napi_create_string_utf8(env, para.funcName.c_str(), para.funcName.length(), &resourceName));
133 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, para.execute, para.complete,
134 static_cast<void *>(asyncContext), &context.work));
135 return result;
136 }
137
138 template<typename AsyncContextType, typename... Ts>
NapiCreateAsyncWork3(const AsyncPara & para,AsyncContextType * asyncContext,std::tuple<Ts...> & theTuple)139 napi_value NapiCreateAsyncWork3(const AsyncPara ¶, AsyncContextType *asyncContext, std::tuple<Ts...> &theTuple)
140 {
141 napi_env env = para.env;
142 BaseContext &context = asyncContext->asyncContext.context;
143 size_t parameterCount = 1;
144 napi_value parameters[] = { nullptr };
145 NAPI_CALL(env, napi_get_cb_info(env, para.info, ¶meterCount, parameters, nullptr, nullptr));
146
147 napi_value result = nullptr;
148 std::optional<NapiError> errCode = MatchParameters(env, parameters, parameterCount, theTuple);
149 if (parameterCount == PARAMETER_COUNT_ZERO) {
150 TELEPHONY_LOGI("parameterCount is zero");
151 } else if (parameterCount == PARAMETER_COUNT_ONE) {
152 napi_valuetype valueType = napi_undefined;
153 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
154 if (valueType == napi_undefined || valueType == napi_null) {
155 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input");
156 } else if (valueType == napi_function) {
157 TELEPHONY_LOGI("napi_function parameter detected");
158 } else {
159 if (errCode.has_value()) {
160 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
161 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
162 delete asyncContext;
163 asyncContext = nullptr;
164 return nullptr;
165 }
166 }
167 } else if (parameterCount >= PARAMETER_COUNT_TWO) {
168 if (errCode.has_value()) {
169 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
170 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
171 delete asyncContext;
172 asyncContext = nullptr;
173 return nullptr;
174 }
175 }
176
177 if (context.callbackRef == nullptr) {
178 NAPI_CALL(env, napi_create_promise(env, &context.deferred, &result));
179 } else {
180 NAPI_CALL(env, napi_get_undefined(env, &result));
181 }
182
183 napi_value resourceName = nullptr;
184 NAPI_CALL(env, napi_create_string_utf8(env, para.funcName.c_str(), para.funcName.length(), &resourceName));
185 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, para.execute, para.complete,
186 static_cast<void *>(asyncContext), &context.work));
187 return result;
188 }
189
190 template<typename T>
NapiAsyncCompleteCallback(napi_env env,napi_status status,const AsyncContext<T> & asyncContext,const std::string & errMessage,bool funcIgnoreReturnVal=false,int errorCode=ERROR_DEFAULT)191 void NapiAsyncCompleteCallback(napi_env env, napi_status status, const AsyncContext<T> &asyncContext,
192 const std::string &errMessage, bool funcIgnoreReturnVal = false, int errorCode = ERROR_DEFAULT)
193 {
194 if (status != napi_ok) {
195 napi_throw_type_error(env, nullptr, "excute failed");
196 return;
197 }
198
199 const BaseContext &context = asyncContext.context;
200 if (context.deferred != nullptr) {
201 if (!context.resolved) {
202 napi_value errorMessage = NapiUtil::CreateErrorMessage(env, errMessage, errorCode);
203 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, errorMessage));
204 } else {
205 napi_value res =
206 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
207 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, res));
208 }
209 } else {
210 napi_value res =
211 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
212 napi_value callbackValue[] {NapiUtil::CreateUndefined(env), res};
213 if (!context.resolved) {
214 callbackValue[0] = NapiUtil::CreateErrorMessage(env, errMessage, errorCode);
215 callbackValue[1] = NapiUtil::CreateUndefined(env);
216 }
217 napi_value undefined = nullptr;
218 napi_value callback = nullptr;
219 napi_value result = nullptr;
220 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
221 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
222 NAPI_CALL_RETURN_VOID(
223 env, napi_call_function(env, undefined, callback, std::size(callbackValue), callbackValue, &result));
224 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, context.callbackRef));
225 }
226 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
227 }
228
229 template<typename T>
NapiAsyncBaseCompleteCallback(napi_env env,const AsyncContext<T> & asyncContext,JsError error,bool funcIgnoreReturnVal=false)230 void NapiAsyncBaseCompleteCallback(
231 napi_env env, const AsyncContext<T> &asyncContext, JsError error, bool funcIgnoreReturnVal = false)
232 {
233 const BaseContext &context = asyncContext.context;
234 if (context.deferred != nullptr && !context.resolved) {
235 napi_value errorMessage = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
236 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, errorMessage));
237 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
238 TELEPHONY_LOGE("NapiAsyncBaseCompleteCallback deferred error and resolved is false");
239 return;
240 }
241
242 if (context.deferred != nullptr && context.resolved) {
243 napi_value res =
244 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
245 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, res));
246 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
247 TELEPHONY_LOGE("NapiAsyncBaseCompleteCallback deferred error and resolved is true");
248 return;
249 }
250
251 napi_value res =
252 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
253 napi_value callbackValue[] { NapiUtil::CreateUndefined(env), res };
254 if (!context.resolved) {
255 callbackValue[0] = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
256 callbackValue[1] = NapiUtil::CreateUndefined(env);
257 }
258 napi_value undefined = nullptr;
259 napi_value callback = nullptr;
260 napi_value result = nullptr;
261 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
262 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
263 NAPI_CALL_RETURN_VOID(
264 env, napi_call_function(env, undefined, callback, std::size(callbackValue), callbackValue, &result));
265 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, context.callbackRef));
266 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
267 }
268
269 template<typename T>
NapiAsyncPermissionCompleteCallback(napi_env env,napi_status status,const AsyncContext<T> & asyncContext,bool funcIgnoreReturnVal,PermissionPara permissionPara)270 void NapiAsyncPermissionCompleteCallback(napi_env env, napi_status status, const AsyncContext<T> &asyncContext,
271 bool funcIgnoreReturnVal, PermissionPara permissionPara)
272 {
273 if (status != napi_ok) {
274 napi_throw_type_error(env, nullptr, "excute failed");
275 return;
276 }
277
278 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
279 asyncContext.context.errorCode, permissionPara.func, permissionPara.permission);
280 NapiAsyncBaseCompleteCallback(env, asyncContext, error, funcIgnoreReturnVal);
281 }
282
283 template<typename T>
NapiAsyncCommomCompleteCallback(napi_env env,napi_status status,const AsyncContext<T> & asyncContext,bool funcIgnoreReturnVal)284 void NapiAsyncCommomCompleteCallback(
285 napi_env env, napi_status status, const AsyncContext<T> &asyncContext, bool funcIgnoreReturnVal)
286 {
287 if (status != napi_ok) {
288 napi_throw_type_error(env, nullptr, "excute failed");
289 return;
290 }
291
292 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext.context.errorCode);
293 NapiAsyncBaseCompleteCallback(env, asyncContext, error, funcIgnoreReturnVal);
294 }
295
IccAccountInfoConversion(napi_env env,const IccAccountInfo & iccAccountInfo)296 napi_value IccAccountInfoConversion(napi_env env, const IccAccountInfo &iccAccountInfo)
297 {
298 napi_value val = nullptr;
299 napi_create_object(env, &val);
300 SetPropertyToNapiObject(env, val, "simId", iccAccountInfo.simId);
301 SetPropertyToNapiObject(env, val, "slotIndex", iccAccountInfo.slotIndex);
302 SetPropertyToNapiObject(env, val, "isEsim", iccAccountInfo.isEsim);
303 SetPropertyToNapiObject(env, val, "isActive", iccAccountInfo.isActive);
304 SetPropertyToNapiObject(env, val, "iccId", NapiUtil::ToUtf8(iccAccountInfo.iccId));
305 SetPropertyToNapiObject(env, val, "showName", NapiUtil::ToUtf8(iccAccountInfo.showName));
306 SetPropertyToNapiObject(env, val, "showNumber", NapiUtil::ToUtf8(iccAccountInfo.showNumber));
307 SetPropertyToNapiObject(env, val, "simLabelIndex", iccAccountInfo.simLabelIndex);
308 SetPropertyToNapiObject(env, val, "operatorName", iccAccountInfo.operatorName);
309 return val;
310 }
311
PinOrPukUnlockConversion(napi_env env,const LockStatusResponse & response)312 napi_value PinOrPukUnlockConversion(napi_env env, const LockStatusResponse &response)
313 {
314 TELEPHONY_LOGI("PinOrPukUnlockConversion response.result %{public}d, response.remain %{public}d", response.result,
315 response.remain);
316 constexpr int32_t passWordErr = -1;
317 napi_value val = nullptr;
318 napi_create_object(env, &val);
319 SetPropertyToNapiObject(env, val, "result", response.result);
320 napi_value res =
321 (response.result == passWordErr ? GetNapiValue(env, response.remain) : NapiUtil::CreateUndefined(env));
322 napi_set_named_property(env, val, "remain", res);
323 return val;
324 }
325
OperatorConfigAnalyze(napi_env env,const ConfigInfo & config)326 napi_value OperatorConfigAnalyze(napi_env env, const ConfigInfo &config)
327 {
328 napi_value obj = nullptr;
329 napi_create_object(env, &obj);
330 SetPropertyToNapiObject(env, obj, "field", config.field);
331 SetPropertyToNapiObject(env, obj, "value", config.value);
332 return obj;
333 }
334
DiallingNumbersConversion(napi_env env,const TelNumbersInfo & info)335 napi_value DiallingNumbersConversion(napi_env env, const TelNumbersInfo &info)
336 {
337 napi_value val = nullptr;
338 napi_create_object(env, &val);
339 SetPropertyToNapiObject(env, val, "recordNumber", info.recordNumber);
340 SetPropertyToNapiObject(env, val, "alphaTag", std::data(info.alphaTag));
341 SetPropertyToNapiObject(env, val, "number", std::data(info.number));
342 SetPropertyToNapiObject(env, val, "pin2", std::data(info.pin2));
343 return val;
344 }
345
SimAuthResultConversion(napi_env env,const SimAuthenticationResponse & responseResult)346 napi_value SimAuthResultConversion(napi_env env, const SimAuthenticationResponse &responseResult)
347 {
348 napi_value val = nullptr;
349 napi_create_object(env, &val);
350 NapiUtil::SetPropertyInt32(env, val, "sw1", responseResult.sw1);
351 NapiUtil::SetPropertyInt32(env, val, "sw2", responseResult.sw2);
352 NapiUtil::SetPropertyInt32(env, val, "simStatusWord1", responseResult.sw1);
353 NapiUtil::SetPropertyInt32(env, val, "simStatusWord2", responseResult.sw2);
354 NapiUtil::SetPropertyStringUtf8(env, val, "response", responseResult.response);
355 return val;
356 }
357
GetDiallingNumberInfo(const std::shared_ptr<DiallingNumbersInfo> & telNumber,const TelNumbersInfo & info)358 void GetDiallingNumberInfo(const std::shared_ptr<DiallingNumbersInfo> &telNumber, const TelNumbersInfo &info)
359 {
360 telNumber->index_ = info.recordNumber;
361 telNumber->name_ = NapiUtil::ToUtf16(info.alphaTag.data());
362 telNumber->number_ = NapiUtil::ToUtf16(info.number.data());
363 telNumber->pin2_ = NapiUtil::ToUtf16(info.pin2.data());
364 }
365
DiallingNumberParaAnalyze(napi_env env,napi_value arg,TelNumbersInfo & info)366 void DiallingNumberParaAnalyze(napi_env env, napi_value arg, TelNumbersInfo &info)
367 {
368 napi_value recordNumber = NapiUtil::GetNamedProperty(env, arg, "recordNumber");
369 if (recordNumber) {
370 NapiValueToCppValue(env, recordNumber, napi_number, &info.recordNumber);
371 }
372
373 napi_value alphaTag = NapiUtil::GetNamedProperty(env, arg, "alphaTag");
374 if (alphaTag) {
375 NapiValueToCppValue(env, alphaTag, napi_string, std::data(info.alphaTag));
376 }
377
378 napi_value number = NapiUtil::GetNamedProperty(env, arg, "number");
379 if (number) {
380 NapiValueToCppValue(env, number, napi_string, std::data(info.number));
381 }
382
383 napi_value pin2 = NapiUtil::GetNamedProperty(env, arg, "pin2");
384 if (pin2) {
385 NapiValueToCppValue(env, pin2, napi_string, std::data(info.pin2));
386 }
387 }
388
PinInfoParaAnalyze(napi_env env,napi_value arg,AsyncContextPIN & pinContext)389 void PinInfoParaAnalyze(napi_env env, napi_value arg, AsyncContextPIN &pinContext)
390 {
391 napi_value lockType = NapiUtil::GetNamedProperty(env, arg, "lockType");
392 if (lockType) {
393 NapiValueToCppValue(env, lockType, napi_number, &pinContext.result);
394 }
395
396 napi_value pin = NapiUtil::GetNamedProperty(env, arg, "password");
397 if (pin) {
398 char tmpStr[ARRAY_SIZE] = {0};
399 NapiValueToCppValue(env, pin, napi_string, tmpStr);
400 pinContext.inStr1 = std::string(tmpStr);
401 }
402
403 napi_value state = NapiUtil::GetNamedProperty(env, arg, "state");
404 if (state) {
405 NapiValueToCppValue(env, state, napi_number, &pinContext.remain);
406 }
407 }
408
PersoLockInfoAnalyze(napi_env env,napi_value arg,AsyncContextPIN & pinContext)409 void PersoLockInfoAnalyze(napi_env env, napi_value arg, AsyncContextPIN &pinContext)
410 {
411 napi_value lockType = NapiUtil::GetNamedProperty(env, arg, "lockType");
412 if (lockType) {
413 NapiValueToCppValue(env, lockType, napi_number, &pinContext.pinEnable);
414 }
415
416 napi_value password = NapiUtil::GetNamedProperty(env, arg, "password");
417 if (password) {
418 char tmpStr[ARRAY_SIZE] = {0};
419 NapiValueToCppValue(env, password, napi_string, tmpStr);
420 pinContext.inStr1 = std::string(tmpStr);
421 }
422 }
423
NativeIsSimActive(napi_env env,void * data)424 void NativeIsSimActive(napi_env env, void *data)
425 {
426 if (data == nullptr) {
427 return;
428 }
429 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
430 if (!IsValidSlotId(reVal->slotId)) {
431 TELEPHONY_LOGE("NativeIsSimActive slotId is invalid");
432 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
433 return;
434 }
435 reVal->callbackVal = DelayedRefSingleton<CoreServiceClient>::GetInstance().IsSimActive(reVal->slotId);
436 TELEPHONY_LOGI("NAPI NativeIsSimActive %{public}d", reVal->callbackVal);
437 /* transparent return value */
438 reVal->context.resolved = true;
439 }
440
IsSimActiveCallback(napi_env env,napi_status status,void * data)441 void IsSimActiveCallback(napi_env env, napi_status status, void *data)
442 {
443 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
444 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
445 if (context->context.errorCode == ERROR_SLOT_ID_INVALID) {
446 NapiAsyncCompleteCallback(
447 env, status, *context, JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING, false, JS_ERROR_TELEPHONY_ARGUMENT_ERROR);
448 } else {
449 NapiAsyncCompleteCallback(env, status, *context, "get simActive state failed");
450 }
451 }
452
IsSimActive(napi_env env,napi_callback_info info)453 napi_value IsSimActive(napi_env env, napi_callback_info info)
454 {
455 return NapiCreateAsyncWork<bool, NativeIsSimActive, IsSimActiveCallback>(env, info, "IsSimActive");
456 }
457
IsSimActiveSync(napi_env env,napi_callback_info info)458 napi_value IsSimActiveSync(napi_env env, napi_callback_info info)
459 {
460 size_t parameterCount = 1;
461 napi_value parameters[] = { nullptr };
462 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
463 bool isSimActive = false;
464 napi_value value = nullptr;
465 if (parameterCount != 1) {
466 TELEPHONY_LOGE("parameter count is incorrect");
467 NAPI_CALL(env, napi_create_int32(env, isSimActive, &value));
468 return value;
469 }
470 int32_t slotId = -1;
471 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
472 TELEPHONY_LOGE("convert parameter fail");
473 NAPI_CALL(env, napi_create_int32(env, isSimActive, &value));
474 return value;
475 }
476 if (IsValidSlotId(slotId)) {
477 isSimActive = DelayedRefSingleton<CoreServiceClient>::GetInstance().IsSimActive(slotId);
478 }
479 NAPI_CALL(env, napi_get_boolean(env, isSimActive, &value));
480 return value;
481 }
482
NativeActivateSim(napi_env env,void * data)483 void NativeActivateSim(napi_env env, void *data)
484 {
485 if (data == nullptr) {
486 return;
487 }
488 AsyncContext<bool> *simContext = static_cast<AsyncContext<bool> *>(data);
489 if (!IsValidSlotId(simContext->slotId)) {
490 TELEPHONY_LOGE("NativeActivateSim slotId is invalid");
491 simContext->context.errorCode = ERROR_SLOT_ID_INVALID;
492 return;
493 }
494 constexpr int32_t active = 1;
495 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetActiveSim(simContext->slotId, active);
496 TELEPHONY_LOGI("NAPI NativeActivateSim %{public}d", errorCode);
497 simContext->context.errorCode = errorCode;
498 simContext->context.resolved = (errorCode == ERROR_NONE);
499 }
500
ActivateSimCallback(napi_env env,napi_status status,void * data)501 void ActivateSimCallback(napi_env env, napi_status status, void *data)
502 {
503 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
504 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
505 NapiAsyncPermissionCompleteCallback(
506 env, status, *context, true, { "ActivateSim", Permission::SET_TELEPHONY_STATE });
507 }
508
ActivateSim(napi_env env,napi_callback_info info)509 napi_value ActivateSim(napi_env env, napi_callback_info info)
510 {
511 return NapiCreateAsyncWork<bool, NativeActivateSim, ActivateSimCallback>(env, info, "ActivateSim");
512 }
513
NativeDeactivateSim(napi_env env,void * data)514 void NativeDeactivateSim(napi_env env, void *data)
515 {
516 if (data == nullptr) {
517 return;
518 }
519 AsyncContext<bool> *simContext = static_cast<AsyncContext<bool> *>(data);
520 if (!IsValidSlotId(simContext->slotId)) {
521 TELEPHONY_LOGE("NativeDeactivateSim slotId is invalid");
522 simContext->context.errorCode = ERROR_SLOT_ID_INVALID;
523 return;
524 }
525 constexpr int32_t deactive = 0;
526 int32_t errorCode =
527 DelayedRefSingleton<CoreServiceClient>::GetInstance().SetActiveSim(simContext->slotId, deactive);
528 TELEPHONY_LOGI("NAPI NativeDeactivateSim %{public}d", errorCode);
529 simContext->context.errorCode = errorCode;
530 simContext->context.resolved = (errorCode == ERROR_NONE);
531 }
532
DeactivateSimCallback(napi_env env,napi_status status,void * data)533 void DeactivateSimCallback(napi_env env, napi_status status, void *data)
534 {
535 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
536 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
537 NapiAsyncPermissionCompleteCallback(
538 env, status, *context, true, { "DeactivateSim", Permission::SET_TELEPHONY_STATE });
539 }
540
DeactivateSim(napi_env env,napi_callback_info info)541 napi_value DeactivateSim(napi_env env, napi_callback_info info)
542 {
543 return NapiCreateAsyncWork<bool, NativeDeactivateSim, DeactivateSimCallback>(env, info, "DeactivateSim");
544 }
545
NativeGetDefaultVoiceSlotId(napi_env env,void * data)546 void NativeGetDefaultVoiceSlotId(napi_env env, void *data)
547 {
548 if (data == nullptr) {
549 return;
550 }
551 AsyncContext<int32_t> *asyncContext = &(static_cast<AsyncDefaultSlotId *>(data)->asyncContext);
552
553 asyncContext->callbackVal = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDefaultVoiceSlotId();
554 TELEPHONY_LOGI("NAPI NativeGetDefaultVoiceSlotId %{public}d", asyncContext->callbackVal);
555 asyncContext->context.resolved = (asyncContext->callbackVal > ERROR_DEFAULT);
556 }
557
GetDefaultVoiceSlotIdCallback(napi_env env,napi_status status,void * data)558 void GetDefaultVoiceSlotIdCallback(napi_env env, napi_status status, void *data)
559 {
560 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
561 std::unique_ptr<AsyncDefaultSlotId> context(static_cast<AsyncDefaultSlotId *>(data));
562 NapiAsyncCompleteCallback(env, status, context->asyncContext, "get default voice slot id failed");
563 }
564
GetDefaultVoiceSlotId(napi_env env,napi_callback_info info)565 napi_value GetDefaultVoiceSlotId(napi_env env, napi_callback_info info)
566 {
567 auto asyncContext = new AsyncDefaultSlotId();
568 BaseContext &context = asyncContext->asyncContext.context;
569
570 auto initPara = std::make_tuple(&context.callbackRef);
571 AsyncPara para {
572 .funcName = "GetDefaultVoiceSlotId",
573 .env = env,
574 .info = info,
575 .execute = NativeGetDefaultVoiceSlotId,
576 .complete = GetDefaultVoiceSlotIdCallback,
577 };
578 napi_value result = NapiCreateAsyncWork2<AsyncDefaultSlotId>(para, asyncContext, initPara);
579 if (result) {
580 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_user_initiated));
581 }
582 return result;
583 }
584
NativeGetDefaultVoiceSimId(napi_env env,void * data)585 void NativeGetDefaultVoiceSimId(napi_env env, void *data)
586 {
587 if (data == nullptr) {
588 return;
589 }
590
591 AsyncContext<int32_t> *asyncContext = &(static_cast<AsyncDefaultSimId *>(data)->asyncContext);
592 int32_t simId = 0;
593 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDefaultVoiceSimId(simId);
594 TELEPHONY_LOGI("error: %{public}d", errorCode);
595 if (errorCode == ERROR_NONE) {
596 asyncContext->callbackVal = simId;
597 asyncContext->context.resolved = true;
598 } else {
599 asyncContext->context.resolved = false;
600 }
601 asyncContext->context.errorCode = errorCode;
602 }
603
GetDefaultVoiceSimIdCallback(napi_env env,napi_status status,void * data)604 void GetDefaultVoiceSimIdCallback(napi_env env, napi_status status, void *data)
605 {
606 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
607 std::unique_ptr<AsyncDefaultSimId> context(static_cast<AsyncDefaultSimId *>(data));
608 NapiAsyncCommomCompleteCallback(env, status, context->asyncContext, false);
609 }
610
GetDefaultVoiceSimId(napi_env env,napi_callback_info info)611 napi_value GetDefaultVoiceSimId(napi_env env, napi_callback_info info)
612 {
613 auto asyncContext = new AsyncDefaultSimId();
614 BaseContext &context = asyncContext->asyncContext.context;
615
616 auto initPara = std::make_tuple(&context.callbackRef);
617 AsyncPara para {
618 .funcName = "GetDefaultVoiceSimId",
619 .env = env,
620 .info = info,
621 .execute = NativeGetDefaultVoiceSimId,
622 .complete = GetDefaultVoiceSimIdCallback,
623 };
624 napi_value result = NapiCreateAsyncWork2<AsyncDefaultSimId>(para, asyncContext, initPara);
625 if (result) {
626 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
627 }
628 return result;
629 }
630
NativeGetIsoForSim(napi_env env,void * data)631 void NativeGetIsoForSim(napi_env env, void *data)
632 {
633 if (data == nullptr) {
634 return;
635 }
636 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
637 if (!IsValidSlotId(asyncContext->slotId)) {
638 TELEPHONY_LOGE("NativeGetIsoForSim slotId is invalid");
639 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
640 return;
641 }
642 std::u16string countryCode;
643 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetISOCountryCodeForSim(
644 asyncContext->slotId, countryCode);
645 if (errorCode == ERROR_NONE) {
646 asyncContext->callbackVal = NapiUtil::ToUtf8(countryCode);
647 asyncContext->context.resolved = true;
648 } else {
649 asyncContext->context.resolved = false;
650 }
651 TELEPHONY_LOGI("NAPI NativeGetIsoForSim %{public}d", errorCode);
652 asyncContext->context.errorCode = errorCode;
653 }
654
GetIsoForSimCallback(napi_env env,napi_status status,void * data)655 void GetIsoForSimCallback(napi_env env, napi_status status, void *data)
656 {
657 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
658 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
659 NapiAsyncCommomCompleteCallback(env, status, *context, false);
660 }
661
GetISOCountryCodeForSim(napi_env env,napi_callback_info info)662 napi_value GetISOCountryCodeForSim(napi_env env, napi_callback_info info)
663 {
664 return NapiCreateAsyncWork<std::string, NativeGetIsoForSim, GetIsoForSimCallback>(
665 env, info, "GetISOCountryCodeForSim");
666 }
667
GetISOCountryCodeForSimSync(napi_env env,napi_callback_info info)668 napi_value GetISOCountryCodeForSimSync(napi_env env, napi_callback_info info)
669 {
670 size_t parameterCount = 1;
671 napi_value parameters[] = { nullptr };
672 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
673 std::u16string countryCode;
674 napi_value value = nullptr;
675 if (parameterCount != 1) {
676 TELEPHONY_LOGE("parameter count is incorrect");
677 std::string code = NapiUtil::ToUtf8(countryCode);
678 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
679 return value;
680 }
681 int32_t slotId = -1;
682 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
683 TELEPHONY_LOGE("convert parameter fail");
684 std::string code = NapiUtil::ToUtf8(countryCode);
685 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
686 return value;
687 }
688 if (IsValidSlotId(slotId)) {
689 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetISOCountryCodeForSim(slotId, countryCode);
690 }
691 std::string code = NapiUtil::ToUtf8(countryCode);
692 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
693 return value;
694 }
695
NativeGetSimOperatorNumeric(napi_env env,void * data)696 void NativeGetSimOperatorNumeric(napi_env env, void *data)
697 {
698 if (data == nullptr) {
699 return;
700 }
701 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
702 if (!IsValidSlotId(asyncContext->slotId)) {
703 TELEPHONY_LOGE("NativeGetSimOperatorNumeric slotId is invalid");
704 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
705 return;
706 }
707 std::u16string operatorNumeric;
708 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimOperatorNumeric(
709 asyncContext->slotId, operatorNumeric);
710 if (errorCode == ERROR_NONE) {
711 asyncContext->callbackVal = NapiUtil::ToUtf8(operatorNumeric);
712 asyncContext->context.resolved = true;
713 } else {
714 asyncContext->context.resolved = false;
715 }
716 TELEPHONY_LOGI("NAPI NativeGetSimOperatorNumeric %{public}d", errorCode);
717 asyncContext->context.errorCode = errorCode;
718 }
719
GetSimOperatorNumericCallback(napi_env env,napi_status status,void * data)720 void GetSimOperatorNumericCallback(napi_env env, napi_status status, void *data)
721 {
722 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
723 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
724 NapiAsyncCommomCompleteCallback(env, status, *context, false);
725 }
726
GetSimOperatorNumeric(napi_env env,napi_callback_info info)727 napi_value GetSimOperatorNumeric(napi_env env, napi_callback_info info)
728 {
729 return NapiCreateAsyncWork<std::string, NativeGetSimOperatorNumeric, GetSimOperatorNumericCallback>(
730 env, info, "GetSimOperatorNumeric");
731 }
732
GetSimOperatorNumericSync(napi_env env,napi_callback_info info)733 napi_value GetSimOperatorNumericSync(napi_env env, napi_callback_info info)
734 {
735 size_t parameterCount = 1;
736 napi_value parameters[] = { nullptr };
737 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
738 std::u16string operatorNumeric;
739 napi_value value = nullptr;
740 if (parameterCount != 1) {
741 TELEPHONY_LOGE("parameter count is incorrect");
742 std::string numeric = NapiUtil::ToUtf8(operatorNumeric);
743 NAPI_CALL(env, napi_create_string_utf8(env, numeric.c_str(), numeric.length(), &value));
744 return value;
745 }
746 int32_t slotId = -1;
747 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
748 TELEPHONY_LOGE("convert parameter fail");
749 std::string numeric = NapiUtil::ToUtf8(operatorNumeric);
750 NAPI_CALL(env, napi_create_string_utf8(env, numeric.c_str(), numeric.length(), &value));
751 return value;
752 }
753 if (IsValidSlotId(slotId)) {
754 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimOperatorNumeric(slotId, operatorNumeric);
755 }
756 std::string numeric = NapiUtil::ToUtf8(operatorNumeric);
757 NAPI_CALL(env, napi_create_string_utf8(env, numeric.c_str(), numeric.length(), &value));
758 return value;
759 }
760
NativeGetSimSpn(napi_env env,void * data)761 void NativeGetSimSpn(napi_env env, void *data)
762 {
763 if (data == nullptr) {
764 return;
765 }
766 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
767 if (!IsValidSlotId(asyncContext->slotId)) {
768 TELEPHONY_LOGE("NativeGetSimSpn slotId is invalid");
769 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
770 return;
771 }
772 std::u16string spn;
773 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimSpn(asyncContext->slotId, spn);
774 if (errorCode == ERROR_NONE) {
775 asyncContext->callbackVal = NapiUtil::ToUtf8(spn);
776 asyncContext->context.resolved = true;
777 } else {
778 asyncContext->context.resolved = false;
779 }
780 TELEPHONY_LOGI("NAPI NativeGetSimSpn %{public}d", errorCode);
781 asyncContext->context.errorCode = errorCode;
782 }
783
GetSimSpnCallback(napi_env env,napi_status status,void * data)784 void GetSimSpnCallback(napi_env env, napi_status status, void *data)
785 {
786 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
787 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
788 NapiAsyncCommomCompleteCallback(env, status, *context, false);
789 }
790
GetSimSpn(napi_env env,napi_callback_info info)791 napi_value GetSimSpn(napi_env env, napi_callback_info info)
792 {
793 return NapiCreateAsyncWork<std::string, NativeGetSimSpn, GetSimSpnCallback>(env, info, "GetSimSpn");
794 }
795
GetSimSpnSync(napi_env env,napi_callback_info info)796 napi_value GetSimSpnSync(napi_env env, napi_callback_info info)
797 {
798 size_t parameterCount = 1;
799 napi_value parameters[] = { nullptr };
800 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
801 std::u16string spn;
802 napi_value value = nullptr;
803 if (parameterCount != 1) {
804 TELEPHONY_LOGE("parameter count is incorrect");
805 std::string simSpn = NapiUtil::ToUtf8(spn);
806 NAPI_CALL(env, napi_create_string_utf8(env, simSpn.c_str(), simSpn.length(), &value));
807 return value;
808 }
809 int32_t slotId = -1;
810 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
811 TELEPHONY_LOGE("convert parameter fail");
812 std::string simSpn = NapiUtil::ToUtf8(spn);
813 NAPI_CALL(env, napi_create_string_utf8(env, simSpn.c_str(), simSpn.length(), &value));
814 return value;
815 }
816 if (IsValidSlotId(slotId)) {
817 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimSpn(slotId, spn);
818 }
819 std::string simSpn = NapiUtil::ToUtf8(spn);
820 NAPI_CALL(env, napi_create_string_utf8(env, simSpn.c_str(), simSpn.length(), &value));
821 return value;
822 }
823
NativeGetDsdsMode(napi_env env,void * data)824 void NativeGetDsdsMode(napi_env env, void *data)
825 {
826 if (data == nullptr) {
827 return;
828 }
829 AsyncContext<int32_t> *asyncContext = &(static_cast<AsyncDsdsInfo *>(data)->asyncContext);
830 int32_t dsdsMode = DSDS_MODE_V2;
831 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
832 TELEPHONY_LOGD("NAPI NativeGetDsdsMode %{public}d", errorCode);
833 if (errorCode == ERROR_NONE) {
834 asyncContext->callbackVal = dsdsMode;
835 asyncContext->context.resolved = true;
836 } else {
837 asyncContext->context.resolved = false;
838 }
839 asyncContext->context.errorCode = errorCode;
840 }
841
GetDsdsModeCallback(napi_env env,napi_status status,void * data)842 void GetDsdsModeCallback(napi_env env, napi_status status, void *data)
843 {
844 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
845 std::unique_ptr<AsyncDsdsInfo> context(static_cast<AsyncDsdsInfo *>(data));
846 NapiAsyncPermissionCompleteCallback(
847 env, status, context->asyncContext, false, { "GetDsdsMode", Permission::GET_TELEPHONY_STATE });
848 }
849
GetDsdsMode(napi_env env,napi_callback_info info)850 napi_value GetDsdsMode(napi_env env, napi_callback_info info)
851 {
852 auto asyncContext = new AsyncDsdsInfo();
853 BaseContext &context = asyncContext->asyncContext.context;
854
855 auto initPara = std::make_tuple(&context.callbackRef);
856 AsyncPara para {
857 .funcName = "GetDsdsMode",
858 .env = env,
859 .info = info,
860 .execute = NativeGetDsdsMode,
861 .complete = GetDsdsModeCallback,
862 };
863 napi_value result = NapiCreateAsyncWork3<AsyncDsdsInfo>(para, asyncContext, initPara);
864 if (result) {
865 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
866 }
867 return result;
868 }
869
NativeGetSimAuthentication(napi_env env,void * data)870 void NativeGetSimAuthentication(napi_env env, void *data)
871 {
872 if (data == nullptr) {
873 return;
874 }
875 AsyncSimAuthInfo *asyncContext = static_cast<AsyncSimAuthInfo *>(data);
876 if (!IsValidSlotId(asyncContext->asyncContext.slotId)) {
877 TELEPHONY_LOGE("NativeGetSimAuthentication slotId is invalid");
878 asyncContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
879 return;
880 }
881 SimAuthenticationResponse response;
882 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SimAuthentication(
883 asyncContext->asyncContext.slotId, static_cast<AuthType>(asyncContext->authType),
884 asyncContext->authData, response);
885 TELEPHONY_LOGI("NAPI NativeGetSimAuthentication %{public}d", errorCode);
886 if (errorCode == ERROR_NONE) {
887 asyncContext->responseResult = response;
888 asyncContext->asyncContext.context.resolved = true;
889 } else {
890 asyncContext->asyncContext.context.resolved = false;
891 }
892 asyncContext->asyncContext.context.errorCode = errorCode;
893 }
894
GetSimAuthenticationCallback(napi_env env,napi_status status,void * data)895 void GetSimAuthenticationCallback(napi_env env, napi_status status, void *data)
896 {
897 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
898 std::unique_ptr<AsyncSimAuthInfo> context(static_cast<AsyncSimAuthInfo *>(data));
899 AsyncContext<napi_value> &asyncContext = context->asyncContext;
900 if (asyncContext.context.resolved) {
901 asyncContext.callbackVal = SimAuthResultConversion(env, context->responseResult);
902 }
903
904 NapiAsyncPermissionCompleteCallback(
905 env, status, context->asyncContext, false, { "GetSimAuthentication", Permission::GET_TELEPHONY_STATE });
906 }
907
GetSimAuthentication(napi_env env,napi_callback_info info)908 napi_value GetSimAuthentication(napi_env env, napi_callback_info info)
909 {
910 auto asyncContext = new AsyncSimAuthInfo();
911 BaseContext &context = asyncContext->asyncContext.context;
912
913 auto initPara = std::make_tuple(&asyncContext->asyncContext.slotId, &asyncContext->authType,
914 &asyncContext->authData, &context.callbackRef);
915 AsyncPara para {
916 .funcName = "GetSimAuthentication",
917 .env = env,
918 .info = info,
919 .execute = NativeGetSimAuthentication,
920 .complete = GetSimAuthenticationCallback,
921 };
922 napi_value result = NapiCreateAsyncWork2<AsyncSimAuthInfo>(para, asyncContext, initPara);
923 if (result) {
924 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
925 }
926 return result;
927 }
928
NativeGetSimState(napi_env env,void * data)929 void NativeGetSimState(napi_env env, void *data)
930 {
931 if (data == nullptr) {
932 return;
933 }
934 AsyncContext<int32_t> *asyncContext = static_cast<AsyncContext<int32_t> *>(data);
935 if (!IsValidSlotId(asyncContext->slotId)) {
936 TELEPHONY_LOGE("slotId is invalid");
937 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
938 return;
939 }
940 SimState simState = SimState::SIM_STATE_UNKNOWN;
941 int32_t errorCode =
942 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimState(asyncContext->slotId, simState);
943 TELEPHONY_LOGI("NAPI NativeGetSimState %{public}d", errorCode);
944 if (errorCode == ERROR_NONE) {
945 asyncContext->context.resolved = true;
946 asyncContext->callbackVal = static_cast<int32_t>(simState);
947 } else {
948 asyncContext->context.resolved = false;
949 }
950 asyncContext->context.errorCode = errorCode;
951 }
952
GetSimStateCallback(napi_env env,napi_status status,void * data)953 void GetSimStateCallback(napi_env env, napi_status status, void *data)
954 {
955 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
956 std::unique_ptr<AsyncContext<int32_t>> context(static_cast<AsyncContext<int32_t> *>(data));
957 NapiAsyncCommomCompleteCallback(env, status, *context, false);
958 TELEPHONY_LOGI("GetSimStateCallback end");
959 }
960
GetSimState(napi_env env,napi_callback_info info)961 napi_value GetSimState(napi_env env, napi_callback_info info)
962 {
963 TELEPHONY_LOGI("GetSimState start");
964 return NapiCreateAsyncWork<int32_t, NativeGetSimState, GetSimStateCallback>(env, info, "GetSimState");
965 }
966
GetSimStateSync(napi_env env,napi_callback_info info)967 napi_value GetSimStateSync(napi_env env, napi_callback_info info)
968 {
969 size_t parameterCount = 1;
970 napi_value parameters[] = { nullptr };
971 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
972 SimState simState = SimState::SIM_STATE_UNKNOWN;
973 napi_value value = nullptr;
974 if (parameterCount != 1) {
975 TELEPHONY_LOGE("parameter count is incorrect");
976 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(simState), &value));
977 return value;
978 }
979 int32_t slotId = -1;
980 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
981 TELEPHONY_LOGE("convert parameter fail");
982 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(simState), &value));
983 return value;
984 }
985 if (IsValidSlotId(slotId)) {
986 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimState(slotId, simState);
987 }
988 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(simState), &value));
989 return value;
990 }
991
NativeGetCardType(napi_env env,void * data)992 void NativeGetCardType(napi_env env, void *data)
993 {
994 if (data == nullptr) {
995 return;
996 }
997 AsyncContext<int32_t> *asyncContext = static_cast<AsyncContext<int32_t> *>(data);
998 if (!IsValidSlotId(asyncContext->slotId)) {
999 TELEPHONY_LOGE("NativeGetCardType slotId is invalid");
1000 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1001 return;
1002 }
1003 CardType cardType = CardType::UNKNOWN_CARD;
1004 int32_t errorCode =
1005 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCardType(asyncContext->slotId, cardType);
1006 TELEPHONY_LOGI("NAPI NativeGetCardType %{public}d", errorCode);
1007 if (errorCode == ERROR_NONE) {
1008 asyncContext->context.resolved = true;
1009 asyncContext->callbackVal = static_cast<int32_t>(cardType);
1010 } else {
1011 asyncContext->context.resolved = false;
1012 }
1013 asyncContext->context.errorCode = errorCode;
1014 }
1015
GetCardTypeCallback(napi_env env,napi_status status,void * data)1016 void GetCardTypeCallback(napi_env env, napi_status status, void *data)
1017 {
1018 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1019 std::unique_ptr<AsyncContext<int32_t>> context(static_cast<AsyncContext<int32_t> *>(data));
1020 NapiAsyncCommomCompleteCallback(env, status, *context, false);
1021 }
1022
GetCardType(napi_env env,napi_callback_info info)1023 napi_value GetCardType(napi_env env, napi_callback_info info)
1024 {
1025 return NapiCreateAsyncWork<int32_t, NativeGetCardType, GetCardTypeCallback>(env, info, "GetCardType");
1026 }
1027
GetCardTypeSync(napi_env env,napi_callback_info info)1028 napi_value GetCardTypeSync(napi_env env, napi_callback_info info)
1029 {
1030 size_t parameterCount = 1;
1031 napi_value parameters[] = { nullptr };
1032 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
1033 CardType cardType = CardType::UNKNOWN_CARD;
1034 napi_value value = nullptr;
1035 if (parameterCount != 1) {
1036 TELEPHONY_LOGE("parameter count is incorrect");
1037 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(cardType), &value));
1038 return value;
1039 }
1040 int32_t slotId = -1;
1041 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
1042 TELEPHONY_LOGE("convert parameter fail");
1043 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(cardType), &value));
1044 return value;
1045 }
1046 if (IsValidSlotId(slotId)) {
1047 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCardType(slotId, cardType);
1048 }
1049 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(cardType), &value));
1050 return value;
1051 }
1052
NativeGetVoiceMailIdentifier(napi_env env,void * data)1053 void NativeGetVoiceMailIdentifier(napi_env env, void *data)
1054 {
1055 if (data == nullptr) {
1056 return;
1057 }
1058 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1059 if (!IsValidSlotId(asyncContext->slotId)) {
1060 TELEPHONY_LOGE("NativeGetVoiceMailIdentifier slotId is invalid");
1061 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1062 return;
1063 }
1064 std::u16string voiceMailIdentifier;
1065 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetVoiceMailIdentifier(
1066 asyncContext->slotId, voiceMailIdentifier);
1067 TELEPHONY_LOGI("NAPI NativeGetVoiceMailIdentifier %{public}d", errorCode);
1068 if (errorCode == ERROR_NONE) {
1069 asyncContext->callbackVal = NapiUtil::ToUtf8(voiceMailIdentifier);
1070 asyncContext->context.resolved = true;
1071 } else {
1072 asyncContext->context.resolved = false;
1073 }
1074 asyncContext->context.errorCode = errorCode;
1075 }
1076
GetVoiceMailIdentifierCallback(napi_env env,napi_status status,void * data)1077 void GetVoiceMailIdentifierCallback(napi_env env, napi_status status, void *data)
1078 {
1079 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1080 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1081 NapiAsyncPermissionCompleteCallback(
1082 env, status, *context, false, { "GetVoiceMailIdentifier", Permission::GET_TELEPHONY_STATE });
1083 }
1084
GetVoiceMailIdentifier(napi_env env,napi_callback_info info)1085 napi_value GetVoiceMailIdentifier(napi_env env, napi_callback_info info)
1086 {
1087 return NapiCreateAsyncWork<std::string, NativeGetVoiceMailIdentifier, GetVoiceMailIdentifierCallback>(
1088 env, info, "GetVoiceMailIdentifier");
1089 }
1090
NativeGetVoiceMailNumber(napi_env env,void * data)1091 void NativeGetVoiceMailNumber(napi_env env, void *data)
1092 {
1093 if (data == nullptr) {
1094 return;
1095 }
1096 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1097 if (!IsValidSlotId(asyncContext->slotId)) {
1098 TELEPHONY_LOGE("NativeGetVoiceMailNumber slotId is invalid");
1099 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1100 return;
1101 }
1102 std::u16string voiceMailNumber;
1103 int32_t errorCode =
1104 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetVoiceMailNumber(asyncContext->slotId, voiceMailNumber);
1105 if (errorCode == ERROR_NONE) {
1106 asyncContext->callbackVal = NapiUtil::ToUtf8(voiceMailNumber);
1107 asyncContext->context.resolved = true;
1108 } else {
1109 asyncContext->context.resolved = false;
1110 }
1111 asyncContext->context.errorCode = errorCode;
1112 }
1113
GetVoiceMailNumberCallback(napi_env env,napi_status status,void * data)1114 void GetVoiceMailNumberCallback(napi_env env, napi_status status, void *data)
1115 {
1116 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1117 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1118 NapiAsyncPermissionCompleteCallback(
1119 env, status, *context, false, { "GetVoiceMailNumber", Permission::GET_TELEPHONY_STATE });
1120 }
1121
GetVoiceMailNumber(napi_env env,napi_callback_info info)1122 napi_value GetVoiceMailNumber(napi_env env, napi_callback_info info)
1123 {
1124 return NapiCreateAsyncWork<std::string, NativeGetVoiceMailNumber, GetVoiceMailNumberCallback>(
1125 env, info, "GetVoiceMailNumber");
1126 }
1127
NativeGetVoiceMailCount(napi_env env,void * data)1128 void NativeGetVoiceMailCount(napi_env env, void *data)
1129 {
1130 if (data == nullptr) {
1131 return;
1132 }
1133 AsyncContext<int32_t> *asyncContext = static_cast<AsyncContext<int32_t> *>(data);
1134 if (!IsValidSlotId(asyncContext->slotId)) {
1135 TELEPHONY_LOGE("NativeGetVoiceMailCount slotId is invalid");
1136 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1137 return;
1138 }
1139 int32_t voiceMailCount = ERROR_DEFAULT;
1140 int32_t errorCode =
1141 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetVoiceMailCount(asyncContext->slotId, voiceMailCount);
1142 if (errorCode == ERROR_NONE) {
1143 asyncContext->callbackVal = voiceMailCount;
1144 asyncContext->context.resolved = true;
1145 } else {
1146 asyncContext->context.resolved = false;
1147 }
1148 asyncContext->context.errorCode = errorCode;
1149 }
1150
GetVoiceMailCountCallback(napi_env env,napi_status status,void * data)1151 void GetVoiceMailCountCallback(napi_env env, napi_status status, void *data)
1152 {
1153 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1154 std::unique_ptr<AsyncContext<int32_t>> context(static_cast<AsyncContext<int32_t> *>(data));
1155 NapiAsyncPermissionCompleteCallback(
1156 env, status, *context, false, { "GetVoiceMailCount", Permission::GET_TELEPHONY_STATE });
1157 }
1158
GetVoiceMailCount(napi_env env,napi_callback_info info)1159 napi_value GetVoiceMailCount(napi_env env, napi_callback_info info)
1160 {
1161 return NapiCreateAsyncWork<int32_t, NativeGetVoiceMailCount, GetVoiceMailCountCallback>(
1162 env, info, "GetVoiceMailCount");
1163 }
1164
NativeGetSimTelephoneNumber(napi_env env,void * data)1165 void NativeGetSimTelephoneNumber(napi_env env, void *data)
1166 {
1167 if (data == nullptr) {
1168 return;
1169 }
1170 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1171 if (!IsValidSlotId(asyncContext->slotId)) {
1172 TELEPHONY_LOGE("NativeGetSimTelephoneNumber slotId is invalid");
1173 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1174 return;
1175 }
1176 std::u16string telephoneNumber;
1177 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimTelephoneNumber(
1178 asyncContext->slotId, telephoneNumber);
1179 if (errorCode == ERROR_NONE) {
1180 asyncContext->callbackVal = NapiUtil::ToUtf8(telephoneNumber);
1181 asyncContext->context.resolved = true;
1182 } else {
1183 asyncContext->context.resolved = false;
1184 }
1185 asyncContext->context.errorCode = errorCode;
1186 }
1187
GetSimTelephoneNumberCallback(napi_env env,napi_status status,void * data)1188 void GetSimTelephoneNumberCallback(napi_env env, napi_status status, void *data)
1189 {
1190 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1191 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1192 NapiAsyncPermissionCompleteCallback(
1193 env, status, *context, false, { "GetSimTelephoneNumber", Permission::GET_TELEPHONY_STATE });
1194 }
1195
GetSimTelephoneNumber(napi_env env,napi_callback_info info)1196 napi_value GetSimTelephoneNumber(napi_env env, napi_callback_info info)
1197 {
1198 return NapiCreateAsyncWork<std::string, NativeGetSimTelephoneNumber, GetSimTelephoneNumberCallback>(
1199 env, info, "GetSimTelephoneNumber");
1200 }
1201
NativeGetSimGid1(napi_env env,void * data)1202 void NativeGetSimGid1(napi_env env, void *data)
1203 {
1204 if (data == nullptr) {
1205 return;
1206 }
1207 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1208 if (!IsValidSlotId(asyncContext->slotId)) {
1209 TELEPHONY_LOGE("NativeGetSimGid1 slotId is invalid");
1210 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1211 return;
1212 }
1213 std::u16string gid1;
1214 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimGid1(asyncContext->slotId, gid1);
1215 TELEPHONY_LOGI("NAPI NativeGetSimGid1 %{public}d", errorCode);
1216 if (errorCode == ERROR_NONE) {
1217 asyncContext->callbackVal = NapiUtil::ToUtf8(gid1);
1218 asyncContext->context.resolved = true;
1219 } else {
1220 asyncContext->context.resolved = false;
1221 }
1222 asyncContext->context.errorCode = errorCode;
1223 }
1224
GetSimGid1Callback(napi_env env,napi_status status,void * data)1225 void GetSimGid1Callback(napi_env env, napi_status status, void *data)
1226 {
1227 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1228 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1229 NapiAsyncPermissionCompleteCallback(
1230 env, status, *context, false, { "GetSimGid1", Permission::GET_TELEPHONY_STATE });
1231 }
1232
GetSimGid1(napi_env env,napi_callback_info info)1233 napi_value GetSimGid1(napi_env env, napi_callback_info info)
1234 {
1235 return NapiCreateAsyncWork<std::string, NativeGetSimGid1, GetSimGid1Callback>(env, info, "GetSimGid1");
1236 }
1237
NativeGetSimIccId(napi_env env,void * data)1238 void NativeGetSimIccId(napi_env env, void *data)
1239 {
1240 if (data == nullptr) {
1241 return;
1242 }
1243 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1244 if (!IsValidSlotId(asyncContext->slotId)) {
1245 TELEPHONY_LOGE("NativeGetSimIccId slotId is invalid");
1246 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1247 return;
1248 }
1249 std::u16string iccId;
1250 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimIccId(asyncContext->slotId, iccId);
1251 if (errorCode == ERROR_NONE) {
1252 asyncContext->callbackVal = NapiUtil::ToUtf8(iccId);
1253 asyncContext->context.resolved = true;
1254 } else {
1255 asyncContext->context.resolved = false;
1256 }
1257 asyncContext->context.errorCode = errorCode;
1258 }
1259
GetSimIccIdCallback(napi_env env,napi_status status,void * data)1260 void GetSimIccIdCallback(napi_env env, napi_status status, void *data)
1261 {
1262 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1263 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1264 NapiAsyncPermissionCompleteCallback(
1265 env, status, *context, false, { "GetSimIccId", Permission::GET_TELEPHONY_STATE });
1266 }
1267
GetSimIccId(napi_env env,napi_callback_info info)1268 napi_value GetSimIccId(napi_env env, napi_callback_info info)
1269 {
1270 return NapiCreateAsyncWork<std::string, NativeGetSimIccId, GetSimIccIdCallback>(env, info, "GetSimIccId");
1271 }
1272
NativeGetSimAccountInfo(napi_env env,void * data)1273 void NativeGetSimAccountInfo(napi_env env, void *data)
1274 {
1275 if (data == nullptr) {
1276 return;
1277 }
1278 AsyncIccAccountInfo *info = static_cast<AsyncIccAccountInfo *>(data);
1279 if (!IsValidSlotIdEx(info->asyncContext.slotId)) {
1280 TELEPHONY_LOGE("NativeGetSimAccountInfo slotId is invalid");
1281 info->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1282 return;
1283 }
1284 IccAccountInfo operInfo;
1285 int32_t errorCode =
1286 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimAccountInfo(info->asyncContext.slotId, operInfo);
1287 TELEPHONY_LOGI("NAPI NativeGetSimAccountInfo %{public}d", errorCode);
1288 if (errorCode == ERROR_NONE) {
1289 info->vecInfo.push_back(std::move(operInfo));
1290 info->asyncContext.context.resolved = true;
1291 } else {
1292 info->asyncContext.context.resolved = false;
1293 }
1294 info->asyncContext.context.errorCode = errorCode;
1295 }
1296
GetSimAccountInfoCallback(napi_env env,napi_status status,void * data)1297 void GetSimAccountInfoCallback(napi_env env, napi_status status, void *data)
1298 {
1299 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1300 std::unique_ptr<AsyncIccAccountInfo> info(static_cast<AsyncIccAccountInfo *>(data));
1301 AsyncContext<napi_value> &asyncContext = info->asyncContext;
1302 if (asyncContext.context.resolved) {
1303 asyncContext.callbackVal = IccAccountInfoConversion(env, info->vecInfo.at(0));
1304 }
1305 NapiAsyncPermissionCompleteCallback(
1306 env, status, asyncContext, false, { "GetSimAccountInfo", Permission::GET_TELEPHONY_STATE });
1307 }
1308
GetSimAccountInfo(napi_env env,napi_callback_info info)1309 napi_value GetSimAccountInfo(napi_env env, napi_callback_info info)
1310 {
1311 auto iccAccountInfo = new AsyncIccAccountInfo();
1312 BaseContext &context = iccAccountInfo->asyncContext.context;
1313
1314 auto initPara = std::make_tuple(&iccAccountInfo->asyncContext.slotId, &context.callbackRef);
1315 AsyncPara para {
1316 .funcName = "GetSimAccountInfo",
1317 .env = env,
1318 .info = info,
1319 .execute = NativeGetSimAccountInfo,
1320 .complete = GetSimAccountInfoCallback,
1321 };
1322 napi_value result = NapiCreateAsyncWork2<AsyncIccAccountInfo>(para, iccAccountInfo, initPara);
1323 if (result) {
1324 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1325 }
1326 return result;
1327 }
1328
NativeSetDefaultVoiceSlotId(napi_env env,void * data)1329 void NativeSetDefaultVoiceSlotId(napi_env env, void *data)
1330 {
1331 if (data == nullptr) {
1332 return;
1333 }
1334 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
1335 if (!IsValidSlotIdForDefault(reVal->slotId)) {
1336 TELEPHONY_LOGE("NativeSetDefaultVoiceSlotId slotId is invalid");
1337 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
1338 return;
1339 }
1340 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetDefaultVoiceSlotId(reVal->slotId);
1341 TELEPHONY_LOGI("NAPI NativeSetDefaultVoiceSlotId %{public}d", errorCode);
1342 reVal->context.errorCode = errorCode;
1343 reVal->context.resolved = (errorCode == ERROR_NONE);
1344 }
1345
SetDefaultVoiceSlotIdCallback(napi_env env,napi_status status,void * data)1346 void SetDefaultVoiceSlotIdCallback(napi_env env, napi_status status, void *data)
1347 {
1348 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1349 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
1350 NapiAsyncPermissionCompleteCallback(
1351 env, status, *context, true, { "SetDefaultVoiceSlotId", Permission::SET_TELEPHONY_STATE });
1352 }
1353
SetDefaultVoiceSlotId(napi_env env,napi_callback_info info)1354 napi_value SetDefaultVoiceSlotId(napi_env env, napi_callback_info info)
1355 {
1356 return NapiCreateAsyncWork<bool, NativeSetDefaultVoiceSlotId, SetDefaultVoiceSlotIdCallback>(
1357 env, info, "SetDefaultVoiceSlotId");
1358 }
1359
NativeUnlockPin(napi_env env,void * data)1360 void NativeUnlockPin(napi_env env, void *data)
1361 {
1362 if (data == nullptr) {
1363 return;
1364 }
1365 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
1366 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
1367 TELEPHONY_LOGE("NativeUnlockPin slotId is invalid");
1368 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1369 return;
1370 }
1371 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1372 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPin(
1373 pinContext->asyncContext.slotId, NapiUtil::ToUtf16(pinContext->inStr1.data()), response);
1374 TELEPHONY_LOGI("NAPI NativeUnlockPin %{public}d", errorCode);
1375 if (errorCode == ERROR_NONE) {
1376 pinContext->result = response.result;
1377 pinContext->remain = response.remain;
1378 pinContext->asyncContext.context.resolved = true;
1379 } else {
1380 pinContext->asyncContext.context.resolved = false;
1381 }
1382 pinContext->asyncContext.context.errorCode = errorCode;
1383 }
1384
UnlockPinCallback(napi_env env,napi_status status,void * data)1385 void UnlockPinCallback(napi_env env, napi_status status, void *data)
1386 {
1387 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1388 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1389 const LockStatusResponse res {context->result, context->remain};
1390 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1391 NapiAsyncPermissionCompleteCallback(
1392 env, status, context->asyncContext, false, { "UnlockPin", Permission::SET_TELEPHONY_STATE });
1393 }
1394
UnlockPin(napi_env env,napi_callback_info info)1395 napi_value UnlockPin(napi_env env, napi_callback_info info)
1396 {
1397 auto pinContext = new AsyncContextPIN();
1398 BaseContext &context = pinContext->asyncContext.context;
1399 char tmpStr[ARRAY_SIZE] = {0};
1400
1401 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr, &context.callbackRef);
1402 AsyncPara para {
1403 .funcName = "UnlockPin",
1404 .env = env,
1405 .info = info,
1406 .execute = NativeUnlockPin,
1407 .complete = UnlockPinCallback,
1408 };
1409 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
1410 if (result) {
1411 pinContext->inStr1 = std::string(tmpStr);
1412 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1413 }
1414 return result;
1415 }
1416
NativeUnlockPuk(napi_env env,void * data)1417 void NativeUnlockPuk(napi_env env, void *data)
1418 {
1419 if (data == nullptr) {
1420 return;
1421 }
1422 AsyncContextPIN *pukContext = static_cast<AsyncContextPIN *>(data);
1423 if (!IsValidSlotId(pukContext->asyncContext.slotId)) {
1424 TELEPHONY_LOGE("NativeUnlockPuk slotId is invalid");
1425 pukContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1426 return;
1427 }
1428 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1429 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPuk(pukContext->asyncContext.slotId,
1430 NapiUtil::ToUtf16(pukContext->inStr1.data()), NapiUtil::ToUtf16(pukContext->inStr2.data()), response);
1431 TELEPHONY_LOGI("NAPI NativeUnlockPuk %{public}d", errorCode);
1432 if (errorCode == ERROR_NONE) {
1433 pukContext->result = response.result;
1434 pukContext->remain = response.remain;
1435 pukContext->asyncContext.context.resolved = true;
1436 } else {
1437 pukContext->asyncContext.context.resolved = false;
1438 }
1439 pukContext->asyncContext.context.errorCode = errorCode;
1440 }
1441
UnlockPukCallback(napi_env env,napi_status status,void * data)1442 void UnlockPukCallback(napi_env env, napi_status status, void *data)
1443 {
1444 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1445 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1446 const LockStatusResponse res {context->result, context->remain};
1447 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1448 NapiAsyncPermissionCompleteCallback(
1449 env, status, context->asyncContext, false, { "UnlockPuk", Permission::SET_TELEPHONY_STATE });
1450 }
1451
UnlockPuk(napi_env env,napi_callback_info info)1452 napi_value UnlockPuk(napi_env env, napi_callback_info info)
1453 {
1454 auto pukContext = new AsyncContextPIN();
1455 BaseContext &context = pukContext->asyncContext.context;
1456 char tmpStr1[ARRAY_SIZE] = {0};
1457 char tmpStr2[ARRAY_SIZE] = {0};
1458
1459 auto initPara = std::make_tuple(&pukContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
1460 AsyncPara para {
1461 .funcName = "UnlockPuk",
1462 .env = env,
1463 .info = info,
1464 .execute = NativeUnlockPuk,
1465 .complete = UnlockPukCallback,
1466 };
1467 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pukContext, initPara);
1468 if (result) {
1469 pukContext->inStr1 = std::string(tmpStr1);
1470 pukContext->inStr2 = std::string(tmpStr2);
1471 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1472 }
1473 return result;
1474 }
1475
NativeAlterPin(napi_env env,void * data)1476 void NativeAlterPin(napi_env env, void *data)
1477 {
1478 if (data == nullptr) {
1479 return;
1480 }
1481
1482 AsyncContextPIN *alterPinContext = static_cast<AsyncContextPIN *>(data);
1483 if (!IsValidSlotId(alterPinContext->asyncContext.slotId)) {
1484 TELEPHONY_LOGE("NativeAlterPin slotId is invalid");
1485 alterPinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1486 return;
1487 }
1488 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1489 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AlterPin(
1490 alterPinContext->asyncContext.slotId, NapiUtil::ToUtf16(alterPinContext->inStr1.data()),
1491 NapiUtil::ToUtf16(alterPinContext->inStr2.data()), response);
1492 TELEPHONY_LOGI("NAPI NativeAlterPin %{public}d", errorCode);
1493 if (errorCode == ERROR_NONE) {
1494 alterPinContext->result = response.result;
1495 alterPinContext->remain = response.remain;
1496 alterPinContext->asyncContext.context.resolved = true;
1497 } else {
1498 alterPinContext->asyncContext.context.resolved = false;
1499 }
1500 alterPinContext->asyncContext.context.errorCode = errorCode;
1501 }
1502
AlterPinCallback(napi_env env,napi_status status,void * data)1503 void AlterPinCallback(napi_env env, napi_status status, void *data)
1504 {
1505 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1506 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1507 const LockStatusResponse res {context->result, context->remain};
1508 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1509 NapiAsyncPermissionCompleteCallback(
1510 env, status, context->asyncContext, false, { "AlterPin", Permission::SET_TELEPHONY_STATE });
1511 }
1512
AlterPin(napi_env env,napi_callback_info info)1513 napi_value AlterPin(napi_env env, napi_callback_info info)
1514 {
1515 auto alterPinContext = new AsyncContextPIN();
1516 BaseContext &context = alterPinContext->asyncContext.context;
1517
1518 char tmpStr1[ARRAY_SIZE] = {0};
1519 char tmpStr2[ARRAY_SIZE] = {0};
1520 auto initPara = std::make_tuple(&alterPinContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
1521 AsyncPara para {
1522 .funcName = "AlterPin",
1523 .env = env,
1524 .info = info,
1525 .execute = NativeAlterPin,
1526 .complete = AlterPinCallback,
1527 };
1528 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, alterPinContext, initPara);
1529 if (result) {
1530 alterPinContext->inStr1 = std::string(tmpStr1);
1531 alterPinContext->inStr2 = std::string(tmpStr2);
1532 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1533 }
1534 return result;
1535 }
1536
NativeSetLockState(napi_env env,void * data)1537 void NativeSetLockState(napi_env env, void *data)
1538 {
1539 if (data == nullptr) {
1540 return;
1541 }
1542 AsyncContextPIN *lockContext = static_cast<AsyncContextPIN *>(data);
1543 if (!IsValidSlotId(lockContext->asyncContext.slotId)) {
1544 TELEPHONY_LOGE("NativeSetLockState slotId is invalid");
1545 lockContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1546 return;
1547 }
1548 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1549 TELEPHONY_LOGI("NativeSetLockState slotId = %{public}d, lockType = %{public}d, state = %{public}d",
1550 lockContext->asyncContext.slotId, lockContext->result, lockContext->remain);
1551 const LockInfo info { static_cast<LockType>(lockContext->result), NapiUtil::ToUtf16(lockContext->inStr1.data()),
1552 static_cast<LockState>(lockContext->remain) };
1553 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetLockState(
1554 lockContext->asyncContext.slotId, info, response);
1555 TELEPHONY_LOGI("NAPI NativeSetLockState %{public}d", errorCode);
1556 if (errorCode == ERROR_NONE) {
1557 lockContext->result = response.result;
1558 lockContext->remain = response.remain;
1559 lockContext->asyncContext.context.resolved = true;
1560 } else {
1561 lockContext->asyncContext.context.resolved = false;
1562 }
1563 lockContext->asyncContext.context.errorCode = errorCode;
1564 }
1565
SetLockStateCallback(napi_env env,napi_status status,void * data)1566 void SetLockStateCallback(napi_env env, napi_status status, void *data)
1567 {
1568 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1569 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1570 const LockStatusResponse res {context->result, context->remain};
1571 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1572 NapiAsyncPermissionCompleteCallback(
1573 env, status, context->asyncContext, false, { "SetLockState", Permission::SET_TELEPHONY_STATE });
1574 }
1575
SetLockState(napi_env env,napi_callback_info info)1576 napi_value SetLockState(napi_env env, napi_callback_info info)
1577 {
1578 auto asyncContextPIN = new AsyncContextPIN;
1579 BaseContext &context = asyncContextPIN->asyncContext.context;
1580 napi_value object = NapiUtil::CreateUndefined(env);
1581 auto initPara = std::make_tuple(&asyncContextPIN->asyncContext.slotId, &object, &context.callbackRef);
1582 AsyncPara para {
1583 .funcName = "SetLockState",
1584 .env = env,
1585 .info = info,
1586 .execute = NativeSetLockState,
1587 .complete = SetLockStateCallback,
1588 };
1589 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, asyncContextPIN, initPara);
1590 if (result) {
1591 PinInfoParaAnalyze(env, object, *asyncContextPIN);
1592 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1593 }
1594 return result;
1595 }
1596
NativeHasSimCard(napi_env env,void * data)1597 void NativeHasSimCard(napi_env env, void *data)
1598 {
1599 if (data == nullptr) {
1600 return;
1601 }
1602 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
1603 if (!IsValidSlotIdEx(reVal->slotId)) {
1604 TELEPHONY_LOGE("slotId is invalid");
1605 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
1606 return;
1607 }
1608 bool hasSimCard = false;
1609 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(reVal->slotId, hasSimCard);
1610 if (errorCode == ERROR_NONE) {
1611 reVal->callbackVal = hasSimCard;
1612 reVal->context.resolved = true;
1613 } else {
1614 reVal->context.resolved = false;
1615 }
1616 TELEPHONY_LOGD("errorCode is %{public}d", errorCode);
1617 reVal->context.errorCode = errorCode;
1618 }
1619
HasSimCardCallback(napi_env env,napi_status status,void * data)1620 void HasSimCardCallback(napi_env env, napi_status status, void *data)
1621 {
1622 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1623 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
1624 NapiAsyncCommomCompleteCallback(env, status, *context, false);
1625 }
1626
HasSimCard(napi_env env,napi_callback_info info)1627 napi_value HasSimCard(napi_env env, napi_callback_info info)
1628 {
1629 return NapiCreateAsyncWork<bool, NativeHasSimCard, HasSimCardCallback>(env, info, "HasSimCard");
1630 }
1631
HasSimCardSync(napi_env env,napi_callback_info info)1632 napi_value HasSimCardSync(napi_env env, napi_callback_info info)
1633 {
1634 size_t parameterCount = 1;
1635 napi_value parameters[] = { nullptr };
1636 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
1637 bool hasSimCard = false;
1638 napi_value value = nullptr;
1639 if (parameterCount != 1) {
1640 TELEPHONY_LOGE("parameter count is incorrect");
1641 NAPI_CALL(env, napi_create_int32(env, hasSimCard, &value));
1642 return value;
1643 }
1644 int32_t slotId = -1;
1645 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
1646 TELEPHONY_LOGE("convert parameter fail");
1647 NAPI_CALL(env, napi_create_int32(env, hasSimCard, &value));
1648 return value;
1649 }
1650 if (IsValidSlotId(slotId)) {
1651 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
1652 }
1653 NAPI_CALL(env, napi_get_boolean(env, hasSimCard, &value));
1654 return value;
1655 }
1656
NativeGetIMSI(napi_env env,void * data)1657 void NativeGetIMSI(napi_env env, void *data)
1658 {
1659 if (data == nullptr) {
1660 return;
1661 }
1662 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1663 if (!IsValidSlotId(asyncContext->slotId)) {
1664 TELEPHONY_LOGE("NativeGetIMSI slotId is invalid");
1665 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1666 return;
1667 }
1668 std::u16string imsi;
1669 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetIMSI(asyncContext->slotId, imsi);
1670 if (errorCode == ERROR_NONE) {
1671 asyncContext->callbackVal = NapiUtil::ToUtf8(imsi);
1672 asyncContext->context.resolved = true;
1673 } else {
1674 asyncContext->context.resolved = false;
1675 }
1676 asyncContext->context.errorCode = errorCode;
1677 }
1678
GetIMSICallback(napi_env env,napi_status status,void * data)1679 void GetIMSICallback(napi_env env, napi_status status, void *data)
1680 {
1681 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1682 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1683 NapiAsyncPermissionCompleteCallback(env, status, *context, false, { "GetIMSI", Permission::GET_TELEPHONY_STATE });
1684 }
1685
GetIMSI(napi_env env,napi_callback_info info)1686 napi_value GetIMSI(napi_env env, napi_callback_info info)
1687 {
1688 return NapiCreateAsyncWork<std::string, NativeGetIMSI, GetIMSICallback>(env, info, "GetIMSI");
1689 }
1690
IsOperatorSimCard(napi_env env,napi_callback_info info)1691 napi_value IsOperatorSimCard(napi_env env, napi_callback_info info)
1692 {
1693 size_t parameterCount = PARAMETER_COUNT_TWO;
1694 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1695 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
1696 if (parameterCount != PARAMETER_COUNT_TWO ||
1697 !NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string })) {
1698 TELEPHONY_LOGE("parameter type is incorrect");
1699 NapiUtil::ThrowParameterError(env);
1700 return nullptr;
1701 }
1702 int32_t slotId = -1;
1703 napi_get_value_int32(env, parameters[0], &slotId);
1704 if (!IsValidSlotId(slotId)) {
1705 NapiUtil::ThrowError(env, JS_ERROR_TELEPHONY_ARGUMENT_ERROR, JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING);
1706 return nullptr;
1707 }
1708 std::string operatorSimCard = NapiUtil::GetStringFromValue(env, parameters[1]);
1709 int32_t errorCode = TELEPHONY_SUCCESS;
1710 bool isOperatorSimCard = false;
1711 if (!operatorSimCard.compare(CHINA_TELECOM_CARD)) {
1712 errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().IsCTSimCard(slotId, isOperatorSimCard);
1713 } else {
1714 errorCode = TELEPHONY_ERR_ARGUMENT_MISMATCH;
1715 }
1716 if (errorCode != TELEPHONY_SUCCESS) {
1717 JsError error = NapiUtil::ConverErrorMessageForJs(errorCode);
1718 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
1719 return nullptr;
1720 }
1721 napi_value value = nullptr;
1722 NAPI_CALL(env, napi_get_boolean(env, isOperatorSimCard, &value));
1723 return value;
1724 }
1725
NativeSetShowName(napi_env env,void * data)1726 void NativeSetShowName(napi_env env, void *data)
1727 {
1728 if (data == nullptr) {
1729 return;
1730 }
1731 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
1732 if (!IsValidSlotId(context->asyncContext.slotId)) {
1733 TELEPHONY_LOGE("NativeSetShowName slotId is invalid");
1734 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1735 return;
1736 }
1737 std::u16string name = NapiUtil::ToUtf16(std::data(context->inputStr));
1738 int32_t errorCode =
1739 DelayedRefSingleton<CoreServiceClient>::GetInstance().SetShowName(context->asyncContext.slotId, name);
1740 TELEPHONY_LOGI("NAPI NativeSetShowName %{public}d", errorCode);
1741 context->asyncContext.context.errorCode = errorCode;
1742 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1743 }
1744
SetShowNameCallback(napi_env env,napi_status status,void * data)1745 void SetShowNameCallback(napi_env env, napi_status status, void *data)
1746 {
1747 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1748 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
1749 NapiAsyncPermissionCompleteCallback(
1750 env, status, context->asyncContext, true, { "SetShowName", Permission::SET_TELEPHONY_STATE });
1751 }
1752
SetShowName(napi_env env,napi_callback_info info)1753 napi_value SetShowName(napi_env env, napi_callback_info info)
1754 {
1755 auto asyncContext = new AsyncContext2();
1756 BaseContext &context = asyncContext->asyncContext.context;
1757
1758 auto initPara =
1759 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr),
1760 &context.callbackRef);
1761 AsyncPara para {
1762 .funcName = "SetShowName",
1763 .env = env,
1764 .info = info,
1765 .execute = NativeSetShowName,
1766 .complete = SetShowNameCallback,
1767 };
1768 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
1769 if (result) {
1770 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1771 }
1772 return result;
1773 }
1774
NativeGetShowName(napi_env env,void * data)1775 void NativeGetShowName(napi_env env, void *data)
1776 {
1777 if (data == nullptr) {
1778 return;
1779 }
1780 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1781 if (!IsValidSlotId(asyncContext->slotId)) {
1782 TELEPHONY_LOGE("NativeGetShowName slotId is invalid");
1783 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1784 return;
1785 }
1786 std::u16string showName;
1787 int32_t errorCode =
1788 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetShowName(asyncContext->slotId, showName);
1789 if (errorCode == ERROR_NONE) {
1790 asyncContext->callbackVal = NapiUtil::ToUtf8(showName);
1791 asyncContext->context.resolved = true;
1792 } else {
1793 asyncContext->context.resolved = false;
1794 }
1795 asyncContext->context.errorCode = errorCode;
1796 }
1797
GetShowNameCallback(napi_env env,napi_status status,void * data)1798 void GetShowNameCallback(napi_env env, napi_status status, void *data)
1799 {
1800 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1801 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1802 NapiAsyncPermissionCompleteCallback(
1803 env, status, *context, false, { "GetShowName", Permission::GET_TELEPHONY_STATE });
1804 }
1805
GetShowName(napi_env env,napi_callback_info info)1806 napi_value GetShowName(napi_env env, napi_callback_info info)
1807 {
1808 return NapiCreateAsyncWork<std::string, NativeGetShowName, GetShowNameCallback>(env, info, "GetShowName");
1809 }
1810
NativeSetShowNumber(napi_env env,void * data)1811 void NativeSetShowNumber(napi_env env, void *data)
1812 {
1813 if (data == nullptr) {
1814 return;
1815 }
1816 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
1817 if (!IsValidSlotId(context->asyncContext.slotId)) {
1818 TELEPHONY_LOGE("NativeSetShowNumber slotId is invalid");
1819 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1820 return;
1821 }
1822 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetShowNumber(
1823 context->asyncContext.slotId, NapiUtil::ToUtf16(std::data(context->inputStr)));
1824 TELEPHONY_LOGI("NAPI NativeSetShowNumber %{public}d", errorCode);
1825 context->asyncContext.context.errorCode = errorCode;
1826 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1827 }
1828
SetShowNumberCallback(napi_env env,napi_status status,void * data)1829 void SetShowNumberCallback(napi_env env, napi_status status, void *data)
1830 {
1831 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1832 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
1833 NapiAsyncPermissionCompleteCallback(
1834 env, status, context->asyncContext, true, { "SetShowNumber", Permission::SET_TELEPHONY_STATE });
1835 }
1836
SetShowNumber(napi_env env,napi_callback_info info)1837 napi_value SetShowNumber(napi_env env, napi_callback_info info)
1838 {
1839 auto asyncContext = new AsyncContext2();
1840 BaseContext &context = asyncContext->asyncContext.context;
1841
1842 auto initPara =
1843 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
1844 AsyncPara para {
1845 .funcName = "SetShowNumber",
1846 .env = env,
1847 .info = info,
1848 .execute = NativeSetShowNumber,
1849 .complete = SetShowNumberCallback,
1850 };
1851 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
1852 if (result) {
1853 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1854 }
1855 return result;
1856 }
1857
NativeGetShowNumber(napi_env env,void * data)1858 void NativeGetShowNumber(napi_env env, void *data)
1859 {
1860 if (data == nullptr) {
1861 return;
1862 }
1863 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1864 if (!IsValidSlotId(asyncContext->slotId)) {
1865 TELEPHONY_LOGE("NativeGetShowNumber slotId is invalid");
1866 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1867 return;
1868 }
1869 std::u16string showNumber;
1870 int32_t errorCode =
1871 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetShowNumber(asyncContext->slotId, showNumber);
1872 if (errorCode == ERROR_NONE) {
1873 asyncContext->callbackVal = NapiUtil::ToUtf8(showNumber);
1874 asyncContext->context.resolved = true;
1875 } else {
1876 asyncContext->context.resolved = false;
1877 }
1878 asyncContext->context.errorCode = errorCode;
1879 }
1880
GetShowNumberCallback(napi_env env,napi_status status,void * data)1881 void GetShowNumberCallback(napi_env env, napi_status status, void *data)
1882 {
1883 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1884 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1885 NapiAsyncPermissionCompleteCallback(
1886 env, status, *context, false, { "GetShowNumber", Permission::GET_TELEPHONY_STATE });
1887 }
1888
GetShowNumber(napi_env env,napi_callback_info info)1889 napi_value GetShowNumber(napi_env env, napi_callback_info info)
1890 {
1891 return NapiCreateAsyncWork<std::string, NativeGetShowNumber, GetShowNumberCallback>(env, info, "GetShowNumber");
1892 }
1893
NativeUnlockPin2(napi_env env,void * data)1894 void NativeUnlockPin2(napi_env env, void *data)
1895 {
1896 if (data == nullptr) {
1897 return;
1898 }
1899 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
1900 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
1901 TELEPHONY_LOGE("NativeUnlockPin2 slotId is invalid");
1902 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1903 return;
1904 }
1905 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1906 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPin2(
1907 pinContext->asyncContext.slotId, NapiUtil::ToUtf16(pinContext->inStr1.data()), response);
1908 TELEPHONY_LOGI("NAPI NativeUnlockPin2 %{public}d", errorCode);
1909 if (errorCode == ERROR_NONE) {
1910 pinContext->result = response.result;
1911 pinContext->remain = response.remain;
1912 pinContext->asyncContext.context.resolved = true;
1913 } else {
1914 pinContext->asyncContext.context.resolved = false;
1915 }
1916 pinContext->asyncContext.context.errorCode = errorCode;
1917 }
1918
UnlockPinCallback2(napi_env env,napi_status status,void * data)1919 void UnlockPinCallback2(napi_env env, napi_status status, void *data)
1920 {
1921 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1922 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1923 const LockStatusResponse res {context->result, context->remain};
1924 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1925 NapiAsyncPermissionCompleteCallback(
1926 env, status, context->asyncContext, false, { "UnlockPin2", Permission::SET_TELEPHONY_STATE });
1927 }
1928
UnlockPin2(napi_env env,napi_callback_info info)1929 napi_value UnlockPin2(napi_env env, napi_callback_info info)
1930 {
1931 auto pinContext = new AsyncContextPIN();
1932 BaseContext &context = pinContext->asyncContext.context;
1933
1934 char tmpStr[ARRAY_SIZE] = {0};
1935 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr, &context.callbackRef);
1936 AsyncPara para {
1937 .funcName = "UnlockPin2",
1938 .env = env,
1939 .info = info,
1940 .execute = NativeUnlockPin2,
1941 .complete = UnlockPinCallback2,
1942 };
1943 napi_value result = NapiCreateAsyncWork2(para, pinContext, initPara);
1944 if (result) {
1945 pinContext->inStr1 = std::string(tmpStr);
1946 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
1947 }
1948 return result;
1949 }
1950
NativeUnlockPuk2(napi_env env,void * data)1951 void NativeUnlockPuk2(napi_env env, void *data)
1952 {
1953 if (data == nullptr) {
1954 return;
1955 }
1956 AsyncContextPIN *pukContext = static_cast<AsyncContextPIN *>(data);
1957 if (!IsValidSlotId(pukContext->asyncContext.slotId)) {
1958 TELEPHONY_LOGE("NativeUnlockPuk2 slotId is invalid");
1959 pukContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1960 return;
1961 }
1962 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1963 int32_t errorCode =
1964 DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPuk2(pukContext->asyncContext.slotId,
1965 NapiUtil::ToUtf16(pukContext->inStr1.data()), NapiUtil::ToUtf16(pukContext->inStr2.data()), response);
1966 TELEPHONY_LOGI("NAPI NativeUnlockPuk2 %{public}d", errorCode);
1967 if (errorCode == ERROR_NONE) {
1968 pukContext->result = response.result;
1969 pukContext->remain = response.remain;
1970 pukContext->asyncContext.context.resolved = true;
1971 } else {
1972 pukContext->asyncContext.context.resolved = false;
1973 }
1974 pukContext->asyncContext.context.errorCode = errorCode;
1975 }
1976
UnlockPukCallback2(napi_env env,napi_status status,void * data)1977 void UnlockPukCallback2(napi_env env, napi_status status, void *data)
1978 {
1979 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1980 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1981 const LockStatusResponse res {context->result, context->remain};
1982 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1983 NapiAsyncPermissionCompleteCallback(
1984 env, status, context->asyncContext, false, { "UnlockPuk2", Permission::SET_TELEPHONY_STATE });
1985 }
1986
UnlockPuk2(napi_env env,napi_callback_info info)1987 napi_value UnlockPuk2(napi_env env, napi_callback_info info)
1988 {
1989 auto pinContext = new AsyncContextPIN();
1990 BaseContext &context = pinContext->asyncContext.context;
1991 char tmpStr1[ARRAY_SIZE] = {0};
1992 char tmpStr2[ARRAY_SIZE] = {0};
1993
1994 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr1,
1995 tmpStr2, &context.callbackRef);
1996 AsyncPara para {
1997 .funcName = "UnlockPuk2",
1998 .env = env,
1999 .info = info,
2000 .execute = NativeUnlockPuk2,
2001 .complete = UnlockPukCallback2,
2002 };
2003 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
2004 if (result) {
2005 pinContext->inStr1 = std::string(tmpStr1);
2006 pinContext->inStr2 = std::string(tmpStr2);
2007 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2008 }
2009 return result;
2010 }
2011
NativeAlterPin2(napi_env env,void * data)2012 void NativeAlterPin2(napi_env env, void *data)
2013 {
2014 if (data == nullptr) {
2015 return;
2016 }
2017 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
2018 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
2019 TELEPHONY_LOGE("NativeAlterPin2 slotId is invalid");
2020 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2021 return;
2022 }
2023 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
2024 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AlterPin2(pinContext->asyncContext.slotId,
2025 NapiUtil::ToUtf16(pinContext->inStr1.data()), NapiUtil::ToUtf16(pinContext->inStr2.data()), response);
2026 TELEPHONY_LOGI("NAPI NativeAlterPin2 %{public}d", errorCode);
2027 if (errorCode == ERROR_NONE) {
2028 pinContext->result = response.result;
2029 pinContext->remain = response.remain;
2030 pinContext->asyncContext.context.resolved = true;
2031 } else {
2032 pinContext->asyncContext.context.resolved = false;
2033 }
2034 pinContext->asyncContext.context.errorCode = errorCode;
2035 }
2036
AlterPinCallback2(napi_env env,napi_status status,void * data)2037 void AlterPinCallback2(napi_env env, napi_status status, void *data)
2038 {
2039 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2040 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
2041 const LockStatusResponse res {context->result, context->remain};
2042 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
2043 NapiAsyncPermissionCompleteCallback(
2044 env, status, context->asyncContext, false, { "AlterPin2", Permission::SET_TELEPHONY_STATE });
2045 }
2046
AlterPin2(napi_env env,napi_callback_info info)2047 napi_value AlterPin2(napi_env env, napi_callback_info info)
2048 {
2049 auto pinContext = new AsyncContextPIN();
2050 BaseContext &context = pinContext->asyncContext.context;
2051 char tmpStr1[ARRAY_SIZE] = {0};
2052 char tmpStr2[ARRAY_SIZE] = {0};
2053
2054 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
2055 AsyncPara para {
2056 .funcName = "AlterPin2",
2057 .env = env,
2058 .info = info,
2059 .execute = NativeAlterPin2,
2060 .complete = AlterPinCallback2,
2061 };
2062 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
2063 if (result) {
2064 pinContext->inStr1 = std::string(tmpStr1);
2065 pinContext->inStr2 = std::string(tmpStr2);
2066 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2067 }
2068 return result;
2069 }
2070
NativeGetOperatorConfigs(napi_env env,void * data)2071 void NativeGetOperatorConfigs(napi_env env, void *data)
2072 {
2073 if (data == nullptr) {
2074 return;
2075 }
2076 AsyncOperatorConfig *info = static_cast<AsyncOperatorConfig *>(data);
2077 if (!IsValidSlotId(info->asyncContext.slotId)) {
2078 TELEPHONY_LOGE("NativeGetOperatorConfigs slotId is invalid");
2079 info->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2080 return;
2081 }
2082 OperatorConfig config;
2083 int32_t errorCode =
2084 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(info->asyncContext.slotId, config);
2085 TELEPHONY_LOGI("NAPI NativeGetOperatorConfigs %{public}d", errorCode);
2086 if (errorCode == ERROR_NONE) {
2087 for (const auto &val : config.configValue) {
2088 ConfigInfo &&config = {NapiUtil::ToUtf8(val.first), NapiUtil::ToUtf8(val.second)};
2089 info->configValue.push_back(config);
2090 }
2091 info->asyncContext.context.resolved = true;
2092 } else {
2093 info->asyncContext.context.resolved = false;
2094 }
2095 info->asyncContext.context.errorCode = errorCode;
2096 }
2097
GetOperatorConfigsCallback(napi_env env,napi_status status,void * data)2098 void GetOperatorConfigsCallback(napi_env env, napi_status status, void *data)
2099 {
2100 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2101 std::unique_ptr<AsyncOperatorConfig> operatorConfig(static_cast<AsyncOperatorConfig *>(data));
2102 AsyncContext<napi_value> &aContext = operatorConfig->asyncContext;
2103 if (aContext.context.resolved) {
2104 aContext.callbackVal = nullptr;
2105 napi_create_array(env, &aContext.callbackVal);
2106 for (size_t i = 0; i < operatorConfig->configValue.size(); i++) {
2107 napi_value val = OperatorConfigAnalyze(env, operatorConfig->configValue.at(i));
2108 napi_set_element(env, aContext.callbackVal, i, val);
2109 }
2110 }
2111 NapiAsyncPermissionCompleteCallback(
2112 env, status, aContext, false, { "GetOperatorConfigs", Permission::GET_TELEPHONY_STATE });
2113 }
2114
GetOperatorConfigs(napi_env env,napi_callback_info info)2115 napi_value GetOperatorConfigs(napi_env env, napi_callback_info info)
2116 {
2117 auto crrierConfig = new AsyncOperatorConfig();
2118 BaseContext &context = crrierConfig->asyncContext.context;
2119
2120 auto initPara = std::make_tuple(&crrierConfig->asyncContext.slotId, &context.callbackRef);
2121 AsyncPara para {
2122 .funcName = "GetOperatorConfigs",
2123 .env = env,
2124 .info = info,
2125 .execute = NativeGetOperatorConfigs,
2126 .complete = GetOperatorConfigsCallback,
2127 };
2128 napi_value result = NapiCreateAsyncWork2<AsyncOperatorConfig>(para, crrierConfig, initPara);
2129 if (result) {
2130 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2131 }
2132 return result;
2133 }
2134
NativeGetActiveSimAccountInfoList(napi_env env,void * data)2135 void NativeGetActiveSimAccountInfoList(napi_env env, void *data)
2136 {
2137 if (data == nullptr) {
2138 return;
2139 }
2140 AsyncIccAccountInfo *accountInfo = static_cast<AsyncIccAccountInfo *>(data);
2141 accountInfo->vecInfo.clear();
2142 std::vector<IccAccountInfo> activeInfo;
2143 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetActiveSimAccountInfoList(activeInfo);
2144 TELEPHONY_LOGI("NAPI NativeGetActiveSimAccountInfoList %{public}d", errorCode);
2145 if (errorCode == ERROR_NONE) {
2146 accountInfo->vecInfo.swap(activeInfo);
2147 accountInfo->asyncContext.context.resolved = true;
2148 } else {
2149 accountInfo->asyncContext.context.resolved = false;
2150 }
2151 accountInfo->asyncContext.context.errorCode = errorCode;
2152 }
2153
GetActiveSimAccountInfoListCallback(napi_env env,napi_status status,void * data)2154 void GetActiveSimAccountInfoListCallback(napi_env env, napi_status status, void *data)
2155 {
2156 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2157 std::unique_ptr<AsyncIccAccountInfo> info(static_cast<AsyncIccAccountInfo *>(data));
2158 AsyncContext<napi_value> &asyncContext = info->asyncContext;
2159 asyncContext.callbackVal = nullptr;
2160 napi_create_array(env, &asyncContext.callbackVal);
2161 for (size_t i = 0; i < info->vecInfo.size(); i++) {
2162 napi_value val = IccAccountInfoConversion(env, info->vecInfo.at(i));
2163 napi_set_element(env, asyncContext.callbackVal, i, val);
2164 }
2165 NapiAsyncPermissionCompleteCallback(
2166 env, status, asyncContext, false, { "GetActiveSimAccountInfoList", Permission::GET_TELEPHONY_STATE });
2167 }
2168
GetActiveSimAccountInfoList(napi_env env,napi_callback_info info)2169 napi_value GetActiveSimAccountInfoList(napi_env env, napi_callback_info info)
2170 {
2171 auto accountInfo = new AsyncIccAccountInfo();
2172 BaseContext &context = accountInfo->asyncContext.context;
2173
2174 auto initPara = std::make_tuple(&context.callbackRef);
2175 AsyncPara para {
2176 .funcName = "GetActiveSimAccountInfoList",
2177 .env = env,
2178 .info = info,
2179 .execute = NativeGetActiveSimAccountInfoList,
2180 .complete = GetActiveSimAccountInfoListCallback,
2181 };
2182 napi_value result = NapiCreateAsyncWork2<AsyncIccAccountInfo>(para, accountInfo, initPara);
2183 if (result) {
2184 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2185 }
2186 return result;
2187 }
2188
NativeQueryIccDiallingNumbers(napi_env env,void * data)2189 void NativeQueryIccDiallingNumbers(napi_env env, void *data)
2190 {
2191 if (data == nullptr) {
2192 return;
2193 }
2194 AsyncDiallingNumbers<napi_value> *diallingNumbers = static_cast<AsyncDiallingNumbers<napi_value> *>(data);
2195 if (!IsValidSlotId(diallingNumbers->asyncContext.slotId)) {
2196 TELEPHONY_LOGE("NativeQueryIccDiallingNumbers slotId is invalid");
2197 diallingNumbers->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2198 return;
2199 }
2200 std::vector<std::shared_ptr<DiallingNumbersInfo>> diallingNumbersResult;
2201 diallingNumbersResult.clear();
2202 std::lock_guard<std::mutex> mtxlock(mtx);
2203 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().QueryIccDiallingNumbers(
2204 diallingNumbers->asyncContext.slotId, diallingNumbers->type, diallingNumbersResult);
2205 TELEPHONY_LOGI("NAPI NativeQueryIccDiallingNumbers %{public}zu", diallingNumbersResult.size());
2206 if (!diallingNumbersResult.empty()) {
2207 std::vector<TelNumbersInfo> &dialNumbers = diallingNumbers->infoVec;
2208 for (const auto &dialNumber : diallingNumbersResult) {
2209 TelNumbersInfo info {};
2210 NapiUtil::ToUtf8(dialNumber->name_).copy(info.alphaTag.data(), ARRAY_SIZE);
2211 NapiUtil::ToUtf8(dialNumber->number_).copy(info.number.data(), ARRAY_SIZE);
2212 info.recordNumber = dialNumber->index_;
2213 dialNumbers.push_back(std::move(info));
2214 }
2215 }
2216 diallingNumbers->asyncContext.context.errorCode = errorCode;
2217 diallingNumbers->asyncContext.context.resolved = (errorCode == ERROR_NONE);
2218 }
2219
QueryIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)2220 void QueryIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
2221 {
2222 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2223 std::unique_ptr<AsyncDiallingNumbers<napi_value>> diallingNumbers(
2224 static_cast<AsyncDiallingNumbers<napi_value> *>(data));
2225 diallingNumbers->asyncContext.callbackVal = nullptr;
2226 napi_create_array(env, &diallingNumbers->asyncContext.callbackVal);
2227 for (size_t i = 0; i < diallingNumbers->infoVec.size(); i++) {
2228 napi_value val = DiallingNumbersConversion(env, diallingNumbers->infoVec.at(i));
2229 napi_set_element(env, diallingNumbers->asyncContext.callbackVal, i, val);
2230 }
2231 NapiAsyncPermissionCompleteCallback(
2232 env, status, diallingNumbers->asyncContext, false, { "QueryIccDiallingNumbers", Permission::READ_CONTACTS });
2233 }
2234
QueryIccDiallingNumbers(napi_env env,napi_callback_info info)2235 napi_value QueryIccDiallingNumbers(napi_env env, napi_callback_info info)
2236 {
2237 auto diallingNumbers = new AsyncDiallingNumbers<napi_value>();
2238 BaseContext &context = diallingNumbers->asyncContext.context;
2239
2240 auto initPara =
2241 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &context.callbackRef);
2242 AsyncPara para {
2243 .funcName = "QueryIccDiallingNumbers",
2244 .env = env,
2245 .info = info,
2246 .execute = NativeQueryIccDiallingNumbers,
2247 .complete = QueryIccDiallingNumbersCallback,
2248 };
2249 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<napi_value>>(para, diallingNumbers, initPara);
2250 if (result) {
2251 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2252 }
2253 return result;
2254 }
2255
NativeAddIccDiallingNumbers(napi_env env,void * data)2256 void NativeAddIccDiallingNumbers(napi_env env, void *data)
2257 {
2258 if (data == nullptr) {
2259 return;
2260 }
2261 AsyncDiallingNumbers<int32_t> *diallingNumbersContext = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
2262 AsyncContext<int32_t> &asyncContext = diallingNumbersContext->asyncContext;
2263 if (!IsValidSlotId(asyncContext.slotId)) {
2264 TELEPHONY_LOGE("NativeAddIccDiallingNumbers slotId is invalid");
2265 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2266 return;
2267 }
2268 if (diallingNumbersContext->infoVec.size() > 0) {
2269 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
2270 GetDiallingNumberInfo(telNumber, diallingNumbersContext->infoVec.at(0));
2271 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AddIccDiallingNumbers(
2272 asyncContext.slotId, diallingNumbersContext->type, telNumber);
2273 TELEPHONY_LOGI("NAPI NativeAddIccDiallingNumbers errorCode: %{public}d", errorCode);
2274 asyncContext.context.errorCode = errorCode;
2275 asyncContext.context.resolved = (errorCode == ERROR_NONE);
2276 }
2277 }
2278
AddIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)2279 void AddIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
2280 {
2281 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2282 std::unique_ptr<AsyncDiallingNumbers<int32_t>> context(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
2283 NapiAsyncPermissionCompleteCallback(
2284 env, status, context->asyncContext, true, { "AddIccDiallingNumbers", Permission::WRITE_CONTACTS });
2285 }
2286
AddIccDiallingNumbers(napi_env env,napi_callback_info info)2287 napi_value AddIccDiallingNumbers(napi_env env, napi_callback_info info)
2288 {
2289 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
2290 BaseContext &context = diallingNumbers->asyncContext.context;
2291
2292 napi_value object = NapiUtil::CreateUndefined(env);
2293 auto initPara =
2294 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
2295
2296 AsyncPara para {
2297 .funcName = "AddIccDiallingNumbers",
2298 .env = env,
2299 .info = info,
2300 .execute = NativeAddIccDiallingNumbers,
2301 .complete = AddIccDiallingNumbersCallback,
2302 };
2303 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<int32_t>>(para, diallingNumbers, initPara);
2304 if (result) {
2305 TelNumbersInfo inputInfo;
2306 DiallingNumberParaAnalyze(env, object, inputInfo);
2307 diallingNumbers->infoVec.push_back(std::move(inputInfo));
2308 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2309 }
2310 return result;
2311 }
2312
NativeDelIccDiallingNumbers(napi_env env,void * data)2313 void NativeDelIccDiallingNumbers(napi_env env, void *data)
2314 {
2315 if (data == nullptr) {
2316 return;
2317 }
2318 AsyncDiallingNumbers<int32_t> *diallingNumbers = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
2319 if (!IsValidSlotId(diallingNumbers->asyncContext.slotId)) {
2320 TELEPHONY_LOGE("NativeDelIccDiallingNumbers slotId is invalid");
2321 diallingNumbers->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2322 return;
2323 }
2324 if (diallingNumbers->infoVec.size() > 0) {
2325 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
2326 GetDiallingNumberInfo(telNumber, diallingNumbers->infoVec.at(0));
2327 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().DelIccDiallingNumbers(
2328 diallingNumbers->asyncContext.slotId, diallingNumbers->type, telNumber);
2329 TELEPHONY_LOGI("NAPI NativeDelIccDiallingNumbers errorCode: %{public}d", errorCode);
2330 diallingNumbers->asyncContext.context.errorCode = errorCode;
2331 diallingNumbers->asyncContext.context.resolved = (errorCode == ERROR_NONE);
2332 }
2333 }
2334
DelIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)2335 void DelIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
2336 {
2337 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2338 std::unique_ptr<AsyncDiallingNumbers<int32_t>> diallingNumbers(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
2339 NapiAsyncPermissionCompleteCallback(
2340 env, status, diallingNumbers->asyncContext, true, { "DelIccDiallingNumbers", Permission::WRITE_CONTACTS });
2341 }
2342
DelIccDiallingNumbers(napi_env env,napi_callback_info info)2343 napi_value DelIccDiallingNumbers(napi_env env, napi_callback_info info)
2344 {
2345 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
2346 BaseContext &context = diallingNumbers->asyncContext.context;
2347
2348 napi_value object = NapiUtil::CreateUndefined(env);
2349 auto initPara =
2350 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
2351 AsyncPara para {
2352 .funcName = "DelIccDiallingNumbers",
2353 .env = env,
2354 .info = info,
2355 .execute = NativeDelIccDiallingNumbers,
2356 .complete = DelIccDiallingNumbersCallback,
2357 };
2358 napi_value result = NapiCreateAsyncWork2(para, diallingNumbers, initPara);
2359 if (result) {
2360 TelNumbersInfo inputInfo;
2361 DiallingNumberParaAnalyze(env, object, inputInfo);
2362 diallingNumbers->infoVec.push_back(std::move(inputInfo));
2363 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2364 }
2365 return result;
2366 }
2367
NativeUpdateIccDiallingNumbers(napi_env env,void * data)2368 void NativeUpdateIccDiallingNumbers(napi_env env, void *data)
2369 {
2370 if (data == nullptr) {
2371 return;
2372 }
2373 AsyncDiallingNumbers<int32_t> *diallingNumbers = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
2374 AsyncContext<int32_t> &asyncContext = diallingNumbers->asyncContext;
2375 if (!IsValidSlotId(asyncContext.slotId)) {
2376 TELEPHONY_LOGE("NativeUpdateIccDiallingNumbers slotId is invalid");
2377 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2378 return;
2379 }
2380 if (diallingNumbers->infoVec.size() > 0) {
2381 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
2382 GetDiallingNumberInfo(telNumber, diallingNumbers->infoVec.at(0));
2383 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UpdateIccDiallingNumbers(
2384 asyncContext.slotId, diallingNumbers->type, telNumber);
2385 TELEPHONY_LOGI("NAPI NativeUpdateIccDiallingNumbers errorCode: %{public}d", errorCode);
2386 asyncContext.context.errorCode = errorCode;
2387 asyncContext.context.resolved = (errorCode == ERROR_NONE);
2388 }
2389 }
2390
UpdateIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)2391 void UpdateIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
2392 {
2393 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2394 std::unique_ptr<AsyncDiallingNumbers<int32_t>> context(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
2395 NapiAsyncPermissionCompleteCallback(
2396 env, status, context->asyncContext, true, { "UpdateIccDiallingNumbers", Permission::WRITE_CONTACTS });
2397 }
2398
UpdateIccDiallingNumbers(napi_env env,napi_callback_info info)2399 napi_value UpdateIccDiallingNumbers(napi_env env, napi_callback_info info)
2400 {
2401 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
2402 BaseContext &context = diallingNumbers->asyncContext.context;
2403
2404 napi_value object = NapiUtil::CreateUndefined(env);
2405 auto initPara =
2406 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
2407
2408 AsyncPara para {
2409 .funcName = "UpdateIccDiallingNumbers",
2410 .env = env,
2411 .info = info,
2412 .execute = NativeUpdateIccDiallingNumbers,
2413 .complete = UpdateIccDiallingNumbersCallback,
2414 };
2415 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<int32_t>>(para, diallingNumbers, initPara);
2416 if (result) {
2417 TelNumbersInfo inputInfo;
2418 DiallingNumberParaAnalyze(env, object, inputInfo);
2419 diallingNumbers->infoVec.push_back(std::move(inputInfo));
2420 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2421 }
2422 return result;
2423 }
2424
NativeSetVoiceMailInfo(napi_env env,void * data)2425 void NativeSetVoiceMailInfo(napi_env env, void *data)
2426 {
2427 if (data == nullptr) {
2428 return;
2429 }
2430 AsyncVoiceMail *mailContext = static_cast<AsyncVoiceMail *>(data);
2431 AsyncContext<bool> &asyncContext = mailContext->asyncContext;
2432 if (!IsValidSlotId(asyncContext.slotId)) {
2433 TELEPHONY_LOGE("NativeSetVoiceMailInfo slotId is invalid");
2434 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2435 return;
2436 }
2437 std::u16string mailName = NapiUtil::ToUtf16(std::data(mailContext->mailName));
2438 std::u16string mailNumber = NapiUtil::ToUtf16(std::data(mailContext->mailNumber));
2439 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetVoiceMailInfo(
2440 asyncContext.slotId, mailName, mailNumber);
2441 TELEPHONY_LOGI("NAPI NativeSetVoiceMailInfo %{public}d", errorCode);
2442 asyncContext.context.errorCode = errorCode;
2443 asyncContext.context.resolved = (errorCode == ERROR_NONE);
2444 }
2445
SetVoiceMailInfoCallback(napi_env env,napi_status status,void * data)2446 void SetVoiceMailInfoCallback(napi_env env, napi_status status, void *data)
2447 {
2448 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2449 std::unique_ptr<AsyncVoiceMail> context(static_cast<AsyncVoiceMail *>(data));
2450 NapiAsyncPermissionCompleteCallback(
2451 env, status, context->asyncContext, true, { "SetVoiceMailInfo", Permission::SET_TELEPHONY_STATE });
2452 }
2453
SetVoiceMailInfo(napi_env env,napi_callback_info info)2454 napi_value SetVoiceMailInfo(napi_env env, napi_callback_info info)
2455 {
2456 auto mailContext = new AsyncVoiceMail();
2457 BaseContext &context = mailContext->asyncContext.context;
2458
2459 auto initPara = std::make_tuple(&mailContext->asyncContext.slotId, std::data(mailContext->mailName),
2460 std::data(mailContext->mailNumber), &context.callbackRef);
2461
2462 AsyncPara para {
2463 .funcName = "SetVoiceMailNumber",
2464 .env = env,
2465 .info = info,
2466 .execute = NativeSetVoiceMailInfo,
2467 .complete = SetVoiceMailInfoCallback,
2468 };
2469 napi_value result = NapiCreateAsyncWork2<AsyncVoiceMail>(para, mailContext, initPara);
2470 if (result) {
2471 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2472 }
2473 return result;
2474 }
2475
NativeSendEnvelopeCmd(napi_env env,void * data)2476 void NativeSendEnvelopeCmd(napi_env env, void *data)
2477 {
2478 if (data == nullptr) {
2479 return;
2480 }
2481 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
2482 if (!IsValidSlotId(context->asyncContext.slotId)) {
2483 TELEPHONY_LOGE("NativeSendEnvelopeCmd slotId is invalid");
2484 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2485 return;
2486 }
2487 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendEnvelopeCmd(
2488 context->asyncContext.slotId, std::data(context->inputStr));
2489 TELEPHONY_LOGI("NAPI NativeSendEnvelopeCmd %{public}d", errorCode);
2490 context->asyncContext.context.errorCode = errorCode;
2491 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
2492 }
2493
SendEnvelopeCmdCallback(napi_env env,napi_status status,void * data)2494 void SendEnvelopeCmdCallback(napi_env env, napi_status status, void *data)
2495 {
2496 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2497 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
2498 NapiAsyncPermissionCompleteCallback(
2499 env, status, context->asyncContext, true, { "SendEnvelopeCmd", Permission::SET_TELEPHONY_STATE });
2500 }
2501
SendEnvelopeCmd(napi_env env,napi_callback_info info)2502 napi_value SendEnvelopeCmd(napi_env env, napi_callback_info info)
2503 {
2504 auto asyncContext = new AsyncContext2();
2505 BaseContext &context = asyncContext->asyncContext.context;
2506
2507 auto initPara =
2508 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
2509 AsyncPara para {
2510 .funcName = "SendEnvelopeCmd",
2511 .env = env,
2512 .info = info,
2513 .execute = NativeSendEnvelopeCmd,
2514 .complete = SendEnvelopeCmdCallback,
2515 };
2516 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
2517 if (result) {
2518 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2519 }
2520 return result;
2521 }
2522
NativeSendTerminalResponseCmd(napi_env env,void * data)2523 void NativeSendTerminalResponseCmd(napi_env env, void *data)
2524 {
2525 if (data == nullptr) {
2526 return;
2527 }
2528 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
2529 if (!IsValidSlotId(context->asyncContext.slotId)) {
2530 TELEPHONY_LOGE("NativeSendTerminalResponseCmd slotId is invalid");
2531 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2532 return;
2533 }
2534 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendTerminalResponseCmd(
2535 context->asyncContext.slotId, std::data(context->inputStr));
2536 TELEPHONY_LOGI("NAPI NativeSendTerminalResponseCmd %{public}d", errorCode);
2537 context->asyncContext.context.errorCode = errorCode;
2538 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
2539 }
2540
SendTerminalResponseCmdCallback(napi_env env,napi_status status,void * data)2541 void SendTerminalResponseCmdCallback(napi_env env, napi_status status, void *data)
2542 {
2543 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2544 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
2545 NapiAsyncPermissionCompleteCallback(
2546 env, status, context->asyncContext, true, { "SendTerminalResponseCmd", Permission::SET_TELEPHONY_STATE });
2547 }
2548
SendTerminalResponseCmd(napi_env env,napi_callback_info info)2549 napi_value SendTerminalResponseCmd(napi_env env, napi_callback_info info)
2550 {
2551 auto asyncContext = new AsyncContext2();
2552 BaseContext &context = asyncContext->asyncContext.context;
2553
2554 auto initPara =
2555 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
2556 AsyncPara para {
2557 .funcName = "SendTerminalResponseCmd",
2558 .env = env,
2559 .info = info,
2560 .execute = NativeSendTerminalResponseCmd,
2561 .complete = SendTerminalResponseCmdCallback,
2562 };
2563 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
2564 if (result) {
2565 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2566 }
2567 return result;
2568 }
2569
NativeAcceptCallSetupRequest(napi_env env,void * data)2570 void NativeAcceptCallSetupRequest(napi_env env, void *data)
2571 {
2572 if (data == nullptr) {
2573 return;
2574 }
2575 AsyncStkCallSetupResult *context = static_cast<AsyncStkCallSetupResult *>(data);
2576 if (!IsValidSlotId(context->asyncContext.slotId)) {
2577 TELEPHONY_LOGE("NativeAcceptCallSetupRequest slotId is invalid");
2578 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2579 return;
2580 }
2581 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendCallSetupRequestResult(
2582 context->asyncContext.slotId, true);
2583 TELEPHONY_LOGI("NAPI NativeAcceptCallSetupRequest %{public}d", errorCode);
2584 context->asyncContext.context.errorCode = errorCode;
2585 context->asyncContext.context.resolved = errorCode == ERROR_NONE;
2586 }
2587
AcceptCallSetupRequestCallback(napi_env env,napi_status status,void * data)2588 void AcceptCallSetupRequestCallback(napi_env env, napi_status status, void *data)
2589 {
2590 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2591 std::unique_ptr<AsyncStkCallSetupResult> context(static_cast<AsyncStkCallSetupResult *>(data));
2592 NapiAsyncPermissionCompleteCallback(
2593 env, status, context->asyncContext, true, { "acceptCallSetup", Permission::SET_TELEPHONY_STATE });
2594 }
2595
AcceptCallSetupRequest(napi_env env,napi_callback_info info)2596 napi_value AcceptCallSetupRequest(napi_env env, napi_callback_info info)
2597 {
2598 auto asyncContext = new AsyncStkCallSetupResult();
2599 BaseContext &context = asyncContext->asyncContext.context;
2600
2601 auto initPara = std::make_tuple(&asyncContext->asyncContext.slotId, &context.callbackRef);
2602 AsyncPara para {
2603 .funcName = "AcceptCallSetupRequest",
2604 .env = env,
2605 .info = info,
2606 .execute = NativeAcceptCallSetupRequest,
2607 .complete = AcceptCallSetupRequestCallback,
2608 };
2609 napi_value result = NapiCreateAsyncWork2<AsyncStkCallSetupResult>(para, asyncContext, initPara);
2610 if (result) {
2611 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2612 }
2613 return result;
2614 }
2615
NativeRejectCallSetupRequest(napi_env env,void * data)2616 void NativeRejectCallSetupRequest(napi_env env, void *data)
2617 {
2618 if (data == nullptr) {
2619 return;
2620 }
2621 AsyncStkCallSetupResult *context = static_cast<AsyncStkCallSetupResult *>(data);
2622 if (!IsValidSlotId(context->asyncContext.slotId)) {
2623 TELEPHONY_LOGE("NativeRejectCallSetupRequest slotId is invalid");
2624 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2625 return;
2626 }
2627 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendCallSetupRequestResult(
2628 context->asyncContext.slotId, false);
2629 TELEPHONY_LOGI("NAPI NativeRejectCallSetupRequest %{public}d", errorCode);
2630 context->asyncContext.context.errorCode = errorCode;
2631 context->asyncContext.context.resolved = errorCode == ERROR_NONE;
2632 }
2633
RejectCallSetupRequestCallback(napi_env env,napi_status status,void * data)2634 void RejectCallSetupRequestCallback(napi_env env, napi_status status, void *data)
2635 {
2636 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2637 std::unique_ptr<AsyncStkCallSetupResult> context(static_cast<AsyncStkCallSetupResult *>(data));
2638 NapiAsyncPermissionCompleteCallback(
2639 env, status, context->asyncContext, true, { "rejectCallSetup", Permission::SET_TELEPHONY_STATE });
2640 }
2641
RejectCallSetupRequest(napi_env env,napi_callback_info info)2642 napi_value RejectCallSetupRequest(napi_env env, napi_callback_info info)
2643 {
2644 auto asyncContext = new AsyncStkCallSetupResult();
2645 BaseContext &context = asyncContext->asyncContext.context;
2646
2647 auto initPara = std::make_tuple(&asyncContext->asyncContext.slotId, &context.callbackRef);
2648 AsyncPara para {
2649 .funcName = "RejectCallSetupRequest",
2650 .env = env,
2651 .info = info,
2652 .execute = NativeRejectCallSetupRequest,
2653 .complete = RejectCallSetupRequestCallback,
2654 };
2655 napi_value result = NapiCreateAsyncWork2<AsyncStkCallSetupResult>(para, asyncContext, initPara);
2656 if (result) {
2657 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2658 }
2659 return result;
2660 }
2661
GetMaxSimCount(napi_env env,napi_callback_info)2662 napi_value GetMaxSimCount(napi_env env, napi_callback_info)
2663 {
2664 return GetNapiValue(env, DelayedRefSingleton<CoreServiceClient>::GetInstance().GetMaxSimCount());
2665 }
2666
NativeGetOpKey(napi_env env,void * data)2667 void NativeGetOpKey(napi_env env, void *data)
2668 {
2669 if (data == nullptr) {
2670 return;
2671 }
2672 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
2673 if (!IsValidSlotId(asyncContext->slotId)) {
2674 TELEPHONY_LOGE("NativeGetOpKey slotId is invalid");
2675 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
2676 return;
2677 }
2678 std::u16string opkey;
2679 int32_t code = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpKey(asyncContext->slotId, opkey);
2680 if (code == ERROR_NONE) {
2681 asyncContext->callbackVal = NapiUtil::ToUtf8(opkey);
2682 asyncContext->context.resolved = true;
2683 return;
2684 }
2685 asyncContext->context.errorCode = code;
2686 asyncContext->context.resolved = false;
2687 }
2688
GetOpKeyCallback(napi_env env,napi_status status,void * data)2689 void GetOpKeyCallback(napi_env env, napi_status status, void *data)
2690 {
2691 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2692 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
2693 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2694 }
2695
GetOpKey(napi_env env,napi_callback_info info)2696 napi_value GetOpKey(napi_env env, napi_callback_info info)
2697 {
2698 return NapiCreateAsyncWork<std::string, NativeGetOpKey, GetOpKeyCallback>(env, info, "GetOpKey");
2699 }
2700
GetOpKeySync(napi_env env,napi_callback_info info)2701 napi_value GetOpKeySync(napi_env env, napi_callback_info info)
2702 {
2703 size_t parameterCount = 1;
2704 napi_value parameters[] = { nullptr };
2705 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
2706 std::u16string opKey;
2707 napi_value value = nullptr;
2708 if (parameterCount != 1) {
2709 TELEPHONY_LOGE("parameter count is incorrect");
2710 std::string operatorKey = NapiUtil::ToUtf8(opKey);
2711 NAPI_CALL(env, napi_create_string_utf8(env, operatorKey.c_str(), operatorKey.length(), &value));
2712 return value;
2713 }
2714 int32_t slotId = -1;
2715 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
2716 TELEPHONY_LOGE("convert parameter fail");
2717 std::string operatorKey = NapiUtil::ToUtf8(opKey);
2718 NAPI_CALL(env, napi_create_string_utf8(env, operatorKey.c_str(), operatorKey.length(), &value));
2719 return value;
2720 }
2721 if (IsValidSlotId(slotId)) {
2722 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpKey(slotId, opKey);
2723 }
2724 std::string operatorKey = NapiUtil::ToUtf8(opKey);
2725 NAPI_CALL(env, napi_create_string_utf8(env, operatorKey.c_str(), operatorKey.length(), &value));
2726 return value;
2727 }
2728
NativeGetOpName(napi_env env,void * data)2729 void NativeGetOpName(napi_env env, void *data)
2730 {
2731 if (data == nullptr) {
2732 return;
2733 }
2734 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
2735 if (!IsValidSlotId(asyncContext->slotId)) {
2736 TELEPHONY_LOGE("NativeGetOpName slotId is invalid");
2737 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
2738 return;
2739 }
2740 std::u16string opname;
2741 int32_t code = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpName(asyncContext->slotId, opname);
2742 if (code == ERROR_NONE) {
2743 asyncContext->callbackVal = NapiUtil::ToUtf8(opname);
2744 asyncContext->context.resolved = true;
2745 return;
2746 }
2747 asyncContext->context.errorCode = code;
2748 asyncContext->context.resolved = false;
2749 }
2750
GetOpNameCallback(napi_env env,napi_status status,void * data)2751 void GetOpNameCallback(napi_env env, napi_status status, void *data)
2752 {
2753 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2754 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
2755 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2756 }
2757
GetOpName(napi_env env,napi_callback_info info)2758 napi_value GetOpName(napi_env env, napi_callback_info info)
2759 {
2760 return NapiCreateAsyncWork<std::string, NativeGetOpName, GetOpNameCallback>(env, info, "GetOpName");
2761 }
2762
GetOpNameSync(napi_env env,napi_callback_info info)2763 napi_value GetOpNameSync(napi_env env, napi_callback_info info)
2764 {
2765 size_t parameterCount = 1;
2766 napi_value parameters[] = { nullptr };
2767 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
2768 std::u16string opName;
2769 napi_value value = nullptr;
2770 if (parameterCount != 1) {
2771 TELEPHONY_LOGE("parameter count is incorrect");
2772 std::string operatorName = NapiUtil::ToUtf8(opName);
2773 NAPI_CALL(env, napi_create_string_utf8(env, operatorName.c_str(), operatorName.length(), &value));
2774 return value;
2775 }
2776 int32_t slotId = -1;
2777 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
2778 TELEPHONY_LOGE("convert parameter fail");
2779 std::string operatorName = NapiUtil::ToUtf8(opName);
2780 NAPI_CALL(env, napi_create_string_utf8(env, operatorName.c_str(), operatorName.length(), &value));
2781 return value;
2782 }
2783 if (IsValidSlotId(slotId)) {
2784 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpName(slotId, opName);
2785 }
2786 std::string operatorName = NapiUtil::ToUtf8(opName);
2787 NAPI_CALL(env, napi_create_string_utf8(env, operatorName.c_str(), operatorName.length(), &value));
2788 return value;
2789 }
2790
NativeGetLockState(napi_env env,void * data)2791 void NativeGetLockState(napi_env env, void *data)
2792 {
2793 if (data == nullptr) {
2794 return;
2795 }
2796 AsyncGetLockState *lockContext = static_cast<AsyncGetLockState *>(data);
2797 AsyncContext<int32_t> &asContext = lockContext->asyncContext;
2798 if (!IsValidSlotId(asContext.slotId)) {
2799 TELEPHONY_LOGE("NativeGetLockState slotId is invalid");
2800 asContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2801 return;
2802 }
2803 LockState lockState = LockState::LOCK_ERROR;
2804 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetLockState(
2805 asContext.slotId, static_cast<LockType>(lockContext->lockType), lockState);
2806 TELEPHONY_LOGI("NAPI NativeGetLockState %{public}d", errorCode);
2807 if (errorCode == ERROR_NONE) {
2808 asContext.context.resolved = true;
2809 asContext.callbackVal = static_cast<int32_t>(lockState);
2810 } else {
2811 asContext.context.resolved = false;
2812 }
2813 asContext.context.errorCode = errorCode;
2814 }
2815
GetLockStateCallback(napi_env env,napi_status status,void * data)2816 void GetLockStateCallback(napi_env env, napi_status status, void *data)
2817 {
2818 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2819 std::unique_ptr<AsyncGetLockState> context(static_cast<AsyncGetLockState *>(data));
2820 TELEPHONY_LOGI("NAPI NativeGetLockState value:%{public}d", context->asyncContext.callbackVal);
2821 NapiAsyncPermissionCompleteCallback(
2822 env, status, context->asyncContext, false, { "GetLockState", Permission::GET_TELEPHONY_STATE });
2823 }
2824
GetLockState(napi_env env,napi_callback_info info)2825 napi_value GetLockState(napi_env env, napi_callback_info info)
2826 {
2827 auto lockStateContext = new AsyncGetLockState();
2828 BaseContext &context = lockStateContext->asyncContext.context;
2829
2830 auto initPara =
2831 std::make_tuple(&lockStateContext->asyncContext.slotId, &lockStateContext->lockType, &context.callbackRef);
2832 AsyncPara para {
2833 .funcName = "GetLockState",
2834 .env = env,
2835 .info = info,
2836 .execute = NativeGetLockState,
2837 .complete = GetLockStateCallback,
2838 };
2839 napi_value result = NapiCreateAsyncWork2<AsyncGetLockState>(para, lockStateContext, initPara);
2840 if (result) {
2841 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2842 }
2843 return result;
2844 }
2845
NativeHasOperatorPrivileges(napi_env env,void * data)2846 void NativeHasOperatorPrivileges(napi_env env, void *data)
2847 {
2848 if (data == nullptr) {
2849 return;
2850 }
2851 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
2852 if (!IsValidSlotId(reVal->slotId)) {
2853 TELEPHONY_LOGE("NativeHasOperatorPrivileges slotId is invalid");
2854 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
2855 return;
2856 }
2857 bool hasOperatorPrivileges = false;
2858 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasOperatorPrivileges(
2859 reVal->slotId, hasOperatorPrivileges);
2860 TELEPHONY_LOGI("NAPI NativeHasOperatorPrivileges %{public}d", errorCode);
2861 if (errorCode == ERROR_NONE) {
2862 reVal->callbackVal = hasOperatorPrivileges;
2863 reVal->context.resolved = true;
2864 } else {
2865 reVal->context.resolved = false;
2866 }
2867 reVal->context.errorCode = errorCode;
2868 }
2869
HasOperatorPrivilegesCallback(napi_env env,napi_status status,void * data)2870 void HasOperatorPrivilegesCallback(napi_env env, napi_status status, void *data)
2871 {
2872 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2873 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
2874 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2875 }
2876
HasOperatorPrivileges(napi_env env,napi_callback_info info)2877 napi_value HasOperatorPrivileges(napi_env env, napi_callback_info info)
2878 {
2879 return NapiCreateAsyncWork<bool, NativeHasOperatorPrivileges, HasOperatorPrivilegesCallback>(
2880 env, info, "HasOperatorPrivileges");
2881 }
2882
NativeUnlockSimLock(napi_env env,void * data)2883 void NativeUnlockSimLock(napi_env env, void *data)
2884 {
2885 if (data == nullptr) {
2886 return;
2887 }
2888 AsyncContextPIN *asyncContext = static_cast<AsyncContextPIN *>(data);
2889 if (!IsValidSlotId(asyncContext->asyncContext.slotId)) {
2890 TELEPHONY_LOGE("NativeUnlockSimLock slotId is invalid");
2891 asyncContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2892 return;
2893 }
2894 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
2895 PersoLockInfo lockInfo { static_cast<PersoLockType>(asyncContext->pinEnable),
2896 NapiUtil::ToUtf16(asyncContext->inStr1.data()) };
2897 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockSimLock(
2898 asyncContext->asyncContext.slotId, lockInfo, response);
2899 TELEPHONY_LOGI("NAPI NativeUnlockSimLock %{public}d", errorCode);
2900 if (errorCode == ERROR_NONE) {
2901 asyncContext->result = response.result;
2902 asyncContext->remain = response.remain;
2903 asyncContext->asyncContext.context.resolved = true;
2904 } else {
2905 asyncContext->asyncContext.context.resolved = false;
2906 }
2907 asyncContext->asyncContext.context.errorCode = errorCode;
2908 }
2909
UnlockSimLockCallback(napi_env env,napi_status status,void * data)2910 void UnlockSimLockCallback(napi_env env, napi_status status, void *data)
2911 {
2912 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2913 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
2914 const LockStatusResponse res {context->result, context->remain};
2915 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
2916 NapiAsyncPermissionCompleteCallback(
2917 env, status, context->asyncContext, false, { "UnlockSimLock", Permission::SET_TELEPHONY_STATE });
2918 }
2919
UnlockSimLock(napi_env env,napi_callback_info info)2920 napi_value UnlockSimLock(napi_env env, napi_callback_info info)
2921 {
2922 auto asyncContextPIN = new AsyncContextPIN();
2923 BaseContext &context = asyncContextPIN->asyncContext.context;
2924 napi_value object = NapiUtil::CreateUndefined(env);
2925 auto initPara = std::make_tuple(&asyncContextPIN->asyncContext.slotId, &object, &context.callbackRef);
2926
2927 AsyncPara para {
2928 .funcName = "UnlockSimLock",
2929 .env = env,
2930 .info = info,
2931 .execute = NativeUnlockSimLock,
2932 .complete = UnlockSimLockCallback,
2933 };
2934 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, asyncContextPIN, initPara);
2935 if (result) {
2936 PersoLockInfoAnalyze(env, object, *asyncContextPIN);
2937 NAPI_CALL(env, napi_queue_async_work_with_qos(env, context.work, napi_qos_default));
2938 }
2939 return result;
2940 }
2941
NativeGetAllSimAccountInfoList(napi_env env,void * data)2942 void NativeGetAllSimAccountInfoList(napi_env env, void *data)
2943 {
2944 if (data == nullptr) {
2945 return;
2946 }
2947 AsyncIccAccountInfo *accountInfo = static_cast<AsyncIccAccountInfo *>(data);
2948 accountInfo->vecInfo.clear();
2949 std::vector<IccAccountInfo> allInfo;
2950 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetAllSimAccountInfoList(allInfo);
2951 TELEPHONY_LOGI("NAPI NativeGetAllSimAccountInfoList %{public}d", errorCode);
2952 if (errorCode == ERROR_NONE) {
2953 accountInfo->vecInfo.swap(allInfo);
2954 accountInfo->asyncContext.context.resolved = true;
2955 } else {
2956 accountInfo->asyncContext.context.resolved = false;
2957 }
2958 accountInfo->asyncContext.context.errorCode = errorCode;
2959 }
2960
GetAllSimAccountInfoListCallback(napi_env env,napi_status status,void * data)2961 void GetAllSimAccountInfoListCallback(napi_env env, napi_status status, void *data)
2962 {
2963 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2964 std::unique_ptr<AsyncIccAccountInfo> info(static_cast<AsyncIccAccountInfo *>(data));
2965 AsyncContext<napi_value> &asyncContext = info->asyncContext;
2966 asyncContext.callbackVal = nullptr;
2967 napi_create_array(env, &asyncContext.callbackVal);
2968 for (size_t i = 0; i < info->vecInfo.size(); i++) {
2969 napi_value val = IccAccountInfoConversion(env, info->vecInfo.at(i));
2970 napi_set_element(env, asyncContext.callbackVal, i, val);
2971 }
2972 NapiAsyncPermissionCompleteCallback(
2973 env, status, asyncContext, false, {"GetAllSimAccountInfoList", Permission::GET_TELEPHONY_STATE});
2974 }
2975
GetAllSimAccountInfoList(napi_env env,napi_callback_info info)2976 napi_value GetAllSimAccountInfoList(napi_env env, napi_callback_info info)
2977 {
2978 auto accountInfo = std::make_unique<AsyncIccAccountInfo>();
2979 if (accountInfo == nullptr) {
2980 return nullptr;
2981 }
2982 BaseContext &context = accountInfo->asyncContext.context;
2983
2984 auto initPara = std::make_tuple(&context.callbackRef);
2985 AsyncPara para {
2986 .funcName = "GetAllSimAccountList",
2987 .env = env,
2988 .info = info,
2989 .execute = NativeGetAllSimAccountInfoList,
2990 .complete = GetAllSimAccountInfoListCallback,
2991 };
2992 napi_value result = NapiCreateAsyncWork2<AsyncIccAccountInfo>(para, accountInfo.get(), initPara);
2993 if (result == nullptr) {
2994 TELEPHONY_LOGE("create asyncwork failed");
2995 return nullptr;
2996 }
2997 if (napi_queue_async_work_with_qos(env, context.work, napi_qos_default) == napi_ok) {
2998 accountInfo.release();
2999 }
3000 return result;
3001 }
3002
NativeGetSimLabel(napi_env env,void * data)3003 void NativeGetSimLabel(napi_env env, void *data)
3004 {
3005 if (data == nullptr) {
3006 return;
3007 }
3008 AsyncSimLabelInfo *asyncContext = static_cast<AsyncSimLabelInfo *>(data);
3009 if (!IsValidSlotId(asyncContext->asyncContext.slotId)) {
3010 TELEPHONY_LOGE("slotId is invalid");
3011 asyncContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
3012 return;
3013 }
3014 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimLabel(
3015 asyncContext->asyncContext.slotId, asyncContext->simLabel);
3016 if (errorCode == ERROR_NONE) {
3017 asyncContext->asyncContext.context.resolved = true;
3018 } else {
3019 asyncContext->asyncContext.context.resolved = false;
3020 }
3021 asyncContext->asyncContext.context.errorCode = errorCode;
3022 }
3023
GetSimLabelCallback(napi_env env,napi_status status,void * data)3024 void GetSimLabelCallback(napi_env env, napi_status status, void *data)
3025 {
3026 NAPI_CALL_RETURN_VOID(env, (data == nullptr) ? napi_invalid_arg : napi_ok);
3027 std::unique_ptr<AsyncSimLabelInfo> context(static_cast<AsyncSimLabelInfo *>(data));
3028 AsyncContext<napi_value> &asyncContext = context->asyncContext;
3029 if (asyncContext.context.resolved) {
3030 napi_value value = nullptr;
3031 napi_create_object(env, &value);
3032 NapiUtil::SetPropertyInt32(env, value, "simType", static_cast<int32_t>(context->simLabel.simType));
3033 NapiUtil::SetPropertyInt32(env, value, "index", context->simLabel.index);
3034 asyncContext.callbackVal = value;
3035 }
3036 TELEPHONY_LOGI("GetSimLabelCallback end");
3037 }
3038
GetSimLabel(napi_env env,napi_callback_info info)3039 napi_value GetSimLabel(napi_env env, napi_callback_info info)
3040 {
3041 TELEPHONY_LOGI("GetSimLabel start");
3042 return NapiCreateAsyncWork<int32_t, NativeGetSimLabel, GetSimLabelCallback>(env, info, "GetSimLabel");
3043 }
3044
GetSimLabelSync(napi_env env,napi_callback_info info)3045 napi_value GetSimLabelSync(napi_env env, napi_callback_info info)
3046 {
3047 size_t parameterCount = 1;
3048 napi_value parameters[] = { nullptr };
3049 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
3050 SimLabel simLabel;
3051 napi_value value = nullptr;
3052 napi_create_object(env, &value);
3053 if (parameterCount != 1) {
3054 TELEPHONY_LOGE("parameter count is incorrect");
3055 return value;
3056 }
3057 int32_t slotId = -1;
3058 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
3059 TELEPHONY_LOGE("convert parameter fail");
3060 return value;
3061 }
3062 if (IsValidSlotId(slotId)) {
3063 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimLabel(slotId, simLabel);
3064 }
3065 NapiUtil::SetPropertyInt32(env, value, "simType", static_cast<int32_t>(simLabel.simType));
3066 NapiUtil::SetPropertyInt32(env, value, "index", simLabel.index);
3067 return value;
3068 }
3069
InitEnumSimState(napi_env env,napi_value exports)3070 napi_status InitEnumSimState(napi_env env, napi_value exports)
3071 {
3072 napi_property_descriptor desc[] = {
3073 DECLARE_NAPI_STATIC_PROPERTY(
3074 "SIM_STATE_UNKNOWN", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_UNKNOWN))),
3075 DECLARE_NAPI_STATIC_PROPERTY(
3076 "SIM_STATE_NOT_PRESENT", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_NOT_PRESENT))),
3077 DECLARE_NAPI_STATIC_PROPERTY(
3078 "SIM_STATE_LOCKED", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_LOCKED))),
3079 DECLARE_NAPI_STATIC_PROPERTY(
3080 "SIM_STATE_NOT_READY", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_NOT_READY))),
3081 DECLARE_NAPI_STATIC_PROPERTY(
3082 "SIM_STATE_READY", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_READY))),
3083 DECLARE_NAPI_STATIC_PROPERTY(
3084 "SIM_STATE_LOADED", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_LOADED))),
3085 };
3086 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3087 NapiUtil::DefineEnumClassByName(env, exports, "SimState", arrSize, desc);
3088 return napi_define_properties(env, exports, arrSize, desc);
3089 }
3090
InitEnumSimType(napi_env env,napi_value exports)3091 napi_status InitEnumSimType(napi_env env, napi_value exports)
3092 {
3093 napi_property_descriptor desc[] = {
3094 DECLARE_NAPI_STATIC_PROPERTY(
3095 "PSIM", GetNapiValue(env, static_cast<int32_t>(SimType::PSIM))),
3096 DECLARE_NAPI_STATIC_PROPERTY(
3097 "ESIM", GetNapiValue(env, static_cast<int32_t>(SimType::ESIM))),
3098 };
3099 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3100 NapiUtil::DefineEnumClassByName(env, exports, "SimType", arrSize, desc);
3101 return napi_define_properties(env, exports, arrSize, desc);
3102 }
3103
InitEnumContactType(napi_env env,napi_value exports)3104 napi_status InitEnumContactType(napi_env env, napi_value exports)
3105 {
3106 napi_property_descriptor desc[] = {
3107 DECLARE_NAPI_STATIC_PROPERTY(
3108 "GENERAL_CONTACT", GetNapiValue(env, static_cast<int32_t>(ContactType::GENERAL_CONTACT))),
3109 DECLARE_NAPI_STATIC_PROPERTY(
3110 "FIXED_DIALING", GetNapiValue(env, static_cast<int32_t>(ContactType::FIXED_DIALING))),
3111 };
3112
3113 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3114 NapiUtil::DefineEnumClassByName(env, exports, "ContactType", arrSize, desc);
3115 return napi_define_properties(env, exports, arrSize, desc);
3116 }
3117
InitEnumLockState(napi_env env,napi_value exports)3118 napi_status InitEnumLockState(napi_env env, napi_value exports)
3119 {
3120 napi_property_descriptor desc[] = {
3121 DECLARE_NAPI_STATIC_PROPERTY("LOCK_OFF", GetNapiValue(env, static_cast<int32_t>(LockState::LOCK_OFF))),
3122 DECLARE_NAPI_STATIC_PROPERTY("LOCK_ON", GetNapiValue(env, static_cast<int32_t>(LockState::LOCK_ON))),
3123 };
3124
3125 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3126 NapiUtil::DefineEnumClassByName(env, exports, "LockState", arrSize, desc);
3127 return napi_define_properties(env, exports, arrSize, desc);
3128 }
3129
InitEnumLockType(napi_env env,napi_value exports)3130 napi_status InitEnumLockType(napi_env env, napi_value exports)
3131 {
3132 napi_property_descriptor desc[] = {
3133 DECLARE_NAPI_STATIC_PROPERTY("PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(LockType::PIN_LOCK))),
3134 DECLARE_NAPI_STATIC_PROPERTY("FDN_LOCK", GetNapiValue(env, static_cast<int32_t>(LockType::FDN_LOCK))),
3135 };
3136
3137 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3138 NapiUtil::DefineEnumClassByName(env, exports, "LockType", arrSize, desc);
3139 return napi_define_properties(env, exports, arrSize, desc);
3140 }
3141
InitEnumCardType(napi_env env,napi_value exports)3142 napi_status InitEnumCardType(napi_env env, napi_value exports)
3143 {
3144 napi_property_descriptor desc[] = {
3145 DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::UNKNOWN_CARD))),
3146 DECLARE_NAPI_STATIC_PROPERTY(
3147 "SINGLE_MODE_SIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_SIM_CARD))),
3148 DECLARE_NAPI_STATIC_PROPERTY(
3149 "SINGLE_MODE_USIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_USIM_CARD))),
3150 DECLARE_NAPI_STATIC_PROPERTY(
3151 "SINGLE_MODE_RUIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_RUIM_CARD))),
3152 DECLARE_NAPI_STATIC_PROPERTY(
3153 "DUAL_MODE_CG_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_CG_CARD))),
3154 DECLARE_NAPI_STATIC_PROPERTY(
3155 "CT_NATIONAL_ROAMING_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::CT_NATIONAL_ROAMING_CARD))),
3156 DECLARE_NAPI_STATIC_PROPERTY(
3157 "CU_DUAL_MODE_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::CU_DUAL_MODE_CARD))),
3158 DECLARE_NAPI_STATIC_PROPERTY("DUAL_MODE_TELECOM_LTE_CARD",
3159 GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_TELECOM_LTE_CARD))),
3160 DECLARE_NAPI_STATIC_PROPERTY(
3161 "DUAL_MODE_UG_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_UG_CARD))),
3162 DECLARE_NAPI_STATIC_PROPERTY(
3163 "SINGLE_MODE_ISIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_ISIM_CARD))),
3164 };
3165
3166 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3167 NapiUtil::DefineEnumClassByName(env, exports, "CardType", arrSize, desc);
3168 return napi_define_properties(env, exports, arrSize, desc);
3169 }
3170
InitEnumPersoLockType(napi_env env,napi_value exports)3171 napi_status InitEnumPersoLockType(napi_env env, napi_value exports)
3172 {
3173 napi_property_descriptor desc[] = {
3174 DECLARE_NAPI_STATIC_PROPERTY(
3175 "PN_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PN_PIN_LOCK))),
3176 DECLARE_NAPI_STATIC_PROPERTY(
3177 "PN_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PN_PUK_LOCK))),
3178 DECLARE_NAPI_STATIC_PROPERTY(
3179 "PU_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PU_PIN_LOCK))),
3180 DECLARE_NAPI_STATIC_PROPERTY(
3181 "PU_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PU_PUK_LOCK))),
3182 DECLARE_NAPI_STATIC_PROPERTY(
3183 "PP_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PP_PIN_LOCK))),
3184 DECLARE_NAPI_STATIC_PROPERTY(
3185 "PP_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PP_PUK_LOCK))),
3186 DECLARE_NAPI_STATIC_PROPERTY(
3187 "PC_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PC_PIN_LOCK))),
3188 DECLARE_NAPI_STATIC_PROPERTY(
3189 "PC_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PC_PUK_LOCK))),
3190 DECLARE_NAPI_STATIC_PROPERTY(
3191 "SIM_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::SIM_PIN_LOCK))),
3192 DECLARE_NAPI_STATIC_PROPERTY(
3193 "SIM_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::SIM_PUK_LOCK))),
3194 };
3195
3196 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3197 NapiUtil::DefineEnumClassByName(env, exports, "PersoLockType", arrSize, desc);
3198 return napi_define_properties(env, exports, arrSize, desc);
3199 }
3200
InitEnumOperatorConfigKey(napi_env env,napi_value exports)3201 napi_status InitEnumOperatorConfigKey(napi_env env, napi_value exports)
3202 {
3203 napi_property_descriptor desc[] = {
3204 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOICE_MAIL_NUMBER_STRING", GetNapiValue(env, "voice_mail_number_string")),
3205 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_SWITCH_ON_BY_DEFAULT_BOOL",
3206 GetNapiValue(env, "ims_switch_on_by_default_bool")),
3207 DECLARE_NAPI_STATIC_PROPERTY("KEY_HIDE_IMS_SWITCH_BOOL", GetNapiValue(env, "hide_ims_switch_bool")),
3208 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOLTE_SUPPORTED_BOOL", GetNapiValue(env, "volte_supported_bool")),
3209 DECLARE_NAPI_STATIC_PROPERTY("KEY_CARRIER_VT_AVAILABLE_BOOL", GetNapiValue(env, "carrier_vt_available_bool")),
3210 DECLARE_NAPI_STATIC_PROPERTY("KEY_NR_MODE_SUPPORTED_LIST_INT_ARRAY",
3211 GetNapiValue(env, "nr_mode_supported_list_int_array")),
3212 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOLTE_PROVISIONING_SUPPORTED_BOOL",
3213 GetNapiValue(env, "volte_provisioning_supported_bool")),
3214 DECLARE_NAPI_STATIC_PROPERTY("KEY_SS_OVER_UT_SUPPORTED_BOOL", GetNapiValue(env, "ss_over_ut_supported_bool")),
3215 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_GBA_REQUIRED_BOOL", GetNapiValue(env, "ims_gba_required_bool")),
3216 DECLARE_NAPI_STATIC_PROPERTY("KEY_UT_PROVISIONING_SUPPORTED_BOOL",
3217 GetNapiValue(env, "ut_provisioning_supported_bool")),
3218 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_PREFER_FOR_EMERGENCY_BOOL",
3219 GetNapiValue(env, "ims_prefer_for_emergency_bool")),
3220 DECLARE_NAPI_STATIC_PROPERTY("KEY_CALL_WAITING_SERVICE_CLASS_INT",
3221 GetNapiValue(env, "call_waiting_service_class_int")),
3222 DECLARE_NAPI_STATIC_PROPERTY("KEY_CALL_TRANSFER_VISIBILITY_BOOL",
3223 GetNapiValue(env, "call_transfer_visibility_bool")),
3224 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_CALL_DISCONNECT_REASON_INFO_MAPPING_STRING_ARRAY",
3225 GetNapiValue(env, "ims_call_disconnect_reason_info_mapping_string_array")),
3226 DECLARE_NAPI_STATIC_PROPERTY("KEY_FORCE_VOLTE_SWITCH_ON_BOOL", GetNapiValue(env, "force_volte_switch_on_bool")),
3227 DECLARE_NAPI_STATIC_PROPERTY("KEY_ENABLE_OPERATOR_NAME_CUST_BOOL",
3228 GetNapiValue(env, "enable_operator_name_cust_bool")),
3229 DECLARE_NAPI_STATIC_PROPERTY("KEY_OPERATOR_NAME_CUST_STRING",
3230 GetNapiValue(env, "operator_name_cust_string")),
3231 DECLARE_NAPI_STATIC_PROPERTY("KEY_SPN_DISPLAY_CONDITION_CUST_INT",
3232 GetNapiValue(env, "spn_display_condition_cust_int")),
3233 DECLARE_NAPI_STATIC_PROPERTY("KEY_PNN_CUST_STRING_ARRAY", GetNapiValue(env, "pnn_cust_string_array")),
3234 DECLARE_NAPI_STATIC_PROPERTY("KEY_OPL_CUST_STRING_ARRAY", GetNapiValue(env, "opl_cust_string_array")),
3235 DECLARE_NAPI_STATIC_PROPERTY("KEY_EMERGENCY_CALL_STRING_ARRAY",
3236 GetNapiValue(env, "emergency_call_string_array")),
3237 DECLARE_NAPI_STATIC_PROPERTY("KEY_VIDEO_CALL_WAITING_ON_BOOL",
3238 GetNapiValue(env, "video_call_waiting_on_bool")),
3239 };
3240
3241 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3242 NapiUtil::DefineEnumClassByName(env, exports, "OperatorConfigKey", arrSize, desc);
3243 return napi_define_properties(env, exports, arrSize, desc);
3244 }
3245
InitEnumOperatorSimCard(napi_env env,napi_value exports)3246 napi_status InitEnumOperatorSimCard(napi_env env, napi_value exports)
3247 {
3248 napi_property_descriptor desc[] = {
3249 DECLARE_NAPI_STATIC_PROPERTY("CHINA_TELECOM_CARD", GetNapiValue(env, CHINA_TELECOM_CARD)),
3250 };
3251
3252 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3253 NapiUtil::DefineEnumClassByName(env, exports, "OperatorSimCard", arrSize, desc);
3254 return napi_define_properties(env, exports, arrSize, desc);
3255 }
3256
InitEnumAuthType(napi_env env,napi_value exports)3257 napi_status InitEnumAuthType(napi_env env, napi_value exports)
3258 {
3259 napi_property_descriptor desc[] = {
3260 DECLARE_NAPI_STATIC_PROPERTY(
3261 "SIM_AUTH_EAP_SIM_TYPE", GetNapiValue(env, static_cast<int32_t>(AuthType::SIM_AUTH_EAP_SIM_TYPE))),
3262 DECLARE_NAPI_STATIC_PROPERTY(
3263 "SIM_AUTH_EAP_AKA_TYPE", GetNapiValue(env, static_cast<int32_t>(AuthType::SIM_AUTH_EAP_AKA_TYPE))),
3264 };
3265
3266 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
3267 NapiUtil::DefineEnumClassByName(env, exports, "AuthType", arrSize, desc);
3268 return napi_define_properties(env, exports, arrSize, desc);
3269 }
3270
InitSimLockInterface(napi_env env,napi_value exports)3271 napi_status InitSimLockInterface(napi_env env, napi_value exports)
3272 {
3273 napi_property_descriptor desc[] = {
3274 DECLARE_NAPI_FUNCTION("unlockPin", UnlockPin),
3275 DECLARE_NAPI_FUNCTION("unlockPuk", UnlockPuk),
3276 DECLARE_NAPI_FUNCTION("alterPin", AlterPin),
3277 DECLARE_NAPI_FUNCTION("setLockState", SetLockState),
3278 DECLARE_NAPI_FUNCTION("unlockPin2", UnlockPin2),
3279 DECLARE_NAPI_FUNCTION("unlockPuk2", UnlockPuk2),
3280 DECLARE_NAPI_FUNCTION("alterPin2", AlterPin2),
3281 DECLARE_NAPI_FUNCTION("getLockState", GetLockState),
3282 DECLARE_NAPI_FUNCTION("unlockSimLock", UnlockSimLock),
3283 };
3284 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
3285 }
3286
InitSimDiallingNumbersInterface(napi_env env,napi_value exports)3287 napi_status InitSimDiallingNumbersInterface(napi_env env, napi_value exports)
3288 {
3289 napi_property_descriptor desc[] = {
3290 DECLARE_NAPI_FUNCTION("queryIccDiallingNumbers", QueryIccDiallingNumbers),
3291 DECLARE_NAPI_FUNCTION("addIccDiallingNumbers", AddIccDiallingNumbers),
3292 DECLARE_NAPI_FUNCTION("delIccDiallingNumbers", DelIccDiallingNumbers),
3293 DECLARE_NAPI_FUNCTION("updateIccDiallingNumbers", UpdateIccDiallingNumbers),
3294 };
3295 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
3296 }
3297
InitSimInterfaceAboutVoice(napi_env env,napi_value exports)3298 napi_status InitSimInterfaceAboutVoice(napi_env env, napi_value exports)
3299 {
3300 napi_property_descriptor desc[] = {
3301 DECLARE_NAPI_FUNCTION("setDefaultVoiceSlotId", SetDefaultVoiceSlotId),
3302 DECLARE_NAPI_FUNCTION("getDefaultVoiceSlotId", GetDefaultVoiceSlotId),
3303 DECLARE_NAPI_FUNCTION("getDefaultVoiceSimId", GetDefaultVoiceSimId),
3304 DECLARE_NAPI_FUNCTION("getVoiceMailIdentifier", GetVoiceMailIdentifier),
3305 DECLARE_NAPI_FUNCTION("getVoiceMailNumber", GetVoiceMailNumber),
3306 DECLARE_NAPI_FUNCTION("getVoiceMailCount", GetVoiceMailCount),
3307 DECLARE_NAPI_FUNCTION("setVoiceMailInfo", SetVoiceMailInfo),
3308 };
3309 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
3310 }
3311
InitSimInterface(napi_env env,napi_value exports)3312 napi_status InitSimInterface(napi_env env, napi_value exports)
3313 {
3314 napi_property_descriptor desc[] = {
3315 DECLARE_NAPI_FUNCTION("getISOCountryCodeForSim", GetISOCountryCodeForSim),
3316 DECLARE_NAPI_FUNCTION("getISOCountryCodeForSimSync", GetISOCountryCodeForSimSync),
3317 DECLARE_NAPI_FUNCTION("getSimOperatorNumeric", GetSimOperatorNumeric),
3318 DECLARE_NAPI_FUNCTION("getSimOperatorNumericSync", GetSimOperatorNumericSync),
3319 DECLARE_NAPI_FUNCTION("getSimSpn", GetSimSpn),
3320 DECLARE_NAPI_FUNCTION("getSimSpnSync", GetSimSpnSync),
3321 DECLARE_NAPI_FUNCTION("getSimState", GetSimState),
3322 DECLARE_NAPI_FUNCTION("getSimStateSync", GetSimStateSync),
3323 DECLARE_NAPI_FUNCTION("getCardType", GetCardType),
3324 DECLARE_NAPI_FUNCTION("getCardTypeSync", GetCardTypeSync),
3325 DECLARE_NAPI_FUNCTION("getSimIccId", GetSimIccId),
3326 DECLARE_NAPI_FUNCTION("getIMSI", GetIMSI),
3327 DECLARE_NAPI_FUNCTION("isOperatorSimCard", IsOperatorSimCard),
3328 DECLARE_NAPI_FUNCTION("hasSimCard", HasSimCard),
3329 DECLARE_NAPI_FUNCTION("hasSimCardSync", HasSimCardSync),
3330 DECLARE_NAPI_FUNCTION("getSimGid1", GetSimGid1),
3331 DECLARE_NAPI_FUNCTION("getSimAccountInfo", GetSimAccountInfo),
3332 DECLARE_NAPI_FUNCTION("isSimActive", IsSimActive),
3333 DECLARE_NAPI_FUNCTION("isSimActiveSync", IsSimActiveSync),
3334 DECLARE_NAPI_FUNCTION("activateSim", ActivateSim),
3335 DECLARE_NAPI_FUNCTION("deactivateSim", DeactivateSim),
3336 DECLARE_NAPI_FUNCTION("setShowName", SetShowName),
3337 DECLARE_NAPI_FUNCTION("getShowName", GetShowName),
3338 DECLARE_NAPI_FUNCTION("setShowNumber", SetShowNumber),
3339 DECLARE_NAPI_FUNCTION("getShowNumber", GetShowNumber),
3340 DECLARE_NAPI_FUNCTION("getOperatorConfigs", GetOperatorConfigs),
3341 DECLARE_NAPI_FUNCTION("getActiveSimAccountInfoList", GetActiveSimAccountInfoList),
3342 DECLARE_NAPI_FUNCTION("getSimTelephoneNumber", GetSimTelephoneNumber),
3343 DECLARE_NAPI_FUNCTION("sendEnvelopeCmd", SendEnvelopeCmd),
3344 DECLARE_NAPI_FUNCTION("sendTerminalResponseCmd", SendTerminalResponseCmd),
3345 DECLARE_NAPI_FUNCTION("acceptCallSetupRequest", AcceptCallSetupRequest),
3346 DECLARE_NAPI_FUNCTION("rejectCallSetupRequest", RejectCallSetupRequest),
3347 DECLARE_NAPI_FUNCTION("getMaxSimCount", GetMaxSimCount),
3348 DECLARE_NAPI_FUNCTION("hasOperatorPrivileges", HasOperatorPrivileges),
3349 DECLARE_NAPI_FUNCTION("getOpKey", GetOpKey),
3350 DECLARE_NAPI_FUNCTION("getOpKeySync", GetOpKeySync),
3351 DECLARE_NAPI_FUNCTION("getOpName", GetOpName),
3352 DECLARE_NAPI_FUNCTION("getOpNameSync", GetOpNameSync),
3353 DECLARE_NAPI_FUNCTION("getDsdsMode", GetDsdsMode),
3354 DECLARE_NAPI_FUNCTION("getSimAuthentication", GetSimAuthentication),
3355 DECLARE_NAPI_FUNCTION("getAllSimAccountInfoList", GetAllSimAccountInfoList),
3356 DECLARE_NAPI_FUNCTION("getSimLabel", GetSimLabel),
3357 DECLARE_NAPI_FUNCTION("getSimLabelSync", GetSimLabelSync),
3358 };
3359 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
3360 }
3361 } // namespace
3362
3363 EXTERN_C_START
InitNapiSim(napi_env env,napi_value exports)3364 napi_value InitNapiSim(napi_env env, napi_value exports)
3365 {
3366 NAPI_CALL(env, InitSimInterface(env, exports));
3367 NAPI_CALL(env, InitSimLockInterface(env, exports));
3368 NAPI_CALL(env, InitSimDiallingNumbersInterface(env, exports));
3369 NAPI_CALL(env, InitSimInterfaceAboutVoice(env, exports));
3370 NAPI_CALL(env, InitEnumSimState(env, exports));
3371 NAPI_CALL(env, InitEnumSimType(env, exports));
3372 NAPI_CALL(env, InitEnumContactType(env, exports));
3373 NAPI_CALL(env, InitEnumLockState(env, exports));
3374 NAPI_CALL(env, InitEnumLockType(env, exports));
3375 NAPI_CALL(env, InitEnumCardType(env, exports));
3376 NAPI_CALL(env, InitEnumPersoLockType(env, exports));
3377 NAPI_CALL(env, InitEnumOperatorConfigKey(env, exports));
3378 NAPI_CALL(env, InitEnumOperatorSimCard(env, exports));
3379 NAPI_CALL(env, InitEnumAuthType(env, exports));
3380 return exports;
3381 }
3382 EXTERN_C_END
3383
3384 static napi_module _simModule = {
3385 .nm_version = 1,
3386 .nm_flags = 0,
3387 .nm_filename = nullptr,
3388 .nm_register_func = InitNapiSim,
3389 .nm_modname = "telephony.sim",
3390 .nm_priv = ((void *)0),
3391 .reserved = {0},
3392 };
3393
RegisterSimCardModule(void)3394 extern "C" __attribute__((constructor)) void RegisterSimCardModule(void)
3395 {
3396 napi_module_register(&_simModule);
3397 }
3398 } // namespace Telephony
3399 } // namespace OHOS
3400