1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_radio.h"
17
18 #include <chrono>
19 #include <cstring>
20 #include <memory>
21 #include <unistd.h>
22
23 #include "core_service_client.h"
24 #include "get_network_search_info_callback.h"
25 #include "get_network_search_mode_callback.h"
26 #include "get_nr_option_mode_callback.h"
27 #include "get_preferred_network_callback.h"
28 #include "get_radio_state_callback.h"
29 #include "napi_ims_reg_info_callback_manager.h"
30 #include "set_network_search_mode_callback.h"
31 #include "set_nr_option_mode_callback.h"
32 #include "set_preferred_network_callback.h"
33 #include "set_radio_state_callback.h"
34 #include "telephony_config.h"
35 #include "telephony_errors.h"
36 #include "telephony_log_wrapper.h"
37 #include "telephony_ext_utils_wrapper.h"
38
39 namespace OHOS {
40 namespace Telephony {
41 constexpr int32_t DEFAULT_REF_COUNT = 1;
42 constexpr int16_t PARAMETER_COUNT_ZERO = 0;
43 constexpr int16_t PARAMETER_COUNT_ONE = 1;
44 constexpr int16_t PARAMETER_COUNT_TWO = 2;
45 constexpr int16_t PARAMETER_COUNT_THREE = 3;
46 constexpr int16_t PARAMETER_COUNT_FOUR = 4;
47
48 static constexpr const char *GET_TELEPHONY_STATE = "ohos.permission.GET_TELEPHONY_STATE";
49 static constexpr const char *SET_TELEPHONY_STATE = "ohos.permission.SET_TELEPHONY_STATE";
50 static constexpr const char *LOCATION = "ohos.permission.LOCATION";
51 static constexpr const char *GET_NETWORK_INFO = "ohos.permission.GET_NETWORK_INFO";
52
WrapRadioTech(int32_t radioTechType)53 static int32_t WrapRadioTech(int32_t radioTechType)
54 {
55 RadioTech techType = static_cast<RadioTech>(radioTechType);
56 switch (techType) {
57 case RadioTech::RADIO_TECHNOLOGY_GSM:
58 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_GSM);
59 case RadioTech::RADIO_TECHNOLOGY_LTE:
60 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE);
61 case RadioTech::RADIO_TECHNOLOGY_WCDMA:
62 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_WCDMA);
63 case RadioTech::RADIO_TECHNOLOGY_1XRTT:
64 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_1XRTT);
65 case RadioTech::RADIO_TECHNOLOGY_HSPA:
66 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPA);
67 case RadioTech::RADIO_TECHNOLOGY_HSPAP:
68 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPAP);
69 case RadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
70 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_TD_SCDMA);
71 case RadioTech::RADIO_TECHNOLOGY_EVDO:
72 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EVDO);
73 case RadioTech::RADIO_TECHNOLOGY_EHRPD:
74 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EHRPD);
75 case RadioTech::RADIO_TECHNOLOGY_LTE_CA:
76 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE_CA);
77 case RadioTech::RADIO_TECHNOLOGY_IWLAN:
78 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_IWLAN);
79 case RadioTech::RADIO_TECHNOLOGY_NR:
80 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_NR);
81 default:
82 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_UNKNOWN);
83 }
84 }
85
WrapSignalInformationType(SignalInformation::NetworkType type)86 static int32_t WrapSignalInformationType(SignalInformation::NetworkType type)
87 {
88 switch (type) {
89 case SignalInformation::NetworkType::GSM:
90 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_GSM);
91 case SignalInformation::NetworkType::CDMA:
92 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_CDMA);
93 case SignalInformation::NetworkType::LTE:
94 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_LTE);
95 case SignalInformation::NetworkType::WCDMA:
96 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_WCDMA);
97 case SignalInformation::NetworkType::TDSCDMA:
98 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_TDSCDMA);
99 case SignalInformation::NetworkType::NR:
100 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_NR);
101 default:
102 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN);
103 }
104 }
105
GetDefaultSlotId()106 static int32_t GetDefaultSlotId()
107 {
108 return DEFAULT_SIM_SLOT_ID;
109 }
110
IsValidSlotId(int32_t slotId)111 static inline bool IsValidSlotId(int32_t slotId)
112 {
113 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
114 }
115
IsValidSlotIdEx(int32_t slotId)116 static inline bool IsValidSlotIdEx(int32_t slotId)
117 {
118 // One more slot for VSim.
119 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT + 1));
120 }
121
IsValidNetworkCapabilityType(int32_t networkCapabilityType)122 static inline bool IsValidNetworkCapabilityType(int32_t networkCapabilityType)
123 {
124 return ((networkCapabilityType == static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_LTE)) ||
125 (networkCapabilityType == static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_NR)));
126 }
127
IsValidNetworkCapabilityState(int32_t networkCapabilityState)128 static inline bool IsValidNetworkCapabilityState(int32_t networkCapabilityState)
129 {
130 return ((networkCapabilityState == static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_OFF)) ||
131 (networkCapabilityState == static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_ON)));
132 }
133
NativeGetRadioTech(napi_env env,void * data)134 static void NativeGetRadioTech(napi_env env, void *data)
135 {
136 auto asyncContext = static_cast<RadioTechContext *>(data);
137 if (!IsValidSlotId(asyncContext->slotId)) {
138 TELEPHONY_LOGE("NativeGetRadioTech slotId is invalid");
139 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
140 return;
141 }
142 int32_t psRadioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
143 int32_t csRadioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
144 int32_t psResult =
145 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetPsRadioTech(asyncContext->slotId, psRadioTech);
146 int32_t csResult =
147 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCsRadioTech(asyncContext->slotId, csRadioTech);
148 if (psResult == TELEPHONY_SUCCESS && csResult == TELEPHONY_SUCCESS) {
149 asyncContext->resolved = true;
150 asyncContext->csTech = WrapRadioTech(csRadioTech);
151 asyncContext->psTech = WrapRadioTech(psRadioTech);
152 }
153 asyncContext->errorCode = csResult;
154 }
155
GetRadioTechCallback(napi_env env,napi_status status,void * data)156 static void GetRadioTechCallback(napi_env env, napi_status status, void *data)
157 {
158 auto asyncContext = static_cast<RadioTechContext *>(data);
159 if (asyncContext == nullptr) {
160 return;
161 }
162 napi_value callbackValue = nullptr;
163 if (asyncContext->resolved) {
164 napi_create_object(env, &callbackValue);
165 NapiUtil::SetPropertyInt32(env, callbackValue, "psRadioTech", asyncContext->psTech);
166 NapiUtil::SetPropertyInt32(env, callbackValue, "csRadioTech", asyncContext->csTech);
167 } else {
168 JsError error =
169 NapiUtil::ConverErrorMessageWithPermissionForJs(asyncContext->errorCode, "getRadioTech", GET_NETWORK_INFO);
170 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
171 }
172 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
173 TELEPHONY_LOGI("GetRadioTechCallback end");
174 }
175
MatchGetRadioTechParameter(napi_env env,const napi_value parameters[],size_t parameterCount)176 static bool MatchGetRadioTechParameter(napi_env env, const napi_value parameters[], size_t parameterCount)
177 {
178 switch (parameterCount) {
179 case PARAMETER_COUNT_ONE: {
180 return NapiUtil::MatchParameters(env, parameters, { napi_number });
181 }
182 case PARAMETER_COUNT_TWO: {
183 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
184 }
185 default: {
186 return false;
187 }
188 }
189 }
190
GetRadioTech(napi_env env,napi_callback_info info)191 static napi_value GetRadioTech(napi_env env, napi_callback_info info)
192 {
193 size_t parameterCount = PARAMETER_COUNT_TWO;
194 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
195 napi_value thisVar = nullptr;
196 void *data = nullptr;
197 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
198 if (!MatchGetRadioTechParameter(env, parameters, parameterCount)) {
199 TELEPHONY_LOGE("GetRadioTech parameter matching failed.");
200 NapiUtil::ThrowParameterError(env);
201 return nullptr;
202 }
203 auto asyncContext = std::make_unique<RadioTechContext>();
204 if (asyncContext == nullptr) {
205 TELEPHONY_LOGE("GetRadioTech asyncContext is nullptr.");
206 NapiUtil::ThrowParameterError(env);
207 return nullptr;
208 }
209 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
210 if (parameterCount == PARAMETER_COUNT_TWO) {
211 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
212 }
213 return NapiUtil::HandleAsyncWork(
214 env, asyncContext.release(), "GetRadioTech", NativeGetRadioTech, GetRadioTechCallback);
215 }
216
NativeGetSignalInfoList(napi_env env,void * data)217 static void NativeGetSignalInfoList(napi_env env, void *data)
218 {
219 auto asyncContext = static_cast<SignalInfoListContext *>(data);
220 if (!IsValidSlotIdEx(asyncContext->slotId)) {
221 TELEPHONY_LOGE("NativeGetSignalInfoList slotId is invalid");
222 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
223 return;
224 }
225 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSignalInfoList(
226 asyncContext->slotId, asyncContext->signalInfoList);
227 TELEPHONY_LOGD("NativeGetSignalInfoList size = %{public}zu", asyncContext->signalInfoList.size());
228 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
229 asyncContext->resolved = true;
230 }
231 }
232
GetSignalInfoListCallback(napi_env env,napi_status status,void * data)233 static void GetSignalInfoListCallback(napi_env env, napi_status status, void *data)
234 {
235 auto asyncContext = static_cast<SignalInfoListContext *>(data);
236 TELEPHONY_LOGD("GetSignalInfoListCallback size = %{public}zu, resolved = %{public}d",
237 asyncContext->signalInfoList.size(), asyncContext->resolved);
238 napi_value callbackValue = nullptr;
239 if (asyncContext->resolved) {
240 napi_create_array(env, &callbackValue);
241 int i = 0;
242 for (sptr<SignalInformation> infoItem : asyncContext->signalInfoList) {
243 napi_value info = nullptr;
244 napi_create_object(env, &info);
245 int32_t signalType = static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN);
246 int32_t signalLevel = 0;
247 int32_t signalIntensity = 0;
248 if (infoItem != nullptr) {
249 signalType = WrapSignalInformationType(infoItem->GetNetworkType());
250 signalLevel = infoItem->GetSignalLevel();
251 signalIntensity = infoItem->GetSignalIntensity();
252 }
253 NapiUtil::SetPropertyInt32(env, info, "signalType", signalType);
254 NapiUtil::SetPropertyInt32(env, info, "signalLevel", signalLevel);
255 NapiUtil::SetPropertyInt32(env, info, "dBm", signalIntensity);
256 napi_set_element(env, callbackValue, i, info);
257 i++;
258 TELEPHONY_LOGI(
259 "GetSignalInfoListCallback signalType:%{public}d, signalIntensity:%{public}d, signalLevel:%{public}d",
260 signalType, signalIntensity, signalLevel);
261 }
262 } else {
263 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
264 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
265 }
266 if (asyncContext->signalInfoList.capacity() != 0) {
267 std::vector<sptr<SignalInformation>>().swap(asyncContext->signalInfoList);
268 }
269 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
270 TELEPHONY_LOGD("GetSignalInfoListCallback end");
271 }
272
MatchGetSignalInfoListParameter(napi_env env,napi_value parameter[],size_t parameterCount)273 static bool MatchGetSignalInfoListParameter(napi_env env, napi_value parameter[], size_t parameterCount)
274 {
275 switch (parameterCount) {
276 case PARAMETER_COUNT_ONE: {
277 return NapiUtil::MatchParameters(env, parameter, { napi_number });
278 }
279 case PARAMETER_COUNT_TWO: {
280 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_function });
281 }
282 default: {
283 return false;
284 }
285 }
286 }
287
GetSignalInfoList(napi_env env,napi_callback_info info)288 static napi_value GetSignalInfoList(napi_env env, napi_callback_info info)
289 {
290 size_t parameterCount = PARAMETER_COUNT_TWO;
291 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
292 napi_value thisVar = nullptr;
293 void *data = nullptr;
294 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
295 if (!MatchGetSignalInfoListParameter(env, parameters, parameterCount)) {
296 TELEPHONY_LOGE("GetSignalInfoList parameter matching failed.");
297 NapiUtil::ThrowParameterError(env);
298 return nullptr;
299 }
300 auto asyncContext = std::make_unique<SignalInfoListContext>();
301 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &(asyncContext->slotId)));
302 if (parameterCount == PARAMETER_COUNT_TWO) {
303 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
304 }
305 return NapiUtil::HandleAsyncWork(
306 env, asyncContext.release(), "GetSignalInfoList", NativeGetSignalInfoList, GetSignalInfoListCallback);
307 }
308
GetSignalInfoListSync(napi_env env,napi_callback_info info)309 static napi_value GetSignalInfoListSync(napi_env env, napi_callback_info info)
310 {
311 size_t parameterCount = 1;
312 napi_value parameters[] = { nullptr };
313 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
314 std::vector<sptr<SignalInformation>> signalInfoList;
315 napi_value value = nullptr;
316 if (parameterCount != 1) {
317 TELEPHONY_LOGE("parameter count is incorrect");
318 NAPI_CALL(env, napi_create_array(env, &value));
319 return value;
320 }
321 int32_t slotId = -1;
322 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
323 TELEPHONY_LOGE("convert parameter fail");
324 NAPI_CALL(env, napi_create_array(env, &value));
325 return value;
326 }
327 if (IsValidSlotId(slotId)) {
328 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSignalInfoList(slotId, signalInfoList);
329 }
330 napi_create_array(env, &value);
331 int i = 0;
332 for (sptr<SignalInformation> infoItem : signalInfoList) {
333 napi_value info = nullptr;
334 napi_create_object(env, &info);
335 int32_t signalType = static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN);
336 int32_t signalLevel = 0;
337 int32_t signalIntensity = 0;
338 if (infoItem != nullptr) {
339 signalType = WrapSignalInformationType(infoItem->GetNetworkType());
340 signalLevel = infoItem->GetSignalLevel();
341 signalIntensity = infoItem->GetSignalIntensity();
342 }
343 NapiUtil::SetPropertyInt32(env, info, "signalType", signalType);
344 NapiUtil::SetPropertyInt32(env, info, "signalLevel", signalLevel);
345 NapiUtil::SetPropertyInt32(env, info, "dBm", signalIntensity);
346 napi_set_element(env, value, i, info);
347 i++;
348 TELEPHONY_LOGI(
349 "GetSignalInfoListCallback signalType:%{public}d, signalIntensity:%{public}d, signalLevel:%{public}d",
350 signalType, signalIntensity, signalLevel);
351 }
352 return value;
353 }
354
WrapRegState(int32_t nativeState)355 static int32_t WrapRegState(int32_t nativeState)
356 {
357 RegServiceState state = static_cast<RegServiceState>(nativeState);
358 switch (state) {
359 case RegServiceState::REG_STATE_IN_SERVICE: {
360 return RegStatus::REGISTRATION_STATE_IN_SERVICE;
361 }
362 case RegServiceState::REG_STATE_EMERGENCY_ONLY: {
363 return RegStatus::REGISTRATION_STATE_EMERGENCY_CALL_ONLY;
364 }
365 case RegServiceState::REG_STATE_POWER_OFF: {
366 return RegStatus::REGISTRATION_STATE_POWER_OFF;
367 }
368 default:
369 return RegStatus::REGISTRATION_STATE_NO_SERVICE;
370 }
371 }
372
NativeGetNetworkState(napi_env env,void * data)373 static void NativeGetNetworkState(napi_env env, void *data)
374 {
375 auto asyncContext = static_cast<GetStateContext *>(data);
376 if (asyncContext == nullptr) {
377 return;
378 }
379 if (!IsValidSlotIdEx(asyncContext->slotId)) {
380 TELEPHONY_LOGE("NativeGetNetworkState slotId is invalid");
381 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
382 return;
383 }
384 sptr<NetworkState> networkState = nullptr;
385 int32_t slotId = asyncContext->slotId;
386 int32_t result = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNetworkState(slotId, networkState);
387 asyncContext->errorCode = result;
388 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
389 TELEPHONY_LOGE("NativeGetNetworkState errorCode = %{public}d", asyncContext->errorCode);
390 return;
391 }
392 if (networkState == nullptr) {
393 TELEPHONY_LOGE("NativeGetNetworkState networkState is nullptr");
394 asyncContext->errorCode = ERROR_NATIVE_API_EXECUTE_FAIL;
395 return;
396 }
397 asyncContext->resolved = true;
398 asyncContext->regStatus = static_cast<int32_t>(networkState->GetRegStatus());
399 asyncContext->longOperatorName = networkState->GetLongOperatorName();
400 asyncContext->shortOperatorName = networkState->GetShortOperatorName();
401 asyncContext->plmnNumeric = networkState->GetPlmnNumeric();
402 asyncContext->isRoaming = networkState->IsRoaming();
403 asyncContext->isEmergency = networkState->IsEmergency();
404 asyncContext->csRoamingStatus = static_cast<int32_t>(networkState->GetCsRoamingStatus());
405 asyncContext->psRoamingStatus = static_cast<int32_t>(networkState->GetPsRoamingStatus());
406 asyncContext->cfgTech = static_cast<int32_t>(networkState->GetCfgTech());
407 TELEPHONY_LOGD("NativeGetNetworkState resolved is true.");
408 }
409
GetNetworkStateCallback(napi_env env,napi_status status,void * data)410 static void GetNetworkStateCallback(napi_env env, napi_status status, void *data)
411 {
412 auto asyncContext = static_cast<GetStateContext *>(data);
413 napi_value callbackValue = nullptr;
414 if (asyncContext->resolved) {
415 napi_create_object(env, &callbackValue);
416 NapiUtil::SetPropertyStringUtf8(env, callbackValue, "longOperatorName", asyncContext->longOperatorName);
417 NapiUtil::SetPropertyStringUtf8(env, callbackValue, "shortOperatorName", asyncContext->shortOperatorName);
418 NapiUtil::SetPropertyStringUtf8(env, callbackValue, "plmnNumeric", asyncContext->plmnNumeric);
419 NapiUtil::SetPropertyBoolean(env, callbackValue, "isRoaming", asyncContext->isRoaming);
420 NapiUtil::SetPropertyInt32(env, callbackValue, "regState", WrapRegState(asyncContext->regStatus));
421 NapiUtil::SetPropertyInt32(env, callbackValue, "nsaState", asyncContext->nsaState);
422 NapiUtil::SetPropertyInt32(env, callbackValue, "cfgTech", WrapRadioTech(asyncContext->cfgTech));
423 NapiUtil::SetPropertyBoolean(env, callbackValue, "isCaActive", asyncContext->isCaActive);
424 NapiUtil::SetPropertyBoolean(env, callbackValue, "isEmergency", asyncContext->isEmergency);
425 } else {
426 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
427 asyncContext->errorCode, "getNetworkState", GET_NETWORK_INFO);
428 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
429 }
430 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
431 }
432
MatchGetNetworkStateParameter(napi_env env,napi_value parameter[],size_t parameterCount)433 static bool MatchGetNetworkStateParameter(napi_env env, napi_value parameter[], size_t parameterCount)
434 {
435 switch (parameterCount) {
436 case PARAMETER_COUNT_ZERO: {
437 return true;
438 }
439 case PARAMETER_COUNT_ONE: {
440 return NapiUtil::MatchParameters(env, parameter, { napi_number }) ||
441 NapiUtil::MatchParameters(env, parameter, { napi_function }) ||
442 NapiUtil::MatchParameters(env, parameter, { napi_null }) ||
443 NapiUtil::MatchParameters(env, parameter, { napi_undefined });
444 }
445 case PARAMETER_COUNT_TWO: {
446 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_function });
447 }
448 default: {
449 return false;
450 }
451 }
452 }
453
MatchGetIMEIParameter(napi_env env,napi_value parameter[],size_t parameterCount)454 static bool MatchGetIMEIParameter(napi_env env, napi_value parameter[], size_t parameterCount)
455 {
456 switch (parameterCount) {
457 case PARAMETER_COUNT_ZERO: {
458 return true;
459 }
460 case PARAMETER_COUNT_ONE: {
461 return NapiUtil::MatchParameters(env, parameter, { napi_number }) ||
462 NapiUtil::MatchParameters(env, parameter, { napi_function }) ||
463 NapiUtil::MatchParameters(env, parameter, { napi_null }) ||
464 NapiUtil::MatchParameters(env, parameter, { napi_undefined });
465 }
466 case PARAMETER_COUNT_TWO: {
467 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_function });
468 }
469 default: {
470 return false;
471 }
472 }
473 }
474
MatchGetNrOptionModeParameter(napi_env env,napi_value parameter[],size_t parameterCount)475 static bool MatchGetNrOptionModeParameter(napi_env env, napi_value parameter[], size_t parameterCount)
476 {
477 switch (parameterCount) {
478 case PARAMETER_COUNT_ZERO: {
479 return true;
480 }
481 case PARAMETER_COUNT_ONE: {
482 return NapiUtil::MatchParameters(env, parameter, { napi_number }) ||
483 NapiUtil::MatchParameters(env, parameter, { napi_function }) ||
484 NapiUtil::MatchParameters(env, parameter, { napi_null }) ||
485 NapiUtil::MatchParameters(env, parameter, { napi_undefined });
486 }
487 case PARAMETER_COUNT_TWO: {
488 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_function });
489 }
490 default: {
491 return false;
492 }
493 }
494 }
495
MatchFactoryResetParameter(napi_env env,napi_value parameter[],size_t parameterCount)496 static bool MatchFactoryResetParameter(napi_env env, napi_value parameter[], size_t parameterCount)
497 {
498 switch (parameterCount) {
499 case PARAMETER_COUNT_ONE: {
500 return NapiUtil::MatchParameters(env, parameter, { napi_number });
501 }
502 default: {
503 return false;
504 }
505 }
506 }
507
MatchSetNrOptionModeParameter(napi_env env,napi_value parameter[],size_t parameterCount)508 static bool MatchSetNrOptionModeParameter(napi_env env, napi_value parameter[], size_t parameterCount)
509 {
510 switch (parameterCount) {
511 case PARAMETER_COUNT_TWO: {
512 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_number });
513 }
514 case PARAMETER_COUNT_THREE: {
515 return NapiUtil::MatchParameters(env, parameter, { napi_number, napi_number, napi_function });
516 }
517 default: {
518 return false;
519 }
520 }
521 }
522
MatchIsNrSupportedParameter(napi_env env,napi_value parameter[],size_t parameterCount)523 static bool MatchIsNrSupportedParameter(napi_env env, napi_value parameter[], size_t parameterCount)
524 {
525 switch (parameterCount) {
526 case PARAMETER_COUNT_ZERO: {
527 return true;
528 }
529 case PARAMETER_COUNT_ONE: {
530 return NapiUtil::MatchParameters(env, parameter, { napi_number });
531 }
532 default: {
533 return false;
534 }
535 }
536 }
537
GetNetworkState(napi_env env,napi_callback_info info)538 static napi_value GetNetworkState(napi_env env, napi_callback_info info)
539 {
540 size_t parameterCount = PARAMETER_COUNT_TWO;
541 napi_value parameters[PARAMETER_COUNT_TWO] = {0};
542 napi_value thisVar = nullptr;
543 void *data = nullptr;
544 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
545 if (!MatchGetNetworkStateParameter(env, parameters, parameterCount)) {
546 TELEPHONY_LOGE("parameter matching failed.");
547 NapiUtil::ThrowParameterError(env);
548 return nullptr;
549 }
550 auto asyncContext = std::make_unique<GetStateContext>();
551 if (parameterCount == PARAMETER_COUNT_ZERO) {
552 asyncContext->slotId = GetDefaultSlotId();
553 } else if (parameterCount == PARAMETER_COUNT_ONE) {
554 napi_valuetype valueType = napi_undefined;
555 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
556 if (valueType == napi_undefined || valueType == napi_null) {
557 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
558 asyncContext->slotId = GetDefaultSlotId();
559 } else if (valueType == napi_number) {
560 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
561 } else if (valueType == napi_function) {
562 asyncContext->slotId = GetDefaultSlotId();
563 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
564 }
565 } else if (parameterCount == PARAMETER_COUNT_TWO) {
566 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
567 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
568 }
569 return NapiUtil::HandleAsyncWork(
570 env, asyncContext.release(), "GetNetworkState", NativeGetNetworkState, GetNetworkStateCallback);
571 }
572
NativeGetNetworkSelectionMode(napi_env env,void * data)573 static void NativeGetNetworkSelectionMode(napi_env env, void *data)
574 {
575 auto asyncContext = static_cast<GetSelectModeContext *>(data);
576 if (!IsValidSlotId(asyncContext->slotId)) {
577 TELEPHONY_LOGE("NativeGetNetworkSelectionMode slotId is invalid");
578 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
579 return;
580 }
581 std::unique_ptr<GetNetworkSearchModeCallback> callback =
582 std::make_unique<GetNetworkSearchModeCallback>(asyncContext);
583 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
584 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNetworkSelectionMode(
585 asyncContext->slotId, callback.release());
586 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
587 asyncContext->cv.wait_for(
588 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
589 TELEPHONY_LOGI("NativeGetNetworkSelectionMode after callback end");
590 }
591 TELEPHONY_LOGI("NativeGetNetworkSelectionMode end");
592 }
593
GetNetworkSelectionModeCallback(napi_env env,napi_status status,void * data)594 static void GetNetworkSelectionModeCallback(napi_env env, napi_status status, void *data)
595 {
596 auto asyncContext = static_cast<GetSelectModeContext *>(data);
597 napi_value callbackValue = nullptr;
598 if (asyncContext->resolved) {
599 napi_create_int32(env, asyncContext->selectMode, &callbackValue);
600 } else {
601 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
602 TELEPHONY_LOGE("GetNetworkSelectionModeCallback time out, errorCode = %{public}d", asyncContext->errorCode);
603 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
604 }
605 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
606 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
607 }
608 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
609 TELEPHONY_LOGI("GetNetworkSelectionModeCallback end");
610 }
611
GetNetworkSelectionMode(napi_env env,napi_callback_info info)612 static napi_value GetNetworkSelectionMode(napi_env env, napi_callback_info info)
613 {
614 size_t parameterCount = PARAMETER_COUNT_TWO;
615 napi_value parameters[PARAMETER_COUNT_TWO] = {0};
616 napi_value thisVar;
617 void *data;
618 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
619 if (!MatchGetRadioTechParameter(env, parameters, parameterCount)) {
620 TELEPHONY_LOGE("GetNetworkSelectionMode parameter matching failed.");
621 NapiUtil::ThrowParameterError(env);
622 return nullptr;
623 }
624 auto asyncContext = std::make_unique<GetSelectModeContext>();
625 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
626 if (parameterCount == PARAMETER_COUNT_TWO) {
627 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
628 }
629 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "GetNetworkSelectionMode",
630 NativeGetNetworkSelectionMode, GetNetworkSelectionModeCallback);
631 }
632
NativeGetNetworkSearchInformation(napi_env env,void * data)633 static void NativeGetNetworkSearchInformation(napi_env env, void *data)
634 {
635 auto asyncContext = static_cast<GetSearchInfoContext *>(data);
636 if (!IsValidSlotId(asyncContext->slotId)) {
637 TELEPHONY_LOGE("NativeGetNetworkSearchInformation slotId is invalid");
638 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
639 return;
640 }
641 std::unique_ptr<GetNetworkSearchInfoCallback> callback =
642 std::make_unique<GetNetworkSearchInfoCallback>(asyncContext);
643 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
644 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNetworkSearchInformation(
645 asyncContext->slotId, callback.release());
646 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
647 asyncContext->cv.wait_for(callbackLock, std::chrono::seconds(WAIT_NETWORK_MANUAL_SEARCH_TIME_SECOND),
648 [asyncContext] { return asyncContext->callbackEnd; });
649 TELEPHONY_LOGI("NativeGetNetworkSearchInformation after callback end");
650 }
651 TELEPHONY_LOGI("NativeGetNetworkSearchInformation end");
652 }
653
WrapToJsPlmnState(int32_t nativeState)654 static int32_t WrapToJsPlmnState(int32_t nativeState)
655 {
656 NetworkPlmnState state = static_cast<NetworkPlmnState>(nativeState);
657 switch (state) {
658 case NetworkPlmnState::NETWORK_PLMN_STATE_AVAILABLE: {
659 return NETWORK_AVAILABLE;
660 }
661 case NetworkPlmnState::NETWORK_PLMN_STATE_REGISTERED: {
662 return NETWORK_CURRENT;
663 }
664 case NetworkPlmnState::NETWORK_PLMN_STATE_FORBIDDEN: {
665 return NETWORK_FORBIDDEN;
666 }
667 default: {
668 return NETWORK_UNKNOWN;
669 }
670 }
671 }
672
GetRadioTechName(int32_t radioTech)673 static std::string GetRadioTechName(int32_t radioTech)
674 {
675 NetworkRat tech = static_cast<NetworkRat>(radioTech);
676 switch (tech) {
677 case NetworkRat::NETWORK_GSM_OR_GPRS: {
678 return "GSM";
679 }
680 case NetworkRat::NETWORK_WCDMA: {
681 return "WCDMA";
682 }
683 case NetworkRat::NETWORK_LTE: {
684 return "LTE";
685 }
686 case NetworkRat::NETWORK_NR: {
687 return "NR";
688 }
689 default: {
690 return "";
691 }
692 }
693 }
694
GetNetworkSearchInformationCallback(napi_env env,napi_status status,void * data)695 static void GetNetworkSearchInformationCallback(napi_env env, napi_status status, void *data)
696 {
697 auto asyncContext = static_cast<GetSearchInfoContext *>(data);
698 napi_value callbackValue = nullptr;
699 if (asyncContext->resolved) {
700 int32_t searchResultSize = asyncContext->searchResult->GetNetworkSearchInformationSize();
701 TELEPHONY_LOGI("GetNetworkSearchInformationCallback SearchResultSize = %{public}d", searchResultSize);
702 napi_create_object(env, &callbackValue);
703 bool isNetworkSearchSuccess = searchResultSize > 0;
704 NapiUtil::SetPropertyBoolean(env, callbackValue, "isNetworkSearchSuccess", isNetworkSearchSuccess);
705 napi_value searchResultArray = nullptr;
706 napi_create_array(env, &searchResultArray);
707 std::vector<NetworkInformation> resultList = asyncContext->searchResult->GetNetworkSearchInformation();
708 int32_t resultListSize = static_cast<int32_t>(resultList.size());
709 TELEPHONY_LOGI("GetNetworkSearchInformationCallback SearchResultSize = %{public}d", searchResultSize);
710 for (int32_t i = 0; i < resultListSize; i++) {
711 napi_value info = nullptr;
712 napi_create_object(env, &info);
713 NapiUtil::SetPropertyStringUtf8(env, info, "operatorName", resultList[i].GetOperatorLongName());
714 NapiUtil::SetPropertyStringUtf8(env, info, "operatorNumeric", resultList[i].GetOperatorNumeric());
715 NapiUtil::SetPropertyInt32(env, info, "state", WrapToJsPlmnState(resultList[i].GetNetworkState()));
716 NapiUtil::SetPropertyStringUtf8(env, info, "radioTech", GetRadioTechName(resultList[i].GetRadioTech()));
717 napi_set_element(env, searchResultArray, i, info);
718 }
719 napi_set_named_property(env, callbackValue, "networkSearchResult", searchResultArray);
720 } else {
721 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
722 TELEPHONY_LOGE(
723 "GetNetworkSearchInformationCallback time out, errorCode = %{public}d", asyncContext->errorCode);
724 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
725 }
726 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
727 asyncContext->errorCode, "getNetworkSearchInformation", GET_TELEPHONY_STATE);
728 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
729 }
730 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
731 TELEPHONY_LOGI("GetNetworkSearchInformationCallback end");
732 }
733
MatchGetNetworkSearchInformation(napi_env env,const napi_value parameters[],size_t parameterCount)734 static bool MatchGetNetworkSearchInformation(napi_env env, const napi_value parameters[], size_t parameterCount)
735 {
736 switch (parameterCount) {
737 case PARAMETER_COUNT_ONE: {
738 return NapiUtil::MatchParameters(env, parameters, { napi_number });
739 }
740 case PARAMETER_COUNT_TWO: {
741 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
742 }
743 default: {
744 return false;
745 }
746 }
747 }
748
GetNetworkSearchInformation(napi_env env,napi_callback_info info)749 static napi_value GetNetworkSearchInformation(napi_env env, napi_callback_info info)
750 {
751 size_t parameterCount = PARAMETER_COUNT_TWO;
752 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
753 napi_value thisVar;
754 void *data;
755 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
756 if (!MatchGetNetworkSearchInformation(env, parameters, parameterCount)) {
757 TELEPHONY_LOGE("GetNetworkSearchInformation parameter matching failed.");
758 NapiUtil::ThrowParameterError(env);
759 return nullptr;
760 }
761 auto asyncContext = std::make_unique<GetSearchInfoContext>().release();
762 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
763 if (parameterCount == PARAMETER_COUNT_TWO) {
764 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
765 }
766 return NapiUtil::HandleAsyncWork(env, asyncContext, "GetNetworkSearchInformation",
767 NativeGetNetworkSearchInformation, GetNetworkSearchInformationCallback);
768 }
769
HasNamedPropertyType(napi_env env,napi_value object,napi_valuetype type,const std::string & propertyName)770 static bool HasNamedPropertyType(napi_env env, napi_value object, napi_valuetype type, const std::string &propertyName)
771 {
772 bool hasProperty = false;
773 napi_has_named_property(env, object, propertyName.c_str(), &hasProperty);
774 if (hasProperty) {
775 napi_value value = nullptr;
776 napi_get_named_property(env, object, propertyName.c_str(), &value);
777 return NapiUtil::MatchValueType(env, value, type);
778 }
779 return false;
780 }
781
GetStringProperty(napi_env env,napi_value object,const std::string & propertyName)782 static std::string GetStringProperty(napi_env env, napi_value object, const std::string &propertyName)
783 {
784 napi_value value = nullptr;
785 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
786 if (getNameStatus == napi_ok) {
787 char chars[BUF_SIZE] = { 0 };
788 size_t charLength = 0;
789 napi_status getStringStatus = napi_get_value_string_utf8(env, value, chars, BUF_SIZE, &charLength);
790 if (getStringStatus == napi_ok && charLength > 0) {
791 return std::string(chars, charLength);
792 }
793 }
794 return "";
795 }
796
GetNamedProperty(napi_env env,napi_value object,const std::string & propertyName)797 static napi_value GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName)
798 {
799 napi_value value = nullptr;
800 napi_get_named_property(env, object, propertyName.c_str(), &value);
801 return value;
802 }
803
MatchSetNetworkSelectionModeParameters(napi_env env,napi_value parameters[],size_t parameterCount)804 static bool MatchSetNetworkSelectionModeParameters(napi_env env, napi_value parameters[], size_t parameterCount)
805 {
806 TELEPHONY_LOGI("start MatchSetNetworkSelectionModeParameters parameterCount = %{public}lu",
807 static_cast<unsigned long>(parameterCount));
808 switch (parameterCount) {
809 case PARAMETER_COUNT_ONE: {
810 if (!NapiUtil::MatchParameters(env, parameters, { napi_object })) {
811 return false;
812 }
813 break;
814 }
815 case PARAMETER_COUNT_TWO: {
816 if (!NapiUtil::MatchParameters(env, parameters, { napi_object, napi_function })) {
817 TELEPHONY_LOGI("start MatchSetNetworkSelectionModeParameters not match two parameter");
818 return false;
819 }
820 break;
821 }
822 default:
823 return false;
824 }
825 bool hasSlotId = HasNamedPropertyType(env, parameters[0], napi_number, "slotId");
826 bool hasSelectMode = HasNamedPropertyType(env, parameters[0], napi_number, "selectMode");
827 bool hasNetworkInformation = HasNamedPropertyType(env, parameters[0], napi_object, "networkInformation");
828 bool hasResumeSelection = HasNamedPropertyType(env, parameters[0], napi_boolean, "resumeSelection");
829 if (hasSlotId && hasSelectMode && hasNetworkInformation && hasResumeSelection) {
830 napi_value networkInfoValue = GetNamedProperty(env, parameters[0], "networkInformation");
831 if (networkInfoValue != nullptr) {
832 bool hasOperatorName = HasNamedPropertyType(env, networkInfoValue, napi_string, "operatorName");
833 bool hasOperatorNumeric = HasNamedPropertyType(env, networkInfoValue, napi_string, "operatorNumeric");
834 bool hasState = HasNamedPropertyType(env, networkInfoValue, napi_number, "state");
835 bool hasRadioTech = HasNamedPropertyType(env, networkInfoValue, napi_string, "radioTech");
836 return hasOperatorName && hasOperatorNumeric && hasState && hasRadioTech;
837 }
838 }
839 return false;
840 }
841
WrapJsSelectMode(int32_t jsSelectMode)842 static int32_t WrapJsSelectMode(int32_t jsSelectMode)
843 {
844 switch (jsSelectMode) {
845 case NETWORK_SELECTION_AUTOMATIC:
846 return NATIVE_NETWORK_SELECTION_AUTOMATIC;
847 case NETWORK_SELECTION_MANUAL:
848 return NATIVE_NETWORK_SELECTION_MANUAL;
849 default:
850 return DEFAULT_ERROR;
851 }
852 }
853
GetRatTechValue(std::string ratTechStr)854 static int32_t GetRatTechValue(std::string ratTechStr)
855 {
856 if (!GSM.compare(ratTechStr) || !GPRS.compare(ratTechStr)) {
857 return static_cast<int32_t>(NetworkRat::NETWORK_GSM_OR_GPRS);
858 }
859 if (!WCDMA.compare(ratTechStr)) {
860 return static_cast<int32_t>(NetworkRat::NETWORK_WCDMA);
861 }
862 if (!LTE.compare(ratTechStr)) {
863 return static_cast<int32_t>(NetworkRat::NETWORK_LTE);
864 }
865 if (!NR.compare(ratTechStr)) {
866 return static_cast<int32_t>(NetworkRat::NETWORK_NR);
867 }
868 return static_cast<int32_t>(NetworkRat::NETWORK_LTE);
869 }
870
WrapPlmnState(int32_t jsState)871 static int32_t WrapPlmnState(int32_t jsState)
872 {
873 switch (jsState) {
874 case NETWORK_AVAILABLE: {
875 return static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_AVAILABLE);
876 }
877 case NETWORK_CURRENT: {
878 return static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_REGISTERED);
879 }
880 case NETWORK_FORBIDDEN: {
881 return static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_FORBIDDEN);
882 }
883 default: {
884 return static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_UNKNOWN);
885 }
886 }
887 }
888
NativeSetNetworkSelectionMode(napi_env env,void * data)889 static void NativeSetNetworkSelectionMode(napi_env env, void *data)
890 {
891 auto asyncContext = static_cast<SetSelectModeContext *>(data);
892 if (!IsValidSlotId(asyncContext->slotId)) {
893 TELEPHONY_LOGE("NativeSetNetworkSelectionMode slotId is invalid");
894 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
895 return;
896 }
897 TELEPHONY_LOGI("NativeSetNetworkSelectionMode selectMode = %{public}d", asyncContext->selectMode);
898 sptr<NetworkInformation> networkInfo = std::make_unique<NetworkInformation>().release();
899 networkInfo->SetOperateInformation(asyncContext->operatorName, "", asyncContext->operatorNumeric,
900 WrapPlmnState(asyncContext->state), GetRatTechValue(asyncContext->radioTech));
901 TELEPHONY_LOGI("NativeSetNetworkSelectionMode operatorName = %{public}s", asyncContext->operatorName.c_str());
902 std::unique_ptr<SetNetworkSearchModeCallback> callback =
903 std::make_unique<SetNetworkSearchModeCallback>(asyncContext);
904 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
905 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetNetworkSelectionMode(
906 asyncContext->slotId, asyncContext->selectMode, networkInfo, asyncContext->resumeSelection, callback.release());
907 TELEPHONY_LOGI("NativeSetNetworkSelectionMode errorCode = %{public}d", asyncContext->errorCode);
908 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
909 asyncContext->cv.wait_for(
910 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
911 TELEPHONY_LOGI("NativeSetNetworkSelectionMode after callback end");
912 }
913 TELEPHONY_LOGI("NativeSetNetworkSelectionMode end");
914 }
915
SetNetworkSelectionModeCallback(napi_env env,napi_status status,void * data)916 static void SetNetworkSelectionModeCallback(napi_env env, napi_status status, void *data)
917 {
918 auto asyncContext = static_cast<SetSelectModeContext *>(data);
919 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
920 asyncContext->resolved = asyncContext->setResult;
921 }
922 TELEPHONY_LOGI("SetNetworkSelectionModeCallback resolved = %{public}d", asyncContext->resolved);
923 napi_value callbackValue = nullptr;
924 if (asyncContext->resolved) {
925 napi_get_undefined(env, &callbackValue);
926 } else {
927 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
928 TELEPHONY_LOGE("SetNetworkSelectionModeCallback time out, errorCode = %{public}d", asyncContext->errorCode);
929 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
930 }
931 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
932 asyncContext->errorCode, "setNetworkSelectionMode", SET_TELEPHONY_STATE);
933 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
934 }
935 NapiUtil::Handle1ValueCallback(env, asyncContext, callbackValue);
936 TELEPHONY_LOGI("SetNetworkSelectionModeCallback end");
937 }
938
ParseNetworkSelectionParameter(napi_env env,napi_value object,SetSelectModeContext & context)939 static void ParseNetworkSelectionParameter(napi_env env, napi_value object, SetSelectModeContext &context)
940 {
941 napi_value slotIdValue = GetNamedProperty(env, object, "slotId");
942 if (slotIdValue != nullptr) {
943 napi_get_value_int32(env, slotIdValue, &context.slotId);
944 }
945 int32_t jsSelectMode = static_cast<int32_t>(NETWORK_SELECTION_UNKNOWN);
946 napi_value selecModeValue = GetNamedProperty(env, object, "selectMode");
947 if (selecModeValue != nullptr) {
948 napi_get_value_int32(env, selecModeValue, &jsSelectMode);
949 }
950 TELEPHONY_LOGI("ParseNetworkSelectionParameter jsSelectMode = %{public}d", jsSelectMode);
951 context.selectMode = WrapJsSelectMode(jsSelectMode);
952 napi_value resumeValue = GetNamedProperty(env, object, "resumeSelection");
953 if (resumeValue != nullptr) {
954 napi_get_value_bool(env, resumeValue, &context.resumeSelection);
955 }
956 napi_value networkInfoValue = GetNamedProperty(env, object, "networkInformation");
957 if (networkInfoValue != nullptr) {
958 context.operatorName = GetStringProperty(env, networkInfoValue, "operatorName");
959 context.operatorNumeric = GetStringProperty(env, networkInfoValue, "operatorNumeric");
960 napi_value stateValue = GetNamedProperty(env, networkInfoValue, "state");
961 if (stateValue != nullptr) {
962 napi_get_value_int32(env, stateValue, &context.state);
963 }
964 context.radioTech = GetStringProperty(env, networkInfoValue, "radioTech");
965 }
966 TELEPHONY_LOGI("ParseNetworkSelectionParameter end");
967 }
968
SetNetworkSelectionMode(napi_env env,napi_callback_info info)969 static napi_value SetNetworkSelectionMode(napi_env env, napi_callback_info info)
970 {
971 size_t parameterCount = PARAMETER_COUNT_TWO;
972 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
973 napi_value thisVar;
974 void *data;
975 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
976 if (!MatchSetNetworkSelectionModeParameters(env, parameters, parameterCount)) {
977 TELEPHONY_LOGE("SetNetworkSelectionMode parameter matching failed.");
978 NapiUtil::ThrowParameterError(env);
979 return nullptr;
980 }
981 auto asyncContext = std::make_unique<SetSelectModeContext>();
982 ParseNetworkSelectionParameter(env, parameters[0], *asyncContext);
983 if (parameterCount == PARAMETER_COUNT_TWO) {
984 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
985 }
986 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "SetNetworkSelectionMode",
987 NativeSetNetworkSelectionMode, SetNetworkSelectionModeCallback);
988 }
989
NativeGetCountryCode(napi_env env,void * data)990 static void NativeGetCountryCode(napi_env env, void *data)
991 {
992 auto context = static_cast<GetISOCountryCodeContext *>(data);
993 if (!IsValidSlotId(context->slotId)) {
994 TELEPHONY_LOGE("NativeGetCountryCode slotId is invalid");
995 context->errorCode = ERROR_SLOT_ID_INVALID;
996 return;
997 }
998 std::u16string countryCode;
999 context->errorCode =
1000 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetIsoCountryCodeForNetwork(context->slotId, countryCode);
1001 context->countryCode = NapiUtil::ToUtf8(countryCode);
1002 TELEPHONY_LOGI("NativeGetCountryCode countryCode = %{public}s", context->countryCode.c_str());
1003 if (context->errorCode == TELEPHONY_SUCCESS) {
1004 context->resolved = true;
1005 }
1006 }
1007
GetCountryCodeCallback(napi_env env,napi_status status,void * data)1008 static void GetCountryCodeCallback(napi_env env, napi_status status, void *data)
1009 {
1010 auto context = static_cast<GetISOCountryCodeContext *>(data);
1011 napi_value callbackValue = nullptr;
1012 if (context->resolved) {
1013 napi_create_string_utf8(env, context->countryCode.c_str(), context->countryCode.size(), &callbackValue);
1014 } else {
1015 JsError error = NapiUtil::ConverErrorMessageForJs(context->errorCode);
1016 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1017 }
1018 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1019 }
1020
MatchGetISOCountryCodeForNetworkParameter(napi_env env,napi_value parameters[],size_t parameterCount)1021 static bool MatchGetISOCountryCodeForNetworkParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1022 {
1023 switch (parameterCount) {
1024 case PARAMETER_COUNT_ONE: {
1025 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1026 }
1027 case PARAMETER_COUNT_TWO: {
1028 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1029 }
1030 default:
1031 return false;
1032 }
1033 }
1034
GetISOCountryCodeForNetwork(napi_env env,napi_callback_info info)1035 static napi_value GetISOCountryCodeForNetwork(napi_env env, napi_callback_info info)
1036 {
1037 size_t parameterCount = PARAMETER_COUNT_TWO;
1038 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1039 napi_value thisVar;
1040 void *data;
1041 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1042 if (!MatchGetISOCountryCodeForNetworkParameter(env, parameters, parameterCount)) {
1043 TELEPHONY_LOGE("GetISOCountryCodeForNetwork parameter matching failed.");
1044 NapiUtil::ThrowParameterError(env);
1045 return nullptr;
1046 }
1047 auto asyncContext = std::make_unique<GetISOCountryCodeContext>();
1048 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1049 if (parameterCount == PARAMETER_COUNT_TWO) {
1050 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1051 }
1052 return NapiUtil::HandleAsyncWork(
1053 env, asyncContext.release(), "GetISOCountryCodeForNetwork", NativeGetCountryCode, GetCountryCodeCallback);
1054 }
1055
GetISOCountryCodeForNetworkSync(napi_env env,napi_callback_info info)1056 static napi_value GetISOCountryCodeForNetworkSync(napi_env env, napi_callback_info info)
1057 {
1058 size_t parameterCount = PARAMETER_COUNT_ONE;
1059 napi_value parameters[] = { nullptr };
1060 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
1061 std::u16string countryCode;
1062 napi_value value = nullptr;
1063 if (parameterCount != 1) {
1064 TELEPHONY_LOGE("parameter count is incorrect");
1065 std::string code = NapiUtil::ToUtf8(countryCode);
1066 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
1067 return value;
1068 }
1069 int32_t slotId = -1;
1070 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
1071 TELEPHONY_LOGE("convert parameter fail");
1072 std::string code = NapiUtil::ToUtf8(countryCode);
1073 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
1074 return value;
1075 }
1076 if (IsValidSlotId(slotId)) {
1077 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetIsoCountryCodeForNetwork(slotId, countryCode);
1078 }
1079 std::string code = NapiUtil::ToUtf8(countryCode);
1080 NAPI_CALL(env, napi_create_string_utf8(env, code.c_str(), code.length(), &value));
1081 return value;
1082 }
1083
MatchIsRadioOnParameter(napi_env env,napi_value parameters[],size_t parameterCount)1084 static bool MatchIsRadioOnParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1085 {
1086 switch (parameterCount) {
1087 case PARAMETER_COUNT_ZERO: {
1088 return true;
1089 }
1090 case PARAMETER_COUNT_ONE: {
1091 return NapiUtil::MatchParameters(env, parameters, { napi_function }) ||
1092 NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1093 NapiUtil::MatchParameters(env, parameters, { napi_null }) ||
1094 NapiUtil::MatchParameters(env, parameters, { napi_undefined });
1095 }
1096 case PARAMETER_COUNT_TWO: {
1097 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1098 }
1099 default:
1100 return false;
1101 }
1102 }
1103
NativeIsRadioOn(napi_env env,void * data)1104 static void NativeIsRadioOn(napi_env env, void *data)
1105 {
1106 auto asyncContext = static_cast<IsRadioOnContext *>(data);
1107 if (!IsValidSlotId(asyncContext->slotId)) {
1108 TELEPHONY_LOGE("NativeIsRadioOn slotId is invalid");
1109 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1110 return;
1111 }
1112 std::unique_ptr<GetRadioStateCallback> callback = std::make_unique<GetRadioStateCallback>(asyncContext);
1113 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
1114 asyncContext->errorCode =
1115 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetRadioState(asyncContext->slotId, callback.release());
1116 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1117 asyncContext->cv.wait_for(
1118 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
1119 TELEPHONY_LOGI("NativeIsRadioOn after callback end");
1120 }
1121 TELEPHONY_LOGI("NativeIsRadioOn end");
1122 }
1123
IsRadioOnCallback(napi_env env,napi_status status,void * data)1124 static void IsRadioOnCallback(napi_env env, napi_status status, void *data)
1125 {
1126 auto asyncContext = static_cast<IsRadioOnContext *>(data);
1127 napi_value callbackValue = nullptr;
1128 if (asyncContext->resolved) {
1129 napi_get_boolean(env, asyncContext->isRadioOn, &callbackValue);
1130 } else {
1131 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1132 TELEPHONY_LOGE("IsRadioOnCallback time out, errorCode = %{public}d", asyncContext->errorCode);
1133 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
1134 }
1135 JsError error =
1136 NapiUtil::ConverErrorMessageWithPermissionForJs(asyncContext->errorCode, "isRadioOn", GET_NETWORK_INFO);
1137 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1138 }
1139 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
1140 TELEPHONY_LOGI("IsRadioOnCallback end");
1141 }
1142
IsRadioOn(napi_env env,napi_callback_info info)1143 static napi_value IsRadioOn(napi_env env, napi_callback_info info)
1144 {
1145 size_t parameterCount = PARAMETER_COUNT_TWO;
1146 napi_value parameters[PARAMETER_COUNT_TWO] = {0};
1147 napi_value thisVar = nullptr;
1148 void *data = nullptr;
1149 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1150 if (!MatchIsRadioOnParameter(env, parameters, parameterCount)) {
1151 TELEPHONY_LOGE("parameter matching failed.");
1152 NapiUtil::ThrowParameterError(env);
1153 return nullptr;
1154 }
1155 auto asyncContext = std::make_unique<IsRadioOnContext>();
1156 if (asyncContext == nullptr) {
1157 TELEPHONY_LOGE("asyncContext is nullptr.");
1158 NapiUtil::ThrowParameterError(env);
1159 return nullptr;
1160 }
1161 if (parameterCount == PARAMETER_COUNT_ZERO) {
1162 asyncContext->slotId = GetDefaultSlotId();
1163 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1164 napi_valuetype valueType = napi_undefined;
1165 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1166 if (valueType == napi_undefined || valueType == napi_null) {
1167 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1168 asyncContext->slotId = GetDefaultSlotId();
1169 } else if (valueType == napi_number) {
1170 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1171 TELEPHONY_LOGI("context->slotId = %{public}d", asyncContext->slotId);
1172 } else if (valueType == napi_function) {
1173 asyncContext->slotId = GetDefaultSlotId();
1174 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1175 }
1176 } else if (parameterCount == PARAMETER_COUNT_TWO) {
1177 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1178 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1179 }
1180 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "IsRadioOn", NativeIsRadioOn, IsRadioOnCallback);
1181 }
1182
NativeTurnOnRadio(napi_env env,void * data)1183 static void NativeTurnOnRadio(napi_env env, void *data)
1184 {
1185 auto asyncContext = static_cast<SwitchRadioContext *>(data);
1186 if (!IsValidSlotId(asyncContext->slotId)) {
1187 TELEPHONY_LOGE("NativeTurnOnRadio slotId is invalid");
1188 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1189 return;
1190 }
1191 std::unique_ptr<SetRadioStateCallback> callback = std::make_unique<SetRadioStateCallback>(asyncContext);
1192 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
1193 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetRadioState(
1194 asyncContext->slotId, true, callback.release());
1195 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1196 asyncContext->cv.wait_for(
1197 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
1198 TELEPHONY_LOGI("NativeTurnOnRadio after callback end");
1199 }
1200 TELEPHONY_LOGI("NativeTurnOnRadio end");
1201 }
1202
TurnOnRadioCallback(napi_env env,napi_status status,void * data)1203 static void TurnOnRadioCallback(napi_env env, napi_status status, void *data)
1204 {
1205 auto asyncContext = static_cast<SwitchRadioContext *>(data);
1206 napi_value callbackValue = nullptr;
1207 if (asyncContext->resolved) {
1208 napi_get_undefined(env, &callbackValue);
1209 } else {
1210 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1211 TELEPHONY_LOGE("TurnOnRadioCallback time out, errorCode = %{public}d", asyncContext->errorCode);
1212 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
1213 }
1214 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1215 asyncContext->errorCode, "turnOnRadio", SET_TELEPHONY_STATE);
1216 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1217 }
1218 NapiUtil::Handle1ValueCallback(env, asyncContext, callbackValue);
1219 TELEPHONY_LOGI("TurnOnRadioCallback end");
1220 }
1221
MatchSwitchRadioParameter(napi_env env,napi_value parameters[],size_t parameterCount)1222 static bool MatchSwitchRadioParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1223 {
1224 switch (parameterCount) {
1225 case PARAMETER_COUNT_ZERO: {
1226 return true;
1227 }
1228 case PARAMETER_COUNT_ONE: {
1229 return NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1230 NapiUtil::MatchParameters(env, parameters, { napi_function });
1231 }
1232 case PARAMETER_COUNT_TWO: {
1233 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1234 }
1235 default:
1236 return false;
1237 }
1238 }
1239
TurnOnRadio(napi_env env,napi_callback_info info)1240 static napi_value TurnOnRadio(napi_env env, napi_callback_info info)
1241 {
1242 size_t parameterCount = PARAMETER_COUNT_TWO;
1243 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1244 napi_value thisVar = nullptr;
1245 void *data = nullptr;
1246 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1247 if (!MatchIsRadioOnParameter(env, parameters, parameterCount)) {
1248 TELEPHONY_LOGE("parameter matching failed.");
1249 NapiUtil::ThrowParameterError(env);
1250 return nullptr;
1251 }
1252 auto asyncContext = std::make_unique<SwitchRadioContext>();
1253 if (parameterCount == PARAMETER_COUNT_ZERO) {
1254 asyncContext->slotId = GetDefaultSlotId();
1255 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1256 napi_valuetype valueType = napi_undefined;
1257 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1258 if (valueType == napi_undefined || valueType == napi_null) {
1259 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1260 asyncContext->slotId = GetDefaultSlotId();
1261 } else if (valueType == napi_number) {
1262 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1263 TELEPHONY_LOGI("context->slotId = %{public}d", asyncContext->slotId);
1264 } else {
1265 asyncContext->slotId = GetDefaultSlotId();
1266 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1267 }
1268 } else {
1269 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1270 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1271 }
1272 return NapiUtil::HandleAsyncWork(
1273 env, asyncContext.release(), "TurnOnRadio", NativeTurnOnRadio, TurnOnRadioCallback);
1274 }
1275
NativeTurnOffRadio(napi_env env,void * data)1276 static void NativeTurnOffRadio(napi_env env, void *data)
1277 {
1278 auto asyncContext = static_cast<SwitchRadioContext *>(data);
1279 if (!IsValidSlotId(asyncContext->slotId)) {
1280 TELEPHONY_LOGE("NativeTurnOffRadio slotId is invalid");
1281 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1282 return;
1283 }
1284 std::unique_ptr<SetRadioStateCallback> callback = std::make_unique<SetRadioStateCallback>(asyncContext);
1285 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
1286 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetRadioState(
1287 asyncContext->slotId, false, callback.release());
1288 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1289 asyncContext->cv.wait_for(
1290 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
1291 TELEPHONY_LOGI("NativeTurnOffRadio after callback end");
1292 }
1293 TELEPHONY_LOGI("NativeTurnOffRadio end");
1294 }
1295
TurnOffRadioCallback(napi_env env,napi_status status,void * data)1296 static void TurnOffRadioCallback(napi_env env, napi_status status, void *data)
1297 {
1298 auto asyncContext = static_cast<SwitchRadioContext *>(data);
1299 napi_value callbackValue = nullptr;
1300 if (asyncContext->resolved) {
1301 napi_get_undefined(env, &callbackValue);
1302 } else {
1303 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1304 TELEPHONY_LOGE("TurnOffRadioCallback time out, errorCode = %{public}d", asyncContext->errorCode);
1305 asyncContext->errorCode = TELEPHONY_ERR_FAIL;
1306 }
1307 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1308 asyncContext->errorCode, "turnOffRadio", SET_TELEPHONY_STATE);
1309 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1310 }
1311 NapiUtil::Handle1ValueCallback(env, asyncContext, callbackValue);
1312 TELEPHONY_LOGI("TurnOffRadioCallback end");
1313 }
1314
TurnOffRadio(napi_env env,napi_callback_info info)1315 static napi_value TurnOffRadio(napi_env env, napi_callback_info info)
1316 {
1317 size_t parameterCount = PARAMETER_COUNT_TWO;
1318 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1319 napi_value thisVar = nullptr;
1320 void *data = nullptr;
1321 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1322 if (!MatchIsRadioOnParameter(env, parameters, parameterCount)) {
1323 TELEPHONY_LOGE("parameter matching failed.");
1324 NapiUtil::ThrowParameterError(env);
1325 return nullptr;
1326 }
1327 auto asyncContext = std::make_unique<SwitchRadioContext>();
1328 if (parameterCount == PARAMETER_COUNT_ZERO) {
1329 asyncContext->slotId = GetDefaultSlotId();
1330 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1331 napi_valuetype valueType = napi_undefined;
1332 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1333 if (valueType == napi_undefined || valueType == napi_null) {
1334 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1335 asyncContext->slotId = GetDefaultSlotId();
1336 } else if (valueType == napi_number) {
1337 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1338 TELEPHONY_LOGI("context->slotId = %{public}d", asyncContext->slotId);
1339 } else if (valueType == napi_function) {
1340 asyncContext->slotId = GetDefaultSlotId();
1341 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1342 }
1343 } else if (parameterCount == PARAMETER_COUNT_TWO) {
1344 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1345 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1346 }
1347 return NapiUtil::HandleAsyncWork(
1348 env, asyncContext.release(), "TurnOffRadio", NativeTurnOffRadio, TurnOffRadioCallback);
1349 }
1350
NativeGetOperatorName(napi_env env,void * data)1351 static void NativeGetOperatorName(napi_env env, void *data)
1352 {
1353 auto context = static_cast<GetOperatorNameContext *>(data);
1354 if (!IsValidSlotId(context->slotId)) {
1355 TELEPHONY_LOGE("NativeGetOperatorName slotId is invalid");
1356 context->errorCode = ERROR_SLOT_ID_INVALID;
1357 return;
1358 }
1359 std::u16string u16OperatorName = u"";
1360 context->errorCode =
1361 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorName(context->slotId, u16OperatorName);
1362 std::string operatorName = NapiUtil::ToUtf8(u16OperatorName);
1363 TELEPHONY_LOGD("NativeGetOperatorName operatorName = %{public}s", operatorName.c_str());
1364 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
1365 context->resolved = true;
1366 context->operatorNameLength = (operatorName.size() < BUF_SIZE) ? operatorName.size() : BUF_SIZE;
1367 for (size_t i = 0; i < context->operatorNameLength; i++) {
1368 context->operatorName[i] = operatorName.at(i);
1369 }
1370 }
1371 }
1372
GetOperatorNameCallback(napi_env env,napi_status status,void * data)1373 static void GetOperatorNameCallback(napi_env env, napi_status status, void *data)
1374 {
1375 auto context = static_cast<GetOperatorNameContext *>(data);
1376 napi_value callbackValue = nullptr;
1377 if (context->resolved) {
1378 napi_create_string_utf8(env, context->operatorName, context->operatorNameLength, &callbackValue);
1379 } else {
1380 JsError error = NapiUtil::ConverErrorMessageForJs(context->errorCode);
1381 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1382 }
1383 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1384 }
1385
MatchGetOperatorNameParameter(napi_env env,napi_value parameters[],size_t parameterCount)1386 static bool MatchGetOperatorNameParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1387 {
1388 switch (parameterCount) {
1389 case PARAMETER_COUNT_ONE: {
1390 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1391 }
1392 case PARAMETER_COUNT_TWO: {
1393 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1394 }
1395 default:
1396 return false;
1397 }
1398 }
1399
GetOperatorName(napi_env env,napi_callback_info info)1400 static napi_value GetOperatorName(napi_env env, napi_callback_info info)
1401 {
1402 size_t parameterCount = PARAMETER_COUNT_TWO;
1403 napi_value parameters[PARAMETER_COUNT_TWO] = {0};
1404 napi_value thisVar = nullptr;
1405 void *data = nullptr;
1406 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1407 if (!MatchGetOperatorNameParameter(env, parameters, parameterCount)) {
1408 TELEPHONY_LOGE("GetOperatorName parameter matching failed.");
1409 NapiUtil::ThrowParameterError(env);
1410 return nullptr;
1411 }
1412 auto asyncContext = std::make_unique<GetOperatorNameContext>();
1413 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1414 if (parameterCount == PARAMETER_COUNT_TWO) {
1415 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1416 }
1417 return NapiUtil::HandleAsyncWork(
1418 env, asyncContext.release(), "GetOperatorName", NativeGetOperatorName, GetOperatorNameCallback);
1419 }
1420
GetOperatorNameSync(napi_env env,napi_callback_info info)1421 static napi_value GetOperatorNameSync(napi_env env, napi_callback_info info)
1422 {
1423 size_t parameterCount = 1;
1424 napi_value parameters[] = { nullptr };
1425 napi_get_cb_info(env, info, ¶meterCount, parameters, nullptr, nullptr);
1426 std::u16string operatorName;
1427 napi_value value = nullptr;
1428 if (parameterCount != 1) {
1429 TELEPHONY_LOGE("parameter count is incorrect");
1430 std::string name = NapiUtil::ToUtf8(operatorName);
1431 NAPI_CALL(env, napi_create_string_utf8(env, name.c_str(), name.length(), &value));
1432 return value;
1433 }
1434 int32_t slotId = -1;
1435 if (napi_get_value_int32(env, parameters[0], &slotId) != napi_ok) {
1436 TELEPHONY_LOGE("convert parameter fail");
1437 std::string name = NapiUtil::ToUtf8(operatorName);
1438 NAPI_CALL(env, napi_create_string_utf8(env, name.c_str(), name.length(), &value));
1439 return value;
1440 }
1441 if (IsValidSlotId(slotId)) {
1442 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorName(slotId, operatorName);
1443 }
1444 std::string name = NapiUtil::ToUtf8(operatorName);
1445 NAPI_CALL(env, napi_create_string_utf8(env, name.c_str(), name.length(), &value));
1446 return value;
1447 }
1448
NativeSetPreferredNetwork(napi_env env,void * data)1449 static void NativeSetPreferredNetwork(napi_env env, void *data)
1450 {
1451 auto asyncContext = static_cast<PreferredNetworkModeContext *>(data);
1452 if (!IsValidSlotId(asyncContext->slotId)) {
1453 TELEPHONY_LOGE("NativeSetPreferredNetwork slotId is invalid");
1454 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1455 return;
1456 }
1457 auto setPreferredNetworkCallback = std::make_unique<SetPreferredNetworkCallback>(asyncContext);
1458 OHOS::sptr<INetworkSearchCallback> callback(setPreferredNetworkCallback.release());
1459 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
1460 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetPreferredNetwork(
1461 asyncContext->slotId, asyncContext->preferredNetworkMode, callback);
1462 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1463 asyncContext->cv.wait_for(
1464 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
1465 TELEPHONY_LOGI("NativeTurnOffRadio after callback end");
1466 }
1467 }
1468
SetPreferredNetworkCallback(napi_env env,napi_status status,void * data)1469 static void SetPreferredNetworkCallback(napi_env env, napi_status status, void *data)
1470 {
1471 auto context = static_cast<PreferredNetworkModeContext *>(data);
1472 TELEPHONY_LOGI("SetPreferredNetworkCallback resolved = %{public}d", context->resolved);
1473 napi_value callbackValue = nullptr;
1474 if (context->resolved) {
1475 napi_get_undefined(env, &callbackValue);
1476 } else {
1477 if (context->errorCode == TELEPHONY_SUCCESS) {
1478 TELEPHONY_LOGE("SetPreferredNetworkCallback time out, errorCode = %{public}d", context->errorCode);
1479 context->errorCode = TELEPHONY_ERR_FAIL;
1480 }
1481 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1482 context->errorCode, "setPreferredNetwork", SET_TELEPHONY_STATE);
1483 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1484 }
1485 TELEPHONY_LOGI("SetPreferredNetworkCallback end");
1486 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
1487 }
1488
MatchSetPreferredNetworkParameter(napi_env env,napi_value parameters[],size_t parameterCount)1489 static bool MatchSetPreferredNetworkParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1490 {
1491 switch (parameterCount) {
1492 case PARAMETER_COUNT_TWO: {
1493 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number });
1494 }
1495 case PARAMETER_COUNT_THREE: {
1496 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
1497 }
1498 default:
1499 return false;
1500 }
1501 }
1502
SetPreferredNetwork(napi_env env,napi_callback_info info)1503 static napi_value SetPreferredNetwork(napi_env env, napi_callback_info info)
1504 {
1505 size_t parameterCount = PARAMETER_COUNT_THREE;
1506 napi_value parameters[PARAMETER_COUNT_THREE] = { 0 };
1507 napi_value thisVar = nullptr;
1508 void *data = nullptr;
1509 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1510 if (!MatchSetPreferredNetworkParameter(env, parameters, parameterCount)) {
1511 TELEPHONY_LOGE("SetPreferredNetwork parameter matching failed.");
1512 NapiUtil::ThrowParameterError(env);
1513 return nullptr;
1514 }
1515 auto asyncContext = std::make_unique<PreferredNetworkModeContext>();
1516 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1517 NAPI_CALL(env, napi_get_value_int32(env, parameters[1], &asyncContext->preferredNetworkMode));
1518 if (parameterCount == PARAMETER_COUNT_THREE) {
1519 NAPI_CALL(env, napi_create_reference(env, parameters[2], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1520 }
1521 return NapiUtil::HandleAsyncWork(
1522 env, asyncContext.release(), "SetPreferredNetworkMode", NativeSetPreferredNetwork, SetPreferredNetworkCallback);
1523 }
1524
NativeGetPreferredNetwork(napi_env env,void * data)1525 static void NativeGetPreferredNetwork(napi_env env, void *data)
1526 {
1527 auto asyncContext = static_cast<PreferredNetworkModeContext *>(data);
1528 if (!IsValidSlotId(asyncContext->slotId)) {
1529 TELEPHONY_LOGE("NativeGetPreferredNetwork slotId is invalid");
1530 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1531 return;
1532 }
1533 auto getPreferredNetworkCallback = std::make_unique<GetPreferredNetworkCallback>(asyncContext);
1534 OHOS::sptr<INetworkSearchCallback> callback(getPreferredNetworkCallback.release());
1535 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
1536 asyncContext->errorCode =
1537 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetPreferredNetwork(asyncContext->slotId, callback);
1538 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1539 asyncContext->cv.wait_for(
1540 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
1541 TELEPHONY_LOGI("NativeGetPreferredNetwork after callback end");
1542 }
1543 }
1544
GetPreferredNetworkCallback(napi_env env,napi_status status,void * data)1545 static void GetPreferredNetworkCallback(napi_env env, napi_status status, void *data)
1546 {
1547 auto context = static_cast<PreferredNetworkModeContext *>(data);
1548 TELEPHONY_LOGI("GetPreferredNetworkCallback resolved = %{public}d", context->resolved);
1549 napi_value callbackValue = nullptr;
1550 if (context->resolved) {
1551 napi_create_int32(env, context->preferredNetworkMode, &callbackValue);
1552 } else {
1553 if (context->errorCode == TELEPHONY_SUCCESS) {
1554 TELEPHONY_LOGE("GetPreferredNetworkCallback time out, errorCode = %{public}d", context->errorCode);
1555 context->errorCode = TELEPHONY_ERR_FAIL;
1556 }
1557 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1558 context->errorCode, "getPreferredNetwork", GET_TELEPHONY_STATE);
1559 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1560 }
1561 TELEPHONY_LOGI("GetPreferredNetworkCallback end");
1562 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1563 }
1564
MatchGetPreferredNetworkParameter(napi_env env,napi_value parameters[],size_t parameterCount)1565 static bool MatchGetPreferredNetworkParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1566 {
1567 switch (parameterCount) {
1568 case PARAMETER_COUNT_ONE: {
1569 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1570 }
1571 case PARAMETER_COUNT_TWO: {
1572 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1573 }
1574 default:
1575 return false;
1576 }
1577 }
1578
GetPreferredNetwork(napi_env env,napi_callback_info info)1579 static napi_value GetPreferredNetwork(napi_env env, napi_callback_info info)
1580 {
1581 size_t parameterCount = PARAMETER_COUNT_TWO;
1582 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1583 napi_value thisVar = nullptr;
1584 void *data = nullptr;
1585 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1586 if (!MatchGetPreferredNetworkParameter(env, parameters, parameterCount)) {
1587 TELEPHONY_LOGE("SendUpdateCellLocationRequest parameter matching failed.");
1588 NapiUtil::ThrowParameterError(env);
1589 return nullptr;
1590 }
1591 auto asyncContext = std::make_unique<PreferredNetworkModeContext>();
1592 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1593 if (parameterCount == PARAMETER_COUNT_TWO) {
1594 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1595 }
1596 return NapiUtil::HandleAsyncWork(
1597 env, asyncContext.release(), "GetPreferredNetworkMode", NativeGetPreferredNetwork, GetPreferredNetworkCallback);
1598 }
1599
NativeSetNetworkCapability(napi_env env,void * data)1600 static void NativeSetNetworkCapability(napi_env env, void *data)
1601 {
1602 auto asyncContext = static_cast<NetworkCapabilityContext *>(data);
1603 if (!IsValidSlotId(asyncContext->slotId)) {
1604 TELEPHONY_LOGE("NativeSetNetworkCapability slotId is invalid");
1605 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1606 return;
1607 }
1608 if (!IsValidNetworkCapabilityType(asyncContext->networkCapabilityType) ||
1609 !IsValidNetworkCapabilityState(asyncContext->networkCapabilityState)) {
1610 TELEPHONY_LOGE("NativeSetNetworkCapability networkCapabilityType or networkCapabilityState is invalid");
1611 asyncContext->errorCode = TELEPHONY_ERR_ARGUMENT_INVALID;
1612 return;
1613 }
1614 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetNetworkCapability(
1615 asyncContext->slotId, asyncContext->networkCapabilityType, asyncContext->networkCapabilityState);
1616 if (asyncContext->errorCode == TELEPHONY_ERR_SUCCESS) {
1617 asyncContext->resolved = true;
1618 }
1619 }
1620
SetNetworkCapabilityCallback(napi_env env,napi_status status,void * data)1621 static void SetNetworkCapabilityCallback(napi_env env, napi_status status, void *data)
1622 {
1623 auto context = static_cast<NetworkCapabilityContext *>(data);
1624 TELEPHONY_LOGD("SetNetworkCapabilityCallback resolved = %{public}d", context->resolved);
1625 napi_value callbackValue = nullptr;
1626 if (context->resolved) {
1627 napi_get_undefined(env, &callbackValue);
1628 } else {
1629 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1630 context->errorCode, "setNetworkCapabilityCallback", SET_TELEPHONY_STATE);
1631 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1632 }
1633 TELEPHONY_LOGD("SetNetworkCapabilityCallback end");
1634 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
1635 }
1636
MatchSetNetworkCapabilityParameter(napi_env env,napi_value parameters[],size_t parameterCount)1637 static bool MatchSetNetworkCapabilityParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1638 {
1639 switch (parameterCount) {
1640 case PARAMETER_COUNT_THREE: {
1641 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_number });
1642 }
1643 case PARAMETER_COUNT_FOUR: {
1644 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_number, napi_function });
1645 }
1646 default:
1647 return false;
1648 }
1649 }
1650
SetNetworkCapability(napi_env env,napi_callback_info info)1651 static napi_value SetNetworkCapability(napi_env env, napi_callback_info info)
1652 {
1653 size_t parameterCount = PARAMETER_COUNT_FOUR;
1654 napi_value parameters[PARAMETER_COUNT_FOUR] = { 0 };
1655 napi_value thisVar = nullptr;
1656 void *data = nullptr;
1657 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1658 if (!MatchSetNetworkCapabilityParameter(env, parameters, parameterCount)) {
1659 TELEPHONY_LOGE("SetNetworkCapability parameter matching failed.");
1660 NapiUtil::ThrowParameterError(env);
1661 return nullptr;
1662 }
1663 auto asyncContext = std::make_unique<NetworkCapabilityContext>();
1664 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
1665 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_SECOND], &asyncContext->networkCapabilityType));
1666 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_THIRD], &asyncContext->networkCapabilityState));
1667 if (parameterCount == PARAMETER_COUNT_FOUR) {
1668 NAPI_CALL(env,
1669 napi_create_reference(env, parameters[ARRAY_INDEX_FOURTH], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1670 }
1671 return NapiUtil::HandleAsyncWork(
1672 env, asyncContext.release(), "SetNetworkCapability", NativeSetNetworkCapability, SetNetworkCapabilityCallback);
1673 }
1674
NativeGetNetworkCapability(napi_env env,void * data)1675 static void NativeGetNetworkCapability(napi_env env, void *data)
1676 {
1677 auto asyncContext = static_cast<NetworkCapabilityContext *>(data);
1678 if (!IsValidSlotId(asyncContext->slotId)) {
1679 TELEPHONY_LOGE("NativeGetNetworkCapability slotId is invalid");
1680 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1681 return;
1682 }
1683 if (!IsValidNetworkCapabilityType(asyncContext->networkCapabilityType)) {
1684 TELEPHONY_LOGE("NativeSetNetworkCapability networkCapabilityType is invalid");
1685 asyncContext->errorCode = TELEPHONY_ERR_ARGUMENT_INVALID;
1686 return;
1687 }
1688 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNetworkCapability(
1689 asyncContext->slotId, asyncContext->networkCapabilityType, asyncContext->networkCapabilityState);
1690 if (asyncContext->errorCode == TELEPHONY_ERR_SUCCESS) {
1691 asyncContext->resolved = true;
1692 }
1693 }
1694
GetNetworkCapabilityCallback(napi_env env,napi_status status,void * data)1695 static void GetNetworkCapabilityCallback(napi_env env, napi_status status, void *data)
1696 {
1697 auto asyncContext = static_cast<NetworkCapabilityContext *>(data);
1698 TELEPHONY_LOGD("GetNetworkCapabilityCallback resolved = %{public}d", asyncContext->resolved);
1699 napi_value callbackValue = nullptr;
1700 if (asyncContext->resolved) {
1701 napi_create_int32(env, asyncContext->networkCapabilityState, &callbackValue);
1702 } else {
1703 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1704 asyncContext->errorCode, "getNetworkCapabilityCallback", GET_TELEPHONY_STATE);
1705 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1706 }
1707 TELEPHONY_LOGD("GetNetworkCapabilityCallback end");
1708 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
1709 }
1710
MatchGetNetworkCapabilityParameter(napi_env env,napi_value parameters[],size_t parameterCount)1711 static bool MatchGetNetworkCapabilityParameter(napi_env env, napi_value parameters[], size_t parameterCount)
1712 {
1713 switch (parameterCount) {
1714 case PARAMETER_COUNT_TWO: {
1715 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number });
1716 }
1717 case PARAMETER_COUNT_THREE: {
1718 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
1719 }
1720 default:
1721 return false;
1722 }
1723 }
1724
GetNetworkCapability(napi_env env,napi_callback_info info)1725 static napi_value GetNetworkCapability(napi_env env, napi_callback_info info)
1726 {
1727 size_t parameterCount = PARAMETER_COUNT_THREE;
1728 napi_value parameters[PARAMETER_COUNT_THREE] = { 0 };
1729 napi_value thisVar = nullptr;
1730 void *data = nullptr;
1731 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1732 if (!MatchGetNetworkCapabilityParameter(env, parameters, parameterCount)) {
1733 TELEPHONY_LOGE("GetNetworkCapability parameter matching failed.");
1734 NapiUtil::ThrowParameterError(env);
1735 return nullptr;
1736 }
1737 auto asyncContext = std::make_unique<NetworkCapabilityContext>();
1738 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
1739 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_SECOND], &asyncContext->networkCapabilityType));
1740 if (parameterCount == PARAMETER_COUNT_THREE) {
1741 NAPI_CALL(env,
1742 napi_create_reference(env, parameters[ARRAY_INDEX_THIRD], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1743 }
1744 return NapiUtil::HandleAsyncWork(
1745 env, asyncContext.release(), "GetNetworkCapability", NativeGetNetworkCapability, GetNetworkCapabilityCallback);
1746 }
1747
NativeGetIMEI(napi_env env,void * data)1748 void NativeGetIMEI(napi_env env, void *data)
1749 {
1750 auto context = static_cast<GetIMEIContext *>(data);
1751 if (!IsValidSlotId(context->slotId)) {
1752 TELEPHONY_LOGE("NativeGetIMEI slotId is invalid");
1753 context->errorCode = ERROR_SLOT_ID_INVALID;
1754 return;
1755 }
1756 std::u16string imei = u"";
1757 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetImei(context->slotId, imei);
1758 if (context->errorCode == TELEPHONY_SUCCESS) {
1759 context->resolved = true;
1760 context->getIMEIResult = NapiUtil::ToUtf8(imei);
1761 TELEPHONY_LOGD("NativeGetIMEI len = %{public}lu", static_cast<unsigned long>(context->getIMEIResult.length()));
1762 } else {
1763 TELEPHONY_LOGE("Get IMEI fail, NativeGetIMEI len = %{public}lu",
1764 static_cast<unsigned long>(context->getIMEIResult.length()));
1765 }
1766 }
1767
GetIMEICallback(napi_env env,napi_status status,void * data)1768 void GetIMEICallback(napi_env env, napi_status status, void *data)
1769 {
1770 auto context = static_cast<GetIMEIContext *>(data);
1771 napi_value callbackValue = nullptr;
1772 if (context->resolved) {
1773 napi_create_string_utf8(env, context->getIMEIResult.c_str(), context->getIMEIResult.size(), &callbackValue);
1774 } else {
1775 JsError error =
1776 NapiUtil::ConverErrorMessageWithPermissionForJs(context->errorCode, "getIMEI", GET_TELEPHONY_STATE);
1777 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1778 }
1779 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1780 }
1781
GetIMEI(napi_env env,napi_callback_info info)1782 static napi_value GetIMEI(napi_env env, napi_callback_info info)
1783 {
1784 size_t parameterCount = PARAMETER_COUNT_TWO;
1785 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1786 napi_value thisVar = nullptr;
1787 void *data = nullptr;
1788 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1789 if (!MatchGetIMEIParameter(env, parameters, parameterCount)) {
1790 TELEPHONY_LOGE("parameter matching failed.");
1791 NapiUtil::ThrowParameterError(env);
1792 return nullptr;
1793 }
1794 auto asyncContext = std::make_unique<GetIMEIContext>();
1795 if (asyncContext == nullptr) {
1796 TELEPHONY_LOGE("asyncContext is nullptr.");
1797 NapiUtil::ThrowParameterError(env);
1798 return nullptr;
1799 }
1800 if (parameterCount == PARAMETER_COUNT_ZERO) {
1801 asyncContext->slotId = GetDefaultSlotId();
1802 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1803 napi_valuetype valueType = napi_undefined;
1804 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1805 if (valueType == napi_undefined || valueType == napi_null) {
1806 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1807 asyncContext->slotId = GetDefaultSlotId();
1808 } else if (valueType == napi_number) {
1809 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1810 } else {
1811 asyncContext->slotId = GetDefaultSlotId();
1812 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1813 }
1814 } else {
1815 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1816 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1817 }
1818 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "GetIMEI", NativeGetIMEI, GetIMEICallback);
1819 }
1820
NativeGetIMEISV(napi_env env,void * data)1821 void NativeGetIMEISV(napi_env env, void *data)
1822 {
1823 auto context = static_cast<GetIMEISVContext *>(data);
1824 if (!IsValidSlotId(context->slotId)) {
1825 TELEPHONY_LOGE("NativeGetIMEISV slotId is invalid");
1826 context->errorCode = ERROR_SLOT_ID_INVALID;
1827 return;
1828 }
1829 std::u16string imeiSv = u"";
1830 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetImeiSv(context->slotId, imeiSv);
1831 if (context->errorCode == TELEPHONY_SUCCESS) {
1832 context->resolved = true;
1833 context->getIMEISVResult = NapiUtil::ToUtf8(imeiSv);
1834 TELEPHONY_LOGI(
1835 "NativeGetIMEISV len = %{public}lu", static_cast<unsigned long>(context->getIMEISVResult.length()));
1836 }
1837 }
1838
GetIMEISVCallback(napi_env env,napi_status status,void * data)1839 void GetIMEISVCallback(napi_env env, napi_status status, void *data)
1840 {
1841 auto context = static_cast<GetIMEISVContext *>(data);
1842 napi_value callbackValue = nullptr;
1843 if (context->resolved) {
1844 napi_create_string_utf8(env, context->getIMEISVResult.c_str(), context->getIMEISVResult.size(), &callbackValue);
1845 } else {
1846 JsError error =
1847 NapiUtil::ConverErrorMessageWithPermissionForJs(context->errorCode, "getIMEISV", GET_TELEPHONY_STATE);
1848 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1849 }
1850 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1851 }
1852
GetIMEISV(napi_env env,napi_callback_info info)1853 static napi_value GetIMEISV(napi_env env, napi_callback_info info)
1854 {
1855 size_t parameterCount = PARAMETER_COUNT_TWO;
1856 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1857 napi_value thisVar = nullptr;
1858 void *data = nullptr;
1859 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1860 if (!MatchGetIMEIParameter(env, parameters, parameterCount)) {
1861 TELEPHONY_LOGE("parameter matching failed.");
1862 NapiUtil::ThrowParameterError(env);
1863 return nullptr;
1864 }
1865 auto asyncContext = std::make_unique<GetIMEISVContext>();
1866 if (asyncContext == nullptr) {
1867 TELEPHONY_LOGE("asyncContext is nullptr.");
1868 NapiUtil::ThrowParameterError(env);
1869 return nullptr;
1870 }
1871 if (parameterCount == PARAMETER_COUNT_ZERO) {
1872 asyncContext->slotId = GetDefaultSlotId();
1873 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1874 napi_valuetype valueType = napi_undefined;
1875 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1876 if (valueType == napi_undefined || valueType == napi_null) {
1877 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1878 asyncContext->slotId = GetDefaultSlotId();
1879 } else if (valueType == napi_number) {
1880 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1881 } else {
1882 asyncContext->slotId = GetDefaultSlotId();
1883 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1884 }
1885 } else {
1886 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1887 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1888 }
1889 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "GetIMEISV", NativeGetIMEISV, GetIMEISVCallback);
1890 }
1891
NativeGetMEID(napi_env env,void * data)1892 void NativeGetMEID(napi_env env, void *data)
1893 {
1894 auto context = static_cast<GetMEIDContext *>(data);
1895 if (!IsValidSlotId(context->slotId)) {
1896 TELEPHONY_LOGE("NativeGetMEID slotId is invalid");
1897 context->errorCode = ERROR_SLOT_ID_INVALID;
1898 return;
1899 }
1900 std::u16string meid = u"";
1901 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetMeid(context->slotId, meid);
1902 if (context->errorCode == TELEPHONY_SUCCESS) {
1903 context->resolved = true;
1904 context->getMEIDResult = NapiUtil::ToUtf8(meid);
1905 TELEPHONY_LOGI("NativeGetMEID len = %{public}lu", static_cast<unsigned long>(context->getMEIDResult.length()));
1906 }
1907 }
1908
GetMEIDCallback(napi_env env,napi_status status,void * data)1909 void GetMEIDCallback(napi_env env, napi_status status, void *data)
1910 {
1911 auto context = static_cast<GetMEIDContext *>(data);
1912 napi_value callbackValue = nullptr;
1913 if (context->resolved) {
1914 napi_create_string_utf8(env, context->getMEIDResult.c_str(), context->getMEIDResult.size(), &callbackValue);
1915 } else {
1916 JsError error =
1917 NapiUtil::ConverErrorMessageWithPermissionForJs(context->errorCode, "getMEID", GET_TELEPHONY_STATE);
1918 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1919 }
1920 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
1921 }
1922
GetMEID(napi_env env,napi_callback_info info)1923 static napi_value GetMEID(napi_env env, napi_callback_info info)
1924 {
1925 size_t parameterCount = PARAMETER_COUNT_TWO;
1926 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1927 napi_value thisVar = nullptr;
1928 void *data = nullptr;
1929 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
1930 if (!MatchGetIMEIParameter(env, parameters, parameterCount)) {
1931 TELEPHONY_LOGE("parameter matching failed.");
1932 NapiUtil::ThrowParameterError(env);
1933 return nullptr;
1934 }
1935 auto asyncContext = std::make_unique<GetMEIDContext>();
1936 if (parameterCount == PARAMETER_COUNT_ZERO) {
1937 asyncContext->slotId = GetDefaultSlotId();
1938 } else if (parameterCount == PARAMETER_COUNT_ONE) {
1939 napi_valuetype valueType = napi_undefined;
1940 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
1941 if (valueType == napi_undefined || valueType == napi_null) {
1942 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
1943 asyncContext->slotId = GetDefaultSlotId();
1944 } else if (valueType == napi_number) {
1945 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1946 TELEPHONY_LOGI("context->slotId = %{public}d", asyncContext->slotId);
1947 } else if (valueType == napi_function) {
1948 asyncContext->slotId = GetDefaultSlotId();
1949 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1950 }
1951 } else if (parameterCount == PARAMETER_COUNT_TWO) {
1952 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
1953 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
1954 }
1955 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "getMEID", NativeGetMEID, GetMEIDCallback);
1956 }
1957
NativeSendUpdateCellLocationRequest(napi_env env,void * data)1958 static void NativeSendUpdateCellLocationRequest(napi_env env, void *data)
1959 {
1960 auto asyncContext = static_cast<SendUpdateCellLocationRequest *>(data);
1961 if (!IsValidSlotId(asyncContext->slotId)) {
1962 TELEPHONY_LOGE("NativeSendUpdateCellLocationRequest slotId is invalid");
1963 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
1964 return;
1965 }
1966 asyncContext->errorCode =
1967 DelayedRefSingleton<CoreServiceClient>::GetInstance().SendUpdateCellLocationRequest(asyncContext->slotId);
1968 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1969 asyncContext->resolved = true;
1970 }
1971 TELEPHONY_LOGI("NativeSendUpdateCellLocationRequest end");
1972 }
1973
SendUpdateCellLocationRequestCallback(napi_env env,napi_status status,void * data)1974 static void SendUpdateCellLocationRequestCallback(napi_env env, napi_status status, void *data)
1975 {
1976 auto asyncContext = static_cast<SendUpdateCellLocationRequest *>(data);
1977 napi_value callbackValue = nullptr;
1978 if (asyncContext->resolved) {
1979 napi_get_undefined(env, &callbackValue);
1980 } else {
1981 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
1982 asyncContext->errorCode, "sendUpdateCellLocationRequest", LOCATION);
1983 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
1984 }
1985 NapiUtil::Handle1ValueCallback(env, asyncContext, callbackValue);
1986 TELEPHONY_LOGI("SendUpdateCellLocationRequestCallback end");
1987 }
1988
SendUpdateCellLocationRequest(napi_env env,napi_callback_info info)1989 static napi_value SendUpdateCellLocationRequest(napi_env env, napi_callback_info info)
1990 {
1991 size_t parameterCount = PARAMETER_COUNT_TWO;
1992 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
1993 napi_value thisVar;
1994 void *data;
1995 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
1996 if (!MatchIsRadioOnParameter(env, parameters, parameterCount)) {
1997 TELEPHONY_LOGE("parameter matching failed.");
1998 NapiUtil::ThrowParameterError(env);
1999 return nullptr;
2000 }
2001 auto asyncContext = std::make_unique<SwitchRadioContext>();
2002 if (parameterCount == PARAMETER_COUNT_ZERO) {
2003 asyncContext->slotId = GetDefaultSlotId();
2004 } else if (parameterCount == PARAMETER_COUNT_ONE) {
2005 napi_valuetype valueType = napi_undefined;
2006 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
2007 if (valueType == napi_undefined || valueType == napi_null) {
2008 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
2009 asyncContext->slotId = GetDefaultSlotId();
2010 } else if (valueType == napi_number) {
2011 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2012 } else if (valueType == napi_function) {
2013 asyncContext->slotId = GetDefaultSlotId();
2014 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2015 }
2016 } else if (parameterCount == PARAMETER_COUNT_TWO) {
2017 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2018 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2019 }
2020 return NapiUtil::HandleAsyncWork(env, asyncContext.release(), "SendUpdateCellLocationRequest",
2021 NativeSendUpdateCellLocationRequest, SendUpdateCellLocationRequestCallback);
2022 }
2023
WrapCellInformationType(const sptr<CellInformation> CellInfo)2024 static int32_t WrapCellInformationType(const sptr<CellInformation> CellInfo)
2025 {
2026 if (CellInfo != nullptr) {
2027 auto type = CellInfo->GetNetworkType();
2028 switch (type) {
2029 case CellInformation::CellType::CELL_TYPE_GSM:
2030 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_GSM);
2031 case CellInformation::CellType::CELL_TYPE_WCDMA:
2032 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_WCDMA);
2033 case CellInformation::CellType::CELL_TYPE_LTE:
2034 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_LTE);
2035 case CellInformation::CellType::CELL_TYPE_TDSCDMA:
2036 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_TDSCDMA);
2037 case CellInformation::CellType::CELL_TYPE_CDMA:
2038 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_CDMA);
2039 case CellInformation::CellType::CELL_TYPE_NR:
2040 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_NR);
2041 default:
2042 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN);
2043 }
2044 }
2045 return static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN);
2046 }
2047
JudgmentDataGsm(napi_env env,napi_value data,sptr<CellInformation> infoItem)2048 void JudgmentDataGsm(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2049 {
2050 auto gsmCellInfo = static_cast<GsmCellInformation *>(infoItem.GetRefPtr());
2051 if (gsmCellInfo != nullptr) {
2052 NapiUtil::SetPropertyInt32(env, data, "lac", gsmCellInfo->GetLac());
2053 NapiUtil::SetPropertyInt32(env, data, "cellId", gsmCellInfo->GetCellId());
2054 NapiUtil::SetPropertyInt32(env, data, "arfcn", gsmCellInfo->GetArfcn());
2055 NapiUtil::SetPropertyInt32(env, data, "bsic", gsmCellInfo->GetBsic());
2056 NapiUtil::SetPropertyStringUtf8(env, data, "mcc", gsmCellInfo->GetMcc());
2057 NapiUtil::SetPropertyStringUtf8(env, data, "mnc", gsmCellInfo->GetMnc());
2058 }
2059 }
2060
JudgmentDataLte(napi_env env,napi_value data,sptr<CellInformation> infoItem)2061 void JudgmentDataLte(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2062 {
2063 auto lteCellInfo = static_cast<LteCellInformation *>(infoItem.GetRefPtr());
2064 if (lteCellInfo != nullptr) {
2065 NapiUtil::SetPropertyInt32(env, data, "cgi", lteCellInfo->GetCellId());
2066 NapiUtil::SetPropertyInt32(env, data, "pci", lteCellInfo->GetPci());
2067 NapiUtil::SetPropertyInt32(env, data, "tac", lteCellInfo->GetTac());
2068 NapiUtil::SetPropertyInt32(env, data, "earfcn", lteCellInfo->GetArfcn());
2069 NapiUtil::SetPropertyInt32(env, data, "bandwidth", 0);
2070 NapiUtil::SetPropertyStringUtf8(env, data, "mcc", lteCellInfo->GetMcc());
2071 NapiUtil::SetPropertyStringUtf8(env, data, "mnc", lteCellInfo->GetMnc());
2072 NapiUtil::SetPropertyBoolean(env, data, "isSupportEndc", false);
2073 }
2074 }
2075
JudgmentDataWcdma(napi_env env,napi_value data,sptr<CellInformation> infoItem)2076 void JudgmentDataWcdma(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2077 {
2078 auto wcdmaCellInfo = static_cast<WcdmaCellInformation *>(infoItem.GetRefPtr());
2079 if (wcdmaCellInfo != nullptr) {
2080 NapiUtil::SetPropertyInt32(env, data, "lac", wcdmaCellInfo->GetLac());
2081 NapiUtil::SetPropertyInt32(env, data, "cellId", wcdmaCellInfo->GetCellId());
2082 NapiUtil::SetPropertyInt32(env, data, "psc", wcdmaCellInfo->GetPsc());
2083 NapiUtil::SetPropertyInt32(env, data, "uarfcn", wcdmaCellInfo->GetArfcn());
2084 NapiUtil::SetPropertyStringUtf8(env, data, "mcc", wcdmaCellInfo->GetMcc());
2085 NapiUtil::SetPropertyStringUtf8(env, data, "mnc", wcdmaCellInfo->GetMnc());
2086 }
2087 }
2088
JudgmentDataCdma(napi_env env,napi_value data,sptr<CellInformation> infoItem)2089 void JudgmentDataCdma(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2090 {
2091 auto cdmaCellInfo = static_cast<CdmaCellInformation *>(infoItem.GetRefPtr());
2092 if (cdmaCellInfo != nullptr) {
2093 NapiUtil::SetPropertyInt32(env, data, "baseId", cdmaCellInfo->GetBaseId());
2094 NapiUtil::SetPropertyInt32(env, data, "latitude", cdmaCellInfo->GetLatitude());
2095 NapiUtil::SetPropertyInt32(env, data, "longitude", cdmaCellInfo->GetLongitude());
2096 NapiUtil::SetPropertyInt32(env, data, "nid", cdmaCellInfo->GetNid());
2097 NapiUtil::SetPropertyInt32(env, data, "sid", cdmaCellInfo->GetSid());
2098 }
2099 }
2100
JudgmentDataTdscdma(napi_env env,napi_value data,sptr<CellInformation> infoItem)2101 void JudgmentDataTdscdma(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2102 {
2103 auto tdscdmaCellInfo = static_cast<TdscdmaCellInformation *>(infoItem.GetRefPtr());
2104 if (tdscdmaCellInfo != nullptr) {
2105 NapiUtil::SetPropertyInt32(env, data, "lac", tdscdmaCellInfo->GetLac());
2106 NapiUtil::SetPropertyInt32(env, data, "cellId", tdscdmaCellInfo->GetCellId());
2107 NapiUtil::SetPropertyInt32(env, data, "cpid", tdscdmaCellInfo->GetCpid());
2108 NapiUtil::SetPropertyInt32(env, data, "uarfcn", tdscdmaCellInfo->GetArfcn());
2109 NapiUtil::SetPropertyStringUtf8(env, data, "mcc", tdscdmaCellInfo->GetMcc());
2110 NapiUtil::SetPropertyStringUtf8(env, data, "mnc", tdscdmaCellInfo->GetMnc());
2111 }
2112 }
2113
JudgmentDataNr(napi_env env,napi_value data,sptr<CellInformation> infoItem)2114 void JudgmentDataNr(napi_env env, napi_value data, sptr<CellInformation> infoItem)
2115 {
2116 auto nrCellCellInfo = static_cast<NrCellInformation *>(infoItem.GetRefPtr());
2117 if (nrCellCellInfo != nullptr) {
2118 NapiUtil::SetPropertyInt32(env, data, "nrArfcn", nrCellCellInfo->GetArfcn());
2119 NapiUtil::SetPropertyInt32(env, data, "pci", nrCellCellInfo->GetPci());
2120 NapiUtil::SetPropertyInt32(env, data, "tac", nrCellCellInfo->GetTac());
2121 NapiUtil::SetPropertyInt64(env, data, "nci", nrCellCellInfo->GetNci());
2122 NapiUtil::SetPropertyStringUtf8(env, data, "mcc", nrCellCellInfo->GetMcc());
2123 NapiUtil::SetPropertyStringUtf8(env, data, "mnc", nrCellCellInfo->GetMnc());
2124 }
2125 }
2126
JudgmentData(napi_env env,sptr<CellInformation> infoItem,CellInformation::CellType cellType)2127 napi_value JudgmentData(napi_env env, sptr<CellInformation> infoItem, CellInformation::CellType cellType)
2128 {
2129 napi_value data = nullptr;
2130 napi_create_object(env, &data);
2131 switch (cellType) {
2132 case CellInformation::CellType::CELL_TYPE_GSM: {
2133 JudgmentDataGsm(env, data, infoItem);
2134 break;
2135 }
2136 case CellInformation::CellType::CELL_TYPE_LTE: {
2137 JudgmentDataLte(env, data, infoItem);
2138 break;
2139 }
2140 case CellInformation::CellType::CELL_TYPE_WCDMA: {
2141 JudgmentDataWcdma(env, data, infoItem);
2142 break;
2143 }
2144 case CellInformation::CellType::CELL_TYPE_CDMA: {
2145 JudgmentDataCdma(env, data, infoItem);
2146 break;
2147 }
2148 case CellInformation::CellType::CELL_TYPE_TDSCDMA: {
2149 JudgmentDataTdscdma(env, data, infoItem);
2150 break;
2151 }
2152 case CellInformation::CellType::CELL_TYPE_NR: {
2153 JudgmentDataNr(env, data, infoItem);
2154 break;
2155 }
2156 default:
2157 break;
2158 }
2159 return data;
2160 }
2161
NativeGetCellInformation(napi_env env,void * data)2162 static void NativeGetCellInformation(napi_env env, void *data)
2163 {
2164 auto asyncContext = static_cast<CellInformationContext *>(data);
2165 if (!IsValidSlotId(asyncContext->slotId)) {
2166 TELEPHONY_LOGE("NativeGetCellInformation slotId is invalid");
2167 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
2168 return;
2169 }
2170 asyncContext->cellInformations.clear();
2171 asyncContext->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCellInfoList(
2172 asyncContext->slotId, asyncContext->cellInformations);
2173 TELEPHONY_LOGD("NativeGetCellInformation len = %{public}lu",
2174 static_cast<unsigned long>(asyncContext->cellInformations.size()));
2175 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
2176 TELEPHONY_LOGE("NativeGetCellInformation errorCode = %{public}d", asyncContext->errorCode);
2177 return;
2178 }
2179 if (asyncContext->cellInformations.size() == 0) {
2180 TELEPHONY_LOGE("NativeGetCellInformation cellInformations is empty.");
2181 asyncContext->errorCode = ERROR_NATIVE_API_EXECUTE_FAIL;
2182 return;
2183 }
2184 asyncContext->resolved = true;
2185 }
2186
GetCellInformationCallback(napi_env env,napi_status status,void * data)2187 void GetCellInformationCallback(napi_env env, napi_status status, void *data)
2188 {
2189 auto asyncContext = static_cast<CellInformationContext *>(data);
2190 TELEPHONY_LOGI("GetCellInformationCallback size = %{public}zu,resolved = %{public}d,slotId = %{public}d",
2191 asyncContext->cellInformations.size(), asyncContext->resolved, asyncContext->slotId);
2192 if (asyncContext->resolved) {
2193 napi_create_array(env, &(asyncContext->callbackValue));
2194 int i = 0;
2195 for (sptr<CellInformation> infoItem : asyncContext->cellInformations) {
2196 napi_value info = nullptr;
2197 napi_create_object(env, &info);
2198 NapiUtil::SetPropertyBoolean(env, info, "isCamped", true);
2199 uint64_t timeStamp = 0;
2200 int32_t signalIntensity = 0;
2201 int32_t signalLevel = 0;
2202 CellInformation::CellType cellType = CellInformation::CellType::CELL_TYPE_NONE;
2203 if (infoItem != nullptr) {
2204 timeStamp = infoItem->GetTimeStamp();
2205 signalLevel = infoItem->GetSignalLevel();
2206 signalIntensity = infoItem->GetSignalIntensity();
2207 cellType = infoItem->GetNetworkType();
2208 }
2209 NapiUtil::SetPropertyInt32(env, info, "timeStamp", timeStamp);
2210 NapiUtil::SetPropertyInt32(env, info, "networkType", WrapCellInformationType(infoItem));
2211 napi_value signalInformation = nullptr;
2212 napi_create_object(env, &signalInformation);
2213 int32_t signalType = WrapCellInformationType(infoItem);
2214 NapiUtil::SetPropertyInt32(env, signalInformation, "signalType", signalType);
2215 NapiUtil::SetPropertyInt32(env, signalInformation, "signalLevel", signalLevel);
2216 NapiUtil::SetPropertyInt32(env, signalInformation, "dBm", signalIntensity);
2217 std::string name = "signalInformation";
2218 napi_set_named_property(env, info, name.c_str(), signalInformation);
2219 napi_set_named_property(env, info, "data", JudgmentData(env, infoItem, cellType));
2220 napi_set_element(env, asyncContext->callbackValue, i, info);
2221 ++i;
2222 }
2223 } else {
2224 JsError error =
2225 NapiUtil::ConverErrorMessageWithPermissionForJs(asyncContext->errorCode, "getCellInformation", LOCATION);
2226 asyncContext->callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2227 }
2228 NapiUtil::Handle2ValueCallback(env, asyncContext, asyncContext->callbackValue);
2229 TELEPHONY_LOGD("GetCellInformationCallback end");
2230 }
2231
GetCellInformation(napi_env env,napi_callback_info info)2232 static napi_value GetCellInformation(napi_env env, napi_callback_info info)
2233 {
2234 size_t parameterCount = PARAMETER_COUNT_TWO;
2235 napi_value parameters[PARAMETER_COUNT_TWO] = {0};
2236 napi_value thisVar;
2237 void *data;
2238 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
2239 if (!MatchGetNetworkStateParameter(env, parameters, parameterCount)) {
2240 TELEPHONY_LOGE("parameter matching failed.");
2241 NapiUtil::ThrowParameterError(env);
2242 return nullptr;
2243 }
2244 auto asyncContext = new CellInformationContext();
2245 if (parameterCount == PARAMETER_COUNT_ZERO) {
2246 asyncContext->slotId = GetDefaultSlotId();
2247 } else if (parameterCount == PARAMETER_COUNT_ONE) {
2248 napi_valuetype valueType = napi_undefined;
2249 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
2250 if (valueType == napi_undefined || valueType == napi_null) {
2251 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
2252 asyncContext->slotId = GetDefaultSlotId();
2253 } else if (valueType == napi_number) {
2254 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2255 } else if (valueType == napi_function) {
2256 asyncContext->slotId = GetDefaultSlotId();
2257 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2258 }
2259 } else if (parameterCount == PARAMETER_COUNT_TWO) {
2260 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2261 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2262 }
2263 napi_value result = nullptr;
2264 if (asyncContext->callbackRef == nullptr) {
2265 NAPI_CALL(env, napi_create_promise(env, &asyncContext->deferred, &result));
2266 } else {
2267 NAPI_CALL(env, napi_get_undefined(env, &result));
2268 }
2269 napi_value resourceName = nullptr;
2270 NAPI_CALL(env, napi_create_string_utf8(env, "GetCellInformation", NAPI_AUTO_LENGTH, &resourceName));
2271 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, NativeGetCellInformation,
2272 GetCellInformationCallback, static_cast<void *>(asyncContext), &(asyncContext->work)));
2273 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncContext->work, napi_qos_default));
2274 return result;
2275 }
2276
NativeGetPrimarySlotId(napi_env env,void * data)2277 static void NativeGetPrimarySlotId(napi_env env, void *data)
2278 {
2279 auto asyncContext = static_cast<GetPrimarySlotIdContext *>(data);
2280 asyncContext->errorCode =
2281 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetPrimarySlotId(asyncContext->slotId);
2282 TELEPHONY_LOGI("GetPrimarySlotId = %{public}d", asyncContext->slotId);
2283 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2284 asyncContext->resolved = true;
2285 }
2286 }
2287
GetPrimarySlotIdCallback(napi_env env,napi_status status,void * data)2288 void GetPrimarySlotIdCallback(napi_env env, napi_status status, void *data)
2289 {
2290 auto asyncContext = static_cast<GetPrimarySlotIdContext *>(data);
2291 napi_value callbackValue = nullptr;
2292 if (asyncContext->resolved) {
2293 napi_create_int32(env, asyncContext->slotId, &callbackValue);
2294 } else {
2295 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2296 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2297 }
2298 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
2299 }
2300
GetPrimarySlotId(napi_env env,napi_callback_info info)2301 static napi_value GetPrimarySlotId(napi_env env, napi_callback_info info)
2302 {
2303 size_t parameterCount = PARAMETER_COUNT_ONE;
2304 napi_value parameters[PARAMETER_COUNT_ONE] = {0};
2305 napi_value thisVar;
2306 void *data;
2307 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
2308 if (!MatchSwitchRadioParameter(env, parameters, parameterCount)) {
2309 TELEPHONY_LOGE("GetPrimarySlotId parameter matching failed.");
2310 NapiUtil::ThrowParameterError(env);
2311 return nullptr;
2312 }
2313 auto asyncContext = std::make_unique<SwitchRadioContext>();
2314 if (parameterCount == PARAMETER_COUNT_ONE) {
2315 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2316 }
2317 return NapiUtil::HandleAsyncWork(
2318 env, asyncContext.release(), "GetPrimarySlotId", NativeGetPrimarySlotId, GetPrimarySlotIdCallback);
2319 }
2320
NativeGetUniqueDeviceId(napi_env env,void * data)2321 static void NativeGetUniqueDeviceId(napi_env env, void *data)
2322 {
2323 auto context = static_cast<GetUniqueDeviceIdContext *>(data);
2324 if (!IsValidSlotId(context->slotId)) {
2325 TELEPHONY_LOGE("NativeGetUniqueDeviceId slotId is invalid");
2326 context->errorCode = ERROR_SLOT_ID_INVALID;
2327 return;
2328 }
2329 std::u16string deviceId = u"";
2330 context->errorCode =
2331 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetUniqueDeviceId(context->slotId, deviceId);
2332 if (context->errorCode == TELEPHONY_SUCCESS) {
2333 context->resolved = true;
2334 context->getUniqueDeviceId = NapiUtil::ToUtf8(deviceId);
2335 TELEPHONY_LOGI("NativeGetUniqueDeviceId len = %{public}lu",
2336 static_cast<unsigned long>(context->getUniqueDeviceId.length()));
2337 }
2338 }
2339
GetUniqueDeviceIdCallback(napi_env env,napi_status status,void * data)2340 void GetUniqueDeviceIdCallback(napi_env env, napi_status status, void *data)
2341 {
2342 auto context = static_cast<GetUniqueDeviceIdContext *>(data);
2343 napi_value callbackValue = nullptr;
2344 if (context->resolved) {
2345 napi_create_string_utf8(
2346 env, context->getUniqueDeviceId.c_str(), context->getUniqueDeviceId.size(), &callbackValue);
2347 } else {
2348 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2349 context->errorCode, "getUniqueDeviceId", GET_TELEPHONY_STATE);
2350 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2351 }
2352 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
2353 }
2354
GetUniqueDeviceId(napi_env env,napi_callback_info info)2355 static napi_value GetUniqueDeviceId(napi_env env, napi_callback_info info)
2356 {
2357 size_t parameterCount = PARAMETER_COUNT_TWO;
2358 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
2359 napi_value thisVar = nullptr;
2360 void *data = nullptr;
2361 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
2362 if (!MatchGetIMEIParameter(env, parameters, parameterCount)) {
2363 TELEPHONY_LOGE("parameter matching failed.");
2364 NapiUtil::ThrowParameterError(env);
2365 return nullptr;
2366 }
2367 auto asyncContext = std::make_unique<GetIMEIContext>();
2368 if (parameterCount == PARAMETER_COUNT_ZERO) {
2369 asyncContext->slotId = GetDefaultSlotId();
2370 } else if (parameterCount == PARAMETER_COUNT_ONE) {
2371 napi_valuetype valueType = napi_undefined;
2372 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
2373 if (valueType == napi_undefined || valueType == napi_null) {
2374 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
2375 asyncContext->slotId = GetDefaultSlotId();
2376 } else if (valueType == napi_number) {
2377 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2378 } else if (valueType == napi_function) {
2379 asyncContext->slotId = GetDefaultSlotId();
2380 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2381 }
2382 } else if (parameterCount == PARAMETER_COUNT_TWO) {
2383 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2384 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2385 }
2386 return NapiUtil::HandleAsyncWork(
2387 env, asyncContext.release(), "GetUniqueDeviceId", NativeGetUniqueDeviceId, GetUniqueDeviceIdCallback);
2388 }
2389
NativeGetNrOptionMode(napi_env env,void * data)2390 static void NativeGetNrOptionMode(napi_env env, void *data)
2391 {
2392 auto context = static_cast<NrOptionModeContext *>(data);
2393 if (!IsValidSlotId(context->slotId)) {
2394 TELEPHONY_LOGE("NativeGetNrOptionMode slotId is invalid");
2395 context->errorCode = ERROR_SLOT_ID_INVALID;
2396 return;
2397 }
2398 auto getNrOptionModeCallback = std::make_unique<GetNrOptionModeCallback>(context);
2399 OHOS::sptr<INetworkSearchCallback> callback(getNrOptionModeCallback.release());
2400 std::unique_lock<std::mutex> callbackLock(context->callbackMutex);
2401 context->errorCode =
2402 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNrOptionMode(context->slotId, callback);
2403 if (context->errorCode == TELEPHONY_SUCCESS) {
2404 context->cv.wait_for(
2405 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [context] { return context->callbackEnd; });
2406 TELEPHONY_LOGI("NativeGetNrOptionMode after callback end");
2407 }
2408 }
2409
GetNrOptionModeCallback(napi_env env,napi_status status,void * data)2410 static void GetNrOptionModeCallback(napi_env env, napi_status status, void *data)
2411 {
2412 auto context = static_cast<NrOptionModeContext *>(data);
2413 TELEPHONY_LOGI("GetNrOptionModeCallback resolved = %{public}d", context->resolved);
2414 napi_value callbackValue = nullptr;
2415 if (context->resolved) {
2416 napi_create_int32(env, context->nrOptionMode, &callbackValue);
2417 } else {
2418 if (context->errorCode == TELEPHONY_SUCCESS) {
2419 TELEPHONY_LOGE("GetNrOptionModeCallback time out, errorCode = %{public}d", context->errorCode);
2420 context->errorCode = TELEPHONY_ERR_FAIL;
2421 }
2422 JsError error = NapiUtil::ConverErrorMessageForJs(context->errorCode);
2423 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2424 }
2425 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
2426 }
2427
GetNrOptionMode(napi_env env,napi_callback_info info)2428 static napi_value GetNrOptionMode(napi_env env, napi_callback_info info)
2429 {
2430 size_t parameterCount = PARAMETER_COUNT_TWO;
2431 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
2432 napi_value thisVar = nullptr;
2433 void *data = nullptr;
2434 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
2435 if (!MatchGetNrOptionModeParameter(env, parameters, parameterCount)) {
2436 TELEPHONY_LOGE("parameter matching failed.");
2437 NapiUtil::ThrowParameterError(env);
2438 return nullptr;
2439 }
2440 auto asyncContext = std::make_unique<NrOptionModeContext>();
2441 if (parameterCount == PARAMETER_COUNT_ZERO) {
2442 asyncContext->slotId = GetDefaultSlotId();
2443 } else if (parameterCount == PARAMETER_COUNT_ONE) {
2444 napi_valuetype valueType = napi_undefined;
2445 NAPI_CALL(env, napi_typeof(env, parameters[0], &valueType));
2446 if (valueType == napi_undefined || valueType == napi_null) {
2447 TELEPHONY_LOGI("undefined or null parameter detected, treating as no parameter input.");
2448 asyncContext->slotId = GetDefaultSlotId();
2449 } else if (valueType == napi_number) {
2450 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2451 } else if (valueType == napi_function) {
2452 asyncContext->slotId = GetDefaultSlotId();
2453 NAPI_CALL(env, napi_create_reference(env, parameters[0], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2454 }
2455 } else if (parameterCount == PARAMETER_COUNT_TWO) {
2456 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2457 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2458 }
2459 return NapiUtil::HandleAsyncWork(
2460 env, asyncContext.release(), "getNROptionMode", NativeGetNrOptionMode, GetNrOptionModeCallback);
2461 }
2462
NativeFactoryReset(napi_env env,void * data)2463 static void NativeFactoryReset(napi_env env, void *data)
2464 {
2465 auto context = static_cast<FactoryResetContext *>(data);
2466 if (!IsValidSlotId(context->slotId)) {
2467 TELEPHONY_LOGE("NativeFactoryReset slotId is invalid");
2468 context->errorCode = ERROR_SLOT_ID_INVALID;
2469 return;
2470 }
2471 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().FactoryReset(context->slotId);
2472 if (context->errorCode == TELEPHONY_SUCCESS) {
2473 context->resolved = true;
2474 }
2475 TELEPHONY_LOGD("NativeFactoryReset end");
2476 }
2477
FactoryResetCallback(napi_env env,napi_status status,void * data)2478 static void FactoryResetCallback(napi_env env, napi_status status, void *data)
2479 {
2480 auto context = static_cast<FactoryResetContext *>(data);
2481 napi_value callbackValue = nullptr;
2482 if (context->resolved) {
2483 napi_get_undefined(env, &callbackValue);
2484 } else {
2485 JsError error =
2486 NapiUtil::ConverErrorMessageWithPermissionForJs(context->errorCode, "FactoryReset", SET_TELEPHONY_STATE);
2487 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2488 }
2489 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
2490 TELEPHONY_LOGD("FactoryResetCallback end");
2491 }
2492
FactoryReset(napi_env env,napi_callback_info info)2493 static napi_value FactoryReset(napi_env env, napi_callback_info info)
2494 {
2495 size_t parameterCount = PARAMETER_COUNT_ONE;
2496 napi_value parameters[PARAMETER_COUNT_ONE] = { 0 };
2497 napi_value thisVar = nullptr;
2498 void *data = nullptr;
2499 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
2500 if (!MatchFactoryResetParameter(env, parameters, parameterCount)) {
2501 TELEPHONY_LOGE("parameter matching failed.");
2502 NapiUtil::ThrowParameterError(env);
2503 return nullptr;
2504 }
2505 auto asyncContext = std::make_unique<FactoryResetContext>();
2506 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
2507 return NapiUtil::HandleAsyncWork(
2508 env, asyncContext.release(), "factoryReset", NativeFactoryReset, FactoryResetCallback);
2509 }
2510
NativeSetNrOptionMode(napi_env env,void * data)2511 static void NativeSetNrOptionMode(napi_env env, void *data)
2512 {
2513 auto asyncContext = static_cast<NrOptionModeContext *>(data);
2514 if (!IsValidSlotId(asyncContext->slotId)) {
2515 TELEPHONY_LOGE("NativeSetNrOptionMode slotId is invalid");
2516 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
2517 return;
2518 }
2519 auto setNrOptionModeCallback = std::make_unique<SetNrOptionModeCallback>(asyncContext);
2520 OHOS::sptr<INetworkSearchCallback> callback(setNrOptionModeCallback.release());
2521 std::unique_lock<std::mutex> callbackLock(asyncContext->callbackMutex);
2522 int32_t mode = asyncContext->nrOptionMode;
2523 asyncContext->errorCode =
2524 DelayedRefSingleton<CoreServiceClient>::GetInstance().SetNrOptionMode(asyncContext->slotId, mode, callback);
2525 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2526 asyncContext->cv.wait_for(
2527 callbackLock, std::chrono::seconds(WAIT_TIME_SECOND), [asyncContext] { return asyncContext->callbackEnd; });
2528 TELEPHONY_LOGD("NativeSetNrOptionMode after callback end");
2529 }
2530 }
2531
SetNrOptionModeCallback(napi_env env,napi_status status,void * data)2532 static void SetNrOptionModeCallback(napi_env env, napi_status status, void *data)
2533 {
2534 auto context = static_cast<NrOptionModeContext *>(data);
2535 TELEPHONY_LOGD("SetNrOptionModeCallback resolved = %{public}d", context->resolved);
2536 napi_value callbackValue = nullptr;
2537 if (context->resolved) {
2538 napi_get_undefined(env, &callbackValue);
2539 } else {
2540 if (context->errorCode == TELEPHONY_SUCCESS) {
2541 TELEPHONY_LOGE("SetNrOptionModeCallback time out, errorCode = %{public}d", context->errorCode);
2542 context->errorCode = TELEPHONY_ERR_FAIL;
2543 }
2544 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2545 context->errorCode, "setNROptionMode", SET_TELEPHONY_STATE);
2546 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2547 }
2548 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
2549 }
2550
SetNrOptionMode(napi_env env,napi_callback_info info)2551 static napi_value SetNrOptionMode(napi_env env, napi_callback_info info)
2552 {
2553 size_t parameterCount = PARAMETER_COUNT_THREE;
2554 napi_value parameters[PARAMETER_COUNT_THREE] = { 0 };
2555 napi_value thisVar = nullptr;
2556 void *data = nullptr;
2557 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
2558 if (!MatchSetNrOptionModeParameter(env, parameters, parameterCount)) {
2559 TELEPHONY_LOGE("SetNrOptionMode parameter matching failed.");
2560 NapiUtil::ThrowParameterError(env);
2561 return nullptr;
2562 }
2563 auto asyncContext = std::make_unique<NrOptionModeContext>();
2564 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
2565 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_SECOND], &asyncContext->nrOptionMode));
2566 if (parameterCount == PARAMETER_COUNT_THREE) {
2567 NAPI_CALL(env,
2568 napi_create_reference(env, parameters[ARRAY_INDEX_THIRD], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2569 }
2570 return NapiUtil::HandleAsyncWork(
2571 env, asyncContext.release(), "setNROptionMode", NativeSetNrOptionMode, SetNrOptionModeCallback);
2572 }
2573
IsNrSupported(napi_env env,napi_callback_info info)2574 static napi_value IsNrSupported(napi_env env, napi_callback_info info)
2575 {
2576 size_t parameterCount = PARAMETER_COUNT_ONE;
2577 napi_value parameters[PARAMETER_COUNT_ONE] = { 0 };
2578 void *data = nullptr;
2579 napi_value thisVar = nullptr;
2580 napi_value result = nullptr;
2581 bool isNrSupported = false;
2582 NAPI_CALL(env, napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data));
2583 if (!MatchIsNrSupportedParameter(env, parameters, parameterCount)) {
2584 TELEPHONY_LOGE("IsNrSupported parameter matching failed.");
2585 NapiUtil::ThrowParameterError(env);
2586 return nullptr;
2587 }
2588 TelephonyConfig telephonyConfig;
2589 isNrSupported =
2590 telephonyConfig.IsCapabilitySupport(static_cast<int32_t>(TelephonyConfig::ConfigType::MODEM_CAP_SUPPORT_NR));
2591 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
2592 TELEPHONY_EXT_UTILS_WRAPPER.InitTelephonyExtUtilsWrapper();
2593 if (TELEPHONY_EXT_UTILS_WRAPPER.isNrSupported_ != nullptr) {
2594 TELEPHONY_EXT_UTILS_WRAPPER.isNrSupported_(isNrSupported);
2595 }
2596 #endif
2597 TELEPHONY_LOGD("isNrSupported:%{public}d", isNrSupported);
2598 napi_get_boolean(env, isNrSupported, &result);
2599 return result;
2600 }
2601
NativeSetPrimarySlotId(napi_env env,void * data)2602 static void NativeSetPrimarySlotId(napi_env env, void *data)
2603 {
2604 auto context = static_cast<SetPrimarySlotIdContext *>(data);
2605 if (!IsValidSlotId(context->slotId)) {
2606 TELEPHONY_LOGE("NativeSetPrimarySlotId slotId is invalid");
2607 context->errorCode = ERROR_SLOT_ID_INVALID;
2608 return;
2609 }
2610 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().SetPrimarySlotId(context->slotId);
2611 TELEPHONY_LOGI("context->errorCode = %{public}d", context->errorCode);
2612 if (context->errorCode == TELEPHONY_ERR_SUCCESS) {
2613 context->resolved = true;
2614 }
2615 }
2616
SetPrimarySlotIdCallback(napi_env env,napi_status status,void * data)2617 static void SetPrimarySlotIdCallback(napi_env env, napi_status status, void *data)
2618 {
2619 auto context = static_cast<SetPrimarySlotIdContext *>(data);
2620 napi_value callbackValue = nullptr;
2621 if (context->resolved) {
2622 napi_get_undefined(env, &callbackValue);
2623 } else {
2624 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2625 context->errorCode, "setPrimarySlotId", SET_TELEPHONY_STATE);
2626 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2627 }
2628 NapiUtil::Handle1ValueCallback(env, context, callbackValue);
2629 }
2630
SetPrimarySlotId(napi_env env,napi_callback_info info)2631 static napi_value SetPrimarySlotId(napi_env env, napi_callback_info info)
2632 {
2633 size_t parameterCount = PARAMETER_COUNT_TWO;
2634 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
2635 napi_value thisVar;
2636 void *data;
2637 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
2638 if (!MatchGetISOCountryCodeForNetworkParameter(env, parameters, parameterCount)) {
2639 TELEPHONY_LOGE("SetPrimarySlotId parameter matching failed.");
2640 NapiUtil::ThrowParameterError(env);
2641 return nullptr;
2642 }
2643 auto asyncContext = std::make_unique<SetPrimarySlotIdContext>();
2644 NAPI_CALL(env, napi_get_value_int32(env, parameters[0], &asyncContext->slotId));
2645 if (parameterCount == PARAMETER_COUNT_TWO) {
2646 NAPI_CALL(env, napi_create_reference(env, parameters[1], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2647 }
2648 return NapiUtil::HandleAsyncWork(
2649 env, asyncContext.release(), "SetPrimarySlotId", NativeSetPrimarySlotId, SetPrimarySlotIdCallback);
2650 }
2651
NativeGetImsRegInfo(napi_env env,void * data)2652 static void NativeGetImsRegInfo(napi_env env, void *data)
2653 {
2654 auto context = static_cast<GetImsRegInfoContext *>(data);
2655 if (!IsValidSlotId(context->slotId)) {
2656 TELEPHONY_LOGE("NativeGetImsRegInfo slotId is invalid");
2657 context->errorCode = TELEPHONY_ERR_SLOTID_INVALID;
2658 return;
2659 }
2660 context->errorCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetImsRegStatus(
2661 context->slotId, static_cast<ImsServiceType>(context->imsSrvType), context->imsRegInfo);
2662 TELEPHONY_LOGD("result is %{public}d", context->errorCode);
2663 context->resolved = (context->errorCode == TELEPHONY_SUCCESS);
2664 }
2665
GetImsRegInfoCallback(napi_env env,napi_status status,void * data)2666 static void GetImsRegInfoCallback(napi_env env, napi_status status, void *data)
2667 {
2668 TELEPHONY_LOGD("status = %{public}d", status);
2669 auto context = static_cast<GetImsRegInfoContext *>(data);
2670 napi_value callbackValue = nullptr;
2671 JsError error = {};
2672 if (status == napi_ok) {
2673 TELEPHONY_LOGD("context->resolved = %{public}d", context->resolved);
2674 if (context->resolved) {
2675 napi_create_object(env, &callbackValue);
2676 NapiUtil::SetPropertyInt32(
2677 env, callbackValue, "imsRegState", static_cast<int32_t>(context->imsRegInfo.imsRegState));
2678 NapiUtil::SetPropertyInt32(
2679 env, callbackValue, "imsRegTech", static_cast<int32_t>(context->imsRegInfo.imsRegTech));
2680 } else {
2681 error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2682 context->errorCode, "getImsRegInfo", GET_TELEPHONY_STATE);
2683 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2684 }
2685 } else {
2686 error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2687 ERROR_NATIVE_API_EXECUTE_FAIL, "getImsRegInfo", GET_TELEPHONY_STATE);
2688 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2689 }
2690 NapiUtil::Handle2ValueCallback(env, context, callbackValue);
2691 }
2692
MatchGetImsRegInfoParameter(napi_env env,napi_value parameters[],size_t parameterCount)2693 static bool MatchGetImsRegInfoParameter(napi_env env, napi_value parameters[], size_t parameterCount)
2694 {
2695 switch (parameterCount) {
2696 case PARAMETER_COUNT_TWO: {
2697 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number });
2698 }
2699 case PARAMETER_COUNT_THREE: {
2700 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
2701 }
2702 default: {
2703 return false;
2704 }
2705 }
2706 }
2707
ReportFunctionFailed(napi_env env,int32_t resultCode,std::string funcName)2708 static void ReportFunctionFailed(napi_env env, int32_t resultCode, std::string funcName)
2709 {
2710 JsError error = {};
2711 switch (resultCode) {
2712 case TELEPHONY_ERR_PERMISSION_ERR:
2713 error = NapiUtil::ConverErrorMessageWithPermissionForJs(resultCode, funcName, GET_TELEPHONY_STATE);
2714 break;
2715 default:
2716 error = NapiUtil::ConverErrorMessageForJs(resultCode);
2717 break;
2718 }
2719 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
2720 }
2721
GetImsRegInfo(napi_env env,napi_callback_info info)2722 static napi_value GetImsRegInfo(napi_env env, napi_callback_info info)
2723 {
2724 size_t parameterCount = PARAMETER_COUNT_THREE;
2725 napi_value parameters[PARAMETER_COUNT_THREE] = { 0 };
2726 napi_value thisVar = nullptr;
2727 void *data = nullptr;
2728 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
2729 if (!MatchGetImsRegInfoParameter(env, parameters, parameterCount)) {
2730 ReportFunctionFailed(env, ERROR_PARAMETER_COUNTS_INVALID, "GetImsRegInfo");
2731 return nullptr;
2732 }
2733 auto asyncContext = std::make_unique<GetImsRegInfoContext>();
2734 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
2735 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_SECOND], &asyncContext->imsSrvType));
2736 if (parameterCount == PARAMETER_COUNT_THREE) {
2737 NAPI_CALL(env,
2738 napi_create_reference(env, parameters[ARRAY_INDEX_THIRD], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2739 }
2740 return NapiUtil::HandleAsyncWork(
2741 env, asyncContext.release(), "GetImsRegInfo", NativeGetImsRegInfo, GetImsRegInfoCallback);
2742 }
2743
RegisterImsRegStateCallback(napi_env env,napi_value thisVar,int32_t slotId,int32_t imsSrvType,napi_value argv[])2744 static bool RegisterImsRegStateCallback(
2745 napi_env env, napi_value thisVar, int32_t slotId, int32_t imsSrvType, napi_value argv[])
2746 {
2747 ImsRegStateCallback stateCallback;
2748 stateCallback.env = env;
2749 stateCallback.slotId = slotId;
2750 stateCallback.imsSrvType = static_cast<ImsServiceType>(imsSrvType);
2751 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(stateCallback.thisVar));
2752 napi_create_reference(env, argv[ARRAY_INDEX_FOURTH], DEFAULT_REF_COUNT, &(stateCallback.callbackRef));
2753
2754 int32_t ret =
2755 DelayedSingleton<NapiImsRegInfoCallbackManager>::GetInstance()->RegisterImsRegStateCallback(stateCallback);
2756 if (ret != TELEPHONY_SUCCESS) {
2757 TELEPHONY_LOGE("Register imsRegState callback failed");
2758 ReportFunctionFailed(env, ret, "on_imsRegStateChange");
2759 return false;
2760 }
2761 return true;
2762 }
2763
MatchObserverOnParameter(napi_env env,napi_value parameters[],size_t parameterCount)2764 static bool MatchObserverOnParameter(napi_env env, napi_value parameters[], size_t parameterCount)
2765 {
2766 switch (parameterCount) {
2767 case PARAMETER_COUNT_FOUR: {
2768 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_number, napi_number, napi_function });
2769 }
2770 default: {
2771 return false;
2772 }
2773 }
2774 }
2775
MatchObserverOffParameter(napi_env env,napi_value parameters[],size_t parameterCount)2776 static bool MatchObserverOffParameter(napi_env env, napi_value parameters[], size_t parameterCount)
2777 {
2778 switch (parameterCount) {
2779 case PARAMETER_COUNT_THREE: {
2780 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_number, napi_number });
2781 }
2782 case PARAMETER_COUNT_FOUR: {
2783 return NapiUtil::MatchParameters(
2784 env, parameters, { napi_string, napi_number, napi_number, napi_function }) ||
2785 NapiUtil::MatchParameters(
2786 env, parameters, { napi_string, napi_number, napi_number, napi_null }) ||
2787 NapiUtil::MatchParameters(
2788 env, parameters, { napi_string, napi_number, napi_number, napi_undefined });
2789 }
2790 default: {
2791 return false;
2792 }
2793 }
2794 }
2795
IsValidImsSrvType(napi_env env,int32_t imsSrvType,const std::string & funcName)2796 static bool IsValidImsSrvType(napi_env env, int32_t imsSrvType, const std::string &funcName)
2797 {
2798 bool flag = true;
2799 switch (imsSrvType) {
2800 case ImsServiceType::TYPE_VOICE:
2801 case ImsServiceType::TYPE_VIDEO:
2802 case ImsServiceType::TYPE_UT:
2803 case ImsServiceType::TYPE_SMS:
2804 break;
2805 default:
2806 TELEPHONY_LOGE("imsSrvType %{public}d is invalid", imsSrvType);
2807 ReportFunctionFailed(env, TELEPHONY_ERR_ARGUMENT_INVALID, funcName);
2808 flag = false;
2809 break;
2810 }
2811
2812 return flag;
2813 }
2814
MatchGetBasebandVersion(napi_env env,napi_value parameters[],size_t parameterCount)2815 static bool MatchGetBasebandVersion(napi_env env, napi_value parameters[], size_t parameterCount)
2816 {
2817 switch (parameterCount) {
2818 case PARAMETER_COUNT_ONE: {
2819 return NapiUtil::MatchParameters(env, parameters, { napi_number });
2820 }
2821 case PARAMETER_COUNT_TWO: {
2822 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
2823 }
2824 default:
2825 return false;
2826 }
2827 }
2828
NativeGetBasebandVersion(napi_env env,void * data)2829 static void NativeGetBasebandVersion(napi_env env, void *data)
2830 {
2831 auto asyncContext = static_cast<GetBasebandVersionContext *>(data);
2832 if (!IsValidSlotId(asyncContext->slotId)) {
2833 TELEPHONY_LOGE("NativeGetBasebandVersion slotId is invalid");
2834 asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
2835 return;
2836 }
2837 std::string version = "";
2838 asyncContext->errorCode =
2839 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetBasebandVersion(asyncContext->slotId, version);
2840 TELEPHONY_LOGI("errorCode = %{public}d", asyncContext->errorCode);
2841 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2842 asyncContext->resolved = true;
2843 asyncContext->getBasebandVersion = version;
2844 }
2845 }
2846
GetBasebandVersionCallback(napi_env env,napi_status status,void * data)2847 static void GetBasebandVersionCallback(napi_env env, napi_status status, void *data)
2848 {
2849 auto asyncContext = static_cast<GetBasebandVersionContext *>(data);
2850 napi_value callbackValue = nullptr;
2851 if (asyncContext->resolved) {
2852 napi_create_string_utf8(
2853 env, asyncContext->getBasebandVersion.c_str(), asyncContext->getBasebandVersion.size(), &callbackValue);
2854 } else {
2855 JsError error = NapiUtil::ConverErrorMessageWithPermissionForJs(
2856 asyncContext->errorCode, "getBasebandVersion", GET_TELEPHONY_STATE);
2857 callbackValue = NapiUtil::CreateErrorMessage(env, error.errorMessage, error.errorCode);
2858 }
2859 NapiUtil::Handle2ValueCallback(env, asyncContext, callbackValue);
2860 }
2861
GetBasebandVersion(napi_env env,napi_callback_info info)2862 static napi_value GetBasebandVersion(napi_env env, napi_callback_info info)
2863 {
2864 size_t parameterCount = PARAMETER_COUNT_TWO;
2865 napi_value parameters[PARAMETER_COUNT_TWO] = { 0 };
2866 napi_value thisVar = nullptr;
2867 void *data = nullptr;
2868 napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);
2869 if (!MatchGetBasebandVersion(env, parameters, parameterCount)) {
2870 TELEPHONY_LOGE("GetBasebandVersion MatchGetBasebandVersion failed.");
2871 NapiUtil::ThrowParameterError(env);
2872 return nullptr;
2873 }
2874 auto asyncContext = std::make_unique<GetBasebandVersionContext>();
2875 NAPI_CALL(env, napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext->slotId));
2876 if (parameterCount == PARAMETER_COUNT_TWO) {
2877 NAPI_CALL(env,
2878 napi_create_reference(env, parameters[ARRAY_INDEX_SECOND], DEFAULT_REF_COUNT, &asyncContext->callbackRef));
2879 }
2880 return NapiUtil::HandleAsyncWork(
2881 env, asyncContext.release(), "GetBasebandVersion", NativeGetBasebandVersion, GetBasebandVersionCallback);
2882 }
2883
ObserverOn(napi_env env,napi_callback_info info)2884 static napi_value ObserverOn(napi_env env, napi_callback_info info)
2885 {
2886 size_t argc = PARAMETER_COUNT_FOUR;
2887 napi_value argv[PARAMETER_COUNT_FOUR];
2888 napi_value thisVar;
2889 if (napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL) != napi_ok) {
2890 TELEPHONY_LOGE("Can not get thisVar value");
2891 return nullptr;
2892 }
2893 if (!MatchObserverOnParameter(env, argv, argc)) {
2894 ReportFunctionFailed(env, ERROR_PARAMETER_COUNTS_INVALID, "on_imsRegStateChange");
2895 return nullptr;
2896 }
2897 size_t strLength = 0;
2898 char callbackType[INFO_MAXIMUM_LIMIT + 1];
2899 if (napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], callbackType, INFO_MAXIMUM_LIMIT, &strLength) !=
2900 napi_ok) {
2901 TELEPHONY_LOGE("Can not get callbackType value");
2902 return nullptr;
2903 }
2904 std::string tmpStr = callbackType;
2905 if (tmpStr.compare("imsRegStateChange") != 0) {
2906 TELEPHONY_LOGE("callbackType is not imsRegStateChange and is %{public}s", tmpStr.c_str());
2907 ReportFunctionFailed(env, TELEPHONY_ERR_ARGUMENT_INVALID, "on_imsRegStateChange");
2908 return nullptr;
2909 }
2910 int32_t slotId;
2911 if (napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &slotId) != napi_ok) {
2912 TELEPHONY_LOGE("Can not get slotId value");
2913 return nullptr;
2914 }
2915 if (!IsValidSlotIdEx(slotId)) {
2916 TELEPHONY_LOGE("slotId%{public}d is invalid", slotId);
2917 ReportFunctionFailed(env, TELEPHONY_ERR_ARGUMENT_INVALID, "on_imsRegStateChange");
2918 return nullptr;
2919 }
2920 int32_t imsSrvType;
2921 if (napi_get_value_int32(env, argv[ARRAY_INDEX_THIRD], &imsSrvType) != napi_ok) {
2922 TELEPHONY_LOGE("Can not get imsSrvType value");
2923 return nullptr;
2924 }
2925 if (!IsValidImsSrvType(env, imsSrvType, "on_imsRegStateChange")) {
2926 return nullptr;
2927 }
2928 if (!RegisterImsRegStateCallback(env, thisVar, slotId, imsSrvType, argv)) {
2929 return nullptr;
2930 }
2931 napi_value result = nullptr;
2932 napi_get_undefined(env, &result);
2933 return result;
2934 }
2935
UnregisterImsRegStateCallback(napi_env env,int32_t slotId,ImsServiceType imsSrvType)2936 static bool UnregisterImsRegStateCallback(napi_env env, int32_t slotId, ImsServiceType imsSrvType)
2937 {
2938 int32_t ret = DelayedSingleton<NapiImsRegInfoCallbackManager>::GetInstance()->UnregisterImsRegStateCallback(
2939 env, slotId, imsSrvType);
2940 if (ret != TELEPHONY_SUCCESS) {
2941 ReportFunctionFailed(env, ret, "off_imsRegStateChange");
2942 return false;
2943 }
2944 return true;
2945 }
2946
ObserverOff(napi_env env,napi_callback_info info)2947 static napi_value ObserverOff(napi_env env, napi_callback_info info)
2948 {
2949 size_t argc = PARAMETER_COUNT_FOUR;
2950 napi_value argv[PARAMETER_COUNT_FOUR];
2951 napi_value thisVar;
2952 if (napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL) != napi_ok) {
2953 TELEPHONY_LOGE("Can not get thisVar value");
2954 return nullptr;
2955 }
2956 if (!MatchObserverOffParameter(env, argv, argc)) {
2957 ReportFunctionFailed(env, ERROR_PARAMETER_COUNTS_INVALID, "off_imsRegStateChange");
2958 return nullptr;
2959 }
2960 size_t strLength = 0;
2961 char callbackType[INFO_MAXIMUM_LIMIT + 1];
2962 if (napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], callbackType, INFO_MAXIMUM_LIMIT, &strLength) !=
2963 napi_ok) {
2964 TELEPHONY_LOGE("Can not get callbackType value");
2965 return nullptr;
2966 }
2967 std::string tmpStr = callbackType;
2968 if (tmpStr.compare("imsRegStateChange") != 0) {
2969 TELEPHONY_LOGE("callbackType is not imsRegStateChange and is %{public}s", tmpStr.c_str());
2970 ReportFunctionFailed(env, TELEPHONY_ERR_ARGUMENT_INVALID, "off_imsRegStateChange");
2971 return nullptr;
2972 }
2973 int32_t slotId;
2974 if (napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &slotId) != napi_ok) {
2975 TELEPHONY_LOGE("Can not get slotId value");
2976 return nullptr;
2977 }
2978 if (!IsValidSlotIdEx(slotId)) {
2979 TELEPHONY_LOGE("slotId%{public}d is invalid", slotId);
2980 ReportFunctionFailed(env, TELEPHONY_ERR_ARGUMENT_INVALID, "off_imsRegStateChange");
2981 return nullptr;
2982 }
2983 int32_t imsSrvType;
2984 if (napi_get_value_int32(env, argv[ARRAY_INDEX_THIRD], &imsSrvType) != napi_ok) {
2985 TELEPHONY_LOGE("Can not get imsSrvType value");
2986 return nullptr;
2987 }
2988 if (!IsValidImsSrvType(env, imsSrvType, "off_imsRegStateChange")) {
2989 return nullptr;
2990 }
2991 if (!UnregisterImsRegStateCallback(env, slotId, static_cast<ImsServiceType>(imsSrvType))) {
2992 return nullptr;
2993 }
2994 napi_value result = nullptr;
2995 napi_get_undefined(env, &result);
2996 return result;
2997 }
2998
InitEnumRadioType(napi_env env,napi_value exports)2999 static napi_value InitEnumRadioType(napi_env env, napi_value exports)
3000 {
3001 napi_property_descriptor desc[] = {
3002 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_UNKNOWN",
3003 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_UNKNOWN))),
3004 DECLARE_NAPI_STATIC_PROPERTY(
3005 "RADIO_TECHNOLOGY_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_GSM))),
3006 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_1XRTT",
3007 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_1XRTT))),
3008 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_WCDMA",
3009 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_WCDMA))),
3010 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_HSPA",
3011 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPA))),
3012 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_HSPAP",
3013 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPAP))),
3014 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_TD_SCDMA",
3015 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_TD_SCDMA))),
3016 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_EVDO",
3017 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EVDO))),
3018 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_EHRPD",
3019 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EHRPD))),
3020 DECLARE_NAPI_STATIC_PROPERTY(
3021 "RADIO_TECHNOLOGY_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE))),
3022 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_LTE_CA",
3023 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE_CA))),
3024 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_IWLAN",
3025 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_IWLAN))),
3026 DECLARE_NAPI_STATIC_PROPERTY(
3027 "RADIO_TECHNOLOGY_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_NR))),
3028 };
3029 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3030 return exports;
3031 }
3032
InitEnumNetworkType(napi_env env,napi_value exports)3033 static napi_value InitEnumNetworkType(napi_env env, napi_value exports)
3034 {
3035 napi_property_descriptor desc[] = {
3036 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_TYPE_UNKNOWN",
3037 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN))),
3038 DECLARE_NAPI_STATIC_PROPERTY(
3039 "NETWORK_TYPE_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_GSM))),
3040 DECLARE_NAPI_STATIC_PROPERTY(
3041 "NETWORK_TYPE_CDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_CDMA))),
3042 DECLARE_NAPI_STATIC_PROPERTY(
3043 "NETWORK_TYPE_WCDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_WCDMA))),
3044 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_TYPE_TDSCDMA",
3045 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_TDSCDMA))),
3046 DECLARE_NAPI_STATIC_PROPERTY(
3047 "NETWORK_TYPE_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_LTE))),
3048 DECLARE_NAPI_STATIC_PROPERTY(
3049 "NETWORK_TYPE_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_NR))),
3050 };
3051 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3052 return exports;
3053 }
3054
InitEnumRegStatus(napi_env env,napi_value exports)3055 static napi_value InitEnumRegStatus(napi_env env, napi_value exports)
3056 {
3057 napi_property_descriptor desc[] = {
3058 DECLARE_NAPI_STATIC_PROPERTY(
3059 "REG_STATE_NO_SERVICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_NO_SERVICE))),
3060 DECLARE_NAPI_STATIC_PROPERTY(
3061 "REG_STATE_IN_SERVICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_IN_SERVICE))),
3062 DECLARE_NAPI_STATIC_PROPERTY("REG_STATE_EMERGENCY_CALL_ONLY",
3063 NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_EMERGENCY_CALL_ONLY))),
3064 DECLARE_NAPI_STATIC_PROPERTY(
3065 "REG_STATE_POWER_OFF", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_POWER_OFF))),
3066 };
3067 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3068 return exports;
3069 }
3070
InitEnumNsaState(napi_env env,napi_value exports)3071 static napi_value InitEnumNsaState(napi_env env, napi_value exports)
3072 {
3073 napi_property_descriptor desc[] = {
3074 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_NOT_SUPPORT",
3075 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_NOT_SUPPORT))),
3076 DECLARE_NAPI_STATIC_PROPERTY(
3077 "NSA_STATE_NO_DETECT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_NO_DETECT))),
3078 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_CONNECTED_DETECT",
3079 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_CONNECTED_DETECT))),
3080 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_IDLE_DETECT",
3081 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_IDLE_DETECT))),
3082 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_DUAL_CONNECTED",
3083 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_DUAL_CONNECTED))),
3084 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_SA_ATTACHED",
3085 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_SA_ATTACHED))),
3086 };
3087 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3088 return exports;
3089 }
3090
InitEnumNetworkSelectionMode(napi_env env,napi_value exports)3091 static napi_value InitEnumNetworkSelectionMode(napi_env env, napi_value exports)
3092 {
3093 napi_property_descriptor desc[] = {
3094 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_SELECTION_UNKNOWN",
3095 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_UNKNOWN))),
3096 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_SELECTION_AUTOMATIC",
3097 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_AUTOMATIC))),
3098 DECLARE_NAPI_STATIC_PROPERTY(
3099 "NETWORK_SELECTION_MANUAL", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_MANUAL))),
3100 };
3101 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3102 return exports;
3103 }
3104
InitEnumNetworkInformationState(napi_env env,napi_value exports)3105 static napi_value InitEnumNetworkInformationState(napi_env env, napi_value exports)
3106 {
3107 napi_property_descriptor desc[] = {
3108 DECLARE_NAPI_STATIC_PROPERTY(
3109 "NETWORK_UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_UNKNOWN))),
3110 DECLARE_NAPI_STATIC_PROPERTY(
3111 "NETWORK_AVAILABLE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_AVAILABLE))),
3112 DECLARE_NAPI_STATIC_PROPERTY(
3113 "NETWORK_CURRENT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_CURRENT))),
3114 DECLARE_NAPI_STATIC_PROPERTY(
3115 "NETWORK_FORBIDDEN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_FORBIDDEN))),
3116 };
3117 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3118 return exports;
3119 }
3120
InitEnumPreferredNetwork(napi_env env,napi_value exports)3121 static napi_value InitEnumPreferredNetwork(napi_env env, napi_value exports)
3122 {
3123 napi_property_descriptor desc[] = {
3124 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3125 NapiUtil::ToInt32Value(
3126 env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3127 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM",
3128 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM))),
3129 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA",
3130 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA))),
3131 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_GSM",
3132 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_GSM))),
3133 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA",
3134 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA))),
3135 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA",
3136 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA))),
3137 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_EVDO_CDMA",
3138 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_EVDO_CDMA))),
3139 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM",
3140 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM))),
3141 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA",
3142 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA))),
3143 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE",
3144 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE))),
3145 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR",
3146 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR))),
3147 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3148 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3149 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3150 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3151 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM",
3152 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM))),
3153 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA",
3154 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA))),
3155 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_GSM",
3156 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_GSM))),
3157 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA",
3158 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA))),
3159 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM",
3160 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM))),
3161 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA",
3162 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA))),
3163 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_GSM",
3164 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_GSM))),
3165 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA",
3166 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA))),
3167 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA",
3168 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA))),
3169 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_EVDO_CDMA",
3170 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_EVDO_CDMA))),
3171 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA",
3172 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA))),
3173 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_EVDO_CDMA",
3174 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_EVDO_CDMA))),
3175 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_EVDO",
3176 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_EVDO))),
3177 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_CDMA",
3178 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_CDMA))),
3179 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA_GSM",
3180 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA_GSM))),
3181 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM",
3182 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM))),
3183 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA",
3184 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA))),
3185 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE",
3186 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE))),
3187 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA",
3188 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA))),
3189 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_GSM",
3190 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_GSM))),
3191 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_AUTO",
3192 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_AUTO))),
3193 };
3194 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3195 return exports;
3196 }
3197
InitEnumNrOptionMode(napi_env env,napi_value exports)3198 static napi_value InitEnumNrOptionMode(napi_env env, napi_value exports)
3199 {
3200 napi_property_descriptor desc[] = {
3201 DECLARE_NAPI_STATIC_PROPERTY(
3202 "NR_OPTION_UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_UNKNOWN))),
3203 DECLARE_NAPI_STATIC_PROPERTY(
3204 "NR_OPTION_NSA_ONLY", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_NSA_ONLY))),
3205 DECLARE_NAPI_STATIC_PROPERTY(
3206 "NR_OPTION_SA_ONLY", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_SA_ONLY))),
3207 DECLARE_NAPI_STATIC_PROPERTY(
3208 "NR_OPTION_NSA_AND_SA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_NSA_AND_SA))),
3209 };
3210 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3211 return exports;
3212 }
3213
InitEnumImsRegState(napi_env env,napi_value exports)3214 static napi_value InitEnumImsRegState(napi_env env, napi_value exports)
3215 {
3216 napi_property_descriptor desc[] = {
3217 DECLARE_NAPI_STATIC_PROPERTY(
3218 "IMS_UNREGISTERED", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_UNREGISTERED))),
3219 DECLARE_NAPI_STATIC_PROPERTY(
3220 "IMS_REGISTERED", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REGISTERED))),
3221 };
3222 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3223 return exports;
3224 }
3225
InitEnumImsRegTech(napi_env env,napi_value exports)3226 static napi_value InitEnumImsRegTech(napi_env env, napi_value exports)
3227 {
3228 napi_property_descriptor desc[] = {
3229 DECLARE_NAPI_STATIC_PROPERTY(
3230 "REGISTRATION_TECH_NONE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_NONE))),
3231 DECLARE_NAPI_STATIC_PROPERTY(
3232 "REGISTRATION_TECH_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_LTE))),
3233 DECLARE_NAPI_STATIC_PROPERTY(
3234 "REGISTRATION_TECH_IWLAN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_IWLAN))),
3235 DECLARE_NAPI_STATIC_PROPERTY(
3236 "REGISTRATION_TECH_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_NR))),
3237 };
3238 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3239 return exports;
3240 }
3241
InitEnumImsServiceType(napi_env env,napi_value exports)3242 static napi_value InitEnumImsServiceType(napi_env env, napi_value exports)
3243 {
3244 napi_property_descriptor desc[] = {
3245 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VOICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_VOICE))),
3246 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_VIDEO))),
3247 DECLARE_NAPI_STATIC_PROPERTY("TYPE_UT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_UT))),
3248 DECLARE_NAPI_STATIC_PROPERTY("TYPE_SMS", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_SMS))),
3249 };
3250 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3251 return exports;
3252 }
3253
InitEnumNetworkCapabilityType(napi_env env,napi_value exports)3254 static napi_value InitEnumNetworkCapabilityType(napi_env env, napi_value exports)
3255 {
3256 napi_property_descriptor desc[] = {
3257 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_TYPE_LTE",
3258 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_LTE))),
3259 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_TYPE_NR",
3260 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_NR))),
3261 };
3262 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3263 return exports;
3264 }
3265
InitEnumNetworkCapabilityState(napi_env env,napi_value exports)3266 static napi_value InitEnumNetworkCapabilityState(napi_env env, napi_value exports)
3267 {
3268 napi_property_descriptor desc[] = {
3269 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_CAPABILITY_OFF",
3270 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_OFF))),
3271 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_CAPABILITY_ON",
3272 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_ON))),
3273 };
3274 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3275 return exports;
3276 }
3277
CreateEnumConstructor(napi_env env,napi_callback_info info)3278 static napi_value CreateEnumConstructor(napi_env env, napi_callback_info info)
3279 {
3280 napi_value thisArg = nullptr;
3281 void *data = nullptr;
3282 napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
3283 napi_value global = nullptr;
3284 napi_get_global(env, &global);
3285 return thisArg;
3286 }
3287
CreateRadioType(napi_env env,napi_value exports)3288 static napi_value CreateRadioType(napi_env env, napi_value exports)
3289 {
3290 napi_property_descriptor desc[] = {
3291 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_UNKNOWN",
3292 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_UNKNOWN))),
3293 DECLARE_NAPI_STATIC_PROPERTY(
3294 "RADIO_TECHNOLOGY_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_GSM))),
3295 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_1XRTT",
3296 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_1XRTT))),
3297 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_WCDMA",
3298 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_WCDMA))),
3299 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_HSPA",
3300 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPA))),
3301 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_HSPAP",
3302 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPAP))),
3303 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_TD_SCDMA",
3304 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_TD_SCDMA))),
3305 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_EVDO",
3306 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EVDO))),
3307 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_EHRPD",
3308 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EHRPD))),
3309 DECLARE_NAPI_STATIC_PROPERTY(
3310 "RADIO_TECHNOLOGY_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE))),
3311 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_LTE_CA",
3312 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE_CA))),
3313 DECLARE_NAPI_STATIC_PROPERTY("RADIO_TECHNOLOGY_IWLAN",
3314 NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_IWLAN))),
3315 DECLARE_NAPI_STATIC_PROPERTY(
3316 "RADIO_TECHNOLOGY_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_NR))),
3317 };
3318 napi_value result = nullptr;
3319 napi_define_class(env, "RadioTechnology", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3320 sizeof(desc) / sizeof(*desc), desc, &result);
3321 napi_set_named_property(env, exports, "RadioTechnology", result);
3322 return exports;
3323 }
3324
CreateNetworkCapabilityType(napi_env env,napi_value exports)3325 static napi_value CreateNetworkCapabilityType(napi_env env, napi_value exports)
3326 {
3327 napi_property_descriptor desc[] = {
3328 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_TYPE_LTE",
3329 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_LTE))),
3330 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_TYPE_NR",
3331 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityType::SERVICE_TYPE_NR))),
3332 };
3333 napi_value result = nullptr;
3334 napi_define_class(env, "NetworkCapabilityType", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3335 sizeof(desc) / sizeof(*desc), desc, &result);
3336 napi_set_named_property(env, exports, "NetworkCapabilityType", result);
3337 return exports;
3338 }
3339
CreateNetworkCapabilityState(napi_env env,napi_value exports)3340 static napi_value CreateNetworkCapabilityState(napi_env env, napi_value exports)
3341 {
3342 napi_property_descriptor desc[] = {
3343 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_CAPABILITY_OFF",
3344 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_OFF))),
3345 DECLARE_NAPI_STATIC_PROPERTY("SERVICE_CAPABILITY_ON",
3346 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkCapabilityState::SERVICE_CAPABILITY_ON))),
3347 };
3348 napi_value result = nullptr;
3349 napi_define_class(env, "NetworkCapabilityState", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3350 sizeof(desc) / sizeof(*desc), desc, &result);
3351 napi_set_named_property(env, exports, "NetworkCapabilityState", result);
3352 return exports;
3353 }
3354
CreateNetworkType(napi_env env,napi_value exports)3355 static napi_value CreateNetworkType(napi_env env, napi_value exports)
3356 {
3357 napi_property_descriptor desc[] = {
3358 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_TYPE_UNKNOWN",
3359 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_UNKNOWN))),
3360 DECLARE_NAPI_STATIC_PROPERTY(
3361 "NETWORK_TYPE_GSM", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_GSM))),
3362 DECLARE_NAPI_STATIC_PROPERTY(
3363 "NETWORK_TYPE_CDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_CDMA))),
3364 DECLARE_NAPI_STATIC_PROPERTY(
3365 "NETWORK_TYPE_WCDMA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_WCDMA))),
3366 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_TYPE_TDSCDMA",
3367 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_TDSCDMA))),
3368 DECLARE_NAPI_STATIC_PROPERTY(
3369 "NETWORK_TYPE_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_LTE))),
3370 DECLARE_NAPI_STATIC_PROPERTY(
3371 "NETWORK_TYPE_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NetworkType::NETWORK_TYPE_NR))),
3372 };
3373 napi_value result = nullptr;
3374 napi_define_class(env, "NetworkType", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3375 sizeof(desc) / sizeof(*desc), desc, &result);
3376 napi_set_named_property(env, exports, "NetworkType", result);
3377 return exports;
3378 }
3379
CreateRegStatus(napi_env env,napi_value exports)3380 static napi_value CreateRegStatus(napi_env env, napi_value exports)
3381 {
3382 napi_property_descriptor desc[] = {
3383 DECLARE_NAPI_STATIC_PROPERTY(
3384 "REG_STATE_NO_SERVICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_NO_SERVICE))),
3385 DECLARE_NAPI_STATIC_PROPERTY(
3386 "REG_STATE_IN_SERVICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_IN_SERVICE))),
3387 DECLARE_NAPI_STATIC_PROPERTY("REG_STATE_EMERGENCY_CALL_ONLY",
3388 NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_EMERGENCY_CALL_ONLY))),
3389 DECLARE_NAPI_STATIC_PROPERTY(
3390 "REG_STATE_POWER_OFF", NapiUtil::ToInt32Value(env, static_cast<int32_t>(REGISTRATION_STATE_POWER_OFF))),
3391 };
3392 napi_value result = nullptr;
3393 napi_define_class(env, "RegState", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr, sizeof(desc) / sizeof(*desc),
3394 desc, &result);
3395 napi_set_named_property(env, exports, "RegState", result);
3396 return exports;
3397 }
3398
CreateNsaState(napi_env env,napi_value exports)3399 static napi_value CreateNsaState(napi_env env, napi_value exports)
3400 {
3401 napi_property_descriptor desc[] = {
3402 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_NOT_SUPPORT",
3403 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_NOT_SUPPORT))),
3404 DECLARE_NAPI_STATIC_PROPERTY(
3405 "NSA_STATE_NO_DETECT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_NO_DETECT))),
3406 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_CONNECTED_DETECT",
3407 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_CONNECTED_DETECT))),
3408 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_IDLE_DETECT",
3409 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_IDLE_DETECT))),
3410 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_DUAL_CONNECTED",
3411 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_DUAL_CONNECTED))),
3412 DECLARE_NAPI_STATIC_PROPERTY("NSA_STATE_SA_ATTACHED",
3413 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NsaState::NSA_STATE_SA_ATTACHED))),
3414 };
3415 napi_value result = nullptr;
3416 napi_define_class(env, "NsaState", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr, sizeof(desc) / sizeof(*desc),
3417 desc, &result);
3418 napi_set_named_property(env, exports, "NsaState", result);
3419 return exports;
3420 }
3421
CreateNetworkSelectionMode(napi_env env,napi_value exports)3422 static napi_value CreateNetworkSelectionMode(napi_env env, napi_value exports)
3423 {
3424 napi_property_descriptor desc[] = {
3425 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_SELECTION_UNKNOWN",
3426 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_UNKNOWN))),
3427 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_SELECTION_AUTOMATIC",
3428 NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_AUTOMATIC))),
3429 DECLARE_NAPI_STATIC_PROPERTY(
3430 "NETWORK_SELECTION_MANUAL", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_SELECTION_MANUAL))),
3431 };
3432 napi_value result = nullptr;
3433 napi_define_class(env, "NetworkSelectionMode", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3434 sizeof(desc) / sizeof(*desc), desc, &result);
3435 napi_set_named_property(env, exports, "NetworkSelectionMode", result);
3436 return exports;
3437 }
3438
CreateNetworkInformationState(napi_env env,napi_value exports)3439 static napi_value CreateNetworkInformationState(napi_env env, napi_value exports)
3440 {
3441 napi_property_descriptor desc[] = {
3442 DECLARE_NAPI_STATIC_PROPERTY(
3443 "NETWORK_UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_UNKNOWN))),
3444 DECLARE_NAPI_STATIC_PROPERTY(
3445 "NETWORK_AVAILABLE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_AVAILABLE))),
3446 DECLARE_NAPI_STATIC_PROPERTY(
3447 "NETWORK_CURRENT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_CURRENT))),
3448 DECLARE_NAPI_STATIC_PROPERTY(
3449 "NETWORK_FORBIDDEN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NETWORK_FORBIDDEN))),
3450 };
3451 napi_value result = nullptr;
3452 napi_define_class(env, "NetworkInformationState", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3453 sizeof(desc) / sizeof(*desc), desc, &result);
3454 napi_set_named_property(env, exports, "NetworkInformationState", result);
3455 return exports;
3456 }
3457
CreatePreferredNetwork(napi_env env,napi_value exports)3458 static napi_value CreatePreferredNetwork(napi_env env, napi_value exports)
3459 {
3460 napi_property_descriptor desc[] = {
3461 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_AUTO",
3462 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_AUTO))),
3463 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_GSM",
3464 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_GSM))),
3465 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA",
3466 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA))),
3467 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE",
3468 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE))),
3469 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA",
3470 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA))),
3471 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM",
3472 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM))),
3473 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA_GSM",
3474 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA_GSM))),
3475 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_CDMA",
3476 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_CDMA))),
3477 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_EVDO",
3478 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_EVDO))),
3479 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_EVDO_CDMA",
3480 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_EVDO_CDMA))),
3481 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA",
3482 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA))),
3483 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_EVDO_CDMA",
3484 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_EVDO_CDMA))),
3485 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA",
3486 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA))),
3487 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA",
3488 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA))),
3489 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_GSM",
3490 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_GSM))),
3491 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA",
3492 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA))),
3493 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM",
3494 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM))),
3495 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA",
3496 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA))),
3497 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM",
3498 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM))),
3499 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3500 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3501 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3502 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3503 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA",
3504 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA))),
3505 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_LTE_TDSCDMA_GSM",
3506 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_LTE_TDSCDMA_GSM))),
3507 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR",
3508 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR))),
3509 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE",
3510 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE))),
3511 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA",
3512 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA))),
3513 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM",
3514 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM))),
3515 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_EVDO_CDMA",
3516 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_EVDO_CDMA))),
3517 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA",
3518 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA))),
3519 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA",
3520 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA))),
3521 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_GSM",
3522 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_GSM))),
3523 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA",
3524 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA))),
3525 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM",
3526 NapiUtil::ToInt32Value(env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM))),
3527 DECLARE_NAPI_STATIC_PROPERTY("PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA",
3528 NapiUtil::ToInt32Value(
3529 env, static_cast<int32_t>(PREFERRED_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA))),
3530 };
3531 napi_value result = nullptr;
3532 napi_define_class(env, "PreferredNetworkMode", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3533 sizeof(desc) / sizeof(*desc), desc, &result);
3534 napi_set_named_property(env, exports, "PreferredNetworkMode", result);
3535 return exports;
3536 }
3537
CreateNrOptionMode(napi_env env,napi_value exports)3538 static napi_value CreateNrOptionMode(napi_env env, napi_value exports)
3539 {
3540 napi_property_descriptor desc[] = {
3541 DECLARE_NAPI_STATIC_PROPERTY(
3542 "NR_OPTION_UNKNOWN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_UNKNOWN))),
3543 DECLARE_NAPI_STATIC_PROPERTY(
3544 "NR_OPTION_NSA_ONLY", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_NSA_ONLY))),
3545 DECLARE_NAPI_STATIC_PROPERTY(
3546 "NR_OPTION_SA_ONLY", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_SA_ONLY))),
3547 DECLARE_NAPI_STATIC_PROPERTY(
3548 "NR_OPTION_NSA_AND_SA", NapiUtil::ToInt32Value(env, static_cast<int32_t>(NR_OPTION_NSA_AND_SA))),
3549 };
3550 napi_value result = nullptr;
3551 napi_define_class(env, "NROptionMode", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3552 sizeof(desc) / sizeof(*desc), desc, &result);
3553 napi_set_named_property(env, exports, "NROptionMode", result);
3554 return exports;
3555 }
3556
CreateImsServiceType(napi_env env,napi_value exports)3557 static napi_value CreateImsServiceType(napi_env env, napi_value exports)
3558 {
3559 napi_property_descriptor desc[] = {
3560 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VOICE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_VOICE))),
3561 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_VIDEO))),
3562 DECLARE_NAPI_STATIC_PROPERTY("TYPE_UT", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_UT))),
3563 DECLARE_NAPI_STATIC_PROPERTY("TYPE_SMS", NapiUtil::ToInt32Value(env, static_cast<int32_t>(TYPE_SMS))),
3564 };
3565 napi_value result = nullptr;
3566 napi_define_class(env, "ImsServiceType", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3567 sizeof(desc) / sizeof(*desc), desc, &result);
3568 napi_set_named_property(env, exports, "ImsServiceType", result);
3569 return exports;
3570 }
3571
CreateImsRegTech(napi_env env,napi_value exports)3572 static napi_value CreateImsRegTech(napi_env env, napi_value exports)
3573 {
3574 napi_property_descriptor desc[] = {
3575 DECLARE_NAPI_STATIC_PROPERTY(
3576 "REGISTRATION_TECH_NONE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_NONE))),
3577 DECLARE_NAPI_STATIC_PROPERTY(
3578 "REGISTRATION_TECH_LTE", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_LTE))),
3579 DECLARE_NAPI_STATIC_PROPERTY(
3580 "REGISTRATION_TECH_IWLAN", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_IWLAN))),
3581 DECLARE_NAPI_STATIC_PROPERTY(
3582 "REGISTRATION_TECH_NR", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REG_TECH_NR))),
3583 };
3584 napi_value result = nullptr;
3585 napi_define_class(env, "ImsRegTech", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr, sizeof(desc) / sizeof(*desc),
3586 desc, &result);
3587 napi_set_named_property(env, exports, "ImsRegTech", result);
3588 return exports;
3589 }
3590
CreateImsRegState(napi_env env,napi_value exports)3591 static napi_value CreateImsRegState(napi_env env, napi_value exports)
3592 {
3593 napi_property_descriptor desc[] = {
3594 DECLARE_NAPI_STATIC_PROPERTY(
3595 "IMS_UNREGISTERED", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_UNREGISTERED))),
3596 DECLARE_NAPI_STATIC_PROPERTY(
3597 "IMS_REGISTERED", NapiUtil::ToInt32Value(env, static_cast<int32_t>(IMS_REGISTERED))),
3598 };
3599 napi_value result = nullptr;
3600 napi_define_class(env, "ImsRegState", NAPI_AUTO_LENGTH, CreateEnumConstructor, nullptr,
3601 sizeof(desc) / sizeof(*desc), desc, &result);
3602 napi_set_named_property(env, exports, "ImsRegState", result);
3603 return exports;
3604 }
3605
CreateFunctions(napi_env env,napi_value exports)3606 static napi_value CreateFunctions(napi_env env, napi_value exports)
3607 {
3608 napi_property_descriptor desc[] = {
3609 DECLARE_NAPI_FUNCTION("getRadioTech", GetRadioTech),
3610 DECLARE_NAPI_FUNCTION("getSignalInformation", GetSignalInfoList),
3611 DECLARE_NAPI_FUNCTION("getSignalInformationSync", GetSignalInfoListSync),
3612 DECLARE_NAPI_FUNCTION("getNetworkState", GetNetworkState),
3613 DECLARE_NAPI_FUNCTION("setNetworkSelectionMode", SetNetworkSelectionMode),
3614 DECLARE_NAPI_FUNCTION("getNetworkSelectionMode", GetNetworkSelectionMode),
3615 DECLARE_NAPI_FUNCTION("getNetworkSearchInformation", GetNetworkSearchInformation),
3616 DECLARE_NAPI_FUNCTION("getISOCountryCodeForNetwork", GetISOCountryCodeForNetwork),
3617 DECLARE_NAPI_FUNCTION("getISOCountryCodeForNetworkSync", GetISOCountryCodeForNetworkSync),
3618 DECLARE_NAPI_FUNCTION("isRadioOn", IsRadioOn),
3619 DECLARE_NAPI_FUNCTION("turnOnRadio", TurnOnRadio),
3620 DECLARE_NAPI_FUNCTION("turnOffRadio", TurnOffRadio),
3621 DECLARE_NAPI_FUNCTION("getOperatorName", GetOperatorName),
3622 DECLARE_NAPI_FUNCTION("getOperatorNameSync", GetOperatorNameSync),
3623 DECLARE_NAPI_FUNCTION("setPreferredNetwork", SetPreferredNetwork),
3624 DECLARE_NAPI_FUNCTION("getPreferredNetwork", GetPreferredNetwork),
3625 DECLARE_NAPI_FUNCTION("setNetworkCapability", SetNetworkCapability),
3626 DECLARE_NAPI_FUNCTION("getNetworkCapability", GetNetworkCapability),
3627 DECLARE_NAPI_FUNCTION("getIMEI", GetIMEI),
3628 DECLARE_NAPI_FUNCTION("getIMEISV", GetIMEISV),
3629 DECLARE_NAPI_FUNCTION("getMEID", GetMEID),
3630 DECLARE_NAPI_FUNCTION("sendUpdateCellLocationRequest", SendUpdateCellLocationRequest),
3631 DECLARE_NAPI_FUNCTION("getCellInformation", GetCellInformation),
3632 DECLARE_NAPI_FUNCTION("getPrimarySlotId", GetPrimarySlotId),
3633 DECLARE_NAPI_FUNCTION("getUniqueDeviceId", GetUniqueDeviceId),
3634 DECLARE_NAPI_FUNCTION("getNrOptionMode", GetNrOptionMode),
3635 DECLARE_NAPI_FUNCTION("isNrSupported", IsNrSupported),
3636 DECLARE_NAPI_FUNCTION("isNRSupported", IsNrSupported),
3637 DECLARE_NAPI_FUNCTION("setPrimarySlotId", SetPrimarySlotId),
3638 DECLARE_NAPI_FUNCTION("getImsRegInfo", GetImsRegInfo),
3639 DECLARE_NAPI_FUNCTION("getBasebandVersion", GetBasebandVersion),
3640 DECLARE_NAPI_FUNCTION("setNROptionMode", SetNrOptionMode),
3641 DECLARE_NAPI_FUNCTION("getNROptionMode", GetNrOptionMode),
3642 DECLARE_NAPI_FUNCTION("on", ObserverOn),
3643 DECLARE_NAPI_FUNCTION("off", ObserverOff),
3644 DECLARE_NAPI_FUNCTION("factoryReset", FactoryReset),
3645 };
3646 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
3647 return exports;
3648 }
3649
3650 EXTERN_C_START
InitNapiRadioNetwork(napi_env env,napi_value exports)3651 napi_value InitNapiRadioNetwork(napi_env env, napi_value exports)
3652 {
3653 CreateFunctions(env, exports);
3654 InitEnumRadioType(env, exports);
3655 InitEnumNetworkType(env, exports);
3656 InitEnumRegStatus(env, exports);
3657 InitEnumNsaState(env, exports);
3658 InitEnumNetworkSelectionMode(env, exports);
3659 InitEnumNetworkInformationState(env, exports);
3660 InitEnumPreferredNetwork(env, exports);
3661 InitEnumNrOptionMode(env, exports);
3662 InitEnumImsRegState(env, exports);
3663 InitEnumImsRegTech(env, exports);
3664 InitEnumImsServiceType(env, exports);
3665 InitEnumNetworkCapabilityType(env, exports);
3666 InitEnumNetworkCapabilityState(env, exports);
3667 CreateImsServiceType(env, exports);
3668 CreateImsRegTech(env, exports);
3669 CreateImsRegState(env, exports);
3670 CreateNrOptionMode(env, exports);
3671 CreatePreferredNetwork(env, exports);
3672 CreateNetworkInformationState(env, exports);
3673 CreateNetworkSelectionMode(env, exports);
3674 CreateNsaState(env, exports);
3675 CreateRegStatus(env, exports);
3676 CreateNetworkType(env, exports);
3677 CreateRadioType(env, exports);
3678 CreateNetworkCapabilityType(env, exports);
3679 CreateNetworkCapabilityState(env, exports);
3680 return exports;
3681 }
3682 EXTERN_C_END
3683
3684 static napi_module _radioModule = {
3685 .nm_version = 1,
3686 .nm_flags = 0,
3687 .nm_filename = nullptr,
3688 .nm_register_func = InitNapiRadioNetwork,
3689 .nm_modname = "telephony.radio",
3690 .nm_priv = ((void *)0),
3691 .reserved = { 0 },
3692 };
3693
RegisterRadioNetworkModule(void)3694 extern "C" __attribute__((constructor)) void RegisterRadioNetworkModule(void)
3695 {
3696 napi_module_register(&_radioModule);
3697 }
3698 } // namespace Telephony
3699 } // namespace OHOS
3700