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 "js_error_code.h"
24 #include "napi_parameter_util.h"
25 #include "napi_sim_type.h"
26 #include "napi_util.h"
27 #include "network_state.h"
28 #include "sim_state_type.h"
29 #include "telephony_log_wrapper.h"
30 #include "telephony_permission.h"
31
32 namespace OHOS {
33 namespace Telephony {
34 namespace {
35 constexpr const char *JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING = "Invalid parameter value.";
36 struct AsyncPara {
37 std::string funcName = "";
38 napi_env env = nullptr;
39 napi_callback_info info = nullptr;
40 napi_async_execute_callback execute = nullptr;
41 napi_async_complete_callback complete = nullptr;
42 };
43
IsValidSlotId(int32_t slotId)44 static inline bool IsValidSlotId(int32_t slotId)
45 {
46 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
47 }
48
IsValidSlotIdForDefault(int32_t slotId)49 static inline bool IsValidSlotIdForDefault(int32_t slotId)
50 {
51 return ((slotId >= DEFAULT_SIM_SLOT_ID_REMOVE) && (slotId < SIM_SLOT_COUNT));
52 }
53
54 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)55 napi_value NapiCreateAsyncWork(napi_env env, napi_callback_info info, std::string_view funcName)
56 {
57 size_t argc = 2;
58 napi_value argv[] {nullptr, nullptr};
59 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
60
61 std::unique_ptr<AsyncContext<T>> asyncContext = std::make_unique<AsyncContext<T>>();
62 BaseContext &context = asyncContext->context;
63 auto inParaTp = std::make_tuple(&asyncContext->slotId, &context.callbackRef);
64 std::optional<NapiError> errCode = MatchParameters(env, argv, argc, inParaTp);
65 if (errCode.has_value()) {
66 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
67 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
68 return nullptr;
69 }
70
71 napi_value result = nullptr;
72 if (context.callbackRef == nullptr) {
73 NAPI_CALL(env, napi_create_promise(env, &context.deferred, &result));
74 } else {
75 NAPI_CALL(env, napi_get_undefined(env, &result));
76 }
77
78 napi_value resourceName = nullptr;
79 NAPI_CALL(env, napi_create_string_utf8(env, funcName.data(), funcName.length(), &resourceName));
80 AsyncContext<T> *pContext = asyncContext.release();
81 NAPI_CALL(env,
82 napi_create_async_work(
83 env, nullptr, resourceName, exec, complete, static_cast<void *>(pContext), &context.work));
84 if (napi_queue_async_work(env, context.work) != napi_ok) {
85 delete pContext;
86 result = nullptr;
87 }
88 return result;
89 }
90
91 template<typename AsyncContextType, typename... Ts>
NapiCreateAsyncWork2(const AsyncPara & para,AsyncContextType * asyncContext,std::tuple<Ts...> & theTuple)92 napi_value NapiCreateAsyncWork2(const AsyncPara ¶, AsyncContextType *asyncContext, std::tuple<Ts...> &theTuple)
93 {
94 napi_env env = para.env;
95 BaseContext &context = asyncContext->asyncContext.context;
96
97 size_t argc = sizeof...(Ts);
98 napi_value argv[sizeof...(Ts)] {nullptr};
99 NAPI_CALL(env, napi_get_cb_info(env, para.info, &argc, argv, nullptr, nullptr));
100
101 std::optional<NapiError> errCode = MatchParameters(env, argv, argc, theTuple);
102 if (errCode.has_value()) {
103 JsError error = NapiUtil::ConverErrorMessageForJs(errCode.value());
104 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
105 return nullptr;
106 }
107
108 napi_value result = nullptr;
109 if (context.callbackRef == nullptr) {
110 NAPI_CALL(env, napi_create_promise(env, &context.deferred, &result));
111 } else {
112 NAPI_CALL(env, napi_get_undefined(env, &result));
113 }
114
115 napi_value resourceName = nullptr;
116 NAPI_CALL(env, napi_create_string_utf8(env, para.funcName.c_str(), para.funcName.length(), &resourceName));
117 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, para.execute, para.complete,
118 static_cast<void *>(asyncContext), &context.work));
119 return result;
120 }
121
122 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)123 void NapiAsyncCompleteCallback(napi_env env, napi_status status, const AsyncContext<T> &asyncContext,
124 const std::string &errMessage, bool funcIgnoreReturnVal = false, int errorCode = ERROR_DEFAULT)
125 {
126 if (status != napi_ok) {
127 napi_throw_type_error(env, nullptr, "excute failed");
128 return;
129 }
130
131 const BaseContext &context = asyncContext.context;
132 if (context.deferred != nullptr) {
133 if (!context.resolved) {
134 napi_value errorMessage = NapiUtil::CreateErrorMessage(env, errMessage, errorCode);
135 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, errorMessage));
136 } else {
137 napi_value res =
138 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
139 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, res));
140 }
141 } else {
142 napi_value res =
143 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
144 napi_value callbackValue[] {NapiUtil::CreateUndefined(env), res};
145 if (!context.resolved) {
146 callbackValue[0] = NapiUtil::CreateErrorMessage(env, errMessage, errorCode);
147 callbackValue[1] = NapiUtil::CreateUndefined(env);
148 }
149 napi_value undefined = nullptr;
150 napi_value callback = nullptr;
151 napi_value result = nullptr;
152 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
153 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
154 NAPI_CALL_RETURN_VOID(
155 env, napi_call_function(env, undefined, callback, std::size(callbackValue), callbackValue, &result));
156 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, context.callbackRef));
157 }
158 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
159 }
160
161 template<typename T>
NapiAsyncBaseCompleteCallback(napi_env env,const AsyncContext<T> & asyncContext,JsError error,bool funcIgnoreReturnVal=false)162 void NapiAsyncBaseCompleteCallback(
163 napi_env env, const AsyncContext<T> &asyncContext, JsError error, bool funcIgnoreReturnVal = false)
164 {
165 const BaseContext &context = asyncContext.context;
166 if (context.deferred != nullptr && !context.resolved) {
167 napi_value errorMessage = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
168 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, errorMessage));
169 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
170 return;
171 }
172
173 if (context.deferred != nullptr && context.resolved) {
174 napi_value res =
175 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
176 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, res));
177 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
178 return;
179 }
180
181 napi_value res =
182 (funcIgnoreReturnVal ? NapiUtil::CreateUndefined(env) : GetNapiValue(env, asyncContext.callbackVal));
183 napi_value callbackValue[] { NapiUtil::CreateUndefined(env), res };
184 if (!context.resolved) {
185 callbackValue[0] = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
186 callbackValue[1] = NapiUtil::CreateUndefined(env);
187 }
188 napi_value undefined = nullptr;
189 napi_value callback = nullptr;
190 napi_value result = nullptr;
191 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
192 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
193 NAPI_CALL_RETURN_VOID(
194 env, napi_call_function(env, undefined, callback, std::size(callbackValue), callbackValue, &result));
195 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, context.callbackRef));
196 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, context.work));
197 }
198
199 template<typename T>
NapiAsyncPermissionCompleteCallback(napi_env env,napi_status status,const AsyncContext<T> & asyncContext,bool funcIgnoreReturnVal,std::string func,std::string permission)200 void NapiAsyncPermissionCompleteCallback(napi_env env, napi_status status, const AsyncContext<T> &asyncContext,
201 bool funcIgnoreReturnVal, std::string func, std::string permission)
202 {
203 if (status != napi_ok) {
204 napi_throw_type_error(env, nullptr, "excute failed");
205 return;
206 }
207
208 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(asyncContext.context.errorCode, func, permission);
209 NapiAsyncBaseCompleteCallback(env, asyncContext, error, funcIgnoreReturnVal);
210 }
211
212 template<typename T>
NapiAsyncCommomCompleteCallback(napi_env env,napi_status status,const AsyncContext<T> & asyncContext,bool funcIgnoreReturnVal)213 void NapiAsyncCommomCompleteCallback(
214 napi_env env, napi_status status, const AsyncContext<T> &asyncContext, bool funcIgnoreReturnVal)
215 {
216 if (status != napi_ok) {
217 napi_throw_type_error(env, nullptr, "excute failed");
218 return;
219 }
220
221 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext.context.errorCode);
222 NapiAsyncBaseCompleteCallback(env, asyncContext, error, funcIgnoreReturnVal);
223 }
224
IccAccountInfoConversion(napi_env env,const IccAccountInfo & iccAccountInfo)225 napi_value IccAccountInfoConversion(napi_env env, const IccAccountInfo &iccAccountInfo)
226 {
227 napi_value val = nullptr;
228 napi_create_object(env, &val);
229 SetPropertyToNapiObject(env, val, "simId", iccAccountInfo.simId);
230 SetPropertyToNapiObject(env, val, "slotIndex", iccAccountInfo.slotIndex);
231 SetPropertyToNapiObject(env, val, "isEsim", iccAccountInfo.isEsim);
232 SetPropertyToNapiObject(env, val, "isActive", iccAccountInfo.isActive);
233 SetPropertyToNapiObject(env, val, "iccId", NapiUtil::ToUtf8(iccAccountInfo.iccId));
234 SetPropertyToNapiObject(env, val, "showName", NapiUtil::ToUtf8(iccAccountInfo.showName));
235 SetPropertyToNapiObject(env, val, "showNumber", NapiUtil::ToUtf8(iccAccountInfo.showNumber));
236 return val;
237 }
238
PinOrPukUnlockConversion(napi_env env,const LockStatusResponse & response)239 napi_value PinOrPukUnlockConversion(napi_env env, const LockStatusResponse &response)
240 {
241 TELEPHONY_LOGI("PinOrPukUnlockConversion response.result %{public}d, response.remain %{public}d", response.result,
242 response.remain);
243 constexpr int32_t passWordErr = -1;
244 napi_value val = nullptr;
245 napi_create_object(env, &val);
246 SetPropertyToNapiObject(env, val, "result", response.result);
247 napi_value res =
248 (response.result == passWordErr ? GetNapiValue(env, response.remain) : NapiUtil::CreateUndefined(env));
249 napi_set_named_property(env, val, "remain", res);
250 return val;
251 }
252
OperatorConfigAnalyze(napi_env env,const ConfigInfo & config)253 napi_value OperatorConfigAnalyze(napi_env env, const ConfigInfo &config)
254 {
255 napi_value obj = nullptr;
256 napi_create_object(env, &obj);
257 SetPropertyToNapiObject(env, obj, "field", config.field);
258 SetPropertyToNapiObject(env, obj, "value", config.value);
259 return obj;
260 }
261
DiallingNumbersConversion(napi_env env,const TelNumbersInfo & info)262 napi_value DiallingNumbersConversion(napi_env env, const TelNumbersInfo &info)
263 {
264 napi_value val = nullptr;
265 napi_create_object(env, &val);
266 SetPropertyToNapiObject(env, val, "recordNumber", info.recordNumber);
267 SetPropertyToNapiObject(env, val, "alphaTag", std::data(info.alphaTag));
268 SetPropertyToNapiObject(env, val, "number", std::data(info.number));
269 SetPropertyToNapiObject(env, val, "pin2", std::data(info.pin2));
270 return val;
271 }
272
GetDiallingNumberInfo(const std::shared_ptr<DiallingNumbersInfo> & telNumber,const TelNumbersInfo & info)273 void GetDiallingNumberInfo(const std::shared_ptr<DiallingNumbersInfo> &telNumber, const TelNumbersInfo &info)
274 {
275 telNumber->index_ = info.recordNumber;
276 telNumber->name_ = NapiUtil::ToUtf16(info.alphaTag.data());
277 telNumber->number_ = NapiUtil::ToUtf16(info.number.data());
278 telNumber->pin2_ = NapiUtil::ToUtf16(info.pin2.data());
279 }
280
DiallingNumberParaAnalyze(napi_env env,napi_value arg,TelNumbersInfo & info)281 void DiallingNumberParaAnalyze(napi_env env, napi_value arg, TelNumbersInfo &info)
282 {
283 napi_value recordNumber = NapiUtil::GetNamedProperty(env, arg, "recordNumber");
284 if (recordNumber) {
285 NapiValueToCppValue(env, recordNumber, napi_number, &info.recordNumber);
286 }
287
288 napi_value alphaTag = NapiUtil::GetNamedProperty(env, arg, "alphaTag");
289 if (alphaTag) {
290 NapiValueToCppValue(env, alphaTag, napi_string, std::data(info.alphaTag));
291 }
292
293 napi_value number = NapiUtil::GetNamedProperty(env, arg, "number");
294 if (number) {
295 NapiValueToCppValue(env, number, napi_string, std::data(info.number));
296 }
297
298 napi_value pin2 = NapiUtil::GetNamedProperty(env, arg, "pin2");
299 if (pin2) {
300 NapiValueToCppValue(env, pin2, napi_string, std::data(info.pin2));
301 }
302 }
303
PinInfoParaAnalyze(napi_env env,napi_value arg,AsyncContextPIN & pinContext)304 void PinInfoParaAnalyze(napi_env env, napi_value arg, AsyncContextPIN &pinContext)
305 {
306 napi_value lockType = NapiUtil::GetNamedProperty(env, arg, "lockType");
307 if (lockType) {
308 NapiValueToCppValue(env, lockType, napi_number, &pinContext.result);
309 }
310
311 napi_value pin = NapiUtil::GetNamedProperty(env, arg, "password");
312 if (pin) {
313 char tmpStr[kMaxNumberLen + 1] = {0};
314 NapiValueToCppValue(env, pin, napi_string, tmpStr);
315 pinContext.inStr1 = std::string(tmpStr);
316 }
317
318 napi_value state = NapiUtil::GetNamedProperty(env, arg, "state");
319 if (state) {
320 NapiValueToCppValue(env, state, napi_number, &pinContext.remain);
321 }
322 }
323
PersoLockInfoAnalyze(napi_env env,napi_value arg,AsyncContextPIN & pinContext)324 void PersoLockInfoAnalyze(napi_env env, napi_value arg, AsyncContextPIN &pinContext)
325 {
326 napi_value lockType = NapiUtil::GetNamedProperty(env, arg, "lockType");
327 if (lockType) {
328 NapiValueToCppValue(env, lockType, napi_number, &pinContext.pinEnable);
329 }
330
331 napi_value password = NapiUtil::GetNamedProperty(env, arg, "password");
332 if (password) {
333 char tmpStr[kMaxNumberLen + 1] = {0};
334 NapiValueToCppValue(env, password, napi_string, tmpStr);
335 pinContext.inStr1 = std::string(tmpStr);
336 }
337 }
338
NativeIsSimActive(napi_env env,void * data)339 void NativeIsSimActive(napi_env env, void *data)
340 {
341 if (data == nullptr) {
342 return;
343 }
344 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
345 if (!IsValidSlotId(reVal->slotId)) {
346 TELEPHONY_LOGE("NativeIsSimActive slotId is invalid");
347 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
348 return;
349 }
350 reVal->callbackVal = DelayedRefSingleton<CoreServiceClient>::GetInstance().IsSimActive(reVal->slotId);
351 TELEPHONY_LOGI("NAPI NativeIsSimActive %{public}d", reVal->callbackVal);
352 /* transparent return value */
353 reVal->context.resolved = true;
354 }
355
IsSimActiveCallback(napi_env env,napi_status status,void * data)356 void IsSimActiveCallback(napi_env env, napi_status status, void *data)
357 {
358 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
359 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
360 if (context->context.errorCode == ERROR_SLOT_ID_INVALID) {
361 NapiAsyncCompleteCallback(
362 env, status, *context, JS_ERROR_TELEPHONY_ARGUMENT_ERROR_STRING, false, JS_ERROR_TELEPHONY_ARGUMENT_ERROR);
363 } else {
364 NapiAsyncCompleteCallback(env, status, *context, "get simActive state failed");
365 }
366 }
367
IsSimActive(napi_env env,napi_callback_info info)368 napi_value IsSimActive(napi_env env, napi_callback_info info)
369 {
370 return NapiCreateAsyncWork<bool, NativeIsSimActive, IsSimActiveCallback>(env, info, "IsSimActive");
371 }
372
NativeActivateSim(napi_env env,void * data)373 void NativeActivateSim(napi_env env, void *data)
374 {
375 if (data == nullptr) {
376 return;
377 }
378 AsyncContext<bool> *simContext = static_cast<AsyncContext<bool> *>(data);
379 if (!IsValidSlotId(simContext->slotId)) {
380 TELEPHONY_LOGE("NativeActivateSim slotId is invalid");
381 simContext->context.errorCode = ERROR_SLOT_ID_INVALID;
382 return;
383 }
384 constexpr int32_t active = 1;
385 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetActiveSim(simContext->slotId, active);
386 TELEPHONY_LOGI("NAPI NativeActivateSim %{public}d", errorCode);
387 simContext->context.errorCode = errorCode;
388 simContext->context.resolved = (errorCode == ERROR_NONE);
389 }
390
ActivateSimCallback(napi_env env,napi_status status,void * data)391 void ActivateSimCallback(napi_env env, napi_status status, void *data)
392 {
393 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
394 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
395 NapiAsyncPermissionCompleteCallback(env, status, *context, true, "ActivateSim", Permission::SET_TELEPHONY_STATE);
396 }
397
ActivateSim(napi_env env,napi_callback_info info)398 napi_value ActivateSim(napi_env env, napi_callback_info info)
399 {
400 return NapiCreateAsyncWork<bool, NativeActivateSim, ActivateSimCallback>(env, info, "ActivateSim");
401 }
402
NativeDeactivateSim(napi_env env,void * data)403 void NativeDeactivateSim(napi_env env, void *data)
404 {
405 if (data == nullptr) {
406 return;
407 }
408 AsyncContext<bool> *simContext = static_cast<AsyncContext<bool> *>(data);
409 if (!IsValidSlotId(simContext->slotId)) {
410 TELEPHONY_LOGE("NativeDeactivateSim slotId is invalid");
411 simContext->context.errorCode = ERROR_SLOT_ID_INVALID;
412 return;
413 }
414 constexpr int32_t deactive = 0;
415 int32_t errorCode =
416 DelayedRefSingleton<CoreServiceClient>::GetInstance().SetActiveSim(simContext->slotId, deactive);
417 TELEPHONY_LOGI("NAPI NativeDeactivateSim %{public}d", errorCode);
418 simContext->context.errorCode = errorCode;
419 simContext->context.resolved = (errorCode == ERROR_NONE);
420 }
421
DeactivateSimCallback(napi_env env,napi_status status,void * data)422 void DeactivateSimCallback(napi_env env, napi_status status, void *data)
423 {
424 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
425 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
426 NapiAsyncPermissionCompleteCallback(env, status, *context, true, "DeactivateSim", Permission::SET_TELEPHONY_STATE);
427 }
428
DeactivateSim(napi_env env,napi_callback_info info)429 napi_value DeactivateSim(napi_env env, napi_callback_info info)
430 {
431 return NapiCreateAsyncWork<bool, NativeDeactivateSim, DeactivateSimCallback>(env, info, "DeactivateSim");
432 }
433
NativeGetDefaultVoiceSlotId(napi_env env,void * data)434 void NativeGetDefaultVoiceSlotId(napi_env env, void *data)
435 {
436 if (data == nullptr) {
437 return;
438 }
439 AsyncContext<int32_t> *asyncContext = &(static_cast<AsyncDefaultSlotId *>(data)->asyncContext);
440
441 asyncContext->callbackVal = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDefaultVoiceSlotId();
442 TELEPHONY_LOGI("NAPI NativeGetDefaultVoiceSlotId %{public}d", asyncContext->callbackVal);
443 asyncContext->context.resolved = (asyncContext->callbackVal > ERROR_DEFAULT);
444 }
445
GetDefaultVoiceSlotIdCallback(napi_env env,napi_status status,void * data)446 void GetDefaultVoiceSlotIdCallback(napi_env env, napi_status status, void *data)
447 {
448 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
449 std::unique_ptr<AsyncDefaultSlotId> context(static_cast<AsyncDefaultSlotId *>(data));
450 NapiAsyncCompleteCallback(env, status, context->asyncContext, "get default voice slot id failed");
451 }
452
GetDefaultVoiceSlotId(napi_env env,napi_callback_info info)453 napi_value GetDefaultVoiceSlotId(napi_env env, napi_callback_info info)
454 {
455 auto asyncContext = new AsyncDefaultSlotId();
456 BaseContext &context = asyncContext->asyncContext.context;
457
458 auto initPara = std::make_tuple(&context.callbackRef);
459 AsyncPara para {
460 .funcName = "GetDefaultVoiceSlotId",
461 .env = env,
462 .info = info,
463 .execute = NativeGetDefaultVoiceSlotId,
464 .complete = GetDefaultVoiceSlotIdCallback,
465 };
466 napi_value result = NapiCreateAsyncWork2<AsyncDefaultSlotId>(para, asyncContext, initPara);
467 if (result) {
468 NAPI_CALL(env, napi_queue_async_work(env, context.work));
469 }
470 return result;
471 }
472
NativeGetIsoForSim(napi_env env,void * data)473 void NativeGetIsoForSim(napi_env env, void *data)
474 {
475 if (data == nullptr) {
476 return;
477 }
478 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
479 if (!IsValidSlotId(asyncContext->slotId)) {
480 TELEPHONY_LOGE("NativeGetIsoForSim slotId is invalid");
481 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
482 return;
483 }
484 std::u16string countryCode;
485 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetISOCountryCodeForSim(
486 asyncContext->slotId, countryCode);
487 if (errorCode == ERROR_NONE) {
488 asyncContext->callbackVal = NapiUtil::ToUtf8(countryCode);
489 asyncContext->context.resolved = true;
490 } else {
491 asyncContext->context.resolved = false;
492 }
493 TELEPHONY_LOGI("NAPI NativeGetIsoForSim %{public}d", errorCode);
494 asyncContext->context.errorCode = errorCode;
495 }
496
GetIsoForSimCallback(napi_env env,napi_status status,void * data)497 void GetIsoForSimCallback(napi_env env, napi_status status, void *data)
498 {
499 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
500 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
501 NapiAsyncCommomCompleteCallback(env, status, *context, false);
502 }
503
GetISOCountryCodeForSim(napi_env env,napi_callback_info info)504 napi_value GetISOCountryCodeForSim(napi_env env, napi_callback_info info)
505 {
506 return NapiCreateAsyncWork<std::string, NativeGetIsoForSim, GetIsoForSimCallback>(
507 env, info, "GetISOCountryCodeForSim");
508 }
509
NativeGetSimOperatorNumeric(napi_env env,void * data)510 void NativeGetSimOperatorNumeric(napi_env env, void *data)
511 {
512 if (data == nullptr) {
513 return;
514 }
515 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
516 if (!IsValidSlotId(asyncContext->slotId)) {
517 TELEPHONY_LOGE("NativeGetSimOperatorNumeric slotId is invalid");
518 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
519 return;
520 }
521 std::u16string operatorNumeric;
522 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimOperatorNumeric(
523 asyncContext->slotId, operatorNumeric);
524 if (errorCode == ERROR_NONE) {
525 asyncContext->callbackVal = NapiUtil::ToUtf8(operatorNumeric);
526 asyncContext->context.resolved = true;
527 } else {
528 asyncContext->context.resolved = false;
529 }
530 TELEPHONY_LOGI("NAPI NativeGetSimOperatorNumeric %{public}d", errorCode);
531 asyncContext->context.errorCode = errorCode;
532 }
533
GetSimOperatorNumericCallback(napi_env env,napi_status status,void * data)534 void GetSimOperatorNumericCallback(napi_env env, napi_status status, void *data)
535 {
536 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
537 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
538 NapiAsyncCommomCompleteCallback(env, status, *context, false);
539 }
540
GetSimOperatorNumeric(napi_env env,napi_callback_info info)541 napi_value GetSimOperatorNumeric(napi_env env, napi_callback_info info)
542 {
543 return NapiCreateAsyncWork<std::string, NativeGetSimOperatorNumeric, GetSimOperatorNumericCallback>(
544 env, info, "GetSimOperatorNumeric");
545 }
546
NativeGetSimSpn(napi_env env,void * data)547 void NativeGetSimSpn(napi_env env, void *data)
548 {
549 if (data == nullptr) {
550 return;
551 }
552 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
553 if (!IsValidSlotId(asyncContext->slotId)) {
554 TELEPHONY_LOGE("NativeGetSimSpn slotId is invalid");
555 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
556 return;
557 }
558 std::u16string spn;
559 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimSpn(asyncContext->slotId, spn);
560 if (errorCode == ERROR_NONE) {
561 asyncContext->callbackVal = NapiUtil::ToUtf8(spn);
562 asyncContext->context.resolved = true;
563 } else {
564 asyncContext->context.resolved = false;
565 }
566 TELEPHONY_LOGI("NAPI NativeGetSimSpn %{public}d", errorCode);
567 asyncContext->context.errorCode = errorCode;
568 }
569
GetSimSpnCallback(napi_env env,napi_status status,void * data)570 void GetSimSpnCallback(napi_env env, napi_status status, void *data)
571 {
572 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
573 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
574 NapiAsyncCommomCompleteCallback(env, status, *context, false);
575 }
576
GetSimSpn(napi_env env,napi_callback_info info)577 napi_value GetSimSpn(napi_env env, napi_callback_info info)
578 {
579 return NapiCreateAsyncWork<std::string, NativeGetSimSpn, GetSimSpnCallback>(env, info, "GetSimSpn");
580 }
581
NativeGetSimState(napi_env env,void * data)582 void NativeGetSimState(napi_env env, void *data)
583 {
584 if (data == nullptr) {
585 return;
586 }
587 AsyncContext<int32_t> *asyncContext = static_cast<AsyncContext<int32_t> *>(data);
588 if (!IsValidSlotId(asyncContext->slotId)) {
589 TELEPHONY_LOGE("NativeGetSimState slotId is invalid");
590 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
591 return;
592 }
593 SimState simState = SimState::SIM_STATE_UNKNOWN;
594 int32_t errorCode =
595 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimState(asyncContext->slotId, simState);
596 TELEPHONY_LOGI("NAPI NativeGetSimState %{public}d", errorCode);
597 if (errorCode == ERROR_NONE) {
598 asyncContext->context.resolved = true;
599 asyncContext->callbackVal = static_cast<int32_t>(simState);
600 } else {
601 asyncContext->context.resolved = false;
602 }
603 asyncContext->context.errorCode = errorCode;
604 }
605
GetSimStateCallback(napi_env env,napi_status status,void * data)606 void GetSimStateCallback(napi_env env, napi_status status, void *data)
607 {
608 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
609 std::unique_ptr<AsyncContext<int32_t>> context(static_cast<AsyncContext<int32_t> *>(data));
610 NapiAsyncCommomCompleteCallback(env, status, *context, false);
611 }
612
GetSimState(napi_env env,napi_callback_info info)613 napi_value GetSimState(napi_env env, napi_callback_info info)
614 {
615 return NapiCreateAsyncWork<int32_t, NativeGetSimState, GetSimStateCallback>(env, info, "GetSimState");
616 }
617
NativeGetCardType(napi_env env,void * data)618 void NativeGetCardType(napi_env env, void *data)
619 {
620 if (data == nullptr) {
621 return;
622 }
623 AsyncContext<int32_t> *asyncContext = static_cast<AsyncContext<int32_t> *>(data);
624 if (!IsValidSlotId(asyncContext->slotId)) {
625 TELEPHONY_LOGE("NativeGetCardType slotId is invalid");
626 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
627 return;
628 }
629 CardType cardType = CardType::UNKNOWN_CARD;
630 int32_t errorCode =
631 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCardType(asyncContext->slotId, cardType);
632 TELEPHONY_LOGI("NAPI NativeGetCardType %{public}d", errorCode);
633 if (errorCode == ERROR_NONE) {
634 asyncContext->context.resolved = true;
635 asyncContext->callbackVal = static_cast<int32_t>(cardType);
636 } else {
637 asyncContext->context.resolved = false;
638 }
639 asyncContext->context.errorCode = errorCode;
640 }
641
GetCardTypeCallback(napi_env env,napi_status status,void * data)642 void GetCardTypeCallback(napi_env env, napi_status status, void *data)
643 {
644 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
645 std::unique_ptr<AsyncContext<int32_t>> context(static_cast<AsyncContext<int32_t> *>(data));
646 NapiAsyncCommomCompleteCallback(env, status, *context, false);
647 }
648
GetCardType(napi_env env,napi_callback_info info)649 napi_value GetCardType(napi_env env, napi_callback_info info)
650 {
651 return NapiCreateAsyncWork<int32_t, NativeGetCardType, GetCardTypeCallback>(env, info, "GetCardType");
652 }
653
NativeGetVoiceMailIdentifier(napi_env env,void * data)654 void NativeGetVoiceMailIdentifier(napi_env env, void *data)
655 {
656 if (data == nullptr) {
657 return;
658 }
659 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
660 if (!IsValidSlotId(asyncContext->slotId)) {
661 TELEPHONY_LOGE("NativeGetVoiceMailIdentifier slotId is invalid");
662 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
663 return;
664 }
665 std::u16string voiceMailIdentifier;
666 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetVoiceMailIdentifier(
667 asyncContext->slotId, voiceMailIdentifier);
668 TELEPHONY_LOGI("NAPI NativeGetVoiceMailIdentifier %{public}d", errorCode);
669 if (errorCode == ERROR_NONE) {
670 asyncContext->callbackVal = NapiUtil::ToUtf8(voiceMailIdentifier);
671 asyncContext->context.resolved = true;
672 } else {
673 asyncContext->context.resolved = false;
674 }
675 asyncContext->context.errorCode = errorCode;
676 }
677
GetVoiceMailIdentifierCallback(napi_env env,napi_status status,void * data)678 void GetVoiceMailIdentifierCallback(napi_env env, napi_status status, void *data)
679 {
680 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
681 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
682 NapiAsyncPermissionCompleteCallback(
683 env, status, *context, false, "GetVoiceMailIdentifier", Permission::GET_TELEPHONY_STATE);
684 }
685
GetVoiceMailIdentifier(napi_env env,napi_callback_info info)686 napi_value GetVoiceMailIdentifier(napi_env env, napi_callback_info info)
687 {
688 return NapiCreateAsyncWork<std::string, NativeGetVoiceMailIdentifier, GetVoiceMailIdentifierCallback>(
689 env, info, "GetVoiceMailIdentifier");
690 }
691
NativeGetVoiceMailNumber(napi_env env,void * data)692 void NativeGetVoiceMailNumber(napi_env env, void *data)
693 {
694 if (data == nullptr) {
695 return;
696 }
697 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
698 if (!IsValidSlotId(asyncContext->slotId)) {
699 TELEPHONY_LOGE("NativeGetVoiceMailNumber slotId is invalid");
700 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
701 return;
702 }
703 std::u16string voiceMailNumber;
704 int32_t errorCode =
705 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetVoiceMailNumber(asyncContext->slotId, voiceMailNumber);
706 if (errorCode == ERROR_NONE) {
707 asyncContext->callbackVal = NapiUtil::ToUtf8(voiceMailNumber);
708 asyncContext->context.resolved = true;
709 } else {
710 asyncContext->context.resolved = false;
711 }
712 asyncContext->context.errorCode = errorCode;
713 }
714
GetVoiceMailNumberCallback(napi_env env,napi_status status,void * data)715 void GetVoiceMailNumberCallback(napi_env env, napi_status status, void *data)
716 {
717 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
718 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
719 NapiAsyncPermissionCompleteCallback(
720 env, status, *context, false, "GetVoiceMailNumber", Permission::GET_TELEPHONY_STATE);
721 }
722
GetVoiceMailNumber(napi_env env,napi_callback_info info)723 napi_value GetVoiceMailNumber(napi_env env, napi_callback_info info)
724 {
725 return NapiCreateAsyncWork<std::string, NativeGetVoiceMailNumber, GetVoiceMailNumberCallback>(
726 env, info, "GetVoiceMailNumber");
727 }
728
NativeGetSimTelephoneNumber(napi_env env,void * data)729 void NativeGetSimTelephoneNumber(napi_env env, void *data)
730 {
731 if (data == nullptr) {
732 return;
733 }
734 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
735 if (!IsValidSlotId(asyncContext->slotId)) {
736 TELEPHONY_LOGE("NativeGetSimTelephoneNumber slotId is invalid");
737 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
738 return;
739 }
740 std::u16string telephoneNumber;
741 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimTelephoneNumber(
742 asyncContext->slotId, telephoneNumber);
743 if (errorCode == ERROR_NONE) {
744 asyncContext->callbackVal = NapiUtil::ToUtf8(telephoneNumber);
745 asyncContext->context.resolved = true;
746 } else {
747 asyncContext->context.resolved = false;
748 }
749 asyncContext->context.errorCode = errorCode;
750 }
751
GetSimTelephoneNumberCallback(napi_env env,napi_status status,void * data)752 void GetSimTelephoneNumberCallback(napi_env env, napi_status status, void *data)
753 {
754 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
755 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
756 NapiAsyncPermissionCompleteCallback(
757 env, status, *context, false, "GetSimTelephoneNumber", Permission::GET_TELEPHONY_STATE);
758 }
759
GetSimTelephoneNumber(napi_env env,napi_callback_info info)760 napi_value GetSimTelephoneNumber(napi_env env, napi_callback_info info)
761 {
762 return NapiCreateAsyncWork<std::string, NativeGetSimTelephoneNumber, GetSimTelephoneNumberCallback>(
763 env, info, "GetSimTelephoneNumber");
764 }
765
NativeGetSimGid1(napi_env env,void * data)766 void NativeGetSimGid1(napi_env env, void *data)
767 {
768 if (data == nullptr) {
769 return;
770 }
771 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
772 if (!IsValidSlotId(asyncContext->slotId)) {
773 TELEPHONY_LOGE("NativeGetSimGid1 slotId is invalid");
774 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
775 return;
776 }
777 std::u16string gid1;
778 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimGid1(asyncContext->slotId, gid1);
779 TELEPHONY_LOGI("NAPI NativeGetSimGid1 %{public}d", errorCode);
780 if (errorCode == ERROR_NONE) {
781 asyncContext->callbackVal = NapiUtil::ToUtf8(gid1);
782 asyncContext->context.resolved = true;
783 } else {
784 asyncContext->context.resolved = false;
785 }
786 asyncContext->context.errorCode = errorCode;
787 }
788
GetSimGid1Callback(napi_env env,napi_status status,void * data)789 void GetSimGid1Callback(napi_env env, napi_status status, void *data)
790 {
791 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
792 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
793 NapiAsyncPermissionCompleteCallback(env, status, *context, false, "GetSimGid1", Permission::GET_TELEPHONY_STATE);
794 }
795
GetSimGid1(napi_env env,napi_callback_info info)796 napi_value GetSimGid1(napi_env env, napi_callback_info info)
797 {
798 return NapiCreateAsyncWork<std::string, NativeGetSimGid1, GetSimGid1Callback>(env, info, "GetSimGid1");
799 }
800
NativeGetSimIccId(napi_env env,void * data)801 void NativeGetSimIccId(napi_env env, void *data)
802 {
803 if (data == nullptr) {
804 return;
805 }
806 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
807 if (!IsValidSlotId(asyncContext->slotId)) {
808 TELEPHONY_LOGE("NativeGetSimIccId slotId is invalid");
809 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
810 return;
811 }
812 std::u16string iccId;
813 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimIccId(asyncContext->slotId, iccId);
814 if (errorCode == ERROR_NONE) {
815 asyncContext->callbackVal = NapiUtil::ToUtf8(iccId);
816 asyncContext->context.resolved = true;
817 } else {
818 asyncContext->context.resolved = false;
819 }
820 asyncContext->context.errorCode = errorCode;
821 }
822
GetSimIccIdCallback(napi_env env,napi_status status,void * data)823 void GetSimIccIdCallback(napi_env env, napi_status status, void *data)
824 {
825 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
826 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
827 NapiAsyncPermissionCompleteCallback(env, status, *context, false, "GetSimIccId", Permission::GET_TELEPHONY_STATE);
828 }
829
GetSimIccId(napi_env env,napi_callback_info info)830 napi_value GetSimIccId(napi_env env, napi_callback_info info)
831 {
832 return NapiCreateAsyncWork<std::string, NativeGetSimIccId, GetSimIccIdCallback>(env, info, "GetSimIccId");
833 }
834
NativeGetSimAccountInfo(napi_env env,void * data)835 void NativeGetSimAccountInfo(napi_env env, void *data)
836 {
837 if (data == nullptr) {
838 return;
839 }
840 AsyncIccAccountInfo *info = static_cast<AsyncIccAccountInfo *>(data);
841 if (!IsValidSlotId(info->asyncContext.slotId)) {
842 TELEPHONY_LOGE("NativeGetSimAccountInfo slotId is invalid");
843 info->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
844 return;
845 }
846 IccAccountInfo operInfo;
847 int32_t errorCode =
848 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimAccountInfo(info->asyncContext.slotId, operInfo);
849 TELEPHONY_LOGI("NAPI NativeGetSimAccountInfo %{public}d", errorCode);
850 if (errorCode == ERROR_NONE) {
851 info->vecInfo.push_back(std::move(operInfo));
852 info->asyncContext.context.resolved = true;
853 } else {
854 info->asyncContext.context.resolved = false;
855 }
856 info->asyncContext.context.errorCode = errorCode;
857 }
858
GetSimAccountInfoCallback(napi_env env,napi_status status,void * data)859 void GetSimAccountInfoCallback(napi_env env, napi_status status, void *data)
860 {
861 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
862 std::unique_ptr<AsyncIccAccountInfo> info(static_cast<AsyncIccAccountInfo *>(data));
863 AsyncContext<napi_value> &asyncContext = info->asyncContext;
864 if (asyncContext.context.resolved) {
865 asyncContext.callbackVal = IccAccountInfoConversion(env, info->vecInfo.at(0));
866 }
867 NapiAsyncPermissionCompleteCallback(
868 env, status, asyncContext, false, "GetSimAccountInfo", Permission::GET_TELEPHONY_STATE);
869 }
870
GetSimAccountInfo(napi_env env,napi_callback_info info)871 napi_value GetSimAccountInfo(napi_env env, napi_callback_info info)
872 {
873 auto iccAccountInfo = new AsyncIccAccountInfo();
874 BaseContext &context = iccAccountInfo->asyncContext.context;
875
876 auto initPara = std::make_tuple(&iccAccountInfo->asyncContext.slotId, &context.callbackRef);
877 AsyncPara para {
878 .funcName = "GetSimAccountInfo",
879 .env = env,
880 .info = info,
881 .execute = NativeGetSimAccountInfo,
882 .complete = GetSimAccountInfoCallback,
883 };
884 napi_value result = NapiCreateAsyncWork2<AsyncIccAccountInfo>(para, iccAccountInfo, initPara);
885 if (result) {
886 NAPI_CALL(env, napi_queue_async_work(env, context.work));
887 }
888 return result;
889 }
890
NativeSetDefaultVoiceSlotId(napi_env env,void * data)891 void NativeSetDefaultVoiceSlotId(napi_env env, void *data)
892 {
893 if (data == nullptr) {
894 return;
895 }
896 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
897 if (!IsValidSlotIdForDefault(reVal->slotId)) {
898 TELEPHONY_LOGE("NativeSetDefaultVoiceSlotId slotId is invalid");
899 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
900 return;
901 }
902 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetDefaultVoiceSlotId(reVal->slotId);
903 TELEPHONY_LOGI("NAPI NativeSetDefaultVoiceSlotId %{public}d", errorCode);
904 reVal->context.errorCode = errorCode;
905 reVal->context.resolved = (errorCode == ERROR_NONE);
906 }
907
SetDefaultVoiceSlotIdCallback(napi_env env,napi_status status,void * data)908 void SetDefaultVoiceSlotIdCallback(napi_env env, napi_status status, void *data)
909 {
910 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
911 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
912 NapiAsyncPermissionCompleteCallback(
913 env, status, *context, true, "SetDefaultVoiceSlotId", Permission::SET_TELEPHONY_STATE);
914 }
915
SetDefaultVoiceSlotId(napi_env env,napi_callback_info info)916 napi_value SetDefaultVoiceSlotId(napi_env env, napi_callback_info info)
917 {
918 return NapiCreateAsyncWork<bool, NativeSetDefaultVoiceSlotId, SetDefaultVoiceSlotIdCallback>(
919 env, info, "SetDefaultVoiceSlotId");
920 }
921
NativeUnlockPin(napi_env env,void * data)922 void NativeUnlockPin(napi_env env, void *data)
923 {
924 if (data == nullptr) {
925 return;
926 }
927 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
928 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
929 TELEPHONY_LOGE("NativeUnlockPin slotId is invalid");
930 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
931 return;
932 }
933 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
934 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPin(
935 pinContext->asyncContext.slotId, NapiUtil::ToUtf16(pinContext->inStr1.data()), response);
936 TELEPHONY_LOGI("NAPI NativeUnlockPin %{public}d", errorCode);
937 if (errorCode == ERROR_NONE) {
938 pinContext->result = response.result;
939 pinContext->remain = response.remain;
940 pinContext->asyncContext.context.resolved = true;
941 } else {
942 pinContext->asyncContext.context.resolved = false;
943 }
944 pinContext->asyncContext.context.errorCode = errorCode;
945 }
946
UnlockPinCallback(napi_env env,napi_status status,void * data)947 void UnlockPinCallback(napi_env env, napi_status status, void *data)
948 {
949 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
950 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
951 const LockStatusResponse res {context->result, context->remain};
952 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
953 NapiAsyncPermissionCompleteCallback(
954 env, status, context->asyncContext, false, "UnlockPin", Permission::SET_TELEPHONY_STATE);
955 }
956
UnlockPin(napi_env env,napi_callback_info info)957 napi_value UnlockPin(napi_env env, napi_callback_info info)
958 {
959 auto pinContext = new AsyncContextPIN();
960 BaseContext &context = pinContext->asyncContext.context;
961 char tmpStr[kMaxNumberLen + 1] = {0};
962
963 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr, &context.callbackRef);
964 AsyncPara para {
965 .funcName = "UnlockPin",
966 .env = env,
967 .info = info,
968 .execute = NativeUnlockPin,
969 .complete = UnlockPinCallback,
970 };
971 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
972 if (result) {
973 pinContext->inStr1 = std::string(tmpStr);
974 NAPI_CALL(env, napi_queue_async_work(env, context.work));
975 }
976 return result;
977 }
978
NativeUnlockPuk(napi_env env,void * data)979 void NativeUnlockPuk(napi_env env, void *data)
980 {
981 if (data == nullptr) {
982 return;
983 }
984 AsyncContextPIN *pukContext = static_cast<AsyncContextPIN *>(data);
985 if (!IsValidSlotId(pukContext->asyncContext.slotId)) {
986 TELEPHONY_LOGE("NativeUnlockPuk slotId is invalid");
987 pukContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
988 return;
989 }
990 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
991 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPuk(pukContext->asyncContext.slotId,
992 NapiUtil::ToUtf16(pukContext->inStr1.data()), NapiUtil::ToUtf16(pukContext->inStr2.data()), response);
993 TELEPHONY_LOGI("NAPI NativeUnlockPuk %{public}d", errorCode);
994 if (errorCode == ERROR_NONE) {
995 pukContext->result = response.result;
996 pukContext->remain = response.remain;
997 pukContext->asyncContext.context.resolved = true;
998 } else {
999 pukContext->asyncContext.context.resolved = false;
1000 }
1001 pukContext->asyncContext.context.errorCode = errorCode;
1002 }
1003
UnlockPukCallback(napi_env env,napi_status status,void * data)1004 void UnlockPukCallback(napi_env env, napi_status status, void *data)
1005 {
1006 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1007 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1008 const LockStatusResponse res {context->result, context->remain};
1009 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1010 NapiAsyncPermissionCompleteCallback(
1011 env, status, context->asyncContext, false, "UnlockPuk", Permission::SET_TELEPHONY_STATE);
1012 }
1013
UnlockPuk(napi_env env,napi_callback_info info)1014 napi_value UnlockPuk(napi_env env, napi_callback_info info)
1015 {
1016 auto pukContext = new AsyncContextPIN();
1017 BaseContext &context = pukContext->asyncContext.context;
1018 char tmpStr1[kMaxNumberLen + 1] = {0};
1019 char tmpStr2[kMaxNumberLen + 1] = {0};
1020
1021 auto initPara = std::make_tuple(&pukContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
1022 AsyncPara para {
1023 .funcName = "UnlockPuk",
1024 .env = env,
1025 .info = info,
1026 .execute = NativeUnlockPuk,
1027 .complete = UnlockPukCallback,
1028 };
1029 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pukContext, initPara);
1030 if (result) {
1031 pukContext->inStr1 = std::string(tmpStr1);
1032 pukContext->inStr2 = std::string(tmpStr2);
1033 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1034 }
1035 return result;
1036 }
1037
NativeAlterPin(napi_env env,void * data)1038 void NativeAlterPin(napi_env env, void *data)
1039 {
1040 if (data == nullptr) {
1041 return;
1042 }
1043
1044 AsyncContextPIN *alterPinContext = static_cast<AsyncContextPIN *>(data);
1045 if (!IsValidSlotId(alterPinContext->asyncContext.slotId)) {
1046 TELEPHONY_LOGE("NativeAlterPin slotId is invalid");
1047 alterPinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1048 return;
1049 }
1050 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1051 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AlterPin(
1052 alterPinContext->asyncContext.slotId, NapiUtil::ToUtf16(alterPinContext->inStr1.data()),
1053 NapiUtil::ToUtf16(alterPinContext->inStr2.data()), response);
1054 TELEPHONY_LOGI("NAPI NativeAlterPin %{public}d", errorCode);
1055 if (errorCode == ERROR_NONE) {
1056 alterPinContext->result = response.result;
1057 alterPinContext->remain = response.remain;
1058 alterPinContext->asyncContext.context.resolved = true;
1059 } else {
1060 alterPinContext->asyncContext.context.resolved = false;
1061 }
1062 alterPinContext->asyncContext.context.errorCode = errorCode;
1063 }
1064
AlterPinCallback(napi_env env,napi_status status,void * data)1065 void AlterPinCallback(napi_env env, napi_status status, void *data)
1066 {
1067 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1068 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1069 const LockStatusResponse res {context->result, context->remain};
1070 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1071 NapiAsyncPermissionCompleteCallback(
1072 env, status, context->asyncContext, false, "AlterPin", Permission::SET_TELEPHONY_STATE);
1073 }
1074
AlterPin(napi_env env,napi_callback_info info)1075 napi_value AlterPin(napi_env env, napi_callback_info info)
1076 {
1077 auto alterPinContext = new AsyncContextPIN();
1078 BaseContext &context = alterPinContext->asyncContext.context;
1079
1080 char tmpStr1[kMaxNumberLen + 1] = {0};
1081 char tmpStr2[kMaxNumberLen + 1] = {0};
1082 auto initPara = std::make_tuple(&alterPinContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
1083 AsyncPara para {
1084 .funcName = "AlterPin",
1085 .env = env,
1086 .info = info,
1087 .execute = NativeAlterPin,
1088 .complete = AlterPinCallback,
1089 };
1090 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, alterPinContext, initPara);
1091 if (result) {
1092 alterPinContext->inStr1 = std::string(tmpStr1);
1093 alterPinContext->inStr2 = std::string(tmpStr2);
1094 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1095 }
1096 return result;
1097 }
1098
NativeSetLockState(napi_env env,void * data)1099 void NativeSetLockState(napi_env env, void *data)
1100 {
1101 if (data == nullptr) {
1102 return;
1103 }
1104 AsyncContextPIN *lockContext = static_cast<AsyncContextPIN *>(data);
1105 if (!IsValidSlotId(lockContext->asyncContext.slotId)) {
1106 TELEPHONY_LOGE("NativeSetLockState slotId is invalid");
1107 lockContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1108 return;
1109 }
1110 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1111 TELEPHONY_LOGI("NativeSetLockState slotId = %{public}d, lockType = %{public}d, state = %{public}d",
1112 lockContext->asyncContext.slotId, lockContext->result, lockContext->remain);
1113 const LockInfo info { static_cast<LockType>(lockContext->result), NapiUtil::ToUtf16(lockContext->inStr1.data()),
1114 static_cast<LockState>(lockContext->remain) };
1115 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetLockState(
1116 lockContext->asyncContext.slotId, info, response);
1117 TELEPHONY_LOGI("NAPI NativeSetLockState %{public}d", errorCode);
1118 if (errorCode == ERROR_NONE) {
1119 lockContext->result = response.result;
1120 lockContext->remain = response.remain;
1121 lockContext->asyncContext.context.resolved = true;
1122 } else {
1123 lockContext->asyncContext.context.resolved = false;
1124 }
1125 lockContext->asyncContext.context.errorCode = errorCode;
1126 }
1127
SetLockStateCallback(napi_env env,napi_status status,void * data)1128 void SetLockStateCallback(napi_env env, napi_status status, void *data)
1129 {
1130 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1131 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1132 const LockStatusResponse res {context->result, context->remain};
1133 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1134 NapiAsyncPermissionCompleteCallback(
1135 env, status, context->asyncContext, false, "SetLockState", Permission::SET_TELEPHONY_STATE);
1136 }
1137
SetLockState(napi_env env,napi_callback_info info)1138 napi_value SetLockState(napi_env env, napi_callback_info info)
1139 {
1140 auto asyncContextPIN = new AsyncContextPIN;
1141 BaseContext &context = asyncContextPIN->asyncContext.context;
1142 napi_value object = NapiUtil::CreateUndefined(env);
1143 auto initPara = std::make_tuple(&asyncContextPIN->asyncContext.slotId, &object, &context.callbackRef);
1144 AsyncPara para {
1145 .funcName = "SetLockState",
1146 .env = env,
1147 .info = info,
1148 .execute = NativeSetLockState,
1149 .complete = SetLockStateCallback,
1150 };
1151 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, asyncContextPIN, initPara);
1152 if (result) {
1153 PinInfoParaAnalyze(env, object, *asyncContextPIN);
1154 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1155 }
1156 return result;
1157 }
1158
NativeHasSimCard(napi_env env,void * data)1159 void NativeHasSimCard(napi_env env, void *data)
1160 {
1161 if (data == nullptr) {
1162 return;
1163 }
1164 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
1165 if (!IsValidSlotId(reVal->slotId)) {
1166 TELEPHONY_LOGE("NativeHasSimCard slotId is invalid");
1167 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
1168 return;
1169 }
1170 bool hasSimCard = false;
1171 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(reVal->slotId, hasSimCard);
1172 if (errorCode == ERROR_NONE) {
1173 reVal->callbackVal = hasSimCard;
1174 reVal->context.resolved = true;
1175 } else {
1176 reVal->context.resolved = false;
1177 }
1178 TELEPHONY_LOGI("NAPI NativeHasSimCard %{public}d", errorCode);
1179 reVal->context.errorCode = errorCode;
1180 }
1181
HasSimCardCallback(napi_env env,napi_status status,void * data)1182 void HasSimCardCallback(napi_env env, napi_status status, void *data)
1183 {
1184 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1185 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
1186 NapiAsyncCommomCompleteCallback(env, status, *context, false);
1187 }
1188
HasSimCard(napi_env env,napi_callback_info info)1189 napi_value HasSimCard(napi_env env, napi_callback_info info)
1190 {
1191 return NapiCreateAsyncWork<bool, NativeHasSimCard, HasSimCardCallback>(env, info, "HasSimCard");
1192 }
1193
NativeGetIMSI(napi_env env,void * data)1194 void NativeGetIMSI(napi_env env, void *data)
1195 {
1196 if (data == nullptr) {
1197 return;
1198 }
1199 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1200 if (!IsValidSlotId(asyncContext->slotId)) {
1201 TELEPHONY_LOGE("NativeGetIMSI slotId is invalid");
1202 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1203 return;
1204 }
1205 std::u16string imsi;
1206 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetIMSI(asyncContext->slotId, imsi);
1207 if (errorCode == ERROR_NONE) {
1208 asyncContext->callbackVal = NapiUtil::ToUtf8(imsi);
1209 asyncContext->context.resolved = true;
1210 } else {
1211 asyncContext->context.resolved = false;
1212 }
1213 asyncContext->context.errorCode = errorCode;
1214 }
1215
GetIMSICallback(napi_env env,napi_status status,void * data)1216 void GetIMSICallback(napi_env env, napi_status status, void *data)
1217 {
1218 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1219 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1220 NapiAsyncPermissionCompleteCallback(env, status, *context, false, "GetIMSI", Permission::GET_TELEPHONY_STATE);
1221 }
1222
GetIMSI(napi_env env,napi_callback_info info)1223 napi_value GetIMSI(napi_env env, napi_callback_info info)
1224 {
1225 return NapiCreateAsyncWork<std::string, NativeGetIMSI, GetIMSICallback>(env, info, "GetIMSI");
1226 }
1227
NativeSetShowName(napi_env env,void * data)1228 void NativeSetShowName(napi_env env, void *data)
1229 {
1230 if (data == nullptr) {
1231 return;
1232 }
1233 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
1234 if (!IsValidSlotId(context->asyncContext.slotId)) {
1235 TELEPHONY_LOGE("NativeSetShowName slotId is invalid");
1236 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1237 return;
1238 }
1239 std::u16string name = NapiUtil::ToUtf16(std::data(context->inputStr));
1240 int32_t errorCode =
1241 DelayedRefSingleton<CoreServiceClient>::GetInstance().SetShowName(context->asyncContext.slotId, name);
1242 TELEPHONY_LOGI("NAPI NativeSetShowName %{public}d", errorCode);
1243 context->asyncContext.context.errorCode = errorCode;
1244 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1245 }
1246
SetShowNameCallback(napi_env env,napi_status status,void * data)1247 void SetShowNameCallback(napi_env env, napi_status status, void *data)
1248 {
1249 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1250 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
1251 NapiAsyncPermissionCompleteCallback(
1252 env, status, context->asyncContext, true, "SetShowName", Permission::SET_TELEPHONY_STATE);
1253 }
1254
SetShowName(napi_env env,napi_callback_info info)1255 napi_value SetShowName(napi_env env, napi_callback_info info)
1256 {
1257 auto asyncContext = new AsyncContext2();
1258 BaseContext &context = asyncContext->asyncContext.context;
1259
1260 auto initPara =
1261 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr),
1262 &context.callbackRef);
1263 AsyncPara para {
1264 .funcName = "SetShowName",
1265 .env = env,
1266 .info = info,
1267 .execute = NativeSetShowName,
1268 .complete = SetShowNameCallback,
1269 };
1270 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
1271 if (result) {
1272 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1273 }
1274 return result;
1275 }
1276
NativeGetShowName(napi_env env,void * data)1277 void NativeGetShowName(napi_env env, void *data)
1278 {
1279 if (data == nullptr) {
1280 return;
1281 }
1282 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1283 if (!IsValidSlotId(asyncContext->slotId)) {
1284 TELEPHONY_LOGE("NativeGetShowName slotId is invalid");
1285 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1286 return;
1287 }
1288 std::u16string showName;
1289 int32_t errorCode =
1290 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetShowName(asyncContext->slotId, showName);
1291 if (errorCode == ERROR_NONE) {
1292 asyncContext->callbackVal = NapiUtil::ToUtf8(showName);
1293 asyncContext->context.resolved = true;
1294 } else {
1295 asyncContext->context.resolved = false;
1296 }
1297 asyncContext->context.errorCode = errorCode;
1298 }
1299
GetShowNameCallback(napi_env env,napi_status status,void * data)1300 void GetShowNameCallback(napi_env env, napi_status status, void *data)
1301 {
1302 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1303 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1304 NapiAsyncPermissionCompleteCallback(env, status, *context, false, "GetShowName", Permission::GET_TELEPHONY_STATE);
1305 }
1306
GetShowName(napi_env env,napi_callback_info info)1307 napi_value GetShowName(napi_env env, napi_callback_info info)
1308 {
1309 return NapiCreateAsyncWork<std::string, NativeGetShowName, GetShowNameCallback>(env, info, "GetShowName");
1310 }
1311
NativeSetShowNumber(napi_env env,void * data)1312 void NativeSetShowNumber(napi_env env, void *data)
1313 {
1314 if (data == nullptr) {
1315 return;
1316 }
1317 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
1318 if (!IsValidSlotId(context->asyncContext.slotId)) {
1319 TELEPHONY_LOGE("NativeSetShowNumber slotId is invalid");
1320 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1321 return;
1322 }
1323 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetShowNumber(
1324 context->asyncContext.slotId, NapiUtil::ToUtf16(std::data(context->inputStr)));
1325 TELEPHONY_LOGI("NAPI NativeSetShowNumber %{public}d", errorCode);
1326 context->asyncContext.context.errorCode = errorCode;
1327 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1328 }
1329
SetShowNumberCallback(napi_env env,napi_status status,void * data)1330 void SetShowNumberCallback(napi_env env, napi_status status, void *data)
1331 {
1332 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1333 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
1334 NapiAsyncPermissionCompleteCallback(
1335 env, status, context->asyncContext, true, "SetShowNumber", Permission::SET_TELEPHONY_STATE);
1336 }
1337
SetShowNumber(napi_env env,napi_callback_info info)1338 napi_value SetShowNumber(napi_env env, napi_callback_info info)
1339 {
1340 auto asyncContext = new AsyncContext2();
1341 BaseContext &context = asyncContext->asyncContext.context;
1342
1343 auto initPara =
1344 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
1345 AsyncPara para {
1346 .funcName = "SetShowNumber",
1347 .env = env,
1348 .info = info,
1349 .execute = NativeSetShowNumber,
1350 .complete = SetShowNumberCallback,
1351 };
1352 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
1353 if (result) {
1354 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1355 }
1356 return result;
1357 }
1358
NativeGetShowNumber(napi_env env,void * data)1359 void NativeGetShowNumber(napi_env env, void *data)
1360 {
1361 if (data == nullptr) {
1362 return;
1363 }
1364 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
1365 if (!IsValidSlotId(asyncContext->slotId)) {
1366 TELEPHONY_LOGE("NativeGetShowNumber slotId is invalid");
1367 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
1368 return;
1369 }
1370 std::u16string showNumber;
1371 int32_t errorCode =
1372 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetShowNumber(asyncContext->slotId, showNumber);
1373 if (errorCode == ERROR_NONE) {
1374 asyncContext->callbackVal = NapiUtil::ToUtf8(showNumber);
1375 asyncContext->context.resolved = true;
1376 } else {
1377 asyncContext->context.resolved = false;
1378 }
1379 asyncContext->context.errorCode = errorCode;
1380 }
1381
GetShowNumberCallback(napi_env env,napi_status status,void * data)1382 void GetShowNumberCallback(napi_env env, napi_status status, void *data)
1383 {
1384 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1385 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
1386 NapiAsyncPermissionCompleteCallback(env, status, *context, false, "GetShowNumber", Permission::GET_TELEPHONY_STATE);
1387 }
1388
GetShowNumber(napi_env env,napi_callback_info info)1389 napi_value GetShowNumber(napi_env env, napi_callback_info info)
1390 {
1391 return NapiCreateAsyncWork<std::string, NativeGetShowNumber, GetShowNumberCallback>(env, info, "GetShowNumber");
1392 }
1393
NativeUnlockPin2(napi_env env,void * data)1394 void NativeUnlockPin2(napi_env env, void *data)
1395 {
1396 if (data == nullptr) {
1397 return;
1398 }
1399 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
1400 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
1401 TELEPHONY_LOGE("NativeUnlockPin2 slotId is invalid");
1402 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1403 return;
1404 }
1405 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1406 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPin2(
1407 pinContext->asyncContext.slotId, NapiUtil::ToUtf16(pinContext->inStr1.data()), response);
1408 TELEPHONY_LOGI("NAPI NativeUnlockPin2 %{public}d", errorCode);
1409 if (errorCode == ERROR_NONE) {
1410 pinContext->result = response.result;
1411 pinContext->remain = response.remain;
1412 pinContext->asyncContext.context.resolved = true;
1413 } else {
1414 pinContext->asyncContext.context.resolved = false;
1415 }
1416 pinContext->asyncContext.context.errorCode = errorCode;
1417 }
1418
UnlockPinCallback2(napi_env env,napi_status status,void * data)1419 void UnlockPinCallback2(napi_env env, napi_status status, void *data)
1420 {
1421 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1422 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1423 const LockStatusResponse res {context->result, context->remain};
1424 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1425 NapiAsyncPermissionCompleteCallback(
1426 env, status, context->asyncContext, false, "UnlockPin2", Permission::SET_TELEPHONY_STATE);
1427 }
1428
UnlockPin2(napi_env env,napi_callback_info info)1429 napi_value UnlockPin2(napi_env env, napi_callback_info info)
1430 {
1431 auto pinContext = new AsyncContextPIN();
1432 BaseContext &context = pinContext->asyncContext.context;
1433
1434 char tmpStr[kMaxNumberLen + 1] = {0};
1435 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr, &context.callbackRef);
1436 AsyncPara para {
1437 .funcName = "UnlockPin2",
1438 .env = env,
1439 .info = info,
1440 .execute = NativeUnlockPin2,
1441 .complete = UnlockPinCallback2,
1442 };
1443 napi_value result = NapiCreateAsyncWork2(para, pinContext, initPara);
1444 if (result) {
1445 pinContext->inStr1 = std::string(tmpStr);
1446 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1447 }
1448 return result;
1449 }
1450
NativeUnlockPuk2(napi_env env,void * data)1451 void NativeUnlockPuk2(napi_env env, void *data)
1452 {
1453 if (data == nullptr) {
1454 return;
1455 }
1456 AsyncContextPIN *pukContext = static_cast<AsyncContextPIN *>(data);
1457 if (!IsValidSlotId(pukContext->asyncContext.slotId)) {
1458 TELEPHONY_LOGE("NativeUnlockPuk2 slotId is invalid");
1459 pukContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1460 return;
1461 }
1462 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1463 int32_t errorCode =
1464 DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockPuk2(pukContext->asyncContext.slotId,
1465 NapiUtil::ToUtf16(pukContext->inStr1.data()), NapiUtil::ToUtf16(pukContext->inStr2.data()), response);
1466 TELEPHONY_LOGI("NAPI NativeUnlockPuk2 %{public}d", errorCode);
1467 if (errorCode == ERROR_NONE) {
1468 pukContext->result = response.result;
1469 pukContext->remain = response.remain;
1470 pukContext->asyncContext.context.resolved = true;
1471 } else {
1472 pukContext->asyncContext.context.resolved = false;
1473 }
1474 pukContext->asyncContext.context.errorCode = errorCode;
1475 }
1476
UnlockPukCallback2(napi_env env,napi_status status,void * data)1477 void UnlockPukCallback2(napi_env env, napi_status status, void *data)
1478 {
1479 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1480 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1481 const LockStatusResponse res {context->result, context->remain};
1482 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1483 NapiAsyncPermissionCompleteCallback(
1484 env, status, context->asyncContext, false, "UnlockPuk2", Permission::SET_TELEPHONY_STATE);
1485 }
1486
UnlockPuk2(napi_env env,napi_callback_info info)1487 napi_value UnlockPuk2(napi_env env, napi_callback_info info)
1488 {
1489 auto pinContext = new AsyncContextPIN();
1490 BaseContext &context = pinContext->asyncContext.context;
1491 char tmpStr1[kMaxNumberLen + 1] = {0};
1492 char tmpStr2[kMaxNumberLen + 1] = {0};
1493
1494 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr1,
1495 tmpStr2, &context.callbackRef);
1496 AsyncPara para {
1497 .funcName = "UnlockPuk2",
1498 .env = env,
1499 .info = info,
1500 .execute = NativeUnlockPuk2,
1501 .complete = UnlockPukCallback2,
1502 };
1503 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
1504 if (result) {
1505 pinContext->inStr1 = std::string(tmpStr1);
1506 pinContext->inStr2 = std::string(tmpStr2);
1507 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1508 }
1509 return result;
1510 }
1511
NativeAlterPin2(napi_env env,void * data)1512 void NativeAlterPin2(napi_env env, void *data)
1513 {
1514 if (data == nullptr) {
1515 return;
1516 }
1517 AsyncContextPIN *pinContext = static_cast<AsyncContextPIN *>(data);
1518 if (!IsValidSlotId(pinContext->asyncContext.slotId)) {
1519 TELEPHONY_LOGE("NativeAlterPin2 slotId is invalid");
1520 pinContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1521 return;
1522 }
1523 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
1524 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AlterPin2(pinContext->asyncContext.slotId,
1525 NapiUtil::ToUtf16(pinContext->inStr1.data()), NapiUtil::ToUtf16(pinContext->inStr2.data()), response);
1526 TELEPHONY_LOGI("NAPI NativeAlterPin2 %{public}d", errorCode);
1527 if (errorCode == ERROR_NONE) {
1528 pinContext->result = response.result;
1529 pinContext->remain = response.remain;
1530 pinContext->asyncContext.context.resolved = true;
1531 } else {
1532 pinContext->asyncContext.context.resolved = false;
1533 }
1534 pinContext->asyncContext.context.errorCode = errorCode;
1535 }
1536
AlterPinCallback2(napi_env env,napi_status status,void * data)1537 void AlterPinCallback2(napi_env env, napi_status status, void *data)
1538 {
1539 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1540 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
1541 const LockStatusResponse res {context->result, context->remain};
1542 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
1543 NapiAsyncPermissionCompleteCallback(
1544 env, status, context->asyncContext, false, "AlterPin2", Permission::SET_TELEPHONY_STATE);
1545 }
1546
AlterPin2(napi_env env,napi_callback_info info)1547 napi_value AlterPin2(napi_env env, napi_callback_info info)
1548 {
1549 auto pinContext = new AsyncContextPIN();
1550 BaseContext &context = pinContext->asyncContext.context;
1551 char tmpStr1[kMaxNumberLen + 1] = {0};
1552 char tmpStr2[kMaxNumberLen + 1] = {0};
1553
1554 auto initPara = std::make_tuple(&pinContext->asyncContext.slotId, tmpStr1, tmpStr2, &context.callbackRef);
1555 AsyncPara para {
1556 .funcName = "AlterPin2",
1557 .env = env,
1558 .info = info,
1559 .execute = NativeAlterPin2,
1560 .complete = AlterPinCallback2,
1561 };
1562 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, pinContext, initPara);
1563 if (result) {
1564 pinContext->inStr1 = std::string(tmpStr1);
1565 pinContext->inStr2 = std::string(tmpStr2);
1566 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1567 }
1568 return result;
1569 }
1570
NativeGetOperatorConfigs(napi_env env,void * data)1571 void NativeGetOperatorConfigs(napi_env env, void *data)
1572 {
1573 if (data == nullptr) {
1574 return;
1575 }
1576 AsyncOperatorConfig *info = static_cast<AsyncOperatorConfig *>(data);
1577 if (!IsValidSlotId(info->asyncContext.slotId)) {
1578 TELEPHONY_LOGE("NativeGetOperatorConfigs slotId is invalid");
1579 info->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1580 return;
1581 }
1582 OperatorConfig config;
1583 int32_t errorCode =
1584 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(info->asyncContext.slotId, config);
1585 TELEPHONY_LOGI("NAPI NativeGetOperatorConfigs %{public}d", errorCode);
1586 if (errorCode == ERROR_NONE) {
1587 for (const auto &val : config.configValue) {
1588 ConfigInfo &&config = {NapiUtil::ToUtf8(val.first), NapiUtil::ToUtf8(val.second)};
1589 info->configValue.push_back(config);
1590 }
1591 info->asyncContext.context.resolved = true;
1592 } else {
1593 info->asyncContext.context.resolved = false;
1594 }
1595 info->asyncContext.context.errorCode = errorCode;
1596 }
1597
GetOperatorConfigsCallback(napi_env env,napi_status status,void * data)1598 void GetOperatorConfigsCallback(napi_env env, napi_status status, void *data)
1599 {
1600 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1601 std::unique_ptr<AsyncOperatorConfig> operatorConfig(static_cast<AsyncOperatorConfig *>(data));
1602 AsyncContext<napi_value> &aContext = operatorConfig->asyncContext;
1603 if (aContext.context.resolved) {
1604 aContext.callbackVal = nullptr;
1605 napi_create_array(env, &aContext.callbackVal);
1606 for (size_t i = 0; i < operatorConfig->configValue.size(); i++) {
1607 napi_value val = OperatorConfigAnalyze(env, operatorConfig->configValue.at(i));
1608 napi_set_element(env, aContext.callbackVal, i, val);
1609 }
1610 }
1611 NapiAsyncPermissionCompleteCallback(
1612 env, status, aContext, false, "GetOperatorConfigs", Permission::GET_TELEPHONY_STATE);
1613 }
1614
GetOperatorConfigs(napi_env env,napi_callback_info info)1615 napi_value GetOperatorConfigs(napi_env env, napi_callback_info info)
1616 {
1617 auto crrierConfig = new AsyncOperatorConfig();
1618 BaseContext &context = crrierConfig->asyncContext.context;
1619
1620 auto initPara = std::make_tuple(&crrierConfig->asyncContext.slotId, &context.callbackRef);
1621 AsyncPara para {
1622 .funcName = "GetOperatorConfigs",
1623 .env = env,
1624 .info = info,
1625 .execute = NativeGetOperatorConfigs,
1626 .complete = GetOperatorConfigsCallback,
1627 };
1628 napi_value result = NapiCreateAsyncWork2<AsyncOperatorConfig>(para, crrierConfig, initPara);
1629 if (result) {
1630 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1631 }
1632 return result;
1633 }
1634
NativeGetActiveSimAccountInfoList(napi_env env,void * data)1635 void NativeGetActiveSimAccountInfoList(napi_env env, void *data)
1636 {
1637 if (data == nullptr) {
1638 return;
1639 }
1640 AsyncIccAccountInfo *accountInfo = static_cast<AsyncIccAccountInfo *>(data);
1641 accountInfo->vecInfo.clear();
1642 std::vector<IccAccountInfo> activeInfo;
1643 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetActiveSimAccountInfoList(activeInfo);
1644 TELEPHONY_LOGI("NAPI NativeGetActiveSimAccountInfoList %{public}d", errorCode);
1645 if (errorCode == ERROR_NONE) {
1646 accountInfo->vecInfo.swap(activeInfo);
1647 accountInfo->asyncContext.context.resolved = true;
1648 } else {
1649 accountInfo->asyncContext.context.resolved = false;
1650 }
1651 accountInfo->asyncContext.context.errorCode = errorCode;
1652 }
1653
GetActiveSimAccountInfoListCallback(napi_env env,napi_status status,void * data)1654 void GetActiveSimAccountInfoListCallback(napi_env env, napi_status status, void *data)
1655 {
1656 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1657 std::unique_ptr<AsyncIccAccountInfo> info(static_cast<AsyncIccAccountInfo *>(data));
1658 AsyncContext<napi_value> &asyncContext = info->asyncContext;
1659 asyncContext.callbackVal = nullptr;
1660 napi_create_array(env, &asyncContext.callbackVal);
1661 for (size_t i = 0; i < info->vecInfo.size(); i++) {
1662 napi_value val = IccAccountInfoConversion(env, info->vecInfo.at(i));
1663 napi_set_element(env, asyncContext.callbackVal, i, val);
1664 }
1665 NapiAsyncPermissionCompleteCallback(
1666 env, status, asyncContext, false, "GetActiveSimAccountInfoList", Permission::GET_TELEPHONY_STATE);
1667 }
1668
GetActiveSimAccountInfoList(napi_env env,napi_callback_info info)1669 napi_value GetActiveSimAccountInfoList(napi_env env, napi_callback_info info)
1670 {
1671 auto accountInfo = new AsyncIccAccountInfo();
1672 BaseContext &context = accountInfo->asyncContext.context;
1673
1674 auto initPara = std::make_tuple(&context.callbackRef);
1675 AsyncPara para {
1676 .funcName = "GetActiveSimAccountInfoList",
1677 .env = env,
1678 .info = info,
1679 .execute = NativeGetActiveSimAccountInfoList,
1680 .complete = GetActiveSimAccountInfoListCallback,
1681 };
1682 napi_value result = NapiCreateAsyncWork2<AsyncIccAccountInfo>(para, accountInfo, initPara);
1683 if (result) {
1684 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1685 }
1686 return result;
1687 }
1688
NativeQueryIccDiallingNumbers(napi_env env,void * data)1689 void NativeQueryIccDiallingNumbers(napi_env env, void *data)
1690 {
1691 if (data == nullptr) {
1692 return;
1693 }
1694 AsyncDiallingNumbers<napi_value> *diallingNumbers = static_cast<AsyncDiallingNumbers<napi_value> *>(data);
1695 if (!IsValidSlotId(diallingNumbers->asyncContext.slotId)) {
1696 TELEPHONY_LOGE("NativeQueryIccDiallingNumbers slotId is invalid");
1697 diallingNumbers->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1698 return;
1699 }
1700 std::vector<std::shared_ptr<DiallingNumbersInfo>> diallingNumbersResult;
1701 diallingNumbersResult.clear();
1702 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().QueryIccDiallingNumbers(
1703 diallingNumbers->asyncContext.slotId, diallingNumbers->type, diallingNumbersResult);
1704 TELEPHONY_LOGI("NAPI NativeQueryIccDiallingNumbers %{public}zu", diallingNumbersResult.size());
1705 if (!diallingNumbersResult.empty()) {
1706 std::vector<TelNumbersInfo> &dialNumbers = diallingNumbers->infoVec;
1707 for (const auto &dialNumber : diallingNumbersResult) {
1708 TelNumbersInfo info {};
1709 NapiUtil::ToUtf8(dialNumber->name_).copy(info.alphaTag.data(), ARRAY_SIZE);
1710 NapiUtil::ToUtf8(dialNumber->number_).copy(info.number.data(), ARRAY_SIZE);
1711 info.recordNumber = dialNumber->index_;
1712 dialNumbers.push_back(std::move(info));
1713 }
1714 }
1715 diallingNumbers->asyncContext.context.errorCode = errorCode;
1716 diallingNumbers->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1717 }
1718
QueryIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)1719 void QueryIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
1720 {
1721 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1722 std::unique_ptr<AsyncDiallingNumbers<napi_value>> diallingNumbers(
1723 static_cast<AsyncDiallingNumbers<napi_value> *>(data));
1724 diallingNumbers->asyncContext.callbackVal = nullptr;
1725 napi_create_array(env, &diallingNumbers->asyncContext.callbackVal);
1726 for (size_t i = 0; i < diallingNumbers->infoVec.size(); i++) {
1727 napi_value val = DiallingNumbersConversion(env, diallingNumbers->infoVec.at(i));
1728 napi_set_element(env, diallingNumbers->asyncContext.callbackVal, i, val);
1729 }
1730 NapiAsyncPermissionCompleteCallback(
1731 env, status, diallingNumbers->asyncContext, false, "QueryIccDiallingNumbers", Permission::READ_CONTACTS);
1732 }
1733
QueryIccDiallingNumbers(napi_env env,napi_callback_info info)1734 napi_value QueryIccDiallingNumbers(napi_env env, napi_callback_info info)
1735 {
1736 auto diallingNumbers = new AsyncDiallingNumbers<napi_value>();
1737 BaseContext &context = diallingNumbers->asyncContext.context;
1738
1739 auto initPara =
1740 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &context.callbackRef);
1741 AsyncPara para {
1742 .funcName = "QueryIccDiallingNumbers",
1743 .env = env,
1744 .info = info,
1745 .execute = NativeQueryIccDiallingNumbers,
1746 .complete = QueryIccDiallingNumbersCallback,
1747 };
1748 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<napi_value>>(para, diallingNumbers, initPara);
1749 if (result) {
1750 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1751 }
1752 return result;
1753 }
1754
NativeAddIccDiallingNumbers(napi_env env,void * data)1755 void NativeAddIccDiallingNumbers(napi_env env, void *data)
1756 {
1757 if (data == nullptr) {
1758 return;
1759 }
1760 AsyncDiallingNumbers<int32_t> *diallingNumbersContext = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
1761 AsyncContext<int32_t> &asyncContext = diallingNumbersContext->asyncContext;
1762 if (!IsValidSlotId(asyncContext.slotId)) {
1763 TELEPHONY_LOGE("NativeAddIccDiallingNumbers slotId is invalid");
1764 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1765 return;
1766 }
1767 if (diallingNumbersContext->infoVec.size() > 0) {
1768 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
1769 GetDiallingNumberInfo(telNumber, diallingNumbersContext->infoVec.at(0));
1770 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().AddIccDiallingNumbers(
1771 asyncContext.slotId, diallingNumbersContext->type, telNumber);
1772 TELEPHONY_LOGI("NAPI NativeAddIccDiallingNumbers errorCode: %{public}d", errorCode);
1773 asyncContext.context.errorCode = errorCode;
1774 asyncContext.context.resolved = (errorCode == ERROR_NONE);
1775 }
1776 }
1777
AddIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)1778 void AddIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
1779 {
1780 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1781 std::unique_ptr<AsyncDiallingNumbers<int32_t>> context(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
1782 NapiAsyncPermissionCompleteCallback(
1783 env, status, context->asyncContext, true, "AddIccDiallingNumbers", Permission::WRITE_CONTACTS);
1784 }
1785
AddIccDiallingNumbers(napi_env env,napi_callback_info info)1786 napi_value AddIccDiallingNumbers(napi_env env, napi_callback_info info)
1787 {
1788 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
1789 BaseContext &context = diallingNumbers->asyncContext.context;
1790
1791 napi_value object = NapiUtil::CreateUndefined(env);
1792 auto initPara =
1793 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
1794
1795 AsyncPara para {
1796 .funcName = "AddIccDiallingNumbers",
1797 .env = env,
1798 .info = info,
1799 .execute = NativeAddIccDiallingNumbers,
1800 .complete = AddIccDiallingNumbersCallback,
1801 };
1802 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<int32_t>>(para, diallingNumbers, initPara);
1803 if (result) {
1804 TelNumbersInfo inputInfo;
1805 DiallingNumberParaAnalyze(env, object, inputInfo);
1806 diallingNumbers->infoVec.push_back(std::move(inputInfo));
1807 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1808 }
1809 return result;
1810 }
1811
NativeDelIccDiallingNumbers(napi_env env,void * data)1812 void NativeDelIccDiallingNumbers(napi_env env, void *data)
1813 {
1814 if (data == nullptr) {
1815 return;
1816 }
1817 AsyncDiallingNumbers<int32_t> *diallingNumbers = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
1818 if (!IsValidSlotId(diallingNumbers->asyncContext.slotId)) {
1819 TELEPHONY_LOGE("NativeDelIccDiallingNumbers slotId is invalid");
1820 diallingNumbers->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1821 return;
1822 }
1823 if (diallingNumbers->infoVec.size() > 0) {
1824 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
1825 GetDiallingNumberInfo(telNumber, diallingNumbers->infoVec.at(0));
1826 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().DelIccDiallingNumbers(
1827 diallingNumbers->asyncContext.slotId, diallingNumbers->type, telNumber);
1828 TELEPHONY_LOGI("NAPI NativeDelIccDiallingNumbers errorCode: %{public}d", errorCode);
1829 diallingNumbers->asyncContext.context.errorCode = errorCode;
1830 diallingNumbers->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1831 }
1832 }
1833
DelIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)1834 void DelIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
1835 {
1836 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1837 std::unique_ptr<AsyncDiallingNumbers<int32_t>> diallingNumbers(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
1838 NapiAsyncPermissionCompleteCallback(
1839 env, status, diallingNumbers->asyncContext, true, "DelIccDiallingNumbers", Permission::WRITE_CONTACTS);
1840 }
1841
DelIccDiallingNumbers(napi_env env,napi_callback_info info)1842 napi_value DelIccDiallingNumbers(napi_env env, napi_callback_info info)
1843 {
1844 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
1845 BaseContext &context = diallingNumbers->asyncContext.context;
1846
1847 napi_value object = NapiUtil::CreateUndefined(env);
1848 auto initPara =
1849 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
1850 AsyncPara para {
1851 .funcName = "DelIccDiallingNumbers",
1852 .env = env,
1853 .info = info,
1854 .execute = NativeDelIccDiallingNumbers,
1855 .complete = DelIccDiallingNumbersCallback,
1856 };
1857 napi_value result = NapiCreateAsyncWork2(para, diallingNumbers, initPara);
1858 if (result) {
1859 TelNumbersInfo inputInfo;
1860 DiallingNumberParaAnalyze(env, object, inputInfo);
1861 diallingNumbers->infoVec.push_back(std::move(inputInfo));
1862 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1863 }
1864 return result;
1865 }
1866
NativeUpdateIccDiallingNumbers(napi_env env,void * data)1867 void NativeUpdateIccDiallingNumbers(napi_env env, void *data)
1868 {
1869 if (data == nullptr) {
1870 return;
1871 }
1872 AsyncDiallingNumbers<int32_t> *diallingNumbers = static_cast<AsyncDiallingNumbers<int32_t> *>(data);
1873 AsyncContext<int32_t> &asyncContext = diallingNumbers->asyncContext;
1874 if (!IsValidSlotId(asyncContext.slotId)) {
1875 TELEPHONY_LOGE("NativeUpdateIccDiallingNumbers slotId is invalid");
1876 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1877 return;
1878 }
1879 if (diallingNumbers->infoVec.size() > 0) {
1880 std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
1881 GetDiallingNumberInfo(telNumber, diallingNumbers->infoVec.at(0));
1882 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UpdateIccDiallingNumbers(
1883 asyncContext.slotId, diallingNumbers->type, telNumber);
1884 TELEPHONY_LOGI("NAPI NativeUpdateIccDiallingNumbers errorCode: %{public}d", errorCode);
1885 asyncContext.context.errorCode = errorCode;
1886 asyncContext.context.resolved = (errorCode == ERROR_NONE);
1887 }
1888 }
1889
UpdateIccDiallingNumbersCallback(napi_env env,napi_status status,void * data)1890 void UpdateIccDiallingNumbersCallback(napi_env env, napi_status status, void *data)
1891 {
1892 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1893 std::unique_ptr<AsyncDiallingNumbers<int32_t>> context(static_cast<AsyncDiallingNumbers<int32_t> *>(data));
1894 NapiAsyncPermissionCompleteCallback(
1895 env, status, context->asyncContext, true, "UpdateIccDiallingNumbers", Permission::WRITE_CONTACTS);
1896 }
1897
UpdateIccDiallingNumbers(napi_env env,napi_callback_info info)1898 napi_value UpdateIccDiallingNumbers(napi_env env, napi_callback_info info)
1899 {
1900 auto diallingNumbers = new AsyncDiallingNumbers<int32_t>();
1901 BaseContext &context = diallingNumbers->asyncContext.context;
1902
1903 napi_value object = NapiUtil::CreateUndefined(env);
1904 auto initPara =
1905 std::make_tuple(&diallingNumbers->asyncContext.slotId, &diallingNumbers->type, &object, &context.callbackRef);
1906
1907 AsyncPara para {
1908 .funcName = "UpdateIccDiallingNumbers",
1909 .env = env,
1910 .info = info,
1911 .execute = NativeUpdateIccDiallingNumbers,
1912 .complete = UpdateIccDiallingNumbersCallback,
1913 };
1914 napi_value result = NapiCreateAsyncWork2<AsyncDiallingNumbers<int32_t>>(para, diallingNumbers, initPara);
1915 if (result) {
1916 TelNumbersInfo inputInfo;
1917 DiallingNumberParaAnalyze(env, object, inputInfo);
1918 diallingNumbers->infoVec.push_back(std::move(inputInfo));
1919 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1920 }
1921 return result;
1922 }
1923
NativeSetVoiceMailInfo(napi_env env,void * data)1924 void NativeSetVoiceMailInfo(napi_env env, void *data)
1925 {
1926 if (data == nullptr) {
1927 return;
1928 }
1929 AsyncVoiceMail *mailContext = static_cast<AsyncVoiceMail *>(data);
1930 AsyncContext<bool> &asyncContext = mailContext->asyncContext;
1931 if (!IsValidSlotId(asyncContext.slotId)) {
1932 TELEPHONY_LOGE("NativeSetVoiceMailInfo slotId is invalid");
1933 asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1934 return;
1935 }
1936 std::u16string mailName = NapiUtil::ToUtf16(std::data(mailContext->mailName));
1937 std::u16string mailNumber = NapiUtil::ToUtf16(std::data(mailContext->mailNumber));
1938 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetVoiceMailInfo(
1939 asyncContext.slotId, mailName, mailNumber);
1940 TELEPHONY_LOGI("NAPI NativeSetVoiceMailInfo %{public}d", errorCode);
1941 asyncContext.context.errorCode = errorCode;
1942 asyncContext.context.resolved = (errorCode == ERROR_NONE);
1943 }
1944
SetVoiceMailInfoCallback(napi_env env,napi_status status,void * data)1945 void SetVoiceMailInfoCallback(napi_env env, napi_status status, void *data)
1946 {
1947 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1948 std::unique_ptr<AsyncVoiceMail> context(static_cast<AsyncVoiceMail *>(data));
1949 NapiAsyncPermissionCompleteCallback(
1950 env, status, context->asyncContext, true, "SetVoiceMailInfo", Permission::SET_TELEPHONY_STATE);
1951 }
1952
SetVoiceMailInfo(napi_env env,napi_callback_info info)1953 napi_value SetVoiceMailInfo(napi_env env, napi_callback_info info)
1954 {
1955 auto mailContext = new AsyncVoiceMail();
1956 BaseContext &context = mailContext->asyncContext.context;
1957
1958 auto initPara = std::make_tuple(&mailContext->asyncContext.slotId, std::data(mailContext->mailName),
1959 std::data(mailContext->mailNumber), &context.callbackRef);
1960
1961 AsyncPara para {
1962 .funcName = "SetVoiceMailNumber",
1963 .env = env,
1964 .info = info,
1965 .execute = NativeSetVoiceMailInfo,
1966 .complete = SetVoiceMailInfoCallback,
1967 };
1968 napi_value result = NapiCreateAsyncWork2<AsyncVoiceMail>(para, mailContext, initPara);
1969 if (result) {
1970 NAPI_CALL(env, napi_queue_async_work(env, context.work));
1971 }
1972 return result;
1973 }
1974
NativeSendEnvelopeCmd(napi_env env,void * data)1975 void NativeSendEnvelopeCmd(napi_env env, void *data)
1976 {
1977 if (data == nullptr) {
1978 return;
1979 }
1980 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
1981 if (!IsValidSlotId(context->asyncContext.slotId)) {
1982 TELEPHONY_LOGE("NativeSendEnvelopeCmd slotId is invalid");
1983 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
1984 return;
1985 }
1986 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendEnvelopeCmd(
1987 context->asyncContext.slotId, std::data(context->inputStr));
1988 TELEPHONY_LOGI("NAPI NativeSendEnvelopeCmd %{public}d", errorCode);
1989 context->asyncContext.context.errorCode = errorCode;
1990 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
1991 }
1992
SendEnvelopeCmdCallback(napi_env env,napi_status status,void * data)1993 void SendEnvelopeCmdCallback(napi_env env, napi_status status, void *data)
1994 {
1995 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
1996 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
1997 NapiAsyncPermissionCompleteCallback(
1998 env, status, context->asyncContext, true, "SendEnvelopeCmd", Permission::SET_TELEPHONY_STATE);
1999 }
2000
SendEnvelopeCmd(napi_env env,napi_callback_info info)2001 napi_value SendEnvelopeCmd(napi_env env, napi_callback_info info)
2002 {
2003 auto asyncContext = new AsyncContext2();
2004 BaseContext &context = asyncContext->asyncContext.context;
2005
2006 auto initPara =
2007 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
2008 AsyncPara para {
2009 .funcName = "SendEnvelopeCmd",
2010 .env = env,
2011 .info = info,
2012 .execute = NativeSendEnvelopeCmd,
2013 .complete = SendEnvelopeCmdCallback,
2014 };
2015 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
2016 if (result) {
2017 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2018 }
2019 return result;
2020 }
2021
NativeSendTerminalResponseCmd(napi_env env,void * data)2022 void NativeSendTerminalResponseCmd(napi_env env, void *data)
2023 {
2024 if (data == nullptr) {
2025 return;
2026 }
2027 AsyncContext2 *context = static_cast<AsyncContext2 *>(data);
2028 if (!IsValidSlotId(context->asyncContext.slotId)) {
2029 TELEPHONY_LOGE("NativeSendTerminalResponseCmd slotId is invalid");
2030 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2031 return;
2032 }
2033 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendTerminalResponseCmd(
2034 context->asyncContext.slotId, std::data(context->inputStr));
2035 TELEPHONY_LOGI("NAPI NativeSendTerminalResponseCmd %{public}d", errorCode);
2036 context->asyncContext.context.errorCode = errorCode;
2037 context->asyncContext.context.resolved = (errorCode == ERROR_NONE);
2038 }
2039
SendTerminalResponseCmdCallback(napi_env env,napi_status status,void * data)2040 void SendTerminalResponseCmdCallback(napi_env env, napi_status status, void *data)
2041 {
2042 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2043 std::unique_ptr<AsyncContext2> context(static_cast<AsyncContext2 *>(data));
2044 NapiAsyncPermissionCompleteCallback(
2045 env, status, context->asyncContext, true, "SendTerminalResponseCmd", Permission::SET_TELEPHONY_STATE);
2046 }
2047
SendTerminalResponseCmd(napi_env env,napi_callback_info info)2048 napi_value SendTerminalResponseCmd(napi_env env, napi_callback_info info)
2049 {
2050 auto asyncContext = new AsyncContext2();
2051 BaseContext &context = asyncContext->asyncContext.context;
2052
2053 auto initPara =
2054 std::make_tuple(&asyncContext->asyncContext.slotId, std::data(asyncContext->inputStr), &context.callbackRef);
2055 AsyncPara para {
2056 .funcName = "SendTerminalResponseCmd",
2057 .env = env,
2058 .info = info,
2059 .execute = NativeSendTerminalResponseCmd,
2060 .complete = SendTerminalResponseCmdCallback,
2061 };
2062 napi_value result = NapiCreateAsyncWork2<AsyncContext2>(para, asyncContext, initPara);
2063 if (result) {
2064 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2065 }
2066 return result;
2067 }
2068
NativeAcceptCallSetupRequest(napi_env env,void * data)2069 void NativeAcceptCallSetupRequest(napi_env env, void *data)
2070 {
2071 if (data == nullptr) {
2072 return;
2073 }
2074 AsyncStkCallSetupResult *context = static_cast<AsyncStkCallSetupResult *>(data);
2075 if (!IsValidSlotId(context->asyncContext.slotId)) {
2076 TELEPHONY_LOGE("NativeAcceptCallSetupRequest slotId is invalid");
2077 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2078 return;
2079 }
2080 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendCallSetupRequestResult(
2081 context->asyncContext.slotId, true);
2082 TELEPHONY_LOGI("NAPI NativeAcceptCallSetupRequest %{public}d", errorCode);
2083 context->asyncContext.context.errorCode = errorCode;
2084 context->asyncContext.context.resolved = errorCode == ERROR_NONE;
2085 }
2086
AcceptCallSetupRequestCallback(napi_env env,napi_status status,void * data)2087 void AcceptCallSetupRequestCallback(napi_env env, napi_status status, void *data)
2088 {
2089 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2090 std::unique_ptr<AsyncStkCallSetupResult> context(static_cast<AsyncStkCallSetupResult *>(data));
2091 NapiAsyncPermissionCompleteCallback(
2092 env, status, context->asyncContext, true, "acceptCallSetup", Permission::SET_TELEPHONY_STATE);
2093 }
2094
AcceptCallSetupRequest(napi_env env,napi_callback_info info)2095 napi_value AcceptCallSetupRequest(napi_env env, napi_callback_info info)
2096 {
2097 auto asyncContext = new AsyncStkCallSetupResult();
2098 BaseContext &context = asyncContext->asyncContext.context;
2099
2100 auto initPara = std::make_tuple(&asyncContext->asyncContext.slotId, &context.callbackRef);
2101 AsyncPara para {
2102 .funcName = "AcceptCallSetupRequest",
2103 .env = env,
2104 .info = info,
2105 .execute = NativeAcceptCallSetupRequest,
2106 .complete = AcceptCallSetupRequestCallback,
2107 };
2108 napi_value result = NapiCreateAsyncWork2<AsyncStkCallSetupResult>(para, asyncContext, initPara);
2109 if (result) {
2110 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2111 }
2112 return result;
2113 }
2114
NativeRejectCallSetupRequest(napi_env env,void * data)2115 void NativeRejectCallSetupRequest(napi_env env, void *data)
2116 {
2117 if (data == nullptr) {
2118 return;
2119 }
2120 AsyncStkCallSetupResult *context = static_cast<AsyncStkCallSetupResult *>(data);
2121 if (!IsValidSlotId(context->asyncContext.slotId)) {
2122 TELEPHONY_LOGE("NativeRejectCallSetupRequest slotId is invalid");
2123 context->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2124 return;
2125 }
2126 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SendCallSetupRequestResult(
2127 context->asyncContext.slotId, false);
2128 TELEPHONY_LOGI("NAPI NativeRejectCallSetupRequest %{public}d", errorCode);
2129 context->asyncContext.context.errorCode = errorCode;
2130 context->asyncContext.context.resolved = errorCode == ERROR_NONE;
2131 }
2132
RejectCallSetupRequestCallback(napi_env env,napi_status status,void * data)2133 void RejectCallSetupRequestCallback(napi_env env, napi_status status, void *data)
2134 {
2135 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2136 std::unique_ptr<AsyncStkCallSetupResult> context(static_cast<AsyncStkCallSetupResult *>(data));
2137 NapiAsyncPermissionCompleteCallback(
2138 env, status, context->asyncContext, true, "rejectCallSetup", Permission::SET_TELEPHONY_STATE);
2139 }
2140
RejectCallSetupRequest(napi_env env,napi_callback_info info)2141 napi_value RejectCallSetupRequest(napi_env env, napi_callback_info info)
2142 {
2143 auto asyncContext = new AsyncStkCallSetupResult();
2144 BaseContext &context = asyncContext->asyncContext.context;
2145
2146 auto initPara = std::make_tuple(&asyncContext->asyncContext.slotId, &context.callbackRef);
2147 AsyncPara para {
2148 .funcName = "RejectCallSetupRequest",
2149 .env = env,
2150 .info = info,
2151 .execute = NativeRejectCallSetupRequest,
2152 .complete = RejectCallSetupRequestCallback,
2153 };
2154 napi_value result = NapiCreateAsyncWork2<AsyncStkCallSetupResult>(para, asyncContext, initPara);
2155 if (result) {
2156 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2157 }
2158 return result;
2159 }
2160
GetMaxSimCount(napi_env env,napi_callback_info)2161 napi_value GetMaxSimCount(napi_env env, napi_callback_info)
2162 {
2163 return GetNapiValue(env, DelayedRefSingleton<CoreServiceClient>::GetInstance().GetMaxSimCount());
2164 }
2165
NativeGetOpKey(napi_env env,void * data)2166 void NativeGetOpKey(napi_env env, void *data)
2167 {
2168 if (data == nullptr) {
2169 return;
2170 }
2171 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
2172 if (!IsValidSlotId(asyncContext->slotId)) {
2173 TELEPHONY_LOGE("NativeGetOpKey slotId is invalid");
2174 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
2175 return;
2176 }
2177 std::u16string opkey;
2178 int32_t code = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpKey(asyncContext->slotId, opkey);
2179 if (code == ERROR_NONE) {
2180 asyncContext->callbackVal = NapiUtil::ToUtf8(opkey);
2181 asyncContext->context.resolved = true;
2182 return;
2183 }
2184 asyncContext->context.errorCode = code;
2185 asyncContext->context.resolved = false;
2186 }
2187
GetOpKeyCallback(napi_env env,napi_status status,void * data)2188 void GetOpKeyCallback(napi_env env, napi_status status, void *data)
2189 {
2190 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2191 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
2192 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2193 }
2194
GetOpKey(napi_env env,napi_callback_info info)2195 napi_value GetOpKey(napi_env env, napi_callback_info info)
2196 {
2197 return NapiCreateAsyncWork<std::string, NativeGetOpKey, GetOpKeyCallback>(env, info, "GetOpKey");
2198 }
2199
NativeGetOpName(napi_env env,void * data)2200 void NativeGetOpName(napi_env env, void *data)
2201 {
2202 if (data == nullptr) {
2203 return;
2204 }
2205 AsyncContext<std::string> *asyncContext = static_cast<AsyncContext<std::string> *>(data);
2206 if (!IsValidSlotId(asyncContext->slotId)) {
2207 TELEPHONY_LOGE("NativeGetOpName slotId is invalid");
2208 asyncContext->context.errorCode = ERROR_SLOT_ID_INVALID;
2209 return;
2210 }
2211 std::u16string opname;
2212 int32_t code = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpName(asyncContext->slotId, opname);
2213 if (code == ERROR_NONE) {
2214 asyncContext->callbackVal = NapiUtil::ToUtf8(opname);
2215 asyncContext->context.resolved = true;
2216 return;
2217 }
2218 asyncContext->context.errorCode = code;
2219 asyncContext->context.resolved = false;
2220 }
2221
GetOpNameCallback(napi_env env,napi_status status,void * data)2222 void GetOpNameCallback(napi_env env, napi_status status, void *data)
2223 {
2224 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2225 std::unique_ptr<AsyncContext<std::string>> context(static_cast<AsyncContext<std::string> *>(data));
2226 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2227 }
2228
GetOpName(napi_env env,napi_callback_info info)2229 napi_value GetOpName(napi_env env, napi_callback_info info)
2230 {
2231 return NapiCreateAsyncWork<std::string, NativeGetOpName, GetOpNameCallback>(env, info, "GetOpName");
2232 }
2233
NativeGetLockState(napi_env env,void * data)2234 void NativeGetLockState(napi_env env, void *data)
2235 {
2236 if (data == nullptr) {
2237 return;
2238 }
2239 AsyncGetLockState *lockContext = static_cast<AsyncGetLockState *>(data);
2240 AsyncContext<int32_t> &asContext = lockContext->asyncContext;
2241 if (!IsValidSlotId(asContext.slotId)) {
2242 TELEPHONY_LOGE("NativeGetLockState slotId is invalid");
2243 asContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2244 return;
2245 }
2246 LockState lockState = LockState::LOCK_ERROR;
2247 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetLockState(
2248 asContext.slotId, static_cast<LockType>(lockContext->lockType), lockState);
2249 TELEPHONY_LOGI("NAPI NativeGetLockState %{public}d", errorCode);
2250 if (errorCode == ERROR_NONE) {
2251 asContext.context.resolved = true;
2252 asContext.callbackVal = static_cast<int32_t>(lockState);
2253 } else {
2254 asContext.context.resolved = false;
2255 }
2256 asContext.context.errorCode = errorCode;
2257 }
2258
GetLockStateCallback(napi_env env,napi_status status,void * data)2259 void GetLockStateCallback(napi_env env, napi_status status, void *data)
2260 {
2261 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2262 std::unique_ptr<AsyncGetLockState> context(static_cast<AsyncGetLockState *>(data));
2263 TELEPHONY_LOGI("NAPI NativeGetLockState value:%{public}d", context->asyncContext.callbackVal);
2264 NapiAsyncPermissionCompleteCallback(
2265 env, status, context->asyncContext, false, "GetLockState", Permission::GET_TELEPHONY_STATE);
2266 }
2267
GetLockState(napi_env env,napi_callback_info info)2268 napi_value GetLockState(napi_env env, napi_callback_info info)
2269 {
2270 auto lockStateContext = new AsyncGetLockState();
2271 BaseContext &context = lockStateContext->asyncContext.context;
2272
2273 auto initPara =
2274 std::make_tuple(&lockStateContext->asyncContext.slotId, &lockStateContext->lockType, &context.callbackRef);
2275 AsyncPara para {
2276 .funcName = "GetLockState",
2277 .env = env,
2278 .info = info,
2279 .execute = NativeGetLockState,
2280 .complete = GetLockStateCallback,
2281 };
2282 napi_value result = NapiCreateAsyncWork2<AsyncGetLockState>(para, lockStateContext, initPara);
2283 if (result) {
2284 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2285 }
2286 return result;
2287 }
2288
NativeHasOperatorPrivileges(napi_env env,void * data)2289 void NativeHasOperatorPrivileges(napi_env env, void *data)
2290 {
2291 if (data == nullptr) {
2292 return;
2293 }
2294 AsyncContext<bool> *reVal = static_cast<AsyncContext<bool> *>(data);
2295 if (!IsValidSlotId(reVal->slotId)) {
2296 TELEPHONY_LOGE("NativeHasOperatorPrivileges slotId is invalid");
2297 reVal->context.errorCode = ERROR_SLOT_ID_INVALID;
2298 return;
2299 }
2300 bool hasOperatorPrivileges = false;
2301 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasOperatorPrivileges(
2302 reVal->slotId, hasOperatorPrivileges);
2303 TELEPHONY_LOGI("NAPI NativeHasOperatorPrivileges %{public}d", errorCode);
2304 if (errorCode == ERROR_NONE) {
2305 reVal->callbackVal = hasOperatorPrivileges;
2306 reVal->context.resolved = true;
2307 } else {
2308 reVal->context.resolved = false;
2309 }
2310 reVal->context.errorCode = errorCode;
2311 }
2312
HasOperatorPrivilegesCallback(napi_env env,napi_status status,void * data)2313 void HasOperatorPrivilegesCallback(napi_env env, napi_status status, void *data)
2314 {
2315 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2316 std::unique_ptr<AsyncContext<bool>> context(static_cast<AsyncContext<bool> *>(data));
2317 NapiAsyncCommomCompleteCallback(env, status, *context, false);
2318 }
2319
HasOperatorPrivileges(napi_env env,napi_callback_info info)2320 napi_value HasOperatorPrivileges(napi_env env, napi_callback_info info)
2321 {
2322 return NapiCreateAsyncWork<bool, NativeHasOperatorPrivileges, HasOperatorPrivilegesCallback>(
2323 env, info, "HasOperatorPrivileges");
2324 }
2325
NativeUnlockSimLock(napi_env env,void * data)2326 void NativeUnlockSimLock(napi_env env, void *data)
2327 {
2328 if (data == nullptr) {
2329 return;
2330 }
2331 AsyncContextPIN *asyncContext = static_cast<AsyncContextPIN *>(data);
2332 if (!IsValidSlotId(asyncContext->asyncContext.slotId)) {
2333 TELEPHONY_LOGE("NativeUnlockSimLock slotId is invalid");
2334 asyncContext->asyncContext.context.errorCode = ERROR_SLOT_ID_INVALID;
2335 return;
2336 }
2337 LockStatusResponse response { UNLOCK_FAIL, ERROR_DEFAULT };
2338 PersoLockInfo lockInfo { static_cast<PersoLockType>(asyncContext->pinEnable),
2339 NapiUtil::ToUtf16(asyncContext->inStr1.data()) };
2340 int32_t errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().UnlockSimLock(
2341 asyncContext->asyncContext.slotId, lockInfo, response);
2342 TELEPHONY_LOGI("NAPI NativeUnlockSimLock %{public}d", errorCode);
2343 if (errorCode == ERROR_NONE) {
2344 asyncContext->result = response.result;
2345 asyncContext->remain = response.remain;
2346 asyncContext->asyncContext.context.resolved = true;
2347 } else {
2348 asyncContext->asyncContext.context.resolved = false;
2349 }
2350 asyncContext->asyncContext.context.errorCode = errorCode;
2351 }
2352
UnlockSimLockCallback(napi_env env,napi_status status,void * data)2353 void UnlockSimLockCallback(napi_env env, napi_status status, void *data)
2354 {
2355 NAPI_CALL_RETURN_VOID(env, (data == nullptr ? napi_invalid_arg : napi_ok));
2356 std::unique_ptr<AsyncContextPIN> context(static_cast<AsyncContextPIN *>(data));
2357 const LockStatusResponse res {context->result, context->remain};
2358 context->asyncContext.callbackVal = PinOrPukUnlockConversion(env, res);
2359 NapiAsyncPermissionCompleteCallback(
2360 env, status, context->asyncContext, false, "UnlockSimLock", Permission::SET_TELEPHONY_STATE);
2361 }
2362
UnlockSimLock(napi_env env,napi_callback_info info)2363 napi_value UnlockSimLock(napi_env env, napi_callback_info info)
2364 {
2365 auto asyncContextPIN = new AsyncContextPIN();
2366 BaseContext &context = asyncContextPIN->asyncContext.context;
2367 napi_value object = NapiUtil::CreateUndefined(env);
2368 auto initPara = std::make_tuple(&asyncContextPIN->asyncContext.slotId, &object, &context.callbackRef);
2369
2370 AsyncPara para {
2371 .funcName = "UnlockSimLock",
2372 .env = env,
2373 .info = info,
2374 .execute = NativeUnlockSimLock,
2375 .complete = UnlockSimLockCallback,
2376 };
2377 napi_value result = NapiCreateAsyncWork2<AsyncContextPIN>(para, asyncContextPIN, initPara);
2378 if (result) {
2379 PersoLockInfoAnalyze(env, object, *asyncContextPIN);
2380 NAPI_CALL(env, napi_queue_async_work(env, context.work));
2381 }
2382 return result;
2383 }
2384
InitEnumSimState(napi_env env,napi_value exports)2385 napi_status InitEnumSimState(napi_env env, napi_value exports)
2386 {
2387 napi_property_descriptor desc[] = {
2388 DECLARE_NAPI_STATIC_PROPERTY(
2389 "SIM_STATE_UNKNOWN", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_UNKNOWN))),
2390 DECLARE_NAPI_STATIC_PROPERTY(
2391 "SIM_STATE_NOT_PRESENT", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_NOT_PRESENT))),
2392 DECLARE_NAPI_STATIC_PROPERTY(
2393 "SIM_STATE_LOCKED", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_LOCKED))),
2394 DECLARE_NAPI_STATIC_PROPERTY(
2395 "SIM_STATE_NOT_READY", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_NOT_READY))),
2396 DECLARE_NAPI_STATIC_PROPERTY(
2397 "SIM_STATE_READY", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_READY))),
2398 DECLARE_NAPI_STATIC_PROPERTY(
2399 "SIM_STATE_LOADED", GetNapiValue(env, static_cast<int32_t>(SimState::SIM_STATE_LOADED))),
2400 };
2401 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2402 NapiUtil::DefineEnumClassByName(env, exports, "SimState", arrSize, desc);
2403 return napi_define_properties(env, exports, arrSize, desc);
2404 }
2405
InitEnumContactType(napi_env env,napi_value exports)2406 napi_status InitEnumContactType(napi_env env, napi_value exports)
2407 {
2408 napi_property_descriptor desc[] = {
2409 DECLARE_NAPI_STATIC_PROPERTY(
2410 "GENERAL_CONTACT", GetNapiValue(env, static_cast<int32_t>(ContactType::GENERAL_CONTACT))),
2411 DECLARE_NAPI_STATIC_PROPERTY(
2412 "FIXED_DIALING", GetNapiValue(env, static_cast<int32_t>(ContactType::FIXED_DIALING))),
2413 };
2414
2415 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2416 NapiUtil::DefineEnumClassByName(env, exports, "ContactType", arrSize, desc);
2417 return napi_define_properties(env, exports, arrSize, desc);
2418 }
2419
InitEnumLockState(napi_env env,napi_value exports)2420 napi_status InitEnumLockState(napi_env env, napi_value exports)
2421 {
2422 napi_property_descriptor desc[] = {
2423 DECLARE_NAPI_STATIC_PROPERTY("LOCK_OFF", GetNapiValue(env, static_cast<int32_t>(LockState::LOCK_OFF))),
2424 DECLARE_NAPI_STATIC_PROPERTY("LOCK_ON", GetNapiValue(env, static_cast<int32_t>(LockState::LOCK_ON))),
2425 };
2426
2427 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2428 NapiUtil::DefineEnumClassByName(env, exports, "LockState", arrSize, desc);
2429 return napi_define_properties(env, exports, arrSize, desc);
2430 }
2431
InitEnumLockType(napi_env env,napi_value exports)2432 napi_status InitEnumLockType(napi_env env, napi_value exports)
2433 {
2434 napi_property_descriptor desc[] = {
2435 DECLARE_NAPI_STATIC_PROPERTY("PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(LockType::PIN_LOCK))),
2436 DECLARE_NAPI_STATIC_PROPERTY("FDN_LOCK", GetNapiValue(env, static_cast<int32_t>(LockType::FDN_LOCK))),
2437 };
2438
2439 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2440 NapiUtil::DefineEnumClassByName(env, exports, "LockType", arrSize, desc);
2441 return napi_define_properties(env, exports, arrSize, desc);
2442 }
2443
InitEnumCardType(napi_env env,napi_value exports)2444 napi_status InitEnumCardType(napi_env env, napi_value exports)
2445 {
2446 napi_property_descriptor desc[] = {
2447 DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::UNKNOWN_CARD))),
2448 DECLARE_NAPI_STATIC_PROPERTY(
2449 "SINGLE_MODE_SIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_SIM_CARD))),
2450 DECLARE_NAPI_STATIC_PROPERTY(
2451 "SINGLE_MODE_USIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_USIM_CARD))),
2452 DECLARE_NAPI_STATIC_PROPERTY(
2453 "SINGLE_MODE_RUIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_RUIM_CARD))),
2454 DECLARE_NAPI_STATIC_PROPERTY(
2455 "DUAL_MODE_CG_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_CG_CARD))),
2456 DECLARE_NAPI_STATIC_PROPERTY(
2457 "CT_NATIONAL_ROAMING_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::CT_NATIONAL_ROAMING_CARD))),
2458 DECLARE_NAPI_STATIC_PROPERTY(
2459 "CU_DUAL_MODE_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::CU_DUAL_MODE_CARD))),
2460 DECLARE_NAPI_STATIC_PROPERTY("DUAL_MODE_TELECOM_LTE_CARD",
2461 GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_TELECOM_LTE_CARD))),
2462 DECLARE_NAPI_STATIC_PROPERTY(
2463 "DUAL_MODE_UG_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::DUAL_MODE_UG_CARD))),
2464 DECLARE_NAPI_STATIC_PROPERTY(
2465 "SINGLE_MODE_ISIM_CARD", GetNapiValue(env, static_cast<int32_t>(CardType::SINGLE_MODE_ISIM_CARD))),
2466 };
2467
2468 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2469 NapiUtil::DefineEnumClassByName(env, exports, "CardType", arrSize, desc);
2470 return napi_define_properties(env, exports, arrSize, desc);
2471 }
2472
InitEnumPersoLockType(napi_env env,napi_value exports)2473 napi_status InitEnumPersoLockType(napi_env env, napi_value exports)
2474 {
2475 napi_property_descriptor desc[] = {
2476 DECLARE_NAPI_STATIC_PROPERTY(
2477 "PN_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PN_PIN_LOCK))),
2478 DECLARE_NAPI_STATIC_PROPERTY(
2479 "PN_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PN_PUK_LOCK))),
2480 DECLARE_NAPI_STATIC_PROPERTY(
2481 "PU_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PU_PIN_LOCK))),
2482 DECLARE_NAPI_STATIC_PROPERTY(
2483 "PU_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PU_PUK_LOCK))),
2484 DECLARE_NAPI_STATIC_PROPERTY(
2485 "PP_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PP_PIN_LOCK))),
2486 DECLARE_NAPI_STATIC_PROPERTY(
2487 "PP_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PP_PUK_LOCK))),
2488 DECLARE_NAPI_STATIC_PROPERTY(
2489 "PC_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PC_PIN_LOCK))),
2490 DECLARE_NAPI_STATIC_PROPERTY(
2491 "PC_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::PC_PUK_LOCK))),
2492 DECLARE_NAPI_STATIC_PROPERTY(
2493 "SIM_PIN_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::SIM_PIN_LOCK))),
2494 DECLARE_NAPI_STATIC_PROPERTY(
2495 "SIM_PUK_LOCK", GetNapiValue(env, static_cast<int32_t>(PersoLockType::SIM_PUK_LOCK))),
2496 };
2497
2498 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2499 NapiUtil::DefineEnumClassByName(env, exports, "PersoLockType", arrSize, desc);
2500 return napi_define_properties(env, exports, arrSize, desc);
2501 }
2502
InitEnumOperatorConfigKey(napi_env env,napi_value exports)2503 napi_status InitEnumOperatorConfigKey(napi_env env, napi_value exports)
2504 {
2505 napi_property_descriptor desc[] = {
2506 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOICE_MAIL_NUMBER_STRING", GetNapiValue(env, "voice_mail_number_string")),
2507 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_SWITCH_ON_BY_DEFAULT_BOOL",
2508 GetNapiValue(env, "ims_switch_on_by_default_bool")),
2509 DECLARE_NAPI_STATIC_PROPERTY("KEY_HIDE_IMS_SWITCH_BOOL", GetNapiValue(env, "hide_ims_switch_bool")),
2510 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOLTE_SUPPORTED_BOOL", GetNapiValue(env, "volte_supported_bool")),
2511 DECLARE_NAPI_STATIC_PROPERTY("KEY_NR_MODE_SUPPORTED_LIST_INT_ARRAY",
2512 GetNapiValue(env, "nr_mode_supported_list_int_array")),
2513 DECLARE_NAPI_STATIC_PROPERTY("KEY_VOLTE_PROVISIONING_SUPPORTED_BOOL",
2514 GetNapiValue(env, "volte_provisioning_supported_bool")),
2515 DECLARE_NAPI_STATIC_PROPERTY("KEY_SS_OVER_UT_SUPPORTED_BOOL", GetNapiValue(env, "ss_over_ut_supported_bool")),
2516 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_GBA_REQUIRED_BOOL", GetNapiValue(env, "ims_gba_required_bool")),
2517 DECLARE_NAPI_STATIC_PROPERTY("KEY_UT_PROVISIONING_SUPPORTED_BOOL",
2518 GetNapiValue(env, "ut_provisioning_supported_bool")),
2519 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_PREFER_FOR_EMERGENCY_BOOL",
2520 GetNapiValue(env, "ims_prefer_for_emergency_bool")),
2521 DECLARE_NAPI_STATIC_PROPERTY("KEY_CALL_WAITING_SERVICE_CLASS_INT",
2522 GetNapiValue(env, "call_waiting_service_class_int")),
2523 DECLARE_NAPI_STATIC_PROPERTY("KEY_CALL_TRANSFER_VISIBILITY_BOOL",
2524 GetNapiValue(env, "call_transfer_visibility_bool")),
2525 DECLARE_NAPI_STATIC_PROPERTY("KEY_IMS_CALL_DISCONNECT_REASON_INFO_MAPPING_STRING_ARRAY",
2526 GetNapiValue(env, "ims_call_disconnect_reason_info_mapping_string_array")),
2527 DECLARE_NAPI_STATIC_PROPERTY("KEY_FORCE_VOLTE_SWITCH_ON_BOOL", GetNapiValue(env, "force_volte_switch_on_bool")),
2528 DECLARE_NAPI_STATIC_PROPERTY("KEY_ENABLE_OPERATOR_NAME_CUST_BOOL",
2529 GetNapiValue(env, "enable_operator_name_cust_bool")),
2530 DECLARE_NAPI_STATIC_PROPERTY("KEY_OPERATOR_NAME_CUST_STRING",
2531 GetNapiValue(env, "operator_name_cust_string")),
2532 DECLARE_NAPI_STATIC_PROPERTY("KEY_SPN_DISPLAY_CONDITION_CUST_INT",
2533 GetNapiValue(env, "spn_display_condition_cust_int")),
2534 DECLARE_NAPI_STATIC_PROPERTY("KEY_PNN_CUST_STRING_ARRAY", GetNapiValue(env, "pnn_cust_string_array")),
2535 DECLARE_NAPI_STATIC_PROPERTY("KEY_OPL_CUST_STRING_ARRAY", GetNapiValue(env, "opl_cust_string_array")),
2536 DECLARE_NAPI_STATIC_PROPERTY("KEY_EMERGENCY_CALL_STRING_ARRAY",
2537 GetNapiValue(env, "emergency_call_string_array")),
2538 };
2539
2540 constexpr size_t arrSize = sizeof(desc) / sizeof(desc[0]);
2541 NapiUtil::DefineEnumClassByName(env, exports, "OperatorConfigKey", arrSize, desc);
2542 return napi_define_properties(env, exports, arrSize, desc);
2543 }
2544
InitSimLockInterface(napi_env env,napi_value exports)2545 napi_status InitSimLockInterface(napi_env env, napi_value exports)
2546 {
2547 napi_property_descriptor desc[] = {
2548 DECLARE_NAPI_FUNCTION("unlockPin", UnlockPin),
2549 DECLARE_NAPI_FUNCTION("unlockPuk", UnlockPuk),
2550 DECLARE_NAPI_FUNCTION("alterPin", AlterPin),
2551 DECLARE_NAPI_FUNCTION("setLockState", SetLockState),
2552 DECLARE_NAPI_FUNCTION("unlockPin2", UnlockPin2),
2553 DECLARE_NAPI_FUNCTION("unlockPuk2", UnlockPuk2),
2554 DECLARE_NAPI_FUNCTION("alterPin2", AlterPin2),
2555 DECLARE_NAPI_FUNCTION("getLockState", GetLockState),
2556 DECLARE_NAPI_FUNCTION("unlockSimLock", UnlockSimLock),
2557 };
2558 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2559 }
2560
InitSimDiallingNumbersInterface(napi_env env,napi_value exports)2561 napi_status InitSimDiallingNumbersInterface(napi_env env, napi_value exports)
2562 {
2563 napi_property_descriptor desc[] = {
2564 DECLARE_NAPI_FUNCTION("queryIccDiallingNumbers", QueryIccDiallingNumbers),
2565 DECLARE_NAPI_FUNCTION("addIccDiallingNumbers", AddIccDiallingNumbers),
2566 DECLARE_NAPI_FUNCTION("delIccDiallingNumbers", DelIccDiallingNumbers),
2567 DECLARE_NAPI_FUNCTION("updateIccDiallingNumbers", UpdateIccDiallingNumbers),
2568 };
2569 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2570 }
2571
InitSimInterfaceAboutVoice(napi_env env,napi_value exports)2572 napi_status InitSimInterfaceAboutVoice(napi_env env, napi_value exports)
2573 {
2574 napi_property_descriptor desc[] = {
2575 DECLARE_NAPI_FUNCTION("setDefaultVoiceSlotId", SetDefaultVoiceSlotId),
2576 DECLARE_NAPI_FUNCTION("getDefaultVoiceSlotId", GetDefaultVoiceSlotId),
2577 DECLARE_NAPI_FUNCTION("getVoiceMailIdentifier", GetVoiceMailIdentifier),
2578 DECLARE_NAPI_FUNCTION("getVoiceMailNumber", GetVoiceMailNumber),
2579 DECLARE_NAPI_FUNCTION("setVoiceMailInfo", SetVoiceMailInfo),
2580 };
2581 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2582 }
2583
InitSimInterface(napi_env env,napi_value exports)2584 napi_status InitSimInterface(napi_env env, napi_value exports)
2585 {
2586 napi_property_descriptor desc[] = {
2587 DECLARE_NAPI_FUNCTION("getISOCountryCodeForSim", GetISOCountryCodeForSim),
2588 DECLARE_NAPI_FUNCTION("getSimOperatorNumeric", GetSimOperatorNumeric),
2589 DECLARE_NAPI_FUNCTION("getSimSpn", GetSimSpn),
2590 DECLARE_NAPI_FUNCTION("getSimState", GetSimState),
2591 DECLARE_NAPI_FUNCTION("getCardType", GetCardType),
2592 DECLARE_NAPI_FUNCTION("getSimIccId", GetSimIccId),
2593 DECLARE_NAPI_FUNCTION("getIMSI", GetIMSI),
2594 DECLARE_NAPI_FUNCTION("hasSimCard", HasSimCard),
2595 DECLARE_NAPI_FUNCTION("getSimGid1", GetSimGid1),
2596 DECLARE_NAPI_FUNCTION("getSimAccountInfo", GetSimAccountInfo),
2597 DECLARE_NAPI_FUNCTION("isSimActive", IsSimActive),
2598 DECLARE_NAPI_FUNCTION("activateSim", ActivateSim),
2599 DECLARE_NAPI_FUNCTION("deactivateSim", DeactivateSim),
2600 DECLARE_NAPI_FUNCTION("setShowName", SetShowName),
2601 DECLARE_NAPI_FUNCTION("getShowName", GetShowName),
2602 DECLARE_NAPI_FUNCTION("setShowNumber", SetShowNumber),
2603 DECLARE_NAPI_FUNCTION("getShowNumber", GetShowNumber),
2604 DECLARE_NAPI_FUNCTION("getOperatorConfigs", GetOperatorConfigs),
2605 DECLARE_NAPI_FUNCTION("getActiveSimAccountInfoList", GetActiveSimAccountInfoList),
2606 DECLARE_NAPI_FUNCTION("getSimTelephoneNumber", GetSimTelephoneNumber),
2607 DECLARE_NAPI_FUNCTION("sendEnvelopeCmd", SendEnvelopeCmd),
2608 DECLARE_NAPI_FUNCTION("sendTerminalResponseCmd", SendTerminalResponseCmd),
2609 DECLARE_NAPI_FUNCTION("acceptCallSetupRequest", AcceptCallSetupRequest),
2610 DECLARE_NAPI_FUNCTION("rejectCallSetupRequest", RejectCallSetupRequest),
2611 DECLARE_NAPI_FUNCTION("getMaxSimCount", GetMaxSimCount),
2612 DECLARE_NAPI_FUNCTION("hasOperatorPrivileges", HasOperatorPrivileges),
2613 DECLARE_NAPI_FUNCTION("getOpKey", GetOpKey),
2614 DECLARE_NAPI_FUNCTION("getOpName", GetOpName),
2615 };
2616 return napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2617 }
2618 } // namespace
2619
2620 EXTERN_C_START
InitNapiSim(napi_env env,napi_value exports)2621 napi_value InitNapiSim(napi_env env, napi_value exports)
2622 {
2623 NAPI_CALL(env, InitSimInterface(env, exports));
2624 NAPI_CALL(env, InitSimLockInterface(env, exports));
2625 NAPI_CALL(env, InitSimDiallingNumbersInterface(env, exports));
2626 NAPI_CALL(env, InitSimInterfaceAboutVoice(env, exports));
2627 NAPI_CALL(env, InitEnumSimState(env, exports));
2628 NAPI_CALL(env, InitEnumContactType(env, exports));
2629 NAPI_CALL(env, InitEnumLockState(env, exports));
2630 NAPI_CALL(env, InitEnumLockType(env, exports));
2631 NAPI_CALL(env, InitEnumCardType(env, exports));
2632 NAPI_CALL(env, InitEnumPersoLockType(env, exports));
2633 NAPI_CALL(env, InitEnumOperatorConfigKey(env, exports));
2634 return exports;
2635 }
2636 EXTERN_C_END
2637
2638 static napi_module _simModule = {
2639 .nm_version = 1,
2640 .nm_flags = 0,
2641 .nm_filename = nullptr,
2642 .nm_register_func = InitNapiSim,
2643 .nm_modname = "telephony.sim",
2644 .nm_priv = ((void *)0),
2645 .reserved = {0},
2646 };
2647
RegisterSimCardModule(void)2648 extern "C" __attribute__((constructor)) void RegisterSimCardModule(void)
2649 {
2650 napi_module_register(&_simModule);
2651 }
2652 } // namespace Telephony
2653 } // namespace OHOS
2654