1 /*
2  * Copyright (C) 2021-2023 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_call_manager.h"
17 
18 #include <securec.h>
19 #include <string_ex.h>
20 
21 #include "ability_manager_client.h"
22 #include "bool_wrapper.h"
23 #include "call_manager_client.h"
24 #include "call_manager_errors.h"
25 #include "napi_call_ability_callback.h"
26 #include "napi_call_manager_types.h"
27 #include "napi_call_manager_utils.h"
28 #include "napi_util.h"
29 #include "string_wrapper.h"
30 #include "system_ability_definition.h"
31 #include "telephony_log_wrapper.h"
32 #include "telephony_napi_common_error.h"
33 #include "telephony_types.h"
34 #include "want.h"
35 
36 namespace OHOS {
37 namespace Telephony {
38 static constexpr const char *OBSERVER_ON_JS_PERMISSION_ERROR_STRING =
39     "BusinessError 201: Permission denied. An attempt was made to On forbidden by permission: "
40     "ohos.permission.SET_TELEPHONY_STATE.";
41 static constexpr const char *OBSERVER_OFF_JS_PERMISSION_ERROR_STRING =
42     "BusinessError 201: Permission denied. An attempt was made to Off forbidden by permission: "
43     "ohos.permission.SET_TELEPHONY_STATE.";
44 int32_t NapiCallManager::registerStatus_ = TELEPHONY_ERROR;
45 
NapiCallManager()46 NapiCallManager::NapiCallManager() {}
47 
~NapiCallManager()48 NapiCallManager::~NapiCallManager()
49 {
50     DelayedSingleton<CallManagerClient>::GetInstance()->UnInit();
51 }
52 
Init()53 void Init()
54 {
55     // Establish a connection with call_manager
56     DelayedSingleton<CallManagerClient>::GetInstance()->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
57 }
58 
DeclareCallBasisInterface(napi_env env, napi_value exports)59 napi_value NapiCallManager::DeclareCallBasisInterface(napi_env env, napi_value exports)
60 {
61     napi_property_descriptor desc[] = {
62         DECLARE_NAPI_FUNCTION("dial", Dial),
63         DECLARE_NAPI_FUNCTION("dialCall", DialCall),
64         DECLARE_NAPI_FUNCTION("makeCall", MakeCall),
65         DECLARE_NAPI_FUNCTION("answer", AnswerCall),
66         DECLARE_NAPI_FUNCTION("reject", RejectCall),
67         DECLARE_NAPI_FUNCTION("hangup", HangUpCall),
68         DECLARE_NAPI_FUNCTION("answerCall", AnswerCall),
69         DECLARE_NAPI_FUNCTION("rejectCall", RejectCall),
70         DECLARE_NAPI_FUNCTION("hangUpCall", HangUpCall),
71         DECLARE_NAPI_FUNCTION("holdCall", HoldCall),
72         DECLARE_NAPI_FUNCTION("unHoldCall", UnHoldCall),
73         DECLARE_NAPI_FUNCTION("switchCall", SwitchCall),
74         DECLARE_NAPI_FUNCTION("setCallPreferenceMode", SetCallPreferenceMode),
75         DECLARE_NAPI_FUNCTION("hasVoiceCapability", HasVoiceCapability),
76         DECLARE_NAPI_FUNCTION("sendCallUiEvent", SendCallUiEvent),
77     };
78     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
79     return exports;
80 }
81 
DeclareCallConferenceInterface(napi_env env, napi_value exports)82 napi_value NapiCallManager::DeclareCallConferenceInterface(napi_env env, napi_value exports)
83 {
84     napi_property_descriptor desc[] = {
85         DECLARE_NAPI_FUNCTION("combineConference", CombineConference),
86         DECLARE_NAPI_FUNCTION("separateConference", SeparateConference),
87         DECLARE_NAPI_FUNCTION("kickOutFromConference", KickOutFromConference),
88         DECLARE_NAPI_FUNCTION("getMainCallId", GetMainCallId),
89         DECLARE_NAPI_FUNCTION("getSubCallIdList", GetSubCallIdList),
90         DECLARE_NAPI_FUNCTION("getCallIdListForConference", GetCallIdListForConference),
91     };
92     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
93     return exports;
94 }
95 
DeclareCallSupplementInterface(napi_env env, napi_value exports)96 napi_value NapiCallManager::DeclareCallSupplementInterface(napi_env env, napi_value exports)
97 {
98     napi_property_descriptor desc[] = {
99         DECLARE_NAPI_FUNCTION("getCallWaitingStatus", GetCallWaiting),
100         DECLARE_NAPI_FUNCTION("setCallWaiting", SetCallWaiting),
101         DECLARE_NAPI_FUNCTION("getCallRestrictionStatus", GetCallRestriction),
102         DECLARE_NAPI_FUNCTION("setCallRestriction", SetCallRestriction),
103         DECLARE_NAPI_FUNCTION("setCallRestrictionPassword", SetCallRestrictionPassword),
104         DECLARE_NAPI_FUNCTION("getCallTransferInfo", GetCallTransferInfo),
105         DECLARE_NAPI_FUNCTION("setCallTransfer", SetCallTransferInfo),
106         DECLARE_NAPI_FUNCTION("enableImsSwitch", EnableImsSwitch),
107         DECLARE_NAPI_FUNCTION("disableImsSwitch", DisableImsSwitch),
108         DECLARE_NAPI_FUNCTION("isImsSwitchEnabled", IsImsSwitchEnabled),
109         DECLARE_NAPI_FUNCTION("isImsSwitchEnabledSync", IsImsSwitchEnabledSync),
110         DECLARE_NAPI_FUNCTION("setVoNRState", SetVoNRState),
111         DECLARE_NAPI_FUNCTION("getVoNRState", GetVoNRState),
112         DECLARE_NAPI_FUNCTION("canSetCallTransferTime", CanSetCallTransferTime),
113         DECLARE_NAPI_FUNCTION("closeUnfinishedUssd", CloseUnFinishedUssd),
114         DECLARE_NAPI_FUNCTION("inputDialerSpecialCode", InputDialerSpecialCode),
115     };
116     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
117     return exports;
118 }
119 
DeclareCallExtendInterface(napi_env env, napi_value exports)120 napi_value NapiCallManager::DeclareCallExtendInterface(napi_env env, napi_value exports)
121 {
122     napi_property_descriptor desc[] = {
123         DECLARE_NAPI_FUNCTION("startDTMF", StartDTMF),
124         DECLARE_NAPI_FUNCTION("stopDTMF", StopDTMF),
125         DECLARE_NAPI_FUNCTION("postDialProceed", PostDialProceed),
126         DECLARE_NAPI_FUNCTION("getCallState", GetCallState),
127         DECLARE_NAPI_FUNCTION("getCallStateSync", GetCallStateSync),
128         DECLARE_NAPI_FUNCTION("isRinging", IsRinging),
129         DECLARE_NAPI_FUNCTION("hasCall", HasCall),
130         DECLARE_NAPI_FUNCTION("hasCallSync", HasCallSync),
131         DECLARE_NAPI_FUNCTION("isNewCallAllowed", IsNewCallAllowed),
132         DECLARE_NAPI_FUNCTION("isInEmergencyCall", IsInEmergencyCall),
133         DECLARE_NAPI_FUNCTION("isEmergencyPhoneNumber", IsEmergencyPhoneNumber),
134         DECLARE_NAPI_FUNCTION("formatPhoneNumber", FormatPhoneNumber),
135         DECLARE_NAPI_FUNCTION("formatPhoneNumberToE164", FormatPhoneNumberToE164),
136         DECLARE_NAPI_FUNCTION("on", ObserverOn),
137         DECLARE_NAPI_FUNCTION("off", ObserverOff),
138         DECLARE_NAPI_FUNCTION("reportOttCallDetailsInfo", ReportOttCallDetailsInfo),
139         DECLARE_NAPI_FUNCTION("reportOttCallEventInfo", ReportOttCallEventInfo),
140         DECLARE_NAPI_FUNCTION("removeMissedIncomingCallNotification", RemoveMissedIncomingCallNotification),
141         DECLARE_NAPI_FUNCTION("setVoIPCallState", SetVoIPCallState),
142     };
143     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
144     return exports;
145 }
146 
DeclareCallMultimediaInterface(napi_env env, napi_value exports)147 napi_value NapiCallManager::DeclareCallMultimediaInterface(napi_env env, napi_value exports)
148 {
149     napi_property_descriptor desc[] = {
150         DECLARE_NAPI_FUNCTION("setMuted", SetMuted),
151         DECLARE_NAPI_FUNCTION("cancelMuted", CancelMuted),
152         DECLARE_NAPI_FUNCTION("muteRinger", MuteRinger),
153         DECLARE_NAPI_FUNCTION("setAudioDevice", SetAudioDevice),
154         DECLARE_NAPI_FUNCTION("controlCamera", ControlCamera),
155         DECLARE_NAPI_FUNCTION("setPreviewSurface", SetPreviewWindow),
156         DECLARE_NAPI_FUNCTION("setDisplaySurface", SetDisplayWindow),
157         DECLARE_NAPI_FUNCTION("setCameraZoom", SetCameraZoom),
158         DECLARE_NAPI_FUNCTION("setDeviceDirection", SetDeviceDirection),
159         DECLARE_NAPI_FUNCTION("updateImsCallMode", UpdateImsCallMode),
160         DECLARE_NAPI_FUNCTION("cancelCallUpgrade", CancelCallUpgrade),
161     };
162     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
163     return exports;
164 }
165 
DeclareCallImsInterface(napi_env env, napi_value exports)166 napi_value NapiCallManager::DeclareCallImsInterface(napi_env env, napi_value exports)
167 {
168     napi_property_descriptor desc[] = {
169         DECLARE_NAPI_FUNCTION("startRTT", StartRTT),
170         DECLARE_NAPI_FUNCTION("stopRTT", StopRTT),
171         DECLARE_NAPI_FUNCTION("joinConference", JoinConference),
172     };
173     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
174     return exports;
175 }
176 
177 /**
178  * Enumeration type extension.
179  */
DeclareVoNRStateEnum(napi_env env, napi_value exports)180 napi_value NapiCallManager::DeclareVoNRStateEnum(napi_env env, napi_value exports)
181 {
182     napi_property_descriptor desc[] = {
183         DECLARE_NAPI_STATIC_PROPERTY("VONR_STATE_ON",
184             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VoNRState::VONR_STATE_ON))),
185         DECLARE_NAPI_STATIC_PROPERTY("VONR_STATE_OFF",
186             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VoNRState::VONR_STATE_OFF))),
187     };
188     napi_value result = nullptr;
189     napi_define_class(env, "VoNRState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
190         sizeof(desc) / sizeof(*desc), desc, &result);
191     napi_set_named_property(env, exports, "VoNRState", result);
192     return exports;
193 }
194 
DeclareAudioDeviceEnum(napi_env env, napi_value exports)195 napi_value NapiCallManager::DeclareAudioDeviceEnum(napi_env env, napi_value exports)
196 {
197     // AudioDeviceType
198     napi_property_descriptor desc[] = {
199         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_UNKNOWN",
200             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_UNKNOWN))),
201         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISABLE",
202             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_DISABLE))),
203         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_BLUETOOTH_SCO",
204             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_BLUETOOTH_SCO))),
205         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISTRIBUTED_AUTOMOTIVE",
206             NapiCallManagerUtils::ToInt32Value(env,
207                 static_cast<int32_t>(AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE))),
208         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISTRIBUTED_PHONE",
209             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_DISTRIBUTED_PHONE))),
210         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISTRIBUTED_PAD",
211             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_DISTRIBUTED_PAD))),
212         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISTRIBUTED_PC",
213             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_DISTRIBUTED_PC))),
214         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_WIRED_HEADSET",
215             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_WIRED_HEADSET))),
216         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_SPEAKER",
217             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_SPEAKER))),
218         DECLARE_NAPI_STATIC_PROPERTY("DEVICE_EARPIECE",
219             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDeviceType::DEVICE_EARPIECE))),
220     };
221     napi_value result = nullptr;
222     napi_define_class(env, "AudioDeviceType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
223         sizeof(desc) / sizeof(*desc), desc, &result);
224     napi_set_named_property(env, exports, "AudioDeviceType", result);
225     return exports;
226 }
227 
DeclareVideoStateTypeEnum(napi_env env, napi_value exports)228 napi_value NapiCallManager::DeclareVideoStateTypeEnum(napi_env env, napi_value exports)
229 {
230     napi_property_descriptor desc[] = {
231         DECLARE_NAPI_STATIC_PROPERTY("TYPE_VOICE",
232             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VOICE))),
233         DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO_SEND_ONLY",
234             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_SEND_ONLY))),
235         DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO_RECEIVE_ONLY",
236             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_RECEIVE_ONLY))),
237         DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO_BIDIRECTIONAL",
238             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VIDEO))),
239     };
240     napi_value result = nullptr;
241     napi_define_class(env, "VideoStateType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
242         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
243     napi_set_named_property(env, exports, "VideoStateType", result);
244     return exports;
245 }
246 
DeclareVideoRequestResultEnum(napi_env env, napi_value exports)247 napi_value NapiCallManager::DeclareVideoRequestResultEnum(napi_env env, napi_value exports)
248 {
249     napi_property_descriptor desc[] = {
250         DECLARE_NAPI_STATIC_PROPERTY(
251             "TYPE_REQUEST_SUCCESS", NapiCallManagerUtils::ToInt32Value(env, TYPE_REQUEST_SUCCESS)),
252         DECLARE_NAPI_STATIC_PROPERTY(
253             "TYPE_REQUEST_FAILURE", NapiCallManagerUtils::ToInt32Value(env, TYPE_REQUEST_FAIL)),
254         DECLARE_NAPI_STATIC_PROPERTY(
255             "TYPE_REQUEST_INVALID", NapiCallManagerUtils::ToInt32Value(env, TYPE_REQUEST_INVALID)),
256         DECLARE_NAPI_STATIC_PROPERTY(
257             "TYPE_REQUEST_TIMED_OUT", NapiCallManagerUtils::ToInt32Value(env, TYPE_REQUEST_TIMED_OUT)),
258         DECLARE_NAPI_STATIC_PROPERTY(
259             "TYPE_REQUEST_REJECTED_BY_REMOTE", NapiCallManagerUtils::ToInt32Value(env, REQUEST_REJECTED_BY_REMOTE)),
260         DECLARE_NAPI_STATIC_PROPERTY(
261             "TYPE_REQUEST_UPGRADE_CANCELED", NapiCallManagerUtils::ToInt32Value(env, TYPE_REQUEST_UPGRADE_CANCELED)),
262         DECLARE_NAPI_STATIC_PROPERTY(
263             "TYPE_DOWNGRADE_RTP_OR_RTCP_TIMEOUT",
264             NapiCallManagerUtils::ToInt32Value(env, TYPE_MODIFY_DOWNGRADE_RTP_OR_RTCP_TIMEOUT)),
265         DECLARE_NAPI_STATIC_PROPERTY(
266             "TYPE_DOWNGRADE_RTP_AND_RTCP_TIMEOUT",
267             NapiCallManagerUtils::ToInt32Value(env, TYPE_MODIFY_DOWNGRADE_RTP_AND_RTCP_TIMEOUT)),
268     };
269     napi_value result = nullptr;
270     napi_define_class(env, "VideoRequestResultType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
271         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
272     napi_set_named_property(env, exports, "VideoRequestResultType", result);
273     return exports;
274 }
275 
DeclareImsCallModeEnum(napi_env env, napi_value exports)276 napi_value NapiCallManager::DeclareImsCallModeEnum(napi_env env, napi_value exports)
277 {
278     napi_property_descriptor desc[] = {
279         DECLARE_NAPI_STATIC_PROPERTY(
280             "CALL_MODE_AUDIO_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_AUDIO_ONLY)),
281         DECLARE_NAPI_STATIC_PROPERTY(
282             "CALL_MODE_SEND_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_SEND_ONLY)),
283         DECLARE_NAPI_STATIC_PROPERTY(
284             "CALL_MODE_RECEIVE_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_RECEIVE_ONLY)),
285         DECLARE_NAPI_STATIC_PROPERTY(
286             "CALL_MODE_SEND_RECEIVE", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_SEND_RECEIVE)),
287         DECLARE_NAPI_STATIC_PROPERTY(
288             "CALL_MODE_VIDEO_PAUSED", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_VIDEO_PAUSED)),
289     };
290     napi_value result = nullptr;
291     napi_define_class(env, "ImsCallMode", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
292         sizeof(desc) / sizeof(*desc), desc, &result);
293     napi_set_named_property(env, exports, "ImsCallMode", result);
294     return exports;
295 }
296 
DeclareDeviceDirectionEnum(napi_env env, napi_value exports)297 napi_value NapiCallManager::DeclareDeviceDirectionEnum(napi_env env, napi_value exports)
298 {
299     napi_property_descriptor desc[] = {
300         // DeviceDirection
301         DECLARE_NAPI_STATIC_PROPERTY(
302             "DEVICE_DIRECTION_0", NapiCallManagerUtils::ToInt32Value(env, DEVICE_DIRECTION_0)),
303         DECLARE_NAPI_STATIC_PROPERTY(
304             "DEVICE_DIRECTION_90", NapiCallManagerUtils::ToInt32Value(env, DEVICE_DIRECTION_90)),
305         DECLARE_NAPI_STATIC_PROPERTY(
306             "DEVICE_DIRECTION_180", NapiCallManagerUtils::ToInt32Value(env, DEVICE_DIRECTION_180)),
307         DECLARE_NAPI_STATIC_PROPERTY(
308             "DEVICE_DIRECTION_270", NapiCallManagerUtils::ToInt32Value(env, DEVICE_DIRECTION_270)),
309     };
310     napi_value result = nullptr;
311     napi_define_class(env, "DeviceDirection", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
312         sizeof(desc) / sizeof(*desc), desc, &result);
313     napi_set_named_property(env, exports, "DeviceDirection", result);
314     return exports;
315 }
316 
DeclareDialSceneEnum(napi_env env, napi_value exports)317 napi_value NapiCallManager::DeclareDialSceneEnum(napi_env env, napi_value exports)
318 {
319     napi_property_descriptor desc[] = {
320         DECLARE_NAPI_STATIC_PROPERTY(
321             "CALL_NORMAL", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_NORMAL))),
322         DECLARE_NAPI_STATIC_PROPERTY("CALL_PRIVILEGED",
323             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_PRIVILEGED))),
324         DECLARE_NAPI_STATIC_PROPERTY("CALL_EMERGENCY",
325             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_EMERGENCY))),
326     };
327     napi_value result = nullptr;
328     napi_define_class(env, "DialScene", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
329         sizeof(desc) / sizeof(*desc), desc, &result);
330     napi_set_named_property(env, exports, "DialScene", result);
331     return exports;
332 }
333 
DeclareCallTypeEnum(napi_env env, napi_value exports)334 napi_value NapiCallManager::DeclareCallTypeEnum(napi_env env, napi_value exports)
335 {
336     napi_property_descriptor desc[] = {
337         DECLARE_NAPI_STATIC_PROPERTY(
338             "TYPE_CS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_CS))),
339         DECLARE_NAPI_STATIC_PROPERTY(
340             "TYPE_IMS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_IMS))),
341         DECLARE_NAPI_STATIC_PROPERTY(
342             "TYPE_OTT", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_OTT))),
343         DECLARE_NAPI_STATIC_PROPERTY(
344             "TYPE_VOIP", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_VOIP))),
345         DECLARE_NAPI_STATIC_PROPERTY(
346             "TYPE_ERR_CALL", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_ERR_CALL))),
347     };
348     napi_value result = nullptr;
349     napi_define_class(env, "CallType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
350         sizeof(desc) / sizeof(*desc), desc, &result);
351     napi_set_named_property(env, exports, "CallType", result);
352     return exports;
353 }
354 
DeclareDialTypeEnum(napi_env env, napi_value exports)355 napi_value NapiCallManager::DeclareDialTypeEnum(napi_env env, napi_value exports)
356 {
357     napi_property_descriptor desc[] = {
358         DECLARE_NAPI_STATIC_PROPERTY("DIAL_CARRIER_TYPE",
359             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE))),
360         DECLARE_NAPI_STATIC_PROPERTY("DIAL_VOICE_MAIL_TYPE",
361             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE))),
362         DECLARE_NAPI_STATIC_PROPERTY("DIAL_OTT_TYPE",
363             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_OTT_TYPE))),
364     };
365     napi_value result = nullptr;
366     napi_define_class(env, "DialType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
367         sizeof(desc) / sizeof(*desc), desc, &result);
368     napi_set_named_property(env, exports, "DialType", result);
369     return exports;
370 }
371 
DeclareTelCallStateEnum(napi_env env, napi_value exports)372 napi_value NapiCallManager::DeclareTelCallStateEnum(napi_env env, napi_value exports)
373 {
374     napi_property_descriptor desc[] = {
375         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_IDLE",
376             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE))),
377         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTING",
378             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTING))),
379         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTED",
380             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED))),
381         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_WAITING",
382             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_WAITING))),
383         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_INCOMING",
384             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING))),
385         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ALERTING",
386             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING))),
387         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DIALING",
388             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DIALING))),
389         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_HOLDING",
390             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_HOLDING))),
391         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ACTIVE",
392             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE))),
393         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ANSWERED",
394             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ANSWERED))),
395     };
396     napi_value result = nullptr;
397     napi_define_class(env, "DetailedCallState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
398         sizeof(desc) / sizeof(*desc), desc, &result);
399     napi_set_named_property(env, exports, "DetailedCallState", result);
400     return exports;
401 }
402 
DeclareConferenceStateEnum(napi_env env, napi_value exports)403 napi_value NapiCallManager::DeclareConferenceStateEnum(napi_env env, napi_value exports)
404 {
405     napi_property_descriptor desc[] = {
406         DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTED",
407             NapiCallManagerUtils::ToInt32Value(
408                 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTED))),
409         DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTING",
410             NapiCallManagerUtils::ToInt32Value(
411                 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTING))),
412         DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_HOLDING",
413             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_HOLDING))),
414         DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_ACTIVE",
415             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_ACTIVE))),
416         DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_IDLE",
417             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_IDLE))),
418     };
419     napi_value result = nullptr;
420     napi_define_class(env, "ConferenceState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
421         sizeof(desc) / sizeof(*desc), desc, &result);
422     napi_set_named_property(env, exports, "ConferenceState", result);
423     return exports;
424 }
425 
DeclareCallStateToAppEnum(napi_env env, napi_value exports)426 napi_value NapiCallManager::DeclareCallStateToAppEnum(napi_env env, napi_value exports)
427 {
428     napi_property_descriptor desc[] = {
429         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_UNKNOWN",
430             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN))),
431         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_IDLE",
432             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_IDLE))),
433         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_RINGING",
434             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_RINGING))),
435         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_OFFHOOK",
436             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_OFFHOOK))),
437         DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_ANSWERED",
438             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_ANSWERED))),
439     };
440     napi_value result = nullptr;
441     napi_define_class(env, "CallState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
442         sizeof(desc) / sizeof(*desc), desc, &result);
443     napi_set_named_property(env, exports, "CallState", result);
444     return exports;
445 }
446 
DeclareCallEventEnumEx(napi_env env, napi_value exports)447 napi_value NapiCallManager::DeclareCallEventEnumEx(napi_env env, napi_value exports)
448 {
449     napi_property_descriptor desc[] = {
450         // CallAbilityEventId
451         DECLARE_NAPI_STATIC_PROPERTY("EVENT_DIAL_NO_CARRIER",
452             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallAbilityEventId::EVENT_DIAL_NO_CARRIER))),
453         DECLARE_NAPI_STATIC_PROPERTY("EVENT_INVALID_FDN_NUMBER",
454             NapiCallManagerUtils::ToInt32Value(
455                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_INVALID_FDN_NUMBER))),
456         DECLARE_NAPI_STATIC_PROPERTY("EVENT_HOLD_CALL_FAILED",
457             NapiCallManagerUtils::ToInt32Value(
458                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_HOLD_CALL_FAILED))),
459         DECLARE_NAPI_STATIC_PROPERTY("EVENT_SWAP_CALL_FAILED",
460             NapiCallManagerUtils::ToInt32Value(
461                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_SWAP_CALL_FAILED))),
462         DECLARE_NAPI_STATIC_PROPERTY("EVENT_COMBINE_CALL_FAILED",
463             NapiCallManagerUtils::ToInt32Value(
464                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_COMBINE_CALL_FAILED))),
465         DECLARE_NAPI_STATIC_PROPERTY("EVENT_SPLIT_CALL_FAILED",
466             NapiCallManagerUtils::ToInt32Value(
467                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_SPLIT_CALL_FAILED))),
468         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CALL_MUTED",
469             NapiCallManagerUtils::ToInt32Value(
470                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_CALL_MUTED))),
471         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CALL_UNMUTED",
472             NapiCallManagerUtils::ToInt32Value(
473                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_CALL_UNMUTED))),
474         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CALL_SPEAKER_ON",
475             NapiCallManagerUtils::ToInt32Value(
476                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_CALL_SPEAKER_ON))),
477         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CALL_SPEAKER_OFF",
478             NapiCallManagerUtils::ToInt32Value(
479                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_CALL_SPEAKER_OFF))),
480         DECLARE_NAPI_STATIC_PROPERTY("EVENT_SHOW_FULL_SCREEN",
481             NapiCallManagerUtils::ToInt32Value(
482                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_SHOW_FULL_SCREEN))),
483         DECLARE_NAPI_STATIC_PROPERTY("EVENT_SHOW_FLOAT_WINDOW",
484             NapiCallManagerUtils::ToInt32Value(
485                 env, static_cast<int32_t>(CallAbilityEventId::EVENT_SHOW_FLOAT_WINDOW))),
486     };
487     napi_value result = nullptr;
488     napi_define_class(env, "CallAbilityEventId", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
489         sizeof(desc) / sizeof(*desc), desc, &result);
490     napi_set_named_property(env, exports, "CallAbilityEventId", result);
491     return exports;
492 }
493 
DeclareCallSessionEventEnumEx(napi_env env, napi_value exports)494 napi_value NapiCallManager::DeclareCallSessionEventEnumEx(napi_env env, napi_value exports)
495 {
496     napi_property_descriptor desc[] = {
497         // CallSessionEventId
498         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CONTROL_CAMERA_FAILURE",
499             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallSessionEventId::EVENT_CAMERA_FAILURE))),
500         DECLARE_NAPI_STATIC_PROPERTY("EVENT_CONTROL_CAMERA_READY",
501             NapiCallManagerUtils::ToInt32Value(
502                 env, static_cast<int32_t>(CallSessionEventId::EVENT_CAMERA_READY))),
503         DECLARE_NAPI_STATIC_PROPERTY("EVENT_DISPLAY_SURFACE_RELEASED",
504             NapiCallManagerUtils::ToInt32Value(
505                 env, static_cast<int32_t>(CallSessionEventId::EVENT_RELEASE_DISPLAY_SURFACE))),
506         DECLARE_NAPI_STATIC_PROPERTY("EVENT_PREVIEW_SURFACE_RELEASED",
507             NapiCallManagerUtils::ToInt32Value(
508                 env, static_cast<int32_t>(CallSessionEventId::EVENT_RELEASE_PREVIEW_SURFACE))),
509     };
510     napi_value result = nullptr;
511     napi_define_class(env, "CallSessionEventId", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
512         sizeof(desc) / sizeof(*desc), desc, &result);
513     napi_set_named_property(env, exports, "CallSessionEventId", result);
514     return exports;
515 }
516 
DeclareRestrictionTypeEnum(napi_env env, napi_value exports)517 napi_value NapiCallManager::DeclareRestrictionTypeEnum(napi_env env, napi_value exports)
518 {
519     napi_property_descriptor desc[] = {
520         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_OUTGOING",
521             NapiCallManagerUtils::ToInt32Value(
522                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING))),
523         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL",
524             NapiCallManagerUtils::ToInt32Value(
525                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL))),
526         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME",
527             NapiCallManagerUtils::ToInt32Value(
528                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME))),
529         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_INCOMING",
530             NapiCallManagerUtils::ToInt32Value(
531                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING))),
532         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ROAMING_INCOMING",
533             NapiCallManagerUtils::ToInt32Value(
534                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ROAMING_INCOMING))),
535         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_CALLS",
536             NapiCallManagerUtils::ToInt32Value(
537                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS))),
538         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_OUTGOING_SERVICES",
539             NapiCallManagerUtils::ToInt32Value(
540                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_OUTGOING_SERVICES))),
541         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INCOMING_SERVICES",
542             NapiCallManagerUtils::ToInt32Value(
543                 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INCOMING_SERVICES))),
544     };
545     napi_value result = nullptr;
546     napi_define_class(env, "CallRestrictionType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
547         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
548     napi_set_named_property(env, exports, "CallRestrictionType", result);
549     return exports;
550 }
551 
DeclareRestrictionModeEnum(napi_env env, napi_value exports)552 napi_value NapiCallManager::DeclareRestrictionModeEnum(napi_env env, napi_value exports)
553 {
554     napi_property_descriptor desc[] = {
555         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_DEACTIVATION",
556             NapiCallManagerUtils::ToInt32Value(
557                 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION))),
558         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_ACTIVATION",
559             NapiCallManagerUtils::ToInt32Value(
560                 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_ACTIVATION))),
561     };
562     napi_value result = nullptr;
563     napi_define_class(env, "CallRestrictionMode", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
564         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
565     napi_set_named_property(env, exports, "CallRestrictionMode", result);
566     return exports;
567 }
568 
DeclareRestrictionStatusEnum(napi_env env, napi_value exports)569 napi_value NapiCallManager::DeclareRestrictionStatusEnum(napi_env env, napi_value exports)
570 {
571     napi_property_descriptor desc[] = {
572         DECLARE_NAPI_STATIC_PROPERTY(
573             "RESTRICTION_DISABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_DISABLE)),
574         DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_ENABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_ENABLE)),
575     };
576     napi_value result = nullptr;
577     napi_define_class(env, "RestrictionStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
578         sizeof(desc) / sizeof(*desc), desc, &result);
579     napi_set_named_property(env, exports, "RestrictionStatus", result);
580     return exports;
581 }
582 
DeclareCallWaitingEnumEx(napi_env env, napi_value exports)583 napi_value NapiCallManager::DeclareCallWaitingEnumEx(napi_env env, napi_value exports)
584 {
585     napi_property_descriptor desc[] = {
586         DECLARE_NAPI_STATIC_PROPERTY(
587             "CALL_WAITING_DISABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_DISABLE)),
588         DECLARE_NAPI_STATIC_PROPERTY(
589             "CALL_WAITING_ENABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_ENABLE)),
590     };
591     napi_value result = nullptr;
592     napi_define_class(env, "CallWaitingStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
593         sizeof(desc) / sizeof(*desc), desc, &result);
594     napi_set_named_property(env, exports, "CallWaitingStatus", result);
595     return exports;
596 }
597 
DeclareTransferStatusEnum(napi_env env, napi_value exports)598 napi_value NapiCallManager::DeclareTransferStatusEnum(napi_env env, napi_value exports)
599 {
600     napi_property_descriptor desc[] = {
601         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_DISABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_DISABLE)),
602         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_ENABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_ENABLE)),
603     };
604     napi_value result = nullptr;
605     napi_define_class(env, "TransferStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
606         sizeof(desc) / sizeof(*desc), desc, &result);
607     napi_set_named_property(env, exports, "TransferStatus", result);
608     return exports;
609 }
610 
DeclareTransferTypeEnum(napi_env env, napi_value exports)611 napi_value NapiCallManager::DeclareTransferTypeEnum(napi_env env, napi_value exports)
612 {
613     napi_property_descriptor desc[] = {
614         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NOT_REACHABLE",
615             NapiCallManagerUtils::ToInt32Value(
616                 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE))),
617         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NO_REPLY",
618             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY))),
619         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_BUSY",
620             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY))),
621         DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_UNCONDITIONAL",
622             NapiCallManagerUtils::ToInt32Value(
623                 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL))),
624     };
625     napi_value result = nullptr;
626     napi_define_class(env, "CallTransferType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
627         sizeof(desc) / sizeof(*desc), desc, &result);
628     napi_set_named_property(env, exports, "CallTransferType", result);
629     return exports;
630 }
631 
DeclareTransferSettingTypeEnum(napi_env env, napi_value exports)632 napi_value NapiCallManager::DeclareTransferSettingTypeEnum(napi_env env, napi_value exports)
633 {
634     napi_property_descriptor desc[] = {
635         DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ERASURE",
636             NapiCallManagerUtils::ToInt32Value(
637                 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ERASURE))),
638         DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_REGISTRATION",
639             NapiCallManagerUtils::ToInt32Value(
640                 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_REGISTRATION))),
641         DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_DISABLE",
642             NapiCallManagerUtils::ToInt32Value(
643                 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_DISABLE))),
644         DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ENABLE",
645             NapiCallManagerUtils::ToInt32Value(
646                 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ENABLE))),
647     };
648     napi_value result = nullptr;
649     napi_define_class(env, "CallTransferSettingType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
650         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
651     napi_set_named_property(env, exports, "CallTransferSettingType", result);
652     return exports;
653 }
654 
DeclareMmiCodeResultEnum(napi_env env, napi_value exports)655 napi_value NapiCallManager::DeclareMmiCodeResultEnum(napi_env env, napi_value exports)
656 {
657     napi_property_descriptor desc[] = {
658         DECLARE_NAPI_STATIC_PROPERTY("MMI_CODE_SUCCESS",
659             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MmiCodeResult::MMI_CODE_SUCCESS))),
660         DECLARE_NAPI_STATIC_PROPERTY("MMI_CODE_FAILED",
661             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MmiCodeResult::MMI_CODE_FAILED))),
662     };
663     napi_value result = nullptr;
664     napi_define_class(env, "MmiCodeResult", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
665         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
666     napi_set_named_property(env, exports, "MmiCodeResult", result);
667     return exports;
668 }
669 
DeclareDisconnectedReasonEnum(napi_env env, napi_value exports)670 napi_value NapiCallManager::DeclareDisconnectedReasonEnum(napi_env env, napi_value exports)
671 {
672     napi_property_descriptor desc[] = {
673         DECLARE_NAPI_STATIC_PROPERTY("UNASSIGNED_NUMBER",
674             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::UNASSIGNED_NUMBER))),
675         DECLARE_NAPI_STATIC_PROPERTY("NO_ROUTE_TO_DESTINATION",
676             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NO_ROUTE_TO_DESTINATION))),
677         DECLARE_NAPI_STATIC_PROPERTY("CHANNEL_UNACCEPTABLE",
678             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::CHANNEL_UNACCEPTABLE))),
679         DECLARE_NAPI_STATIC_PROPERTY("OPERATOR_DETERMINED_BARRING",
680             NapiCallManagerUtils::ToInt32Value(env,
681             static_cast<int32_t>(DisconnectedReason::OPERATOR_DETERMINED_BARRING))),
682         DECLARE_NAPI_STATIC_PROPERTY("CALL_COMPLETED_ELSEWHERE",
683             NapiCallManagerUtils::ToInt32Value(env,
684             static_cast<int32_t>(DisconnectedReason::CALL_COMPLETED_ELSEWHERE))),
685         DECLARE_NAPI_STATIC_PROPERTY("NORMAL_CALL_CLEARING",
686             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NORMAL_CALL_CLEARING))),
687         DECLARE_NAPI_STATIC_PROPERTY("USER_BUSY",
688             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::USER_BUSY))),
689         DECLARE_NAPI_STATIC_PROPERTY("NO_USER_RESPONDING",
690             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NO_USER_RESPONDING))),
691         DECLARE_NAPI_STATIC_PROPERTY("USER_ALERTING_NO_ANSWER",
692             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::USER_ALERTING_NO_ANSWER))),
693         DECLARE_NAPI_STATIC_PROPERTY("CALL_REJECTED",
694             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::CALL_REJECTED))),
695         DECLARE_NAPI_STATIC_PROPERTY("NUMBER_CHANGED",
696             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NUMBER_CHANGED))),
697         DECLARE_NAPI_STATIC_PROPERTY("CALL_REJECTED_DUE_TO_FEATURE_AT_THE_DESTINATION",
698             NapiCallManagerUtils::ToInt32Value(env,
699             static_cast<int32_t>(DisconnectedReason::CALL_REJECTED_DUE_TO_FEATURE_AT_THE_DESTINATION))),
700         DECLARE_NAPI_STATIC_PROPERTY("FAILED_PRE_EMPTION",
701             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::FAILED_PRE_EMPTION))),
702         DECLARE_NAPI_STATIC_PROPERTY("NON_SELECTED_USER_CLEARING",
703             NapiCallManagerUtils::ToInt32Value(env,
704             static_cast<int32_t>(DisconnectedReason::NON_SELECTED_USER_CLEARING))),
705         DECLARE_NAPI_STATIC_PROPERTY("DESTINATION_OUT_OF_ORDER",
706             NapiCallManagerUtils::ToInt32Value(env,
707             static_cast<int32_t>(DisconnectedReason::DESTINATION_OUT_OF_ORDER))),
708         DECLARE_NAPI_STATIC_PROPERTY("INVALID_NUMBER_FORMAT",
709             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::INVALID_NUMBER_FORMAT))),
710         DECLARE_NAPI_STATIC_PROPERTY("FACILITY_REJECTED",
711             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::FACILITY_REJECTED))),
712         DECLARE_NAPI_STATIC_PROPERTY("RESPONSE_TO_STATUS_ENQUIRY",
713             NapiCallManagerUtils::ToInt32Value(env,
714             static_cast<int32_t>(DisconnectedReason::RESPONSE_TO_STATUS_ENQUIRY))),
715         DECLARE_NAPI_STATIC_PROPERTY("NORMAL_UNSPECIFIED",
716             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NORMAL_UNSPECIFIED))),
717         DECLARE_NAPI_STATIC_PROPERTY("NO_CIRCUIT_CHANNEL_AVAILABLE",
718             NapiCallManagerUtils::ToInt32Value(env,
719             static_cast<int32_t>(DisconnectedReason::NO_CIRCUIT_CHANNEL_AVAILABLE))),
720         DECLARE_NAPI_STATIC_PROPERTY("NETWORK_OUT_OF_ORDER",
721             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NETWORK_OUT_OF_ORDER))),
722         DECLARE_NAPI_STATIC_PROPERTY("TEMPORARY_FAILURE",
723             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::TEMPORARY_FAILURE))),
724         DECLARE_NAPI_STATIC_PROPERTY("SWITCHING_EQUIPMENT_CONGESTION",
725             NapiCallManagerUtils::ToInt32Value(env,
726             static_cast<int32_t>(DisconnectedReason::SWITCHING_EQUIPMENT_CONGESTION))),
727         DECLARE_NAPI_STATIC_PROPERTY("ACCESS_INFORMATION_DISCARDED",
728             NapiCallManagerUtils::ToInt32Value(env,
729             static_cast<int32_t>(DisconnectedReason::ACCESS_INFORMATION_DISCARDED))),
730         DECLARE_NAPI_STATIC_PROPERTY("REQUEST_CIRCUIT_CHANNEL_NOT_AVAILABLE",
731             NapiCallManagerUtils::ToInt32Value(env,
732             static_cast<int32_t>(DisconnectedReason::REQUEST_CIRCUIT_CHANNEL_NOT_AVAILABLE))),
733         DECLARE_NAPI_STATIC_PROPERTY("RESOURCES_UNAVAILABLE_UNSPECIFIED",
734             NapiCallManagerUtils::ToInt32Value(env,
735             static_cast<int32_t>(DisconnectedReason::RESOURCES_UNAVAILABLE_UNSPECIFIED))),
736         DECLARE_NAPI_STATIC_PROPERTY("QUALITY_OF_SERVICE_UNAVAILABLE",
737             NapiCallManagerUtils::ToInt32Value(env,
738             static_cast<int32_t>(DisconnectedReason::QUALITY_OF_SERVICE_UNAVAILABLE))),
739         DECLARE_NAPI_STATIC_PROPERTY("REQUESTED_FACILITY_NOT_SUBSCRIBED",
740             NapiCallManagerUtils::ToInt32Value(env,
741             static_cast<int32_t>(DisconnectedReason::REQUESTED_FACILITY_NOT_SUBSCRIBED))),
742         DECLARE_NAPI_STATIC_PROPERTY("INCOMING_CALLS_BARRED_WITHIN_THE_CUG",
743             NapiCallManagerUtils::ToInt32Value(env,
744             static_cast<int32_t>(DisconnectedReason::INCOMING_CALLS_BARRED_WITHIN_THE_CUG))),
745         DECLARE_NAPI_STATIC_PROPERTY("BEARER_CAPABILITY_NOT_AUTHORIZED",
746             NapiCallManagerUtils::ToInt32Value(env,
747             static_cast<int32_t>(DisconnectedReason::BEARER_CAPABILITY_NOT_AUTHORIZED))),
748         DECLARE_NAPI_STATIC_PROPERTY("BEARER_CAPABILITY_NOT_PRESENTLY_AVAILABLE",
749             NapiCallManagerUtils::ToInt32Value(env,
750             static_cast<int32_t>(DisconnectedReason::BEARER_CAPABILITY_NOT_PRESENTLY_AVAILABLE))),
751         DECLARE_NAPI_STATIC_PROPERTY("SERVICE_OR_OPTION_NOT_AVAILABLE_UNSPECIFIED",
752             NapiCallManagerUtils::ToInt32Value(env,
753             static_cast<int32_t>(DisconnectedReason::SERVICE_OR_OPTION_NOT_AVAILABLE_UNSPECIFIED))),
754         DECLARE_NAPI_STATIC_PROPERTY("BEARER_SERVICE_NOT_IMPLEMENTED",
755             NapiCallManagerUtils::ToInt32Value(env,
756             static_cast<int32_t>(DisconnectedReason::BEARER_SERVICE_NOT_IMPLEMENTED))),
757         DECLARE_NAPI_STATIC_PROPERTY("ACM_EQUALTO_OR_GREATER_THAN_THE_MAXIMUM_VALUE",
758             NapiCallManagerUtils::ToInt32Value(env,
759             static_cast<int32_t>(DisconnectedReason::ACM_EQUALTO_OR_GREATE_THAN_ACMMAX))),
760         DECLARE_NAPI_STATIC_PROPERTY("REQUESTED_FACILITY_NOT_IMPLEMENTED",
761             NapiCallManagerUtils::ToInt32Value(env,
762             static_cast<int32_t>(DisconnectedReason::REQUESTED_FACILITY_NOT_IMPLEMENTED))),
763         DECLARE_NAPI_STATIC_PROPERTY("ONLY_RESTRICTED_DIGITAL_INFO_BEARER_CAPABILITY_IS_AVAILABLE",
764             NapiCallManagerUtils::ToInt32Value(env,
765             static_cast<int32_t>(DisconnectedReason::ONLY_RESTRICTED_DIGITAL_INFO_BEARER_CAPABILITY_IS_AVAILABLE))),
766         DECLARE_NAPI_STATIC_PROPERTY("SERVICE_OR_OPTION_NOT_IMPLEMENTED_UNSPECIFIED",
767             NapiCallManagerUtils::ToInt32Value(env,
768             static_cast<int32_t>(DisconnectedReason::SERVICE_OR_OPTION_NOT_IMPLEMENTED_UNSPECIFIED))),
769         DECLARE_NAPI_STATIC_PROPERTY("INVALID_TRANSACTION_IDENTIFIER_VALUE",
770             NapiCallManagerUtils::ToInt32Value(env,
771             static_cast<int32_t>(DisconnectedReason::INVALID_TRANSACTION_IDENTIFIER_VALUE))),
772         DECLARE_NAPI_STATIC_PROPERTY("USER_NOT_MEMBER_OF_CUG",
773             NapiCallManagerUtils::ToInt32Value(env,
774             static_cast<int32_t>(DisconnectedReason::USER_NOT_MEMBER_OF_CUG))),
775         DECLARE_NAPI_STATIC_PROPERTY("INCOMPATIBLE_DESTINATION",
776             NapiCallManagerUtils::ToInt32Value(env,
777             static_cast<int32_t>(DisconnectedReason::INCOMPATIBLE_DESTINATION))),
778         DECLARE_NAPI_STATIC_PROPERTY("INVALID_TRANSIT_NETWORK_SELECTION",
779             NapiCallManagerUtils::ToInt32Value(env,
780             static_cast<int32_t>(DisconnectedReason::INVALID_TRANSIT_NETWORK_SELECTION))),
781         DECLARE_NAPI_STATIC_PROPERTY("SEMANTICALLY_INCORRECT_MESSAGE",
782             NapiCallManagerUtils::ToInt32Value(env,
783             static_cast<int32_t>(DisconnectedReason::SEMANTICALLY_INCORRECT_MESSAGE))),
784         DECLARE_NAPI_STATIC_PROPERTY("INVALID_MANDATORY_INFORMATION",
785             NapiCallManagerUtils::ToInt32Value(env,
786             static_cast<int32_t>(DisconnectedReason::INVALID_MANDATORY_INFORMATION))),
787         DECLARE_NAPI_STATIC_PROPERTY("MESSAGE_TYPE_NON_EXISTENT_OR_NOT_IMPLEMENTED",
788             NapiCallManagerUtils::ToInt32Value(env,
789             static_cast<int32_t>(DisconnectedReason::MESSAGE_TYPE_NON_EXISTENT_OR_NOT_IMPLEMENTED))),
790         DECLARE_NAPI_STATIC_PROPERTY("MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE",
791             NapiCallManagerUtils::ToInt32Value(env,
792             static_cast<int32_t>(DisconnectedReason::MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE))),
793         DECLARE_NAPI_STATIC_PROPERTY("INFORMATION_ELEMENT_NON_EXISTENT_OR_NOT_IMPLEMENTED",
794             NapiCallManagerUtils::ToInt32Value(env,
795             static_cast<int32_t>(DisconnectedReason::INFORMATION_ELEMENT_NON_EXISTENT_OR_NOT_IMPLEMENTED))),
796         DECLARE_NAPI_STATIC_PROPERTY("CONDITIONAL_IE_ERROR",
797             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::CONDITIONAL_IE_ERROR))),
798         DECLARE_NAPI_STATIC_PROPERTY("MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE",
799             NapiCallManagerUtils::ToInt32Value(env,
800             static_cast<int32_t>(DisconnectedReason::MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE))),
801         DECLARE_NAPI_STATIC_PROPERTY("RECOVERY_ON_TIMER_EXPIRED",
802             NapiCallManagerUtils::ToInt32Value(env,
803             static_cast<int32_t>(DisconnectedReason::RECOVERY_ON_TIMER_EXPIRED))),
804         DECLARE_NAPI_STATIC_PROPERTY("PROTOCOL_ERROR_UNSPECIFIED",
805             NapiCallManagerUtils::ToInt32Value(env,
806             static_cast<int32_t>(DisconnectedReason::PROTOCOL_ERROR_UNSPECIFIED))),
807         DECLARE_NAPI_STATIC_PROPERTY("INTERWORKING_UNSPECIFIED",
808             NapiCallManagerUtils::ToInt32Value(env,
809             static_cast<int32_t>(DisconnectedReason::INTERWORKING_UNSPECIFIED))),
810         DECLARE_NAPI_STATIC_PROPERTY("CALL_BARRED",
811             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::CALL_BARRED))),
812         DECLARE_NAPI_STATIC_PROPERTY("FDN_BLOCKED",
813             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::FDN_BLOCKED))),
814         DECLARE_NAPI_STATIC_PROPERTY("IMSI_UNKNOWN_IN_VLR",
815             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::IMSI_UNKNOWN_IN_VLR))),
816         DECLARE_NAPI_STATIC_PROPERTY("IMEI_NOT_ACCEPTED",
817             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::IMEI_NOT_ACCEPTED))),
818         DECLARE_NAPI_STATIC_PROPERTY("DIAL_MODIFIED_TO_USSD",
819             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::DIAL_MODIFIED_TO_USSD))),
820         DECLARE_NAPI_STATIC_PROPERTY("DIAL_MODIFIED_TO_SS",
821             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::DIAL_MODIFIED_TO_SS))),
822         DECLARE_NAPI_STATIC_PROPERTY("DIAL_MODIFIED_TO_DIAL",
823             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::DIAL_MODIFIED_TO_DIAL))),
824         DECLARE_NAPI_STATIC_PROPERTY("RADIO_OFF",
825             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_OFF))),
826         DECLARE_NAPI_STATIC_PROPERTY("OUT_OF_SERVICE",
827             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::OUT_OF_SERVICE))),
828         DECLARE_NAPI_STATIC_PROPERTY("NO_VALID_SIM",
829             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NO_VALID_SIM))),
830         DECLARE_NAPI_STATIC_PROPERTY("RADIO_INTERNAL_ERROR",
831             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_INTERNAL_ERROR))),
832         DECLARE_NAPI_STATIC_PROPERTY("NETWORK_RESP_TIMEOUT",
833             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NETWORK_RESP_TIMEOUT))),
834         DECLARE_NAPI_STATIC_PROPERTY("NETWORK_REJECT",
835             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NETWORK_REJECT))),
836         DECLARE_NAPI_STATIC_PROPERTY("RADIO_ACCESS_FAILURE",
837             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_ACCESS_FAILURE))),
838         DECLARE_NAPI_STATIC_PROPERTY("RADIO_LINK_FAILURE",
839             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_LINK_FAILURE))),
840         DECLARE_NAPI_STATIC_PROPERTY("RADIO_LINK_LOST",
841             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_LINK_LOST))),
842         DECLARE_NAPI_STATIC_PROPERTY("RADIO_UPLINK_FAILURE",
843             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_UPLINK_FAILURE))),
844         DECLARE_NAPI_STATIC_PROPERTY("RADIO_SETUP_FAILURE",
845             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_SETUP_FAILURE))),
846         DECLARE_NAPI_STATIC_PROPERTY("RADIO_RELEASE_NORMAL",
847             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_RELEASE_NORMAL))),
848         DECLARE_NAPI_STATIC_PROPERTY("RADIO_RELEASE_ABNORMAL",
849             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::RADIO_RELEASE_ABNORMAL))),
850         DECLARE_NAPI_STATIC_PROPERTY("ACCESS_CLASS_BLOCKED",
851             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::ACCESS_CLASS_BLOCKED))),
852         DECLARE_NAPI_STATIC_PROPERTY("NETWORK_DETACH",
853             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::NETWORK_DETACH))),
854         DECLARE_NAPI_STATIC_PROPERTY("INVALID_PARAMETER",
855             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::INVALID_PARAMETER))),
856         DECLARE_NAPI_STATIC_PROPERTY("SIM_NOT_EXIT",
857             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::SIM_NOT_EXIT))),
858         DECLARE_NAPI_STATIC_PROPERTY("SIM_PIN_NEED",
859             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::SIM_PIN_NEED))),
860         DECLARE_NAPI_STATIC_PROPERTY("CALL_NOT_ALLOW",
861             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::CALL_NOT_ALLOW))),
862         DECLARE_NAPI_STATIC_PROPERTY("SIM_INVALID",
863             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::SIM_INVALID))),
864         DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN",
865             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DisconnectedReason::FAILED_UNKNOWN))),
866     };
867     napi_value result = nullptr;
868     napi_define_class(env, "DisconnectedReason", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
869         nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
870     napi_set_named_property(env, exports, "DisconnectedReason", result);
871     return exports;
872 }
873 
DeclareMarkTypeEnum(napi_env env, napi_value exports)874 napi_value NapiCallManager::DeclareMarkTypeEnum(napi_env env, napi_value exports)
875 {
876     napi_property_descriptor desc[] = {
877         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_NONE",
878             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_NONE))),
879         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_CRANK",
880             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_CRANK))),
881         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_FRAUD",
882             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_FRAUD))),
883         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_EXPRESS",
884             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_EXPRESS))),
885         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_PROMOTE_SALES",
886             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_PROMOTE_SALES))),
887         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_HOUSE_AGENT",
888             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_HOUSE_AGENT))),
889         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_INSURANCE",
890             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_INSURANCE))),
891         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_TAXI",
892             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_TAXI))),
893         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_CUSTOM",
894             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_CUSTOM))),
895         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_OTHERS",
896             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_OTHERS))),
897         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_YELLOW_PAGE",
898             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_YELLOW_PAGE))),
899         DECLARE_NAPI_STATIC_PROPERTY("MARK_TYPE_ENTERPRISE",
900             NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(MarkType::MARK_TYPE_ENTERPRISE))),
901     };
902     napi_value result = nullptr;
903     napi_define_class(env, "MarkType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
904                       sizeof(desc) / sizeof(*desc), desc, &result);
905     napi_set_named_property(env, exports, "MarkType", result);
906     return exports;
907 }
908 
909 /**
910  * The call_manager is initialized.
911  */
RegisterCallManagerFunc(napi_env env, napi_value exports)912 napi_value NapiCallManager::RegisterCallManagerFunc(napi_env env, napi_value exports)
913 {
914     // Interface initialization
915     DeclareCallBasisInterface(env, exports);
916     DeclareCallConferenceInterface(env, exports);
917     DeclareCallSupplementInterface(env, exports);
918     DeclareCallExtendInterface(env, exports);
919     DeclareCallMultimediaInterface(env, exports);
920     DeclareCallImsInterface(env, exports);
921     // Enumeration class extension initialization
922     DeclareVoNRStateEnum(env, exports);
923     DeclareAudioDeviceEnum(env, exports);
924     DeclareVideoStateTypeEnum(env, exports);
925     DeclareVideoRequestResultEnum(env, exports);
926     DeclareImsCallModeEnum(env, exports);
927     DeclareDeviceDirectionEnum(env, exports);
928     DeclareDialSceneEnum(env, exports);
929     DeclareCallTypeEnum(env, exports);
930     DeclareDialTypeEnum(env, exports);
931     DeclareTelCallStateEnum(env, exports);
932     DeclareConferenceStateEnum(env, exports);
933     DeclareCallStateToAppEnum(env, exports);
934     DeclareCallEventEnumEx(env, exports);
935     DeclareCallSessionEventEnumEx(env, exports);
936     DeclareRestrictionTypeEnum(env, exports);
937     DeclareRestrictionModeEnum(env, exports);
938     DeclareRestrictionStatusEnum(env, exports);
939     DeclareCallWaitingEnumEx(env, exports);
940     DeclareTransferStatusEnum(env, exports);
941     DeclareTransferTypeEnum(env, exports);
942     DeclareTransferSettingTypeEnum(env, exports);
943     DeclareMmiCodeResultEnum(env, exports);
944     DeclareDisconnectedReasonEnum(env, exports);
945     DeclareMarkTypeEnum(env, exports);
946     Init();
947     RegisterCallBack();
948     return exports;
949 }
950 
Dial(napi_env env, napi_callback_info info)951 napi_value NapiCallManager::Dial(napi_env env, napi_callback_info info)
952 {
953     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
954     NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
955     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string);
956     NAPI_ASSERT(env, matchFlag, "Dial type error, should be string type");
957     auto asyncContext = (std::make_unique<DialAsyncContext>());
958     if (asyncContext == nullptr) {
959         std::string errorCode = std::to_string(napi_generic_failure);
960         std::string errorMessage = "Dial error at baseContext is nullptr";
961         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
962         return nullptr;
963     }
964     napi_get_value_string_utf8(
965         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
966     if (argc == TWO_VALUE_LIMIT) {
967         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_undefined) ||
968             NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_null)) {
969             TELEPHONY_LOGI("undefined or null param is detected, second param is ignored.");
970         } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
971             napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
972         } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_object)) {
973             GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
974         }
975     } else if (argc == VALUE_MAXIMUM_LIMIT &&
976         NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_object)) {
977         GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
978         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
979     }
980     return HandleAsyncWork(env, asyncContext.release(), "Dial", NativeDial, NativeDialCallBack);
981 }
982 
MatchStringAndVariableObjectParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)983 bool NapiCallManager::MatchStringAndVariableObjectParameters(
984     napi_env env, const napi_value parameters[], const size_t parameterCount)
985 {
986     TELEPHONY_LOGD("Match parmameter count %{public}zu", parameterCount);
987     switch (parameterCount) {
988         case ONLY_ONE_VALUE:
989             return NapiUtil::MatchParameters(env, parameters, { napi_string });
990         case TWO_VALUE_LIMIT:
991             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_function }) ||
992                    NapiUtil::MatchParameters(env, parameters, { napi_string, napi_null}) ||
993                    NapiUtil::MatchParameters(env, parameters, { napi_string, napi_undefined }) ||
994                    NapiUtil::MatchParameters(env, parameters, { napi_string, napi_object });
995         case VALUE_MAXIMUM_LIMIT:
996             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_object, napi_function });
997         default:
998             return false;
999     }
1000 }
1001 
MakeCall(napi_env env, napi_callback_info info)1002 napi_value NapiCallManager::MakeCall(napi_env env, napi_callback_info info)
1003 {
1004     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1005     if (!MatchOneStringParameter(env, argv, argc)) {
1006         TELEPHONY_LOGE("NapiCallManager::MakeCall MatchOneStringParameter failed.");
1007         NapiUtil::ThrowParameterError(env);
1008         return nullptr;
1009     }
1010     auto asyncContext = std::make_unique<AsyncContext>();
1011     if (asyncContext == nullptr) {
1012         NapiUtil::ThrowParameterError(env);
1013         return nullptr;
1014     }
1015     napi_get_value_string_utf8(
1016         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1017     if (argc == TWO_VALUE_LIMIT) {
1018         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1019     }
1020     return HandleAsyncWork(env, asyncContext.release(), "MakeCall", NativeMakeCall, NativeVoidCallBackWithErrorCode);
1021 }
1022 
DialCall(napi_env env, napi_callback_info info)1023 napi_value NapiCallManager::DialCall(napi_env env, napi_callback_info info)
1024 {
1025     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1026     if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
1027         TELEPHONY_LOGE("MatchStringAndVariableObjectParameters failed.");
1028         NapiUtil::ThrowParameterError(env);
1029         return nullptr;
1030     }
1031     auto asyncContext = (std::make_unique<DialAsyncContext>());
1032     if (asyncContext == nullptr) {
1033         NapiUtil::ThrowParameterError(env);
1034         TELEPHONY_LOGE("asyncContext is nullptr.");
1035         return nullptr;
1036     }
1037     napi_get_value_string_utf8(
1038         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1039     if (argc == TWO_VALUE_LIMIT) {
1040         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1041             napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1042         } else {
1043             GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1044         }
1045     } else if (argc == VALUE_MAXIMUM_LIMIT &&
1046         NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_object) &&
1047         NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_THIRD], napi_function)) {
1048         GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1049         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1050     }
1051     return HandleAsyncWork(env, asyncContext.release(), "DialCall", NativeDialCall, NativeVoidCallBackWithErrorCode);
1052 }
1053 
AnswerCall(napi_env env, napi_callback_info info)1054 napi_value NapiCallManager::AnswerCall(napi_env env, napi_callback_info info)
1055 {
1056     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1057     if (!MatchOneOptionalNumberParameter(env, argv, argc)) {
1058         TELEPHONY_LOGE("MatchOneOptionalNumberParameter failed.");
1059         NapiUtil::ThrowParameterError(env);
1060         return nullptr;
1061     }
1062     auto answerAsyncContext = std::make_unique<AnswerAsyncContext>();
1063     if (answerAsyncContext == nullptr) {
1064         TELEPHONY_LOGE("answerAsyncContext is nullptr.");
1065         NapiUtil::ThrowParameterError(env);
1066         return nullptr;
1067     }
1068 
1069     if (argc == ZERO_VALUE) {
1070         TELEPHONY_LOGI("no param input");
1071     } else if (argc == ONLY_ONE_VALUE) {
1072         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_undefined) ||
1073             NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_null)) {
1074             TELEPHONY_LOGI("undefined or null param is detected, treating as no param input.");
1075         } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_function)) {
1076             napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(answerAsyncContext->callbackRef));
1077         } else {
1078             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->callId);
1079         }
1080     } else if (argc == TWO_VALUE_LIMIT) {
1081         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1082             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->callId);
1083             napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(answerAsyncContext->callbackRef));
1084         } else {
1085             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->videoState);
1086             napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &answerAsyncContext->callId);
1087         }
1088     }
1089 
1090     return HandleAsyncWork(
1091         env, answerAsyncContext.release(), "AnswerCall", NativeAnswerCall, NativeVoidCallBackWithErrorCode);
1092 }
1093 
AnswerVideoCall(napi_env env, napi_callback_info info)1094 napi_value NapiCallManager::AnswerVideoCall(napi_env env, napi_callback_info info)
1095 {
1096     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1097     if (!MatchAnswerCallParameter(env, argv, argc)) {
1098         TELEPHONY_LOGE("MatchOneOptionalNumberParameter failed.");
1099         NapiUtil::ThrowParameterError(env);
1100         return nullptr;
1101     }
1102     auto answerAsyncContext = std::make_unique<AnswerAsyncContext>();
1103     if (answerAsyncContext == nullptr) {
1104         TELEPHONY_LOGE("answerAsyncContext is nullptr.");
1105         NapiUtil::ThrowParameterError(env);
1106         return nullptr;
1107     }
1108     if (argc == ZERO_VALUE) {
1109         TELEPHONY_LOGI("no param input");
1110     } else if (argc == ONLY_ONE_VALUE) {
1111         napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->videoState);
1112     } else if (argc == TWO_VALUE_LIMIT) {
1113         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1114             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->videoState);
1115             napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(answerAsyncContext->callbackRef));
1116         } else {
1117             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &answerAsyncContext->videoState);
1118             napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &answerAsyncContext->callId);
1119         }
1120     }
1121 
1122     return HandleAsyncWork(
1123         env, answerAsyncContext.release(), "AnswerCall", NativeAnswerCall, NativeVoidCallBackWithErrorCode);
1124 }
1125 
RejectCall(napi_env env, napi_callback_info info)1126 napi_value NapiCallManager::RejectCall(napi_env env, napi_callback_info info)
1127 {
1128     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1129     if (!MatchRejectCallParameters(env, argv, argc)) {
1130         TELEPHONY_LOGE("MatchRejectCallParameters failed.");
1131         NapiUtil::ThrowParameterError(env);
1132         return nullptr;
1133     }
1134     auto asyncContext = std::make_unique<RejectAsyncContext>();
1135     if (asyncContext == nullptr) {
1136         TELEPHONY_LOGE("asyncContext is nullptr.");
1137         NapiUtil::ThrowParameterError(env);
1138         return nullptr;
1139     }
1140     asyncContext->isSendSms = false;
1141     HandleRejectCall(env, *asyncContext, argv, argc);
1142     return HandleAsyncWork(
1143         env, asyncContext.release(), "RejectCall", NativeRejectCall, NativeVoidCallBackWithErrorCode);
1144 }
1145 
HandleRejectCall(napi_env env, RejectAsyncContext &asyncContext, const napi_value parameters[], const size_t parameterCount)1146 void NapiCallManager::HandleRejectCall(napi_env env, RejectAsyncContext &asyncContext,
1147     const napi_value parameters[], const size_t parameterCount)
1148 {
1149     if (parameterCount == ZERO_VALUE) {
1150         TELEPHONY_LOGI("no param input.");
1151     } else if (parameterCount == ONLY_ONE_VALUE) {
1152         if (NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_FIRST], napi_undefined)) {
1153             TELEPHONY_LOGI("undefined or null param is detected, treating as no param input.");
1154         } else if (NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_FIRST], napi_function)) {
1155             napi_create_reference(env, parameters[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext.callbackRef));
1156         } else if (NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_FIRST], napi_number)) {
1157             napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext.callId);
1158         } else {
1159             GetSmsInfo(env, parameters[ARRAY_INDEX_FIRST], asyncContext);
1160         }
1161     } else if (parameterCount == TWO_VALUE_LIMIT) {
1162         if (MatchRejectCallTwoIllegalParameters(env, parameters)) {
1163             TELEPHONY_LOGI("undefined or null params are detected, treating as no param input.");
1164         } else if (MatchRejectCallFirstIllegalParameters(env, parameters)) {
1165             TELEPHONY_LOGI("undefined or null param is detected, first param is ignored.");
1166             GetSmsInfo(env, parameters[ARRAY_INDEX_SECOND], asyncContext);
1167         } else if (MatchRejectCallSecondIllegalParameters(env, parameters)) {
1168             TELEPHONY_LOGI("undefined or null param is detected, second param is ignored.");
1169             napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext.callId);
1170         } else if (NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_FIRST], napi_object) &&
1171             NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_SECOND], napi_function)) {
1172             GetSmsInfo(env, parameters[ARRAY_INDEX_FIRST], asyncContext);
1173             napi_create_reference(env, parameters[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext.callbackRef));
1174         } else if (NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_FIRST], napi_number) &&
1175                    NapiCallManagerUtils::MatchValueType(env, parameters[ARRAY_INDEX_SECOND], napi_function)) {
1176             napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext.callId);
1177             napi_create_reference(env, parameters[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext.callbackRef));
1178         } else {
1179             napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext.callId);
1180             GetSmsInfo(env, parameters[ARRAY_INDEX_SECOND], asyncContext);
1181         }
1182     } else {
1183         napi_get_value_int32(env, parameters[ARRAY_INDEX_FIRST], &asyncContext.callId);
1184         GetSmsInfo(env, parameters[ARRAY_INDEX_SECOND], asyncContext);
1185         napi_create_reference(env, parameters[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext.callbackRef));
1186     }
1187 }
1188 
HangUpCall(napi_env env, napi_callback_info info)1189 napi_value NapiCallManager::HangUpCall(napi_env env, napi_callback_info info)
1190 {
1191     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1192     if (!MatchOneOptionalNumberParameter(env, argv, argc)) {
1193         TELEPHONY_LOGE("MatchOneOptionalNumberParameter failed.");
1194         NapiUtil::ThrowParameterError(env);
1195         return nullptr;
1196     }
1197     auto asyncContext = std::make_unique<AsyncContext>();
1198     if (asyncContext == nullptr) {
1199         TELEPHONY_LOGE("asyncContext is nullptr.");
1200         NapiUtil::ThrowParameterError(env);
1201         return nullptr;
1202     }
1203 
1204     if (argc == ZERO_VALUE) {
1205         TELEPHONY_LOGI("no param input");
1206     } else if (argc == ONLY_ONE_VALUE) {
1207         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_undefined) ||
1208             NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_null)) {
1209             TELEPHONY_LOGI("undefined or null param is detected, treating as no param input.");
1210         } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_function)) {
1211             napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1212         } else {
1213             napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1214         }
1215     } else {
1216         napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1217         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1218     }
1219 
1220     return HandleAsyncWork(
1221         env, asyncContext.release(), "HangUpCall", NativeHangUpCall, NativeVoidCallBackWithErrorCode);
1222 }
1223 
HoldCall(napi_env env, napi_callback_info info)1224 napi_value NapiCallManager::HoldCall(napi_env env, napi_callback_info info)
1225 {
1226     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1227     if (!MatchOneNumberParameter(env, argv, argc)) {
1228         TELEPHONY_LOGE("NapiCallManager::HoldCall MatchOneNumberParameter failed.");
1229         NapiUtil::ThrowParameterError(env);
1230         return nullptr;
1231     }
1232     auto asyncContext = std::make_unique<AsyncContext>();
1233     if (asyncContext == nullptr) {
1234         TELEPHONY_LOGE("NapiCallManager::HoldCall asyncContext is nullptr.");
1235         NapiUtil::ThrowParameterError(env);
1236         return nullptr;
1237     }
1238     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1239     if (argc == TWO_VALUE_LIMIT) {
1240         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1241     }
1242     return HandleAsyncWork(env, asyncContext.release(), "HoldCall", NativeHoldCall, NativeVoidCallBackWithErrorCode);
1243 }
1244 
UnHoldCall(napi_env env, napi_callback_info info)1245 napi_value NapiCallManager::UnHoldCall(napi_env env, napi_callback_info info)
1246 {
1247     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1248     if (!MatchOneNumberParameter(env, argv, argc)) {
1249         TELEPHONY_LOGE("NapiCallManager::UnHoldCall MatchOneNumberParameter failed.");
1250         NapiUtil::ThrowParameterError(env);
1251         return nullptr;
1252     }
1253     auto asyncContext = std::make_unique<AsyncContext>();
1254     if (asyncContext == nullptr) {
1255         TELEPHONY_LOGE("NapiCallManager::UnHoldCall asyncContext is nullptr.");
1256         NapiUtil::ThrowParameterError(env);
1257         return nullptr;
1258     }
1259     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1260     if (argc == TWO_VALUE_LIMIT) {
1261         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1262     }
1263     return HandleAsyncWork(
1264         env, asyncContext.release(), "UnHoldCall", NativeUnHoldCall, NativeVoidCallBackWithErrorCode);
1265 }
1266 
SwitchCall(napi_env env, napi_callback_info info)1267 napi_value NapiCallManager::SwitchCall(napi_env env, napi_callback_info info)
1268 {
1269     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1270     if (!MatchOneNumberParameter(env, argv, argc)) {
1271         TELEPHONY_LOGE("NapiCallManager::SwitchCall MatchOneNumberParameter failed.");
1272         NapiUtil::ThrowParameterError(env);
1273         return nullptr;
1274     }
1275     auto asyncContext = std::make_unique<AsyncContext>();
1276     if (asyncContext == nullptr) {
1277         TELEPHONY_LOGE("NapiCallManager::SwitchCall asyncContext is nullptr.");
1278         NapiUtil::ThrowParameterError(env);
1279         return nullptr;
1280     }
1281     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1282     if (argc == TWO_VALUE_LIMIT) {
1283         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1284     }
1285 
1286     return HandleAsyncWork(
1287         env, asyncContext.release(), "SwitchCall", NativeSwitchCall, NativeVoidCallBackWithErrorCode);
1288 }
1289 
CombineConference(napi_env env, napi_callback_info info)1290 napi_value NapiCallManager::CombineConference(napi_env env, napi_callback_info info)
1291 {
1292     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1293     if (!MatchOneNumberParameter(env, argv, argc)) {
1294         TELEPHONY_LOGE("NapiCallManager::CombineConference MatchOneNumberParameter failed.");
1295         NapiUtil::ThrowParameterError(env);
1296         return nullptr;
1297     }
1298     auto asyncContext = std::make_unique<AsyncContext>();
1299     if (asyncContext == nullptr) {
1300         TELEPHONY_LOGE("NapiCallManager::CombineConference asyncContext is nullptr.");
1301         NapiUtil::ThrowParameterError(env);
1302         return nullptr;
1303     }
1304     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1305     if (argc == TWO_VALUE_LIMIT) {
1306         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1307     }
1308 
1309     return HandleAsyncWork(
1310         env, asyncContext.release(), "CombineConference", NativeCombineConference, NativeVoidCallBackWithErrorCode);
1311 }
1312 
SeparateConference(napi_env env, napi_callback_info info)1313 napi_value NapiCallManager::SeparateConference(napi_env env, napi_callback_info info)
1314 {
1315     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1316     if (!MatchOneNumberParameter(env, argv, argc)) {
1317         TELEPHONY_LOGE("NapiCallManager::SeparateConference MatchOneNumberParameter failed.");
1318         NapiUtil::ThrowParameterError(env);
1319         return nullptr;
1320     }
1321     auto asyncContext = std::make_unique<AsyncContext>();
1322     if (asyncContext == nullptr) {
1323         TELEPHONY_LOGE("NapiCallManager::SeparateConference asyncContext is nullptr.");
1324         NapiUtil::ThrowParameterError(env);
1325         return nullptr;
1326     }
1327     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1328     if (argc == TWO_VALUE_LIMIT) {
1329         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1330     }
1331     return HandleAsyncWork(
1332         env, asyncContext.release(), "SeparateConference", NativeSeparateConference, NativeVoidCallBackWithErrorCode);
1333 }
1334 
KickOutFromConference(napi_env env, napi_callback_info info)1335 napi_value NapiCallManager::KickOutFromConference(napi_env env, napi_callback_info info)
1336 {
1337     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1338     if (!MatchOneNumberParameter(env, argv, argc)) {
1339         TELEPHONY_LOGE("NapiCallManager::KickoutFromConference MatchOneNumberParameter failed.");
1340         NapiUtil::ThrowParameterError(env);
1341         return nullptr;
1342     }
1343     auto asyncContext = std::make_unique<AsyncContext>();
1344     if (asyncContext == nullptr) {
1345         TELEPHONY_LOGE("NapiCallManager::KickoutFromConference asyncContext is nullptr.");
1346         NapiUtil::ThrowParameterError(env);
1347         return nullptr;
1348     }
1349     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1350     if (argc == TWO_VALUE_LIMIT) {
1351         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1352     }
1353     return HandleAsyncWork(env, asyncContext.release(), "KickoutFromConference", NativeKickOutFromConference,
1354         NativeVoidCallBackWithErrorCode);
1355 }
1356 
GetMainCallId(napi_env env, napi_callback_info info)1357 napi_value NapiCallManager::GetMainCallId(napi_env env, napi_callback_info info)
1358 {
1359     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1360     if (!MatchOneNumberParameter(env, argv, argc)) {
1361         TELEPHONY_LOGE("NapiCallManager::GetMainCallId MatchOneNumberParameter failed.");
1362         NapiUtil::ThrowParameterError(env);
1363         return nullptr;
1364     }
1365     auto asyncContext = std::make_unique<IntResultAsyncContext>();
1366     if (asyncContext == nullptr) {
1367         TELEPHONY_LOGE("NapiCallManager::GetMainCallId asyncContext is nullptr.");
1368         NapiUtil::ThrowParameterError(env);
1369         return nullptr;
1370     }
1371     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1372     if (argc == TWO_VALUE_LIMIT) {
1373         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1374     }
1375     return HandleAsyncWork(
1376         env, asyncContext.release(), "GetMainCallId", NativeGetMainCallId, NativeGetMainCallIdCallBack);
1377 }
1378 
GetSubCallIdList(napi_env env, napi_callback_info info)1379 napi_value NapiCallManager::GetSubCallIdList(napi_env env, napi_callback_info info)
1380 {
1381     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1382     if (!MatchOneNumberParameter(env, argv, argc)) {
1383         TELEPHONY_LOGE("NapiCallManager::GetSubCallIdList MatchOneNumberParameter failed.");
1384         NapiUtil::ThrowParameterError(env);
1385         return nullptr;
1386     }
1387     auto asyncContext = std::make_unique<ListAsyncContext>();
1388     if (asyncContext == nullptr) {
1389         TELEPHONY_LOGE("NapiCallManager::GetSubCallIdList asyncContext is nullptr.");
1390         NapiUtil::ThrowParameterError(env);
1391         return nullptr;
1392     }
1393     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1394     if (argc == TWO_VALUE_LIMIT) {
1395         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1396     }
1397     return HandleAsyncWork(env, asyncContext.release(), "GetSubCallIdList", NativeGetSubCallIdList, NativeListCallBack);
1398 }
1399 
GetCallIdListForConference(napi_env env, napi_callback_info info)1400 napi_value NapiCallManager::GetCallIdListForConference(napi_env env, napi_callback_info info)
1401 {
1402     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1403     if (!MatchOneNumberParameter(env, argv, argc)) {
1404         TELEPHONY_LOGE("NapiCallManager::GetCallIdListForConference MatchOneNumberParameter failed.");
1405         NapiUtil::ThrowParameterError(env);
1406         return nullptr;
1407     }
1408     auto asyncContext = std::make_unique<ListAsyncContext>();
1409     if (asyncContext == nullptr) {
1410         TELEPHONY_LOGE("NapiCallManager::GetCallIdListForConference asyncContext is nullptr.");
1411         NapiUtil::ThrowParameterError(env);
1412         return nullptr;
1413     }
1414     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1415     if (argc == TWO_VALUE_LIMIT) {
1416         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1417     }
1418     return HandleAsyncWork(env, asyncContext.release(), "GetCallIdListForConference", NativeGetCallIdListForConference,
1419         NativeListCallBack);
1420 }
1421 
MatchEmptyParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)1422 bool NapiCallManager::MatchEmptyParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1423 {
1424     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1425     switch (parameterCount) {
1426         case ZERO_VALUE:
1427             return true;
1428         case ONLY_ONE_VALUE:
1429             return NapiUtil::MatchParameters(env, parameters, { napi_function });
1430         default:
1431             return false;
1432     }
1433 }
1434 
MatchOneOptionalNumberParameter( napi_env env, const napi_value parameters[], const size_t parameterCount)1435 bool NapiCallManager::MatchOneOptionalNumberParameter(
1436     napi_env env, const napi_value parameters[], const size_t parameterCount)
1437 {
1438     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1439     switch (parameterCount) {
1440         case ZERO_VALUE:
1441             return true;
1442         case ONLY_ONE_VALUE:
1443             return NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1444                    NapiUtil::MatchParameters(env, parameters, { napi_function }) ||
1445                    NapiUtil::MatchParameters(env, parameters, { napi_null }) ||
1446                    NapiUtil::MatchParameters(env, parameters, { napi_undefined });
1447         case TWO_VALUE_LIMIT:
1448             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number }) ||
1449                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1450         default:
1451             return false;
1452     }
1453 }
1454 
MatchAnswerCallParameter( napi_env env, const napi_value parameters[], const size_t parameterCount)1455 bool NapiCallManager::MatchAnswerCallParameter(
1456     napi_env env, const napi_value parameters[], const size_t parameterCount)
1457 {
1458     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1459     switch (parameterCount) {
1460         case ZERO_VALUE:
1461             return true;
1462         case ONLY_ONE_VALUE:
1463             return NapiUtil::MatchParameters(env, parameters, { napi_number });
1464         case TWO_VALUE_LIMIT:
1465             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number }) ||
1466                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function});
1467         case THREE_VALUE_MAXIMUM_LIMIT:
1468             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
1469         default:
1470             return false;
1471     }
1472 }
1473 
MatchOneStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)1474 bool NapiCallManager::MatchOneStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1475 {
1476     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1477     switch (parameterCount) {
1478         case ONLY_ONE_VALUE:
1479             return NapiUtil::MatchParameters(env, parameters, { napi_string });
1480         case TWO_VALUE_LIMIT:
1481             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_function });
1482         default:
1483             return false;
1484     }
1485 }
1486 
MatchObserverOffParameter( napi_env env, const napi_value parameters[], const size_t parameterCount)1487 bool NapiCallManager::MatchObserverOffParameter(
1488     napi_env env, const napi_value parameters[], const size_t parameterCount)
1489 {
1490     TELEPHONY_LOGD("parameter count: %{public}zu", parameterCount);
1491     switch (parameterCount) {
1492         case ONLY_ONE_VALUE:
1493             return NapiUtil::MatchParameters(env, parameters, { napi_string });
1494         case TWO_VALUE_LIMIT:
1495             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_function }) ||
1496                    NapiUtil::MatchParameters(env, parameters, { napi_string, napi_null }) ||
1497                    NapiUtil::MatchParameters(env, parameters, { napi_string, napi_undefined });
1498         default:
1499             return false;
1500     }
1501 }
1502 
MatchOneNumberParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)1503 bool NapiCallManager::MatchOneNumberParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1504 {
1505     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1506     switch (parameterCount) {
1507         case ONLY_ONE_VALUE:
1508             return NapiUtil::MatchParameters(env, parameters, { napi_number });
1509         case TWO_VALUE_LIMIT:
1510             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1511         default:
1512             return false;
1513     }
1514 }
1515 
MatchTwoNumberParameters(napi_env env, const napi_value parameters[], const size_t parameterCount)1516 bool NapiCallManager::MatchTwoNumberParameters(napi_env env, const napi_value parameters[], const size_t parameterCount)
1517 {
1518     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1519     switch (parameterCount) {
1520         case TWO_VALUE_LIMIT:
1521             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number });
1522         case THREE_VALUE_MAXIMUM_LIMIT:
1523             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
1524         default:
1525             return false;
1526     }
1527 }
1528 
MatchTwoStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)1529 bool NapiCallManager::MatchTwoStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1530 {
1531     TELEPHONY_LOGD("Match parmameter count %{public}zu", parameterCount);
1532     switch (parameterCount) {
1533         case TWO_VALUE_LIMIT:
1534             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_string });
1535         case THREE_VALUE_MAXIMUM_LIMIT:
1536             return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_string, napi_function });
1537         default:
1538             return false;
1539     }
1540 }
1541 
MatchNumberAndBoolParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)1542 bool NapiCallManager::MatchNumberAndBoolParameters(
1543     napi_env env, const napi_value parameters[], const size_t parameterCount)
1544 {
1545     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1546     switch (parameterCount) {
1547         case TWO_VALUE_LIMIT:
1548             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_boolean });
1549         case THREE_VALUE_MAXIMUM_LIMIT:
1550             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_boolean, napi_function });
1551         default:
1552             return false;
1553     }
1554 }
1555 
MatchNumberAndStringParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)1556 bool NapiCallManager::MatchNumberAndStringParameters(
1557     napi_env env, const napi_value parameters[], const size_t parameterCount)
1558 {
1559     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1560     switch (parameterCount) {
1561         case TWO_VALUE_LIMIT:
1562             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string });
1563         case THREE_VALUE_MAXIMUM_LIMIT:
1564             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string, napi_function });
1565         default:
1566             return false;
1567     }
1568 }
1569 
MatchAudioDeviceParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)1570 bool NapiCallManager::MatchAudioDeviceParameters(
1571     napi_env env, const napi_value parameters[], const size_t parameterCount)
1572 {
1573     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1574     switch (parameterCount) {
1575         case ONLY_ONE_VALUE:
1576             return NapiUtil::MatchParameters(env, parameters, { napi_object });
1577         case TWO_VALUE_LIMIT:
1578             return NapiUtil::MatchParameters(env, parameters, { napi_object, napi_function });
1579         default:
1580             return false;
1581     }
1582 }
1583 
MatchRejectCallParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)1584 bool NapiCallManager::MatchRejectCallParameters(
1585     napi_env env, const napi_value parameters[], const size_t parameterCount)
1586 {
1587     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1588     switch (parameterCount) {
1589         case ZERO_VALUE:
1590             return true;
1591         case ONLY_ONE_VALUE:
1592             return NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1593                    NapiUtil::MatchParameters(env, parameters, { napi_object }) ||
1594                    NapiUtil::MatchParameters(env, parameters, { napi_function }) ||
1595                    NapiUtil::MatchParameters(env, parameters, { napi_null }) ||
1596                    NapiUtil::MatchParameters(env, parameters, { napi_undefined });
1597         case TWO_VALUE_LIMIT:
1598             return NapiUtil::MatchParameters(env, parameters, { napi_object, napi_function }) ||
1599                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function }) ||
1600                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object }) ||
1601                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_null }) ||
1602                    NapiUtil::MatchParameters(env, parameters, { napi_number, napi_undefined }) ||
1603                    NapiUtil::MatchParameters(env, parameters, { napi_null, napi_object }) ||
1604                    NapiUtil::MatchParameters(env, parameters, { napi_undefined, napi_object }) ||
1605                    NapiUtil::MatchParameters(env, parameters, { napi_undefined, napi_undefined }) ||
1606                    NapiUtil::MatchParameters(env, parameters, { napi_null, napi_null });
1607         case THREE_VALUE_MAXIMUM_LIMIT:
1608             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object, napi_function });
1609         default:
1610             return false;
1611     }
1612 }
1613 
MatchRejectCallFirstIllegalParameters(napi_env env, const napi_value parameters[])1614 bool NapiCallManager::MatchRejectCallFirstIllegalParameters(napi_env env, const napi_value parameters[])
1615 {
1616     return NapiUtil::MatchParameters(env, parameters, { napi_null, napi_object }) ||
1617            NapiUtil::MatchParameters(env, parameters, { napi_undefined, napi_object });
1618 }
1619 
MatchRejectCallSecondIllegalParameters(napi_env env, const napi_value parameters[])1620 bool NapiCallManager::MatchRejectCallSecondIllegalParameters(napi_env env, const napi_value parameters[])
1621 {
1622     return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_null }) ||
1623            NapiUtil::MatchParameters(env, parameters, { napi_number, napi_undefined });
1624 }
1625 
MatchRejectCallTwoIllegalParameters(napi_env env, const napi_value parameters[])1626 bool NapiCallManager::MatchRejectCallTwoIllegalParameters(napi_env env, const napi_value parameters[])
1627 {
1628     return NapiUtil::MatchParameters(env, parameters, { napi_undefined, napi_undefined }) ||
1629            NapiUtil::MatchParameters(env, parameters, { napi_null, napi_null });
1630 }
1631 
MatchNumberAndObjectParameters( napi_env env, const napi_value parameters[], const size_t parameterCount)1632 bool NapiCallManager::MatchNumberAndObjectParameters(
1633     napi_env env, const napi_value parameters[], const size_t parameterCount)
1634 {
1635     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1636     switch (parameterCount) {
1637         case TWO_VALUE_LIMIT:
1638             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object });
1639         case THREE_VALUE_MAXIMUM_LIMIT:
1640             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object, napi_function });
1641         default:
1642             return false;
1643     }
1644 }
1645 
MatchCallRestrictionPasswordParameter( napi_env env, const napi_value parameters[], const size_t parameterCount)1646 bool NapiCallManager::MatchCallRestrictionPasswordParameter(
1647     napi_env env, const napi_value parameters[], const size_t parameterCount)
1648 {
1649     TELEPHONY_LOGI("Match parmameter count %{public}zu", parameterCount);
1650     switch (parameterCount) {
1651         case THREE_VALUE_MAXIMUM_LIMIT:
1652             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string, napi_string });
1653         case FOUR_VALUE_MAXIMUM_LIMIT:
1654             return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string, napi_string, napi_function });
1655         default:
1656             return false;
1657     }
1658 }
1659 
GetCallWaiting(napi_env env, napi_callback_info info)1660 napi_value NapiCallManager::GetCallWaiting(napi_env env, napi_callback_info info)
1661 {
1662     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1663     if (!MatchOneNumberParameter(env, argv, argc)) {
1664         TELEPHONY_LOGE("NapiCallManager::GetCallWaiting MatchOneNumberParameter failed.");
1665         NapiUtil::ThrowParameterError(env);
1666         return nullptr;
1667     }
1668     auto asyncContext = std::make_unique<SupplementAsyncContext>();
1669     if (asyncContext == nullptr) {
1670         TELEPHONY_LOGE("NapiCallManager::GetCallWaiting asyncContext is nullptr.");
1671         NapiUtil::ThrowParameterError(env);
1672         return nullptr;
1673     }
1674     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1675     if (argc == TWO_VALUE_LIMIT) {
1676         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1677     }
1678     asyncContext->env = env;
1679     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1680     return HandleAsyncWork(env, asyncContext.release(), "GetCallWaiting", NativeGetCallWaiting, NativeCallBack);
1681 }
1682 
SetCallWaiting(napi_env env, napi_callback_info info)1683 napi_value NapiCallManager::SetCallWaiting(napi_env env, napi_callback_info info)
1684 {
1685     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1686     if (!MatchNumberAndBoolParameters(env, argv, argc)) {
1687         TELEPHONY_LOGE("NapiCallManager::SetCallWaiting MatchNumberAndBoolParameters failed.");
1688         NapiUtil::ThrowParameterError(env);
1689         return nullptr;
1690     }
1691     auto asyncContext = std::make_unique<SupplementAsyncContext>();
1692     if (asyncContext == nullptr) {
1693         TELEPHONY_LOGE("NapiCallManager::SetCallWaiting asyncContext is nullptr.");
1694         NapiUtil::ThrowParameterError(env);
1695         return nullptr;
1696     }
1697     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1698     napi_get_value_bool(env, argv[ARRAY_INDEX_SECOND], &asyncContext->flag);
1699     if (argc == VALUE_MAXIMUM_LIMIT) {
1700         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1701     }
1702     asyncContext->env = env;
1703     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1704     return HandleAsyncWork(env, asyncContext.release(), "SetCallWaiting", NativeSetCallWaiting, NativeCallBack);
1705 }
1706 
GetCallRestriction(napi_env env, napi_callback_info info)1707 napi_value NapiCallManager::GetCallRestriction(napi_env env, napi_callback_info info)
1708 {
1709     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1710     if (!MatchTwoNumberParameters(env, argv, argc)) {
1711         TELEPHONY_LOGE("NapiCallManager::GetCallRestriction MatchTwoNumberParameters failed.");
1712         NapiUtil::ThrowParameterError(env);
1713         return nullptr;
1714     }
1715     auto restrictionAsyncContext = std::make_unique<SupplementAsyncContext>();
1716     if (restrictionAsyncContext == nullptr) {
1717         TELEPHONY_LOGE("NapiCallManager::GetCallRestriction asyncContext is nullptr.");
1718         NapiUtil::ThrowParameterError(env);
1719         return nullptr;
1720     }
1721     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &restrictionAsyncContext->slotId);
1722     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &restrictionAsyncContext->type);
1723     if (argc == VALUE_MAXIMUM_LIMIT) {
1724         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(restrictionAsyncContext->callbackRef));
1725     }
1726     restrictionAsyncContext->env = env;
1727     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(restrictionAsyncContext->thisVar));
1728     return HandleAsyncWork(
1729         env, restrictionAsyncContext.release(), "GetCallRestriction", NativeGetCallRestriction, NativeCallBack);
1730 }
1731 
SetCallRestriction(napi_env env, napi_callback_info info)1732 napi_value NapiCallManager::SetCallRestriction(napi_env env, napi_callback_info info)
1733 {
1734     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1735     if (!MatchNumberAndObjectParameters(env, argv, argc)) {
1736         TELEPHONY_LOGE("NapiCallManager::SetCallRestriction MatchNumberAndObjectParameters failed.");
1737         NapiUtil::ThrowParameterError(env);
1738         return nullptr;
1739     }
1740     auto asyncContext = std::make_unique<CallRestrictionAsyncContext>();
1741     if (asyncContext == nullptr) {
1742         TELEPHONY_LOGE("NapiCallManager::SetCallRestriction asyncContext is nullptr.");
1743         NapiUtil::ThrowParameterError(env);
1744         return nullptr;
1745     }
1746     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1747     asyncContext->errorCode = GetRestrictionInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1748     if (asyncContext->errorCode == ERROR_PARAMETER_TYPE_INVALID) {
1749         NapiUtil::ThrowParameterError(env);
1750         return nullptr;
1751     }
1752     if (argc == VALUE_MAXIMUM_LIMIT) {
1753         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1754     }
1755     asyncContext->env = env;
1756     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1757     return HandleAsyncWork(env, asyncContext.release(), "SetCallRestriction", NativeSetCallRestriction, NativeCallBack);
1758 }
1759 
SetCallRestrictionPassword(napi_env env, napi_callback_info info)1760 napi_value NapiCallManager::SetCallRestrictionPassword(napi_env env, napi_callback_info info)
1761 {
1762     GET_PARAMS(env, info, FOUR_VALUE_MAXIMUM_LIMIT);
1763     if (!MatchCallRestrictionPasswordParameter(env, argv, argc)) {
1764         TELEPHONY_LOGE("MatchCallRestrictionPasswordParameter failed.");
1765         NapiUtil::ThrowParameterError(env);
1766         return nullptr;
1767     }
1768     auto asyncContext = std::make_unique<CallBarringPasswordAsyncContext>();
1769     if (asyncContext == nullptr) {
1770         TELEPHONY_LOGE("CallBarringPasswordAsyncContext is nullptr.");
1771         NapiUtil::ThrowParameterError(env);
1772         return nullptr;
1773     }
1774     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1775     size_t strLen = 0;
1776     napi_get_value_string_utf8(
1777         env, argv[ARRAY_INDEX_SECOND], asyncContext->oldPassword, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
1778     napi_get_value_string_utf8(
1779         env, argv[ARRAY_INDEX_THIRD], asyncContext->newPassword, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
1780     if (argc == FOUR_VALUE_MAXIMUM_LIMIT) {
1781         napi_create_reference(env, argv[ARRAY_INDEX_FOURTH], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1782     }
1783     asyncContext->env = env;
1784     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1785     return HandleAsyncWork(
1786         env, asyncContext.release(), "SetCallRestrictionPassword", NativeSetCallRestrictionPassword, NativeCallBack);
1787 }
1788 
GetCallTransferInfo(napi_env env, napi_callback_info info)1789 napi_value NapiCallManager::GetCallTransferInfo(napi_env env, napi_callback_info info)
1790 {
1791     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1792     if (!MatchTwoNumberParameters(env, argv, argc)) {
1793         TELEPHONY_LOGE("NapiCallManager::GetCallTransferInfo MatchTwoNumberParameters failed.");
1794         NapiUtil::ThrowParameterError(env);
1795         return nullptr;
1796     }
1797     auto asyncContext = std::make_unique<SupplementAsyncContext>();
1798     if (asyncContext == nullptr) {
1799         TELEPHONY_LOGE("NapiCallManager::GetCallTransferInfo asyncContext is nullptr.");
1800         NapiUtil::ThrowParameterError(env);
1801         return nullptr;
1802     }
1803     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1804     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->type);
1805     if (argc == VALUE_MAXIMUM_LIMIT) {
1806         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1807     }
1808     asyncContext->env = env;
1809     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1810     return HandleAsyncWork(env, asyncContext.release(), "GetCallTransferInfo", NativeGetTransferNumber, NativeCallBack);
1811 }
1812 
SetCallTransferInfo(napi_env env, napi_callback_info info)1813 napi_value NapiCallManager::SetCallTransferInfo(napi_env env, napi_callback_info info)
1814 {
1815     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1816     if (!MatchNumberAndObjectParameters(env, argv, argc)) {
1817         TELEPHONY_LOGE("NapiCallManager::SetCallTransferInfo MatchNumberAndObjectParameters failed.");
1818         NapiUtil::ThrowParameterError(env);
1819         return nullptr;
1820     }
1821     auto asyncContext = std::make_unique<CallTransferAsyncContext>();
1822     if (asyncContext == nullptr) {
1823         TELEPHONY_LOGE("NapiCallManager::SetCallTransferInfo asyncContext is nullptr.");
1824         NapiUtil::ThrowParameterError(env);
1825         return nullptr;
1826     }
1827     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1828     asyncContext->errorCode = GetTransferInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1829     if (asyncContext->errorCode == ERROR_PARAMETER_TYPE_INVALID) {
1830         NapiUtil::ThrowParameterError(env);
1831         return nullptr;
1832     }
1833     if (argc == VALUE_MAXIMUM_LIMIT) {
1834         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1835     }
1836     asyncContext->env = env;
1837     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1838     return HandleAsyncWork(env, asyncContext.release(), "SetCallTransferInfo", NativeSetTransferNumber, NativeCallBack);
1839 }
1840 
IsValidSlotId(int32_t slotId)1841 static inline bool IsValidSlotId(int32_t slotId)
1842 {
1843     return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
1844 }
1845 
CanSetCallTransferTime(napi_env env, napi_callback_info info)1846 napi_value NapiCallManager::CanSetCallTransferTime(napi_env env, napi_callback_info info)
1847 {
1848     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1849     if (!MatchOneNumberParameter(env, argv, argc)) {
1850         TELEPHONY_LOGE("MatchOneNumberParameter failed.");
1851         NapiUtil::ThrowParameterError(env);
1852         return nullptr;
1853     }
1854     auto asyncContext = std::make_unique<BoolResultAsyncContext>();
1855     asyncContext->eventId = CALL_MANAGER_CAN_SET_CALL_TRANSFER_TIME;
1856     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1857     if (argc == TWO_VALUE_LIMIT) {
1858         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1859     }
1860     return HandleAsyncWork(env, asyncContext.release(), "CanSetCallTransferTime", NativeCanSetCallTransferTime,
1861         NativeBoolCallBackWithErrorCode);
1862 }
1863 
EnableImsSwitch(napi_env env, napi_callback_info info)1864 napi_value NapiCallManager::EnableImsSwitch(napi_env env, napi_callback_info info)
1865 {
1866     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1867     if (!MatchOneNumberParameter(env, argv, argc)) {
1868         TELEPHONY_LOGE("NapiCallManager::EnableImsSwitch MatchOneNumberParameter failed.");
1869         NapiUtil::ThrowParameterError(env);
1870         return nullptr;
1871     }
1872     auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1873     if (asyncContext == nullptr) {
1874         TELEPHONY_LOGE("NapiCallManager::EnableImsSwitch asyncContext is nullptr.");
1875         NapiUtil::ThrowParameterError(env);
1876         return nullptr;
1877     }
1878     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1879     if (argc == TWO_VALUE_LIMIT) {
1880         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1881     }
1882 
1883     return HandleAsyncWork(
1884         env, asyncContext.release(), "EnableImsSwitch", NativeEnableImsSwitch, NativeVoidCallBackWithErrorCode);
1885 }
1886 
DisableImsSwitch(napi_env env, napi_callback_info info)1887 napi_value NapiCallManager::DisableImsSwitch(napi_env env, napi_callback_info info)
1888 {
1889     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1890     if (!MatchOneNumberParameter(env, argv, argc)) {
1891         TELEPHONY_LOGE("NapiCallManager::DisableImsSwitch MatchOneNumberParameter failed.");
1892         NapiUtil::ThrowParameterError(env);
1893         return nullptr;
1894     }
1895     auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1896     if (asyncContext == nullptr) {
1897         TELEPHONY_LOGE("NapiCallManager::DisableImsSwitch asyncContext is nullptr.");
1898         NapiUtil::ThrowParameterError(env);
1899         return nullptr;
1900     }
1901     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1902     if (argc == TWO_VALUE_LIMIT) {
1903         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1904     }
1905 
1906     return HandleAsyncWork(
1907         env, asyncContext.release(), "DisableImsSwitch", NativeDisableImsSwitch, NativeVoidCallBackWithErrorCode);
1908 }
1909 
IsImsSwitchEnabled(napi_env env, napi_callback_info info)1910 napi_value NapiCallManager::IsImsSwitchEnabled(napi_env env, napi_callback_info info)
1911 {
1912     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1913     if (!MatchOneNumberParameter(env, argv, argc)) {
1914         TELEPHONY_LOGE("NapiCallManager::IsImsSwitchEnabled MatchOneNumberParameter failed.");
1915         NapiUtil::ThrowParameterError(env);
1916         return nullptr;
1917     }
1918     auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1919     if (asyncContext == nullptr) {
1920         TELEPHONY_LOGE("NapiCallManager::IsImsSwitchEnabled asyncContext is nullptr.");
1921         NapiUtil::ThrowParameterError(env);
1922         return nullptr;
1923     }
1924     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1925     if (argc == TWO_VALUE_LIMIT) {
1926         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1927     }
1928     return HandleAsyncWork(
1929         env, asyncContext.release(), "IsImsSwitchEnabled", NativeIsImsSwitchEnabled, NativeIsImsSwitchEnabledCallBack);
1930 }
1931 
IsImsSwitchEnabledSync(napi_env env, napi_callback_info info)1932 napi_value NapiCallManager::IsImsSwitchEnabledSync(napi_env env, napi_callback_info info)
1933 {
1934     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1935     if (!MatchOneNumberParameter(env, argv, argc)) {
1936         TELEPHONY_LOGE("NapiCallManager::IsImsSwitchEnabledSync MatchOneNumberParameter failed.");
1937         NapiUtil::ThrowParameterError(env);
1938         return nullptr;
1939     }
1940     size_t parameterCount = 0;
1941     napi_value parameters[] = { nullptr };
1942     napi_get_cb_info(env, info, &parameterCount, parameters, nullptr, nullptr);
1943     bool enabled = false;
1944     int32_t slotId;
1945     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &slotId);
1946     DelayedSingleton<CallManagerClient>::GetInstance()->IsImsSwitchEnabled(slotId, enabled);
1947     napi_value value = nullptr;
1948     NAPI_CALL(env, napi_get_boolean(env, enabled, &value));
1949     return value;
1950 }
1951 
SetVoNRState(napi_env env, napi_callback_info info)1952 napi_value NapiCallManager::SetVoNRState(napi_env env, napi_callback_info info)
1953 {
1954     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1955     if (!MatchTwoNumberParameters(env, argv, argc)) {
1956         TELEPHONY_LOGE("NapiCallManager::SetVoNRState MatchTwoNumberParameters failed.");
1957         NapiUtil::ThrowParameterError(env);
1958         return nullptr;
1959     }
1960     auto asyncContext = std::make_unique<VoNRSwitchAsyncContext>();
1961     if (asyncContext == nullptr) {
1962         TELEPHONY_LOGE("NapiCallManager::SetVoNRState asyncContext is nullptr.");
1963         NapiUtil::ThrowParameterError(env);
1964         return nullptr;
1965     }
1966     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1967     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->state);
1968     if (argc == VALUE_MAXIMUM_LIMIT) {
1969         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1970     }
1971     return HandleAsyncWork(
1972         env, asyncContext.release(), "SetVoNRState", NativeSetVoNRState, NativeVoidCallBackWithErrorCode);
1973 }
1974 
GetVoNRState(napi_env env, napi_callback_info info)1975 napi_value NapiCallManager::GetVoNRState(napi_env env, napi_callback_info info)
1976 {
1977     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1978     if (!MatchOneNumberParameter(env, argv, argc)) {
1979         TELEPHONY_LOGE("NapiCallManager::GetVoNRState MatchOneNumberParameter failed.");
1980         NapiUtil::ThrowParameterError(env);
1981         return nullptr;
1982     }
1983     auto asyncContext = std::make_unique<VoNRSwitchAsyncContext>();
1984     if (asyncContext == nullptr) {
1985         TELEPHONY_LOGE("NapiCallManager::GetVoNRState asyncContext is nullptr.");
1986         NapiUtil::ThrowParameterError(env);
1987         return nullptr;
1988     }
1989     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1990     if (argc == TWO_VALUE_LIMIT) {
1991         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1992     }
1993     return HandleAsyncWork(
1994         env, asyncContext.release(), "GetVoNRState", NativeGetVoNRState, NativeGetVoNRStateCallBack);
1995 }
1996 
StartDTMF(napi_env env, napi_callback_info info)1997 napi_value NapiCallManager::StartDTMF(napi_env env, napi_callback_info info)
1998 {
1999     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2000     if (!MatchNumberAndStringParameters(env, argv, argc)) {
2001         TELEPHONY_LOGE("NapiCallManager::StartDTMF MatchNumberAndStringParameters failed.");
2002         NapiUtil::ThrowParameterError(env);
2003         return nullptr;
2004     }
2005     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2006     if (asyncContext == nullptr) {
2007         TELEPHONY_LOGE("NapiCallManager::StartDTMF asyncContext is nullptr.");
2008         NapiUtil::ThrowParameterError(env);
2009         return nullptr;
2010     }
2011     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2012     napi_get_value_string_utf8(
2013         env, argv[ARRAY_INDEX_SECOND], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
2014     if (argc == VALUE_MAXIMUM_LIMIT) {
2015         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2016     }
2017     return HandleAsyncWork(env, asyncContext.release(), "StartDTMF", NativeStartDTMF, NativeVoidCallBackWithErrorCode);
2018 }
2019 
StopDTMF(napi_env env, napi_callback_info info)2020 napi_value NapiCallManager::StopDTMF(napi_env env, napi_callback_info info)
2021 {
2022     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2023     if (!MatchOneNumberParameter(env, argv, argc)) {
2024         TELEPHONY_LOGE("NapiCallManager::StopDTMF MatchOneNumberParameter failed.");
2025         NapiUtil::ThrowParameterError(env);
2026         return nullptr;
2027     }
2028     auto asyncContext = std::make_unique<AsyncContext>();
2029     if (asyncContext == nullptr) {
2030         TELEPHONY_LOGE("NapiCallManager::StopDTMF asyncContext is nullptr.");
2031         NapiUtil::ThrowParameterError(env);
2032         return nullptr;
2033     }
2034     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2035     if (argc == TWO_VALUE_LIMIT) {
2036         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2037     }
2038     return HandleAsyncWork(env, asyncContext.release(), "StopDTMF", NativeStopDTMF, NativeVoidCallBackWithErrorCode);
2039 }
2040 
PostDialProceed(napi_env env, napi_callback_info info)2041 napi_value NapiCallManager::PostDialProceed(napi_env env, napi_callback_info info)
2042 {
2043     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2044     if (!MatchNumberAndBoolParameters(env, argv, argc)) {
2045         TELEPHONY_LOGE("NapiCallManager::PostDialProceed MatchNumberAndBoolParameters failed.");
2046         NapiUtil::ThrowParameterError(env);
2047         return nullptr;
2048     }
2049     auto asyncContext = std::make_unique<PostDialAsyncContext>();
2050     if (asyncContext == nullptr) {
2051         TELEPHONY_LOGE("NapiCallManager::PostDialProceed asyncContext is nullptr.");
2052         NapiUtil::ThrowParameterError(env);
2053         return nullptr;
2054     }
2055     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2056     napi_get_value_bool(env, argv[ARRAY_INDEX_SECOND], &asyncContext->proceed);
2057     if (argc == VALUE_MAXIMUM_LIMIT) {
2058         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2059     }
2060     return HandleAsyncWork(env, asyncContext.release(), "PostDialProceed", NativePostDialProceed,
2061         NativeVoidCallBackWithErrorCode);
2062 }
2063 
GetCallState(napi_env env, napi_callback_info info)2064 napi_value NapiCallManager::GetCallState(napi_env env, napi_callback_info info)
2065 {
2066     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
2067     NAPI_ASSERT(env, argc < TWO_VALUE_LIMIT, "parameter error!");
2068     auto asyncContext = std::make_unique<AsyncContext>();
2069     if (asyncContext == nullptr) {
2070         std::string errorCode = std::to_string(napi_generic_failure);
2071         std::string errorMessage = "GetCallState error at asyncContext is nullptr";
2072         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2073         return nullptr;
2074     }
2075     if (argc == ONLY_ONE_VALUE) {
2076         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2077     }
2078     return HandleAsyncWork(env, asyncContext.release(), "GetCallState", NativeGetCallState, NativePropertyCallBack);
2079 }
2080 
GetCallStateSync(napi_env env, napi_callback_info info)2081 napi_value NapiCallManager::GetCallStateSync(napi_env env, napi_callback_info info)
2082 {
2083     size_t parameterCount = 0;
2084     napi_value parameters[] = { nullptr };
2085     napi_get_cb_info(env, info, &parameterCount, parameters, nullptr, nullptr);
2086     int32_t callState = static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN);
2087     if (parameterCount == 0) {
2088         callState = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallState();
2089     }
2090     napi_value value = nullptr;
2091     NAPI_CALL(env, napi_create_int32(env, callState, &value));
2092     return value;
2093 }
2094 
IsRinging(napi_env env, napi_callback_info info)2095 napi_value NapiCallManager::IsRinging(napi_env env, napi_callback_info info)
2096 {
2097     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2098     if (!MatchEmptyParameter(env, argv, argc)) {
2099         TELEPHONY_LOGE("NapiCallManager::IsRinging MatchEmptyParameter failed.");
2100         NapiUtil::ThrowParameterError(env);
2101         return nullptr;
2102     }
2103     auto asyncContext = std::make_unique<BoolResultAsyncContext>();
2104     if (asyncContext == nullptr) {
2105         TELEPHONY_LOGE("NapiCallManager::IsRinging asyncContext is nullptr.");
2106         NapiUtil::ThrowParameterError(env);
2107         return nullptr;
2108     }
2109     if (argc == ONLY_ONE_VALUE) {
2110         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2111     }
2112     return HandleAsyncWork(env, asyncContext.release(), "IsRinging", NativeIsRinging, NativeBoolCallBackWithErrorCode);
2113 }
2114 
HasCall(napi_env env, napi_callback_info info)2115 napi_value NapiCallManager::HasCall(napi_env env, napi_callback_info info)
2116 {
2117     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
2118     NAPI_ASSERT(env, argc < TWO_VALUE_LIMIT, "parameter error!");
2119     auto asyncContext = std::make_unique<AsyncContext>();
2120     if (asyncContext == nullptr) {
2121         std::string errorCode = std::to_string(napi_generic_failure);
2122         std::string errorMessage = "HasCall error at asyncContext is nullptr";
2123         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2124         return nullptr;
2125     }
2126     if (argc == ONLY_ONE_VALUE) {
2127         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2128     }
2129     return HandleAsyncWork(env, asyncContext.release(), "HasCall", NativeHasCall, NativeBoolCallBack);
2130 }
2131 
HasCallSync(napi_env env, napi_callback_info info)2132 napi_value NapiCallManager::HasCallSync(napi_env env, napi_callback_info info)
2133 {
2134     size_t parameterCount = 0;
2135     napi_value parameters[] = { nullptr };
2136     napi_get_cb_info(env, info, &parameterCount, parameters, nullptr, nullptr);
2137     bool hasCall = false;
2138     if (parameterCount == 0) {
2139         hasCall = DelayedSingleton<CallManagerClient>::GetInstance()->HasCall();
2140     }
2141     napi_value value = nullptr;
2142     NAPI_CALL(env, napi_get_boolean(env, hasCall, &value));
2143     return value;
2144 }
2145 
IsNewCallAllowed(napi_env env, napi_callback_info info)2146 napi_value NapiCallManager::IsNewCallAllowed(napi_env env, napi_callback_info info)
2147 {
2148     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2149     if (!MatchEmptyParameter(env, argv, argc)) {
2150         TELEPHONY_LOGE("NapiCallManager::IsNewCallAllowed MatchEmptyParameter failed.");
2151         NapiUtil::ThrowParameterError(env);
2152         return nullptr;
2153     }
2154     auto asyncContext = std::make_unique<BoolResultAsyncContext>();
2155     if (asyncContext == nullptr) {
2156         TELEPHONY_LOGE("NapiCallManager::IsNewCallAllowed asyncContext is nullptr.");
2157         NapiUtil::ThrowParameterError(env);
2158         return nullptr;
2159     }
2160     if (argc == ONLY_ONE_VALUE) {
2161         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2162     }
2163     return HandleAsyncWork(
2164         env, asyncContext.release(), "IsNewCallAllowed", NativeIsNewCallAllowed, NativeBoolCallBackWithErrorCode);
2165 }
2166 
IsInEmergencyCall(napi_env env, napi_callback_info info)2167 napi_value NapiCallManager::IsInEmergencyCall(napi_env env, napi_callback_info info)
2168 {
2169     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2170     if (!MatchEmptyParameter(env, argv, argc)) {
2171         TELEPHONY_LOGE("NapiCallManager::IsInEmergencyCall MatchEmptyParameter failed.");
2172         NapiUtil::ThrowParameterError(env);
2173         return nullptr;
2174     }
2175     auto asyncContext = std::make_unique<BoolResultAsyncContext>();
2176     if (asyncContext == nullptr) {
2177         TELEPHONY_LOGE("NapiCallManager::IsInEmergencyCall asyncContext is nullptr.");
2178         NapiUtil::ThrowParameterError(env);
2179         return nullptr;
2180     }
2181     if (argc == ONLY_ONE_VALUE) {
2182         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2183     }
2184     return HandleAsyncWork(
2185         env, asyncContext.release(), "IsInEmergencyCall", NativeIsInEmergencyCall, NativeBoolCallBackWithErrorCode);
2186 }
2187 
IsEmergencyPhoneNumber(napi_env env, napi_callback_info info)2188 napi_value NapiCallManager::IsEmergencyPhoneNumber(napi_env env, napi_callback_info info)
2189 {
2190     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2191     if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
2192         TELEPHONY_LOGE("MatchStringAndVariableObjectParameters failed.");
2193         NapiUtil::ThrowParameterError(env);
2194         return nullptr;
2195     }
2196     auto emergencyAsyncContext = std::make_unique<UtilsAsyncContext>();
2197     if (emergencyAsyncContext == nullptr) {
2198         TELEPHONY_LOGE("emergencyAsyncContext is nullptr.");
2199         NapiUtil::ThrowParameterError(env);
2200         return nullptr;
2201     }
2202     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], emergencyAsyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT,
2203         &(emergencyAsyncContext->numberLen));
2204     emergencyAsyncContext->slotId = 0;
2205     if (argc == TWO_VALUE_LIMIT) {
2206         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
2207             napi_create_reference(
2208                 env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(emergencyAsyncContext->callbackRef));
2209         } else {
2210             emergencyAsyncContext->slotId =
2211                 NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_SECOND], "slotId");
2212         }
2213     }
2214     if (argc == VALUE_MAXIMUM_LIMIT) {
2215         emergencyAsyncContext->slotId = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_SECOND], "slotId");
2216         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(emergencyAsyncContext->callbackRef));
2217     }
2218     return HandleAsyncWork(env, emergencyAsyncContext.release(), "IsEmergencyPhoneNumber", NativeIsEmergencyPhoneNumber,
2219         NativeIsEmergencyPhoneNumberCallBack);
2220 }
2221 
FormatPhoneNumber(napi_env env, napi_callback_info info)2222 napi_value NapiCallManager::FormatPhoneNumber(napi_env env, napi_callback_info info)
2223 {
2224     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2225     if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
2226         TELEPHONY_LOGE("MatchStringAndVariableObjectParameters failed.");
2227         NapiUtil::ThrowParameterError(env);
2228         return nullptr;
2229     }
2230     auto asyncContext = std::make_unique<UtilsAsyncContext>();
2231     if (asyncContext == nullptr) {
2232         TELEPHONY_LOGE("asyncContext is nullptr.");
2233         NapiUtil::ThrowParameterError(env);
2234         return nullptr;
2235     }
2236     asyncContext->code = "cn";
2237     napi_get_value_string_utf8(
2238         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
2239     if (argc == TWO_VALUE_LIMIT) {
2240         if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
2241             napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2242         } else {
2243             asyncContext->code = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "countryCode");
2244         }
2245     }
2246     if (argc == VALUE_MAXIMUM_LIMIT) {
2247         asyncContext->code = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "countryCode");
2248         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2249     }
2250     if ((argc >= TWO_VALUE_LIMIT) && (asyncContext->code == "")) {
2251         TELEPHONY_LOGI("country code is undefined, using default country code: 'cn'.");
2252         asyncContext->code = "cn";
2253     }
2254     return HandleAsyncWork(
2255         env, asyncContext.release(), "FormatPhoneNumber", NativeFormatPhoneNumber, NativeFormatNumberCallBack);
2256 }
2257 
FormatPhoneNumberToE164(napi_env env, napi_callback_info info)2258 napi_value NapiCallManager::FormatPhoneNumberToE164(napi_env env, napi_callback_info info)
2259 {
2260     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2261     if (!MatchTwoStringParameter(env, argv, argc)) {
2262         TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumberToE164 MatchTwoStringParameter failed.");
2263         NapiUtil::ThrowParameterError(env);
2264         return nullptr;
2265     }
2266     auto asyncContext = std::make_unique<UtilsAsyncContext>();
2267     if (asyncContext == nullptr) {
2268         TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumberToE164 asyncContext is nullptr.");
2269         NapiUtil::ThrowParameterError(env);
2270         return nullptr;
2271     }
2272     napi_get_value_string_utf8(
2273         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
2274     char tmpStr[kMaxNumberLen + 1] = {0};
2275     size_t strLen = 0;
2276     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
2277     std::string tmpCode(tmpStr, strLen);
2278     asyncContext->code = tmpCode;
2279     if (argc == VALUE_MAXIMUM_LIMIT) {
2280         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2281     }
2282     return HandleAsyncWork(env, asyncContext.release(), "FormatPhoneNumberToE164", NativeFormatPhoneNumberToE164,
2283         NativeFormatNumberCallBack);
2284 }
2285 
ObserverOn(napi_env env, napi_callback_info info)2286 napi_value NapiCallManager::ObserverOn(napi_env env, napi_callback_info info)
2287 {
2288     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2289     if ((argc != TWO_VALUE_LIMIT) ||
2290         (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string)) ||
2291         (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function))) {
2292         NapiUtil::ThrowParameterError(env);
2293         return nullptr;
2294     }
2295     if (registerStatus_ != TELEPHONY_SUCCESS) {
2296         TELEPHONY_LOGE("RegisterCallBack failed!");
2297         if (registerStatus_ == TELEPHONY_ERR_PERMISSION_ERR) {
2298             NapiUtil::ThrowError(env, JS_ERROR_TELEPHONY_PERMISSION_DENIED, OBSERVER_ON_JS_PERMISSION_ERROR_STRING);
2299             return nullptr;
2300         }
2301         JsError error = NapiUtil::ConverErrorMessageForJs(registerStatus_);
2302         NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
2303         return nullptr;
2304     }
2305     char listenerType[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
2306     size_t strLength = 0;
2307     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], listenerType, PHONE_NUMBER_MAXIMUM_LIMIT, &strLength);
2308     std::string tmpStr = listenerType;
2309     TELEPHONY_LOGI("listenerType == %{public}s", tmpStr.c_str());
2310     EventCallback stateCallback;
2311     (void)memset_s(&stateCallback, sizeof(EventCallback), 0, sizeof(EventCallback));
2312     stateCallback.env = env;
2313     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &stateCallback.thisVar);
2314     napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &stateCallback.callbackRef);
2315     RegisterNapiCallFuncCallback(tmpStr, stateCallback);
2316     napi_value result = nullptr;
2317     return result;
2318 }
2319 
RegisterNapiCallFuncCallback(std::string tmpStr, EventCallback stateCallback)2320 void NapiCallManager::RegisterNapiCallFuncCallback(std::string tmpStr, EventCallback stateCallback)
2321 {
2322     if (tmpStr == "callDetailsChange") {
2323         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallStateCallback(stateCallback);
2324         DelayedSingleton<CallManagerClient>::GetInstance()->ObserverOnCallDetailsChange();
2325     } else if (tmpStr == "callEventChange") {
2326         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallEventCallback(stateCallback);
2327     } else if (tmpStr == "callOttRequest") {
2328         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallOttRequestCallback(stateCallback);
2329     } else if (tmpStr == "callDisconnectedCause") {
2330         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterDisconnectedCauseCallback(stateCallback);
2331     } else if (tmpStr == "mmiCodeResult") {
2332         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterMmiCodeCallback(stateCallback);
2333     } else if (tmpStr == "audioDeviceChange") {
2334         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterAudioDeviceCallback(stateCallback);
2335         int32_t result = DelayedSingleton<CallManagerClient>::GetInstance()->ReportAudioDeviceInfo();
2336         TELEPHONY_LOGI("result == %{public}d", result);
2337     } else if (tmpStr == "postDialDelay") {
2338         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterPostDialDelay(stateCallback);
2339     } else if (tmpStr == "imsCallModeChange") {
2340         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterImsCallModeChangeCallback(stateCallback);
2341     } else if (tmpStr == "callSessionEvent") {
2342         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallSessionEventChangeCallback(
2343             stateCallback);
2344     } else if (tmpStr == "peerDimensionsChange") {
2345         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterPeerDimensionsChangeCallback(stateCallback);
2346     } else if (tmpStr == "cameraCapabilitiesChange") {
2347         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCameraCapabilitiesChangeCallback(
2348             stateCallback);
2349     }
2350 }
2351 
ObserverOff(napi_env env, napi_callback_info info)2352 napi_value NapiCallManager::ObserverOff(napi_env env, napi_callback_info info)
2353 {
2354     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
2355     if (!MatchObserverOffParameter(env, argv, argc)) {
2356         TELEPHONY_LOGE("MatchObserverOffParameter failed.");
2357         NapiUtil::ThrowParameterError(env);
2358         return nullptr;
2359     }
2360     auto asyncContext = std::make_unique<AsyncContext>();
2361     if (asyncContext == nullptr) {
2362         TELEPHONY_LOGE("asyncContext is nullptr.");
2363         NapiUtil::ThrowParameterError(env);
2364         return nullptr;
2365     }
2366     if (registerStatus_ != TELEPHONY_SUCCESS) {
2367         TELEPHONY_LOGE("RegisterCallBack failed!");
2368         if (registerStatus_ == TELEPHONY_ERR_PERMISSION_ERR) {
2369             NapiUtil::ThrowError(env, JS_ERROR_TELEPHONY_PERMISSION_DENIED, OBSERVER_OFF_JS_PERMISSION_ERROR_STRING);
2370             return nullptr;
2371         }
2372         JsError error = NapiUtil::ConverErrorMessageForJs(registerStatus_);
2373         NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
2374         return nullptr;
2375     }
2376     char listenerType[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
2377     size_t strLength = 0;
2378     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], listenerType, PHONE_NUMBER_MAXIMUM_LIMIT, &strLength);
2379     std::string tmpStr = listenerType;
2380     TELEPHONY_LOGI("listenerType == %{public}s", tmpStr.c_str());
2381     UnRegisterCallbackWithListenerType(tmpStr);
2382     if (argc == TWO_VALUE_LIMIT) {
2383         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2384     }
2385     return HandleAsyncWork(
2386         env, asyncContext.release(), "Off", [](napi_env env, void *data) {}, NativeOffCallBack);
2387 }
2388 
UnRegisterCallbackWithListenerType(std::string tmpStr)2389 void NapiCallManager::UnRegisterCallbackWithListenerType(std::string tmpStr)
2390 {
2391     if (tmpStr == "callDetailsChange") {
2392         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallStateCallback();
2393     } else if (tmpStr == "callEventChange") {
2394         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallEventCallback();
2395     } else if (tmpStr == "callOttRequest") {
2396         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallOttRequestCallback();
2397     } else if (tmpStr == "callDisconnectedCause") {
2398         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterDisconnectedCauseCallback();
2399     } else if (tmpStr == "mmiCodeResult") {
2400         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterMmiCodeCallback();
2401     } else if (tmpStr == "audioDeviceChange") {
2402         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterAudioDeviceCallback();
2403     } else if (tmpStr == "postDialDelay") {
2404         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterPostDialDelayCallback();
2405     } else if (tmpStr == "imsCallModeChange") {
2406         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterImsCallModeChangeCallback();
2407     } else if (tmpStr == "callSessionEvent") {
2408         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallSessionEventChangeCallback();
2409     } else if (tmpStr == "peerDimensionsChange") {
2410         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterPeerDimensionsChangeCallback();
2411     } else if (tmpStr == "cameraCapabilitiesChange") {
2412         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCameraCapabilitiesChangeCallback();
2413     }
2414 }
2415 
SetMuted(napi_env env, napi_callback_info info)2416 napi_value NapiCallManager::SetMuted(napi_env env, napi_callback_info info)
2417 {
2418     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2419     if (!MatchEmptyParameter(env, argv, argc)) {
2420         TELEPHONY_LOGE("NapiCallManager::SetMuted MatchEmptyParameter failed.");
2421         NapiUtil::ThrowParameterError(env);
2422         return nullptr;
2423     }
2424     auto asyncContext = std::make_unique<AudioAsyncContext>();
2425     if (asyncContext == nullptr) {
2426         TELEPHONY_LOGE("NapiCallManager::SetMuted asyncContext is nullptr.");
2427         NapiUtil::ThrowParameterError(env);
2428         return nullptr;
2429     }
2430     if (argc == ONLY_ONE_VALUE) {
2431         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2432     }
2433     return HandleAsyncWork(env, asyncContext.release(), "SetMuted", NativeSetMuted, NativeVoidCallBackWithErrorCode);
2434 }
2435 
CancelMuted(napi_env env, napi_callback_info info)2436 napi_value NapiCallManager::CancelMuted(napi_env env, napi_callback_info info)
2437 {
2438     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2439     if (!MatchEmptyParameter(env, argv, argc)) {
2440         TELEPHONY_LOGE("NapiCallManager::CancelMuted MatchEmptyParameter failed.");
2441         NapiUtil::ThrowParameterError(env);
2442         return nullptr;
2443     }
2444     auto asyncContext = std::make_unique<AudioAsyncContext>();
2445     if (asyncContext == nullptr) {
2446         TELEPHONY_LOGE("NapiCallManager::CancelMuted asyncContext is nullptr.");
2447         NapiUtil::ThrowParameterError(env);
2448         return nullptr;
2449     }
2450     if (argc == ONLY_ONE_VALUE) {
2451         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2452     }
2453     return HandleAsyncWork(
2454         env, asyncContext.release(), "CancelMuted", NativeCancelMuted, NativeVoidCallBackWithErrorCode);
2455 }
2456 
MuteRinger(napi_env env, napi_callback_info info)2457 napi_value NapiCallManager::MuteRinger(napi_env env, napi_callback_info info)
2458 {
2459     GET_PARAMS(env, info, ONLY_ONE_VALUE);
2460     if (!MatchEmptyParameter(env, argv, argc)) {
2461         TELEPHONY_LOGE("NapiCallManager::MuteRinger MatchEmptyParameter failed.");
2462         NapiUtil::ThrowParameterError(env);
2463         return nullptr;
2464     }
2465     auto asyncContext = std::make_unique<AudioAsyncContext>();
2466     if (asyncContext == nullptr) {
2467         TELEPHONY_LOGE("NapiCallManager::MuteRinger asyncContext is nullptr.");
2468         NapiUtil::ThrowParameterError(env);
2469         return nullptr;
2470     }
2471     if (argc == ONLY_ONE_VALUE) {
2472         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2473     }
2474     return HandleAsyncWork(
2475         env, asyncContext.release(), "MuteRinger", NativeMuteRinger, NativeVoidCallBackWithErrorCode);
2476 }
2477 
SetAudioDevice(napi_env env, napi_callback_info info)2478 napi_value NapiCallManager::SetAudioDevice(napi_env env, napi_callback_info info)
2479 {
2480     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2481     if (!MatchAudioDeviceParameters(env, argv, argc)) {
2482         TELEPHONY_LOGE("NapiCallManager::SetAudioDevice MatchAudioDeviceParameters failed.");
2483         NapiUtil::ThrowParameterError(env);
2484         return nullptr;
2485     }
2486     auto asyncContext = std::make_unique<AudioAsyncContext>();
2487     if (asyncContext == nullptr) {
2488         TELEPHONY_LOGE("NapiCallManager::SetAudioDevice asyncContext is nullptr.");
2489         NapiUtil::ThrowParameterError(env);
2490         return nullptr;
2491     }
2492     asyncContext->deviceType = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "deviceType");
2493     asyncContext->address = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_FIRST], "address");
2494     if (argc == TWO_VALUE_LIMIT) {
2495         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2496     }
2497 
2498     return HandleAsyncWork(
2499         env, asyncContext.release(), "SetAudioDevice", NativeSetAudioDevice, NativeVoidCallBackWithErrorCode);
2500 }
2501 
ControlCamera(napi_env env, napi_callback_info info)2502 napi_value NapiCallManager::ControlCamera(napi_env env, napi_callback_info info)
2503 {
2504     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2505     if (!MatchNumberAndStringParameters(env, argv, argc)) {
2506         TELEPHONY_LOGE("MatchNumberAndStringParameters failed.");
2507         NapiUtil::ThrowParameterError(env);
2508         return nullptr;
2509     }
2510     auto asyncContext = std::make_unique<VideoAsyncContext>();
2511     if (asyncContext == nullptr) {
2512         std::string errorCode = std::to_string(napi_generic_failure);
2513         std::string errorMessage = "ControlCamera error at baseContext is nullptr";
2514         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2515         return nullptr;
2516     }
2517     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2518     char tmpStr[kMaxNumberLen + 1] = {0};
2519     size_t strLen = 0;
2520     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
2521     std::string tmpCode(tmpStr, strLen);
2522     asyncContext->cameraId = tmpCode;
2523     if (argc == THREE_VALUE_MAXIMUM_LIMIT) {
2524         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2525     }
2526     return HandleAsyncWork(
2527         env, asyncContext.release(), "ControlCamera", NativeControlCamera, NativeVoidCallBackWithErrorCode);
2528 }
2529 
SetPreviewWindow(napi_env env, napi_callback_info info)2530 napi_value NapiCallManager::SetPreviewWindow(napi_env env, napi_callback_info info)
2531 {
2532     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2533     if (!MatchNumberAndStringParameters(env, argv, argc)) {
2534         TELEPHONY_LOGE("MatchNumberAndStringParameters failed.");
2535         NapiUtil::ThrowParameterError(env);
2536         return nullptr;
2537     }
2538 
2539     auto previwWindowContext = std::make_unique<VideoAsyncContext>();
2540     if (previwWindowContext == nullptr) {
2541         std::string errorCode = std::to_string(napi_generic_failure);
2542         std::string errorMessage = "SetPreviewWindow error at baseContext is nullptr";
2543         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2544         return nullptr;
2545     }
2546     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &previwWindowContext->callId);
2547     char tmpStr[kMaxNumberLen + 1] = { 0 };
2548     size_t strLen = 0;
2549     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, MESSAGE_CONTENT_MAXIMUM_LIMIT, &strLen);
2550     std::string tmpCode(tmpStr, strLen);
2551     previwWindowContext->surfaceId = tmpCode;
2552     if (argc == THREE_VALUE_MAXIMUM_LIMIT) {
2553         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(previwWindowContext->callbackRef));
2554     }
2555     return HandleAsyncWork(env, previwWindowContext.release(), "SetPreviewWindow", NativeSetPreviewWindow,
2556         NativeVoidCallBackWithErrorCode);
2557 }
2558 
SetDisplayWindow(napi_env env, napi_callback_info info)2559 napi_value NapiCallManager::SetDisplayWindow(napi_env env, napi_callback_info info)
2560 {
2561     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2562     if (!MatchNumberAndStringParameters(env, argv, argc)) {
2563         TELEPHONY_LOGE("MatchNumberAndStringParameters failed.");
2564         NapiUtil::ThrowParameterError(env);
2565         return nullptr;
2566     }
2567 
2568     auto dislpayWindowContext = std::make_unique<VideoAsyncContext>();
2569     if (dislpayWindowContext == nullptr) {
2570         std::string errorCode = std::to_string(napi_generic_failure);
2571         std::string errorMessage = "SetDisplayWindow error at baseContext is nullptr";
2572         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2573         return nullptr;
2574     }
2575     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &dislpayWindowContext->callId);
2576     char tmpStr[kMaxNumberLen + 1] = { 0 };
2577     size_t strLen = 0;
2578     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, MESSAGE_CONTENT_MAXIMUM_LIMIT, &strLen);
2579     std::string tmpCode(tmpStr, strLen);
2580     dislpayWindowContext->surfaceId = tmpCode;
2581     if (argc == THREE_VALUE_MAXIMUM_LIMIT) {
2582         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(dislpayWindowContext->callbackRef));
2583     }
2584     return HandleAsyncWork(env, dislpayWindowContext.release(), "SetDisplayWindow", NativeSetDisplayWindow,
2585         NativeVoidCallBackWithErrorCode);
2586 }
2587 
SetCameraZoom(napi_env env, napi_callback_info info)2588 napi_value NapiCallManager::SetCameraZoom(napi_env env, napi_callback_info info)
2589 {
2590     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2591     NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2592     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2593     NAPI_ASSERT(env, matchFlag, "SetCameraZoom type error, should be number type");
2594 
2595     auto asyncContext = std::make_unique<VideoAsyncContext>();
2596     if (asyncContext == nullptr) {
2597         std::string errorCode = std::to_string(napi_generic_failure);
2598         std::string errorMessage = "SetCameraZoom error at baseContext is nullptr";
2599         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2600         return nullptr;
2601     }
2602     napi_get_value_double(env, argv[ARRAY_INDEX_FIRST], &asyncContext->zoomRatio);
2603     if (argc == TWO_VALUE_LIMIT) {
2604         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2605     }
2606     return HandleAsyncWork(env, asyncContext.release(), "SetCameraZoom", NativeSetCameraZoom, NativeVoidCallBack);
2607 }
2608 
SetPausePicture(napi_env env, napi_callback_info info)2609 napi_value NapiCallManager::SetPausePicture(napi_env env, napi_callback_info info)
2610 {
2611     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2612     if (!MatchOneNumberParameter(env, argv, argc)) {
2613         TELEPHONY_LOGE("MatchNumberAndStringParameters failed.");
2614         NapiUtil::ThrowParameterError(env);
2615         return nullptr;
2616     }
2617 
2618     auto asyncContext = std::make_unique<VideoAsyncContext>();
2619     if (asyncContext == nullptr) {
2620         std::string errorCode = std::to_string(napi_generic_failure);
2621         std::string errorMessage = "SetPausePicture error at baseContext is nullptr";
2622         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2623         return nullptr;
2624     }
2625     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2626     if (argc == TWO_VALUE_LIMIT) {
2627         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2628     }
2629     return HandleAsyncWork(
2630         env, asyncContext.release(), "SetPausePicture", NativeSetPausePicture, NativeVoidCallBackWithErrorCode);
2631 }
2632 
SetDeviceDirection(napi_env env, napi_callback_info info)2633 napi_value NapiCallManager::SetDeviceDirection(napi_env env, napi_callback_info info)
2634 {
2635     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2636     if (!MatchTwoNumberParameters(env, argv, argc)) {
2637         TELEPHONY_LOGE("NapiCallManager::SetDeviceDirection MatchTwoNumberParameters failed.");
2638         NapiUtil::ThrowParameterError(env);
2639         return nullptr;
2640     }
2641 
2642     auto asyncContext = std::make_unique<VideoAsyncContext>();
2643     if (asyncContext == nullptr) {
2644         std::string errorCode = std::to_string(napi_generic_failure);
2645         std::string errorMessage = "SetDeviceDirection error at baseContext is nullptr";
2646         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2647         return nullptr;
2648     }
2649     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2650     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->rotation);
2651     if (argc == THREE_VALUE_MAXIMUM_LIMIT) {
2652         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2653     }
2654     return HandleAsyncWork(
2655         env, asyncContext.release(), "SetDeviceDirection", NativeSetDeviceDirection, NativeVoidCallBackWithErrorCode);
2656 }
2657 
RequestCameraCapabilities(napi_env env, napi_callback_info info)2658 napi_value NapiCallManager::RequestCameraCapabilities(napi_env env, napi_callback_info info)
2659 {
2660     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
2661     if (!MatchOneNumberParameter(env, argv, argc)) {
2662         TELEPHONY_LOGE("NapiCallManager::RequestCameraCapabilities MatchOneNumberParameter failed.");
2663         NapiUtil::ThrowParameterError(env);
2664         return nullptr;
2665     }
2666     auto asyncContext = std::make_unique<AsyncContext>();
2667     if (asyncContext == nullptr) {
2668         TELEPHONY_LOGE("NapiCallManager::RequestCameraCapabilities asyncContext is nullptr.");
2669         NapiUtil::ThrowParameterError(env);
2670         return nullptr;
2671     }
2672     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2673     if (argc == TWO_VALUE_LIMIT) {
2674         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2675     }
2676     return HandleAsyncWork(env, asyncContext.release(), "RequestCameraCapabilities",
2677         NativeRequestCameraCapabilities, NativeVoidCallBackWithErrorCode);
2678 }
2679 
CancelCallUpgrade(napi_env env, napi_callback_info info)2680 napi_value NapiCallManager::CancelCallUpgrade(napi_env env, napi_callback_info info)
2681 {
2682     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
2683     if (!MatchOneNumberParameter(env, argv, argc)) {
2684         TELEPHONY_LOGE("NapiCallManager::CancelCallUpgrade MatchOneNumberParameter failed.");
2685         NapiUtil::ThrowParameterError(env);
2686         return nullptr;
2687     }
2688     auto asyncContext = std::make_unique<AsyncContext>();
2689     if (asyncContext == nullptr) {
2690         TELEPHONY_LOGE("NapiCallManager::CancelCallUpgrade asyncContext is nullptr.");
2691         NapiUtil::ThrowParameterError(env);
2692         return nullptr;
2693     }
2694     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2695     if (argc == TWO_VALUE_LIMIT) {
2696         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2697     }
2698     return HandleAsyncWork(env, asyncContext.release(), "CancelCallUpgrade", NativeCancelCallUpgrade,
2699         NativeVoidCallBackWithErrorCode);
2700 }
2701 
SetCallPreferenceMode(napi_env env, napi_callback_info info)2702 napi_value NapiCallManager::SetCallPreferenceMode(napi_env env, napi_callback_info info)
2703 {
2704     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2705     NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2706     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2707     NAPI_ASSERT(env, matchFlag, "SetCallPreferenceMode type error, should be number type");
2708     matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_number);
2709     NAPI_ASSERT(env, matchFlag, "SetCallPreferenceMode type error, should be number type");
2710     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2711     if (asyncContext == nullptr) {
2712         std::string errorCode = std::to_string(napi_generic_failure);
2713         std::string errorMessage = "SetCallPreferenceMode error at baseContext is nullptr";
2714         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2715         return nullptr;
2716     }
2717     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2718     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->mode);
2719     if (argc == VALUE_MAXIMUM_LIMIT) {
2720         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2721     }
2722     return HandleAsyncWork(
2723         env, asyncContext.release(), "SetCallPreferenceMode", NativeSetCallPreferenceMode, NativeVoidCallBack);
2724 }
2725 
StartRTT(napi_env env, napi_callback_info info)2726 napi_value NapiCallManager::StartRTT(napi_env env, napi_callback_info info)
2727 {
2728     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2729     NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2730     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2731     NAPI_ASSERT(env, matchFlag, "StartRTT type error, should be number type");
2732     matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_string);
2733     NAPI_ASSERT(env, matchFlag, "StartRTT type error, should be string type");
2734     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2735     if (asyncContext == nullptr) {
2736         std::string errorCode = std::to_string(napi_generic_failure);
2737         std::string errorMessage = "StartRTT error at supplementAsyncContext is nullptr";
2738         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2739         return nullptr;
2740     }
2741     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2742     char tmpStr[kMaxNumberLen + 1] = {0};
2743     size_t strLen = 0;
2744     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
2745     std::string tmpCode(tmpStr, strLen);
2746     asyncContext->content = tmpCode;
2747     if (argc == VALUE_MAXIMUM_LIMIT) {
2748         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2749     }
2750     asyncContext->env = env;
2751     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2752     return HandleAsyncWork(env, asyncContext.release(), "StartRTT", NativeStartRTT, NativeVoidCallBack);
2753 }
2754 
StopRTT(napi_env env, napi_callback_info info)2755 napi_value NapiCallManager::StopRTT(napi_env env, napi_callback_info info)
2756 {
2757     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2758     NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2759     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2760     NAPI_ASSERT(env, matchFlag, "StopRTT type error, should be number type");
2761     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2762     if (asyncContext == nullptr) {
2763         std::string errorCode = std::to_string(napi_generic_failure);
2764         std::string errorMessage = "StopRTT error at supplementAsyncContext is nullptr";
2765         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2766         return nullptr;
2767     }
2768     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2769     if (argc == TWO_VALUE_LIMIT) {
2770         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2771     }
2772     asyncContext->env = env;
2773     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2774     return HandleAsyncWork(env, asyncContext.release(), "StopRTT", NativeStopRTT, NativeVoidCallBack);
2775 }
2776 
JoinConference(napi_env env, napi_callback_info info)2777 napi_value NapiCallManager::JoinConference(napi_env env, napi_callback_info info)
2778 {
2779     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2780     if (!MatchNumberAndObjectParameters(env, argv, argc)) {
2781         TELEPHONY_LOGE("NapiCallManager::JoinConference MatchNumberAndObjectParameters failed.");
2782         NapiUtil::ThrowParameterError(env);
2783         return nullptr;
2784     }
2785     uint32_t arrayLength = 0;
2786     NAPI_CALL(env, napi_get_array_length(env, argv[ARRAY_INDEX_SECOND], &arrayLength));
2787     if (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number) || arrayLength == 0) {
2788         TELEPHONY_LOGE("NapiCallManager::JoinConference parameter type matching failed.");
2789         NapiUtil::ThrowParameterError(env);
2790         return nullptr;
2791     }
2792     auto asyncContext = std::make_unique<ListAsyncContext>();
2793     if (asyncContext == nullptr) {
2794         TELEPHONY_LOGE("NapiCallManager::JoinConference asyncContext is nullptr.");
2795         NapiUtil::ThrowParameterError(env);
2796         return nullptr;
2797     }
2798     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2799     (asyncContext->listResult).clear();
2800 
2801     napi_value napiFormId;
2802     std::string str = "";
2803     size_t len = 0;
2804     char chars[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
2805     napi_status getStringStatus = napi_invalid_arg;
2806     for (uint32_t i = 0; i < arrayLength; i++) {
2807         napi_get_element(env, argv[ARRAY_INDEX_SECOND], i, &napiFormId);
2808         if (!NapiCallManagerUtils::MatchValueType(env, napiFormId, napi_string)) {
2809             TELEPHONY_LOGE("NapiCallManager::JoinConference parameter type matching failed.");
2810             NapiUtil::ThrowParameterError(env);
2811             return nullptr;
2812         }
2813         getStringStatus = napi_get_value_string_utf8(env, napiFormId, chars, PHONE_NUMBER_MAXIMUM_LIMIT, &len);
2814         if (getStringStatus == napi_ok && len > 0) {
2815             str = std::string(chars, len);
2816             (asyncContext->listResult).push_back(Str8ToStr16(str));
2817             TELEPHONY_LOGI("napi_string  %{public}s", str.c_str());
2818         }
2819     }
2820 
2821     if (argc == VALUE_MAXIMUM_LIMIT) {
2822         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2823     }
2824     return HandleAsyncWork(
2825         env, asyncContext.release(), "JoinConference", NativeJoinConference, NativeVoidCallBackWithErrorCode);
2826 }
2827 
UpdateImsCallMode(napi_env env, napi_callback_info info)2828 napi_value NapiCallManager::UpdateImsCallMode(napi_env env, napi_callback_info info)
2829 {
2830     GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2831     if (!MatchTwoNumberParameters(env, argv, argc)) {
2832         TELEPHONY_LOGE("NapiCallManager::UpdateImsCallMode MatchTwoNumberParameters failed.");
2833         NapiUtil::ThrowParameterError(env);
2834         return nullptr;
2835     }
2836     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2837     if (asyncContext == nullptr) {
2838         TELEPHONY_LOGE("NapiCallManager::UpdateImsCallMode asyncContext is nullptr.");
2839         NapiUtil::ThrowParameterError(env);
2840         return nullptr;
2841     }
2842     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2843     napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->type);
2844     if (argc == VALUE_MAXIMUM_LIMIT) {
2845         napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2846     }
2847     asyncContext->env = env;
2848     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2849     return HandleAsyncWork(
2850         env, asyncContext.release(), "UpdateImsCallMode", NativeUpdateImsCallMode, NativeVoidCallBackWithErrorCode);
2851 }
2852 
ReportOttCallDetailsInfo(napi_env env, napi_callback_info info)2853 napi_value NapiCallManager::ReportOttCallDetailsInfo(napi_env env, napi_callback_info info)
2854 {
2855     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2856     NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2857     uint32_t arrayLength = 0;
2858     NAPI_CALL(env, napi_get_array_length(env, argv[ARRAY_INDEX_FIRST], &arrayLength));
2859     NAPI_ASSERT(env, arrayLength > 0, "Parameter cannot be empty");
2860     auto asyncContext = std::make_unique<OttCallAsyncContext>();
2861     if (asyncContext == nullptr) {
2862         std::string errorCode = std::to_string(napi_generic_failure);
2863         std::string errorMessage = "ReportOttCallDetailsInfo error at baseContext is nullptr";
2864         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2865         return nullptr;
2866     }
2867     (asyncContext->ottVec).clear();
2868 
2869     napi_value napiFormId;
2870     OttCallDetailsInfo tmpOttVec;
2871     (void)memset_s(&tmpOttVec, sizeof(OttCallDetailsInfo), 0, sizeof(OttCallDetailsInfo));
2872     for (uint32_t i = 0; i < arrayLength; i++) {
2873         napi_get_element(env, argv[ARRAY_INDEX_FIRST], i, &napiFormId);
2874         bool matchFlag = NapiCallManagerUtils::MatchValueType(env, napiFormId, napi_object);
2875         NAPI_ASSERT(env, matchFlag, "ReportOttCallDetailsInfo type error, should be napi_object type");
2876         std::string tmpStr = NapiCallManagerUtils::GetStringProperty(env, napiFormId, "phoneNumber");
2877         if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2878             TELEPHONY_LOGE("Number out of limit!");
2879             return (napi_value) nullptr;
2880         }
2881         if (memcpy_s(tmpOttVec.phoneNum, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2882             return (napi_value) nullptr;
2883         }
2884         tmpStr = NapiCallManagerUtils::GetStringProperty(env, napiFormId, "bundleName");
2885         if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2886             TELEPHONY_LOGE("Number out of limit!");
2887             return (napi_value) nullptr;
2888         }
2889         if (memcpy_s(tmpOttVec.bundleName, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2890             return (napi_value) nullptr;
2891         }
2892         int32_t tmpValue = NapiCallManagerUtils::GetIntProperty(env, napiFormId, "videoState");
2893         tmpOttVec.videoState = static_cast<VideoStateType>(tmpValue);
2894         tmpValue = NapiCallManagerUtils::GetIntProperty(env, napiFormId, "callState");
2895         tmpOttVec.callState = static_cast<TelCallState>(tmpValue);
2896         (asyncContext->ottVec).push_back(tmpOttVec);
2897     }
2898 
2899     return HandleAsyncWork(
2900         env, asyncContext.release(), "ReportOttCallDetailsInfo", NativeReportOttCallDetailsInfo, NativeVoidCallBack);
2901 }
2902 
ReportOttCallEventInfo(napi_env env, napi_callback_info info)2903 napi_value NapiCallManager::ReportOttCallEventInfo(napi_env env, napi_callback_info info)
2904 {
2905     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2906     NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2907     bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_object);
2908     NAPI_ASSERT(env, matchFlag, "ReportOttCallEventInfo type error, should be object type");
2909     auto asyncContext = std::make_unique<OttEventAsyncContext>();
2910     if (asyncContext == nullptr) {
2911         std::string errorCode = std::to_string(napi_generic_failure);
2912         std::string errorMessage = "ReportOttCallEventInfo error at baseContext is nullptr";
2913         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2914         return nullptr;
2915     }
2916     (void)memset_s(&asyncContext->eventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
2917     int32_t eventId = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "eventId");
2918     std::string tmpStr = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_FIRST], "bundleName");
2919     if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2920         TELEPHONY_LOGE("Number out of limit!");
2921         return (napi_value) nullptr;
2922     }
2923     asyncContext->eventInfo.ottCallEventId = static_cast<OttCallEventId>(eventId);
2924     if (memcpy_s(asyncContext->eventInfo.bundleName, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2925         return (napi_value) nullptr;
2926     }
2927     return HandleAsyncWork(
2928         env, asyncContext.release(), "ReportOttCallEventInfo", NativeReportOttCallEventInfo, NativeVoidCallBack);
2929 }
2930 
CloseUnFinishedUssd(napi_env env, napi_callback_info info)2931 napi_value NapiCallManager::CloseUnFinishedUssd(napi_env env, napi_callback_info info)
2932 {
2933     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2934     if (!MatchOneNumberParameter(env, argv, argc)) {
2935         TELEPHONY_LOGE("NapiCallManager::CloseUnFinishedUssd MatchOneNumberParameter failed.");
2936         NapiUtil::ThrowParameterError(env);
2937         return nullptr;
2938     }
2939     auto asyncContext = std::make_unique<SupplementAsyncContext>();
2940     if (asyncContext == nullptr) {
2941         TELEPHONY_LOGE("NapiCallManager::CloseUnFinishedUssd asyncContext is nullptr.");
2942         NapiUtil::ThrowParameterError(env);
2943         return nullptr;
2944     }
2945     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
2946     if (argc == TWO_VALUE_LIMIT) {
2947         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2948     }
2949     asyncContext->env = env;
2950     napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2951     return HandleAsyncWork(
2952         env, asyncContext.release(), "CloseUnFinishedUssd", NativeCloseUnFinishedUssd, NativeVoidCallBackWithErrorCode);
2953 }
2954 
InputDialerSpecialCode(napi_env env, napi_callback_info info)2955 napi_value NapiCallManager::InputDialerSpecialCode(napi_env env, napi_callback_info info)
2956 {
2957     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2958     if (!MatchOneStringParameter(env, argv, argc)) {
2959         TELEPHONY_LOGE("NapiCallManager::InputDialerSpecialCode MatchOneStringParameter failed.");
2960         NapiUtil::ThrowParameterError(env);
2961         return nullptr;
2962     }
2963 
2964     auto asyncContext = std::make_unique<AsyncContext>();
2965     if (asyncContext == nullptr) {
2966         TELEPHONY_LOGE("NapiCallManager::InputDialerSpecialCode asyncContext is nullptr.");
2967         NapiUtil::ThrowParameterError(env);
2968         return nullptr;
2969     }
2970     napi_get_value_string_utf8(
2971         env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
2972     if (argc == TWO_VALUE_LIMIT) {
2973         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2974     }
2975     return HandleAsyncWork(env, asyncContext.release(), "InputDialerSpecialCode", NativeInputDialerSpecialCode,
2976         NativeVoidCallBackWithErrorCode);
2977 }
2978 
RemoveMissedIncomingCallNotification(napi_env env, napi_callback_info info)2979 napi_value NapiCallManager::RemoveMissedIncomingCallNotification(napi_env env, napi_callback_info info)
2980 {
2981     GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2982     if (!MatchEmptyParameter(env, argv, argc)) {
2983         TELEPHONY_LOGE("NapiCallManager::RemoveMissedIncomingCallNotification "
2984                        "MatchEmptyParameter failed.");
2985         NapiUtil::ThrowParameterError(env);
2986         return nullptr;
2987     }
2988 
2989     auto asyncContext = std::make_unique<AsyncContext>();
2990     if (asyncContext == nullptr) {
2991         TELEPHONY_LOGE("NapiCallManager::RemoveMissedIncomingCallNotification "
2992                        "asyncContext is nullptr.");
2993         NapiUtil::ThrowParameterError(env);
2994         return nullptr;
2995     }
2996 
2997     if (argc == ONLY_ONE_VALUE) {
2998         napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2999     }
3000     return HandleAsyncWork(env, asyncContext.release(), "RemoveMissedIncomingCallNotification",
3001         NativeRemoveMissedIncomingCallNotification, NativeVoidCallBackWithErrorCode);
3002 }
3003 
SetVoIPCallState(napi_env env, napi_callback_info info)3004 napi_value NapiCallManager::SetVoIPCallState(napi_env env, napi_callback_info info)
3005 {
3006     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
3007     if (!MatchOneNumberParameter(env, argv, argc)) {
3008         TELEPHONY_LOGE("NapiCallManager::SetVoIPCallState MatchEmptyParameter failed.");
3009         NapiUtil::ThrowParameterError(env);
3010         return nullptr;
3011     }
3012     auto asyncContext = std::make_unique<VoIPCallStateAsyncContext>();
3013     if (asyncContext == nullptr) {
3014         TELEPHONY_LOGE("NapiCallManager::SetVoIPCallState asyncContext is nullptr.");
3015         NapiUtil::ThrowParameterError(env);
3016         return nullptr;
3017     }
3018     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->state);
3019     if (argc == TWO_VALUE_LIMIT) {
3020         napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
3021     }
3022     return HandleAsyncWork(
3023         env, asyncContext.release(), "SetVoIPCallState", NativeSetVoIPCallState, NativeVoidCallBackWithErrorCode);
3024 }
3025 
HasVoiceCapability(napi_env env, napi_callback_info)3026 napi_value NapiCallManager::HasVoiceCapability(napi_env env, napi_callback_info)
3027 {
3028     TELEPHONY_LOGD("napi_call HasVoiceCapability");
3029     napi_value result = nullptr;
3030     napi_get_boolean(env, DelayedSingleton<CallManagerClient>::GetInstance()->HasVoiceCapability(), &result);
3031     return result;
3032 }
3033 
SendCallUiEvent(napi_env env, napi_callback_info info)3034 napi_value NapiCallManager::SendCallUiEvent(napi_env env, napi_callback_info info)
3035 {
3036     GET_PARAMS(env, info, TWO_VALUE_LIMIT);
3037     if (!MatchNumberAndStringParameters(env, argv, argc)) {
3038         TELEPHONY_LOGE("MatchNumberAndStringParameters failed.");
3039         NapiUtil::ThrowParameterError(env);
3040         return nullptr;
3041     }
3042     auto asyncContext = std::make_unique<SendCallUiEventAsyncContext>();
3043     if (asyncContext == nullptr) {
3044         std::string errorCode = std::to_string(napi_generic_failure);
3045         std::string errorMessage = "SendCallUiEvent error at baseContext is nullptr";
3046         NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
3047         return nullptr;
3048     }
3049     napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
3050     char tmpStr[kMaxNumberLen + 1] = { 0 };
3051     size_t strLen = 0;
3052     napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, MESSAGE_CONTENT_MAXIMUM_LIMIT, &strLen);
3053     std::string tmpName(tmpStr, strLen);
3054     asyncContext->eventName = tmpName;
3055     return HandleAsyncWork(
3056         env, asyncContext.release(), "SendCallUiEvent", NativeSendCallUiEvent, NativeVoidCallBackWithErrorCode);
3057 }
3058 
NativeSendCallUiEvent(napi_env env, void *data)3059 void NapiCallManager::NativeSendCallUiEvent(napi_env env, void *data)
3060 {
3061     if (data == nullptr) {
3062         TELEPHONY_LOGE("NapiCallManager::NativeSendCallUiEvent data is nullptr");
3063         NapiUtil::ThrowParameterError(env);
3064         return;
3065     }
3066     auto asyncContext = (SendCallUiEventAsyncContext *)data;
3067     asyncContext->errorCode =
3068         DelayedSingleton<CallManagerClient>::GetInstance()->SendCallUiEvent(asyncContext->callId,
3069         asyncContext->eventName);
3070     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3071         asyncContext->resolved = TELEPHONY_SUCCESS;
3072     }
3073 }
3074 
NativeCallBack(napi_env env, napi_status status, void *data)3075 void NapiCallManager::NativeCallBack(napi_env env, napi_status status, void *data)
3076 {
3077     if (data == nullptr) {
3078         TELEPHONY_LOGE("data is nullptr");
3079         NapiUtil::ThrowParameterError(env);
3080         return;
3081     }
3082     auto callBackContext = (AsyncContext *)data;
3083     if (callBackContext->deferred != nullptr) {
3084         if (callBackContext->resolved == TELEPHONY_SUCCESS) {
3085             napi_value promiseValue = nullptr;
3086             napi_create_int32(env, callBackContext->resolved, &promiseValue);
3087             napi_resolve_deferred(env, callBackContext->deferred, promiseValue);
3088         } else {
3089             napi_reject_deferred(env, callBackContext->deferred,
3090                 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3091                     env, callBackContext->errorCode, callBackContext->eventId));
3092         }
3093     } else if (callBackContext->callbackRef != nullptr) {
3094         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3095         if (callBackContext->resolved == TELEPHONY_SUCCESS) {
3096             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3097             napi_create_int32(env, callBackContext->resolved, &callbackValue[ARRAY_INDEX_SECOND]);
3098         } else {
3099             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3100                 env, callBackContext->errorCode, callBackContext->eventId);
3101             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3102         }
3103         napi_value callback = nullptr;
3104         napi_value result = nullptr;
3105         napi_get_reference_value(env, callBackContext->callbackRef, &callback);
3106         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3107         napi_delete_reference(env, callBackContext->callbackRef);
3108     }
3109     napi_delete_async_work(env, callBackContext->work);
3110     delete callBackContext;
3111     callBackContext = nullptr;
3112 }
3113 
NativeDialCallBack(napi_env env, napi_status status, void *data)3114 void NapiCallManager::NativeDialCallBack(napi_env env, napi_status status, void *data)
3115 {
3116     if (data == nullptr) {
3117         TELEPHONY_LOGE("data is nullptr");
3118         return;
3119     }
3120     auto asyncContext = (AsyncContext *)data;
3121     if (asyncContext->deferred != nullptr) {
3122         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3123             napi_value promiseValue = nullptr;
3124             napi_get_boolean(env, true, &promiseValue);
3125             napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3126         } else {
3127             if (asyncContext->errorCode == SLOT_ID_INVALID) {
3128                 napi_reject_deferred(env, asyncContext->deferred,
3129                     NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID));
3130             } else {
3131                 std::string errTip = std::to_string(asyncContext->resolved);
3132                 napi_reject_deferred(
3133                     env, asyncContext->deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
3134             }
3135         }
3136     } else if (asyncContext->callbackRef != nullptr) {
3137         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3138         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3139             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3140             napi_get_boolean(env, true, &callbackValue[ARRAY_INDEX_SECOND]);
3141         } else {
3142             if (asyncContext->errorCode == SLOT_ID_INVALID) {
3143                 callbackValue[ARRAY_INDEX_FIRST] =
3144                     NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID);
3145                 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3146             } else {
3147                 std::string errTip = std::to_string(asyncContext->resolved);
3148                 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
3149                 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3150             }
3151         }
3152         napi_value callback = nullptr;
3153         napi_value result = nullptr;
3154         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3155         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3156         napi_delete_reference(env, asyncContext->callbackRef);
3157     }
3158     napi_delete_async_work(env, asyncContext->work);
3159     delete asyncContext;
3160     asyncContext = nullptr;
3161 }
3162 
NativeVoidCallBack(napi_env env, napi_status status, void *data)3163 void NapiCallManager::NativeVoidCallBack(napi_env env, napi_status status, void *data)
3164 {
3165     if (data == nullptr) {
3166         TELEPHONY_LOGE("data is nullptr");
3167         return;
3168     }
3169     auto voidCallBackContext = (AsyncContext *)data;
3170     if (voidCallBackContext->deferred != nullptr) {
3171         if (voidCallBackContext->resolved == TELEPHONY_SUCCESS) {
3172             napi_value promiseValue = nullptr;
3173             napi_get_null(env, &promiseValue);
3174             napi_status ret = napi_resolve_deferred(env, voidCallBackContext->deferred, promiseValue);
3175             TELEPHONY_LOGI("promise successful result = %{public}d", ret);
3176         } else {
3177             std::string errTip = std::to_string(voidCallBackContext->resolved);
3178             napi_status ret = napi_reject_deferred(
3179                 env, voidCallBackContext->deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
3180             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3181         }
3182     } else if (voidCallBackContext->callbackRef != nullptr) {
3183         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3184         if (voidCallBackContext->resolved == TELEPHONY_SUCCESS) {
3185             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3186             napi_get_null(env, &callbackValue[ARRAY_INDEX_SECOND]);
3187         } else {
3188             std::string errTip = std::to_string(voidCallBackContext->resolved);
3189             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
3190             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3191         }
3192         napi_value callback = nullptr;
3193         napi_value result = nullptr;
3194         napi_get_reference_value(env, voidCallBackContext->callbackRef, &callback);
3195         napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3196         TELEPHONY_LOGI("callback result = %{public}d", ret);
3197         napi_delete_reference(env, voidCallBackContext->callbackRef);
3198     }
3199     napi_delete_async_work(env, voidCallBackContext->work);
3200     delete voidCallBackContext;
3201     voidCallBackContext = nullptr;
3202 }
3203 
NativeVoidCallBackWithErrorCode(napi_env env, napi_status status, void *data)3204 void NapiCallManager::NativeVoidCallBackWithErrorCode(napi_env env, napi_status status, void *data)
3205 {
3206     if (data == nullptr) {
3207         TELEPHONY_LOGE("NapiCallManager::NativeVoidCallBackWithErrorCode data is nullptr");
3208         NapiUtil::ThrowParameterError(env);
3209         return;
3210     }
3211     auto asyncContext = (AsyncContext *)data;
3212     if (asyncContext->deferred != nullptr) {
3213         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3214             napi_status ret = napi_resolve_deferred(env, asyncContext->deferred,
3215                 NapiCallManagerUtils::CreateUndefined(env));
3216             TELEPHONY_LOGI("promise successful result = %{public}d", ret);
3217         } else {
3218             napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
3219                 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3220                     env, asyncContext->errorCode, asyncContext->eventId));
3221             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3222         }
3223     } else if (asyncContext->callbackRef != nullptr) {
3224         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3225         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3226             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3227             napi_get_undefined(env, &callbackValue[ARRAY_INDEX_SECOND]);
3228         } else {
3229             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3230                 env, asyncContext->errorCode, asyncContext->eventId);
3231             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3232         }
3233         napi_value callback = nullptr;
3234         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3235         napi_value result = nullptr;
3236         napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3237         TELEPHONY_LOGI("callback result = %{public}d", ret);
3238         napi_delete_reference(env, asyncContext->callbackRef);
3239     }
3240     napi_delete_async_work(env, asyncContext->work);
3241     delete asyncContext;
3242     asyncContext = nullptr;
3243 }
3244 
NativePropertyCallBack(napi_env env, napi_status status, void *data)3245 void NapiCallManager::NativePropertyCallBack(napi_env env, napi_status status, void *data)
3246 {
3247     if (data == nullptr) {
3248         TELEPHONY_LOGE("data is nullptr");
3249         return;
3250     }
3251     auto asyncContext = (AsyncContext *)data;
3252     if (asyncContext->deferred != nullptr) {
3253         napi_value promiseValue = nullptr;
3254         napi_create_int32(env, asyncContext->resolved, &promiseValue);
3255         napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3256     } else {
3257         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3258         callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3259         napi_create_int32(env, asyncContext->resolved, &callbackValue[ARRAY_INDEX_SECOND]);
3260         napi_value callback = nullptr;
3261         napi_value result = nullptr;
3262         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3263         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3264         napi_delete_reference(env, asyncContext->callbackRef);
3265     }
3266     napi_delete_async_work(env, asyncContext->work);
3267     delete asyncContext;
3268     asyncContext = nullptr;
3269 }
3270 
NativeGetMainCallIdCallBack(napi_env env, napi_status status, void *data)3271 void NapiCallManager::NativeGetMainCallIdCallBack(napi_env env, napi_status status, void *data)
3272 {
3273     if (data == nullptr) {
3274         TELEPHONY_LOGE("NapiCallManager::NativeGetMainCallIdCallBack data is nullptr");
3275         NapiUtil::ThrowParameterError(env);
3276         return;
3277     }
3278     auto asyncContext = (IntResultAsyncContext *)data;
3279     if (asyncContext->deferred != nullptr) {
3280         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3281             napi_value promiseValue = nullptr;
3282             napi_create_int32(env, asyncContext->result, &promiseValue);
3283             napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3284             TELEPHONY_LOGI("promise successful result = %{public}d", ret);
3285         } else {
3286             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3287             napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
3288                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
3289             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3290         }
3291     } else if (asyncContext->callbackRef != nullptr) {
3292         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3293         if (asyncContext->resolved == TELEPHONY_SUCCESS) {
3294             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3295             napi_create_int32(env, asyncContext->result, &callbackValue[ARRAY_INDEX_SECOND]);
3296         } else {
3297             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3298             callbackValue[ARRAY_INDEX_FIRST] =
3299                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
3300             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3301         }
3302         napi_value callback = nullptr;
3303         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3304         napi_value result = nullptr;
3305         napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3306         TELEPHONY_LOGI("callback result = %{public}d", ret);
3307         napi_delete_reference(env, asyncContext->callbackRef);
3308     }
3309     napi_delete_async_work(env, asyncContext->work);
3310     delete asyncContext;
3311     asyncContext = nullptr;
3312 }
3313 
NativeIsImsSwitchEnabledCallBack(napi_env env, napi_status status, void *data)3314 void NapiCallManager::NativeIsImsSwitchEnabledCallBack(napi_env env, napi_status status, void *data)
3315 {
3316     if (data == nullptr) {
3317         TELEPHONY_LOGE("NapiCallManager::NativeIsImsSwitchEnabledCallBack data is nullptr");
3318         NapiUtil::ThrowParameterError(env);
3319         return;
3320     }
3321     auto asyncContext = (ImsSwitchAsyncContext *)data;
3322     if (asyncContext->deferred != nullptr) {
3323         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3324             napi_value promiseValue = nullptr;
3325             napi_get_boolean(env, asyncContext->enabled, &promiseValue);
3326             napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3327         } else {
3328             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3329             napi_reject_deferred(env, asyncContext->deferred,
3330                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
3331         }
3332     } else {
3333         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3334         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3335             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3336             napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
3337         } else {
3338             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3339             callbackValue[ARRAY_INDEX_FIRST] =
3340                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
3341             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3342         }
3343         napi_value callback = nullptr;
3344         napi_value result = nullptr;
3345         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3346         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3347         napi_delete_reference(env, asyncContext->callbackRef);
3348     }
3349     napi_delete_async_work(env, asyncContext->work);
3350     delete asyncContext;
3351     asyncContext = nullptr;
3352 }
3353 
NativeGetVoNRStateCallBack(napi_env env, napi_status status, void *data)3354 void NapiCallManager::NativeGetVoNRStateCallBack(napi_env env, napi_status status, void *data)
3355 {
3356     if (data == nullptr) {
3357         TELEPHONY_LOGE("NapiCallManager::NativeGetVoNRStateCallBack data is nullptr");
3358         NapiUtil::ThrowParameterError(env);
3359         return;
3360     }
3361     auto getVoNRStateContext = (VoNRSwitchAsyncContext *)data;
3362     if (getVoNRStateContext->deferred != nullptr) {
3363         if (getVoNRStateContext->errorCode == TELEPHONY_SUCCESS) {
3364             napi_value promiseValue = nullptr;
3365             napi_create_int32(env, getVoNRStateContext->state, &promiseValue);
3366             napi_resolve_deferred(env, getVoNRStateContext->deferred, promiseValue);
3367         } else {
3368             napi_reject_deferred(env, getVoNRStateContext->deferred,
3369                 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3370                     env, getVoNRStateContext->errorCode, getVoNRStateContext->eventId));
3371         }
3372     } else {
3373         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3374         if (getVoNRStateContext->errorCode == TELEPHONY_SUCCESS) {
3375             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3376             napi_create_int32(env, getVoNRStateContext->state, &callbackValue[ARRAY_INDEX_SECOND]);
3377         } else {
3378             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3379                 env, getVoNRStateContext->errorCode, getVoNRStateContext->eventId);
3380             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3381         }
3382         napi_value callback = nullptr;
3383         napi_value result = nullptr;
3384         napi_get_reference_value(env, getVoNRStateContext->callbackRef, &callback);
3385         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3386         napi_delete_reference(env, getVoNRStateContext->callbackRef);
3387     }
3388     napi_delete_async_work(env, getVoNRStateContext->work);
3389     delete getVoNRStateContext;
3390     getVoNRStateContext = nullptr;
3391 }
3392 
NativeBoolCallBack(napi_env env, napi_status status, void *data)3393 void NapiCallManager::NativeBoolCallBack(napi_env env, napi_status status, void *data)
3394 {
3395     if (data == nullptr) {
3396         TELEPHONY_LOGE("data is nullptr");
3397         return;
3398     }
3399     auto boolCallBackContext = (AsyncContext *)data;
3400     if (boolCallBackContext->deferred != nullptr) {
3401         if (boolCallBackContext->resolved == BOOL_VALUE_IS_TRUE) {
3402             napi_value promiseValue = nullptr;
3403             napi_get_boolean(env, true, &promiseValue);
3404             napi_resolve_deferred(env, boolCallBackContext->deferred, promiseValue);
3405         } else if (boolCallBackContext->errorCode == TELEPHONY_SUCCESS) {
3406             napi_value promiseValue = nullptr;
3407             napi_get_boolean(env, false, &promiseValue);
3408             napi_resolve_deferred(env, boolCallBackContext->deferred, promiseValue);
3409         } else if (boolCallBackContext->errorCode == SLOT_ID_INVALID) {
3410             napi_reject_deferred(env, boolCallBackContext->deferred,
3411                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID));
3412         } else {
3413             std::string errTip = std::to_string(boolCallBackContext->errorCode);
3414             napi_reject_deferred(
3415                 env, boolCallBackContext->deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
3416         }
3417     } else {
3418         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3419         if (boolCallBackContext->resolved == BOOL_VALUE_IS_TRUE) {
3420             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3421             napi_get_boolean(env, true, &callbackValue[ARRAY_INDEX_SECOND]);
3422         } else if (boolCallBackContext->errorCode == TELEPHONY_SUCCESS) {
3423             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3424             napi_get_boolean(env, false, &callbackValue[ARRAY_INDEX_SECOND]);
3425         } else if (boolCallBackContext->errorCode == SLOT_ID_INVALID) {
3426             callbackValue[ARRAY_INDEX_FIRST] =
3427                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID);
3428             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3429         } else {
3430             std::string errTip = std::to_string(boolCallBackContext->errorCode);
3431             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
3432             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3433         }
3434         napi_value callback = nullptr;
3435         napi_value result = nullptr;
3436         napi_get_reference_value(env, boolCallBackContext->callbackRef, &callback);
3437         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3438         napi_delete_reference(env, boolCallBackContext->callbackRef);
3439     }
3440     napi_delete_async_work(env, boolCallBackContext->work);
3441     delete boolCallBackContext;
3442     boolCallBackContext = nullptr;
3443 }
3444 
NativeIsEmergencyPhoneNumberCallBack(napi_env env, napi_status status, void *data)3445 void NapiCallManager::NativeIsEmergencyPhoneNumberCallBack(napi_env env, napi_status status, void *data)
3446 {
3447     if (data == nullptr) {
3448         TELEPHONY_LOGE("NapiCallManager::NativeIsEmergencyPhoneNumberCallBack data is nullptr");
3449         NapiUtil::ThrowParameterError(env);
3450         return;
3451     }
3452     auto asyncContext = (UtilsAsyncContext *)data;
3453     if (asyncContext->deferred != nullptr) {
3454         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3455             napi_value promiseValue = nullptr;
3456             napi_get_boolean(env, asyncContext->enabled, &promiseValue);
3457             napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3458             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3459         } else {
3460             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3461             napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
3462                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
3463             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3464         }
3465     } else if (asyncContext->callbackRef != nullptr) {
3466         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3467         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3468             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3469             napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
3470         } else {
3471             JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
3472             callbackValue[ARRAY_INDEX_FIRST] =
3473                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
3474             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3475         }
3476         napi_value callback = nullptr;
3477         napi_value result = nullptr;
3478         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3479         napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3480         TELEPHONY_LOGI("callback result = %{public}d", ret);
3481         napi_delete_reference(env, asyncContext->callbackRef);
3482     }
3483     napi_delete_async_work(env, asyncContext->work);
3484     delete asyncContext;
3485     asyncContext = nullptr;
3486 }
3487 
NativeBoolCallBackWithErrorCode(napi_env env, napi_status status, void *data)3488 void NapiCallManager::NativeBoolCallBackWithErrorCode(napi_env env, napi_status status, void *data)
3489 {
3490     if (data == nullptr) {
3491         TELEPHONY_LOGE("NapiCallManager::NativeBoolCallBackWithErrorCode data is nullptr");
3492         NapiUtil::ThrowParameterError(env);
3493         return;
3494     }
3495     auto asyncContext = (BoolResultAsyncContext *)data;
3496     if (asyncContext->deferred != nullptr) {
3497         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3498             napi_value promiseValue = nullptr;
3499             napi_get_boolean(env, asyncContext->enabled, &promiseValue);
3500             napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3501             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3502         } else {
3503             napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
3504                 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3505                     env, asyncContext->errorCode, asyncContext->eventId));
3506             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3507         }
3508     } else if (asyncContext->callbackRef != nullptr) {
3509         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3510         if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3511             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3512             napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
3513         } else {
3514             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3515                 env, asyncContext->errorCode, asyncContext->eventId);
3516             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3517         }
3518         napi_value callback = nullptr;
3519         napi_value result = nullptr;
3520         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3521         napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3522         TELEPHONY_LOGI("callback result = %{public}d", ret);
3523         napi_delete_reference(env, asyncContext->callbackRef);
3524     }
3525     napi_delete_async_work(env, asyncContext->work);
3526     delete asyncContext;
3527     asyncContext = nullptr;
3528 }
3529 
NativeFormatNumberCallBack(napi_env env, napi_status status, void *data)3530 void NapiCallManager::NativeFormatNumberCallBack(napi_env env, napi_status status, void *data)
3531 {
3532     if (data == nullptr) {
3533         TELEPHONY_LOGE("NapiCallManager::NativeFormatNumberCallBack data is nullptr");
3534         NapiUtil::ThrowParameterError(env);
3535         return;
3536     }
3537     auto formatNumberContext = (UtilsAsyncContext *)data;
3538     if (formatNumberContext->deferred != nullptr) {
3539         if (formatNumberContext->resolved == TELEPHONY_SUCCESS) {
3540             napi_value promiseValue = nullptr;
3541             napi_create_string_utf8(env, Str16ToStr8(formatNumberContext->formatNumber).data(),
3542                 formatNumberContext->formatNumber.length(), &promiseValue);
3543             napi_status ret = napi_resolve_deferred(env, formatNumberContext->deferred, promiseValue);
3544             TELEPHONY_LOGD("promise successful result = %{public}d", ret);
3545         } else {
3546             JsError error = NapiUtil::ConverErrorMessageForJs(formatNumberContext->errorCode);
3547             napi_status ret = napi_reject_deferred(env, formatNumberContext->deferred,
3548                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
3549             TELEPHONY_LOGI("promise failed result = %{public}d", ret);
3550         }
3551     } else if (formatNumberContext->callbackRef != nullptr) {
3552         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3553         if (formatNumberContext->resolved == TELEPHONY_SUCCESS) {
3554             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3555             napi_create_string_utf8(env, Str16ToStr8(formatNumberContext->formatNumber).data(),
3556                 formatNumberContext->formatNumber.length(), &callbackValue[ARRAY_INDEX_SECOND]);
3557         } else {
3558             JsError error = NapiUtil::ConverErrorMessageForJs(formatNumberContext->errorCode);
3559             callbackValue[ARRAY_INDEX_FIRST] =
3560                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
3561             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3562         }
3563         napi_value callback = nullptr;
3564         napi_value result = nullptr;
3565         napi_get_reference_value(env, formatNumberContext->callbackRef, &callback);
3566         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3567         napi_delete_reference(env, formatNumberContext->callbackRef);
3568     }
3569     napi_delete_async_work(env, formatNumberContext->work);
3570     delete formatNumberContext;
3571     formatNumberContext = nullptr;
3572 }
3573 
NativeListCallBack(napi_env env, napi_status status, void *data)3574 void NapiCallManager::NativeListCallBack(napi_env env, napi_status status, void *data)
3575 {
3576     if (data == nullptr) {
3577         NapiUtil::ThrowParameterError(env);
3578         return;
3579     }
3580     int32_t i = 0;
3581     napi_value info = nullptr;
3582     auto listCallBakcContext = (ListAsyncContext *)data;
3583     std::vector<std::u16string>::iterator it = listCallBakcContext->listResult.begin();
3584     if (listCallBakcContext->deferred != nullptr) {
3585         if (listCallBakcContext->resolved == TELEPHONY_SUCCESS) {
3586             napi_value promiseValue = nullptr;
3587             napi_create_array(env, &promiseValue);
3588             for (; it != listCallBakcContext->listResult.end(); ++it) {
3589                 napi_create_string_utf8(env, Str16ToStr8(*it).data(), (*it).length(), &info);
3590                 napi_set_element(env, promiseValue, i, info);
3591                 ++i;
3592             }
3593             napi_resolve_deferred(env, listCallBakcContext->deferred, promiseValue);
3594         } else {
3595             napi_reject_deferred(env, listCallBakcContext->deferred,
3596                 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3597                     env, listCallBakcContext->errorCode, listCallBakcContext->eventId));
3598         }
3599     } else if (listCallBakcContext->callbackRef != nullptr) {
3600         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3601         if (listCallBakcContext->resolved == TELEPHONY_SUCCESS) {
3602             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3603             napi_create_array(env, &callbackValue[ARRAY_INDEX_SECOND]);
3604             for (; it != listCallBakcContext->listResult.end(); ++it) {
3605                 napi_create_string_utf8(env, Str16ToStr8(*it).data(), (*it).length(), &info);
3606                 napi_set_element(env, callbackValue[ARRAY_INDEX_SECOND], i, info);
3607                 ++i;
3608             }
3609         } else {
3610             callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
3611                 env, listCallBakcContext->errorCode, listCallBakcContext->eventId);
3612             callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
3613         }
3614         napi_value callback = nullptr;
3615         napi_value result = nullptr;
3616         napi_get_reference_value(env, listCallBakcContext->callbackRef, &callback);
3617         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
3618         napi_delete_reference(env, listCallBakcContext->callbackRef);
3619     }
3620     napi_delete_async_work(env, listCallBakcContext->work);
3621     delete listCallBakcContext;
3622     listCallBakcContext = nullptr;
3623 }
3624 
NativeOffCallBack(napi_env env, napi_status status, void *data)3625 void NapiCallManager::NativeOffCallBack(napi_env env, napi_status status, void *data)
3626 {
3627     if (data == nullptr) {
3628         TELEPHONY_LOGE("NapiCallManager::NativeOffCallBack data is nullptr");
3629         NapiUtil::ThrowParameterError(env);
3630         return;
3631     }
3632     auto asyncContext = (AsyncContext *)data;
3633     if (asyncContext->deferred != nullptr) {
3634         napi_value promiseValue = nullptr;
3635         napi_get_null(env, &promiseValue);
3636         napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
3637         TELEPHONY_LOGI("promise result = %{public}d", ret);
3638     } else if (asyncContext->callbackRef != nullptr) {
3639         napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
3640         callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
3641         napi_value callback = nullptr;
3642         napi_value result = nullptr;
3643         napi_get_reference_value(env, asyncContext->callbackRef, &callback);
3644         napi_status ret = napi_call_function(env, nullptr, callback, DATA_LENGTH_ONE, callbackValue, &result);
3645         TELEPHONY_LOGD("callback result = %{public}d", ret);
3646         napi_delete_reference(env, asyncContext->callbackRef);
3647     }
3648     napi_delete_async_work(env, asyncContext->work);
3649     delete asyncContext;
3650     asyncContext = nullptr;
3651 }
3652 
GetDialInfo(napi_env env, napi_value objValue, DialAsyncContext &asyncContext)3653 void NapiCallManager::GetDialInfo(napi_env env, napi_value objValue, DialAsyncContext &asyncContext)
3654 {
3655     asyncContext.accountId = NapiCallManagerUtils::GetIntProperty(env, objValue, "accountId");
3656     asyncContext.videoState = NapiCallManagerUtils::GetIntProperty(env, objValue, "videoState");
3657     asyncContext.dialScene = NapiCallManagerUtils::GetIntProperty(env, objValue, "dialScene");
3658     asyncContext.dialType = NapiCallManagerUtils::GetIntProperty(env, objValue, "dialType");
3659     asyncContext.extraParams = NapiCallManagerUtils::GetWantParamsProperty(env, objValue, "extraParams");
3660 }
3661 
GetSmsInfo(napi_env env, napi_value objValue, RejectAsyncContext &asyncContext)3662 void NapiCallManager::GetSmsInfo(napi_env env, napi_value objValue, RejectAsyncContext &asyncContext)
3663 {
3664     asyncContext.isSendSms = true;
3665     asyncContext.messageContent = NapiCallManagerUtils::GetStringProperty(env, objValue, "messageContent");
3666 }
3667 
GetRestrictionInfo( napi_env env, napi_value objValue, CallRestrictionAsyncContext &asyncContext)3668 int32_t NapiCallManager::GetRestrictionInfo(
3669     napi_env env, napi_value objValue, CallRestrictionAsyncContext &asyncContext)
3670 {
3671     int32_t type = 0;
3672     int32_t mode = 0;
3673     std::string pw = "";
3674     if (!NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "type", type) ||
3675         !NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "mode", mode) ||
3676         !NapiCallManagerUtils::GetUssdStringProperty(env, objValue, "password", pw)) {
3677         NapiUtil::ThrowParameterError(env);
3678         return ERROR_PARAMETER_TYPE_INVALID;
3679     }
3680     if (pw.length() > static_cast<size_t>(kMaxNumberLen)) {
3681         TELEPHONY_LOGE("Number out of limit!");
3682         return TELEPHONY_ERR_ARGUMENT_INVALID;
3683     }
3684     if (memcpy_s(asyncContext.info.password, kMaxNumberLen, pw.c_str(), pw.length()) != EOK) {
3685         TELEPHONY_LOGE("memcpy_s failed!");
3686         return TELEPHONY_ERR_MEMCPY_FAIL;
3687     }
3688     asyncContext.info.fac = static_cast<CallRestrictionType>(type);
3689     asyncContext.info.mode = static_cast<CallRestrictionMode>(mode);
3690     TELEPHONY_LOGI("GetRestrictionInfo: type = %{public}d, mode = %{public}d",
3691         asyncContext.info.fac, asyncContext.info.mode);
3692     return TELEPHONY_SUCCESS;
3693 }
3694 
GetTransferInfo(napi_env env, napi_value objValue, CallTransferAsyncContext &asyncContext)3695 int32_t NapiCallManager::GetTransferInfo(napi_env env, napi_value objValue, CallTransferAsyncContext &asyncContext)
3696 {
3697     int32_t type = 0;
3698     int32_t settingType = 0;
3699     std::string transferNum = "";
3700     if (!NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "type", type) ||
3701         !NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "settingType", settingType) ||
3702         !NapiCallManagerUtils::GetUssdStringProperty(env, objValue, "transferNum", transferNum)) {
3703         return ERROR_PARAMETER_TYPE_INVALID;
3704     }
3705     int32_t startHour = NapiCallManagerUtils::GetIntProperty(env, objValue, "startHour");
3706     int32_t startMinute = NapiCallManagerUtils::GetIntProperty(env, objValue, "startMinute");
3707     int32_t endHour = NapiCallManagerUtils::GetIntProperty(env, objValue, "endHour");
3708     int32_t endMinute = NapiCallManagerUtils::GetIntProperty(env, objValue, "endMinute");
3709     if (transferNum.length() > static_cast<size_t>(kMaxNumberLen)) {
3710         TELEPHONY_LOGE("Number out of limit!");
3711         return TELEPHONY_ERR_ARGUMENT_INVALID;
3712     }
3713     if (memcpy_s(asyncContext.info.transferNum, kMaxNumberLen, transferNum.c_str(), transferNum.length()) != EOK) {
3714         TELEPHONY_LOGE("memcpy_s failed!");
3715         return TELEPHONY_ERR_MEMCPY_FAIL;
3716     }
3717     asyncContext.info.settingType = static_cast<CallTransferSettingType>(settingType);
3718     asyncContext.info.type = static_cast<CallTransferType>(type);
3719     asyncContext.info.startHour = startHour;
3720     asyncContext.info.startMinute = startMinute;
3721     asyncContext.info.endHour = endHour;
3722     asyncContext.info.endMinute = endMinute;
3723     TELEPHONY_LOGI(
3724         "GetTransferInfo: type = %{public}d, settingType = %{public}d, startHour = %{public}d, startMinute = "
3725         "%{public}d, endHour = %{public}d, endMinute = %{public}d",
3726         asyncContext.info.type, asyncContext.info.settingType, asyncContext.info.startHour,
3727         asyncContext.info.startMinute, asyncContext.info.endHour, asyncContext.info.endMinute);
3728     return TELEPHONY_SUCCESS;
3729 }
3730 
NativeDial(napi_env env, void *data)3731 void NapiCallManager::NativeDial(napi_env env, void *data)
3732 {
3733     if (data == nullptr) {
3734         TELEPHONY_LOGE("data is nullptr");
3735         return;
3736     }
3737     auto asyncContext = (DialAsyncContext *)data;
3738     if (!IsValidSlotId(asyncContext->accountId) && asyncContext->accountId != -1) {
3739         TELEPHONY_LOGE("NativeDial slotId is invalid");
3740         asyncContext->errorCode = SLOT_ID_INVALID;
3741         return;
3742     }
3743     TELEPHONY_LOGI("NativeDial enter");
3744     std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
3745     OHOS::AppExecFwk::PacMap dialInfo;
3746     dialInfo.PutIntValue("accountId", asyncContext->accountId);
3747     dialInfo.PutIntValue("videoState", asyncContext->videoState);
3748     dialInfo.PutIntValue("dialScene", asyncContext->dialScene);
3749     dialInfo.PutIntValue("dialType", asyncContext->dialType);
3750     asyncContext->resolved =
3751         DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(Str8ToStr16(phoneNumber), dialInfo);
3752 }
3753 
NativeDialCall(napi_env env, void *data)3754 void NapiCallManager::NativeDialCall(napi_env env, void *data)
3755 {
3756     if (data == nullptr) {
3757         TELEPHONY_LOGE("NapiCallManager::NativeDialCall data is nullptr");
3758         NapiUtil::ThrowParameterError(env);
3759         return;
3760     }
3761     auto asyncContext = (DialAsyncContext *)data;
3762     if (!IsValidSlotId(asyncContext->accountId) && asyncContext->accountId != -1) {
3763         TELEPHONY_LOGE("NativeDialCall slotId is invalid");
3764         asyncContext->errorCode = SLOT_ID_INVALID;
3765         return;
3766     }
3767     TELEPHONY_LOGI("NativeDialCall enter");
3768     asyncContext->eventId = CALL_MANAGER_DIAL_CALL;
3769     std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
3770     std::u16string tmpPhoneNumber = Str8ToStr16(phoneNumber);
3771     bool isEmergencyNumber = false;
3772     if (!(DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(
3773         tmpPhoneNumber, asyncContext->accountId, isEmergencyNumber) == TELEPHONY_SUCCESS && isEmergencyNumber)) {
3774         int32_t state;
3775         DelayedSingleton<CallManagerClient>::GetInstance()->GetVoIPCallState(state);
3776         if (state == (int32_t)CallStateToApp::CALL_STATE_OFFHOOK
3777             || state == (int32_t)CallStateToApp::CALL_STATE_RINGING) {
3778             TELEPHONY_LOGE("VoIP CALL is active, cannot dial now");
3779             asyncContext->errorCode = CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
3780             return;
3781         }
3782     }
3783 
3784     OHOS::AppExecFwk::PacMap dialInfo;
3785     dialInfo.PutIntValue("accountId", asyncContext->accountId);
3786     dialInfo.PutIntValue("videoState", asyncContext->videoState);
3787     dialInfo.PutIntValue("dialScene", asyncContext->dialScene);
3788     dialInfo.PutIntValue("dialType", asyncContext->dialType);
3789     dialInfo.PutStringValue("extraParams", AAFwk::WantParamWrapper(asyncContext->extraParams).ToString());
3790     asyncContext->errorCode =
3791         DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(Str8ToStr16(phoneNumber), dialInfo);
3792     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3793         asyncContext->resolved = TELEPHONY_SUCCESS;
3794     }
3795 }
3796 
NativeMakeCall(napi_env env, void *data)3797 void NapiCallManager::NativeMakeCall(napi_env env, void *data)
3798 {
3799     if (data == nullptr) {
3800         TELEPHONY_LOGE("NapiCallManager::NativeMakeCall data is nullptr");
3801         NapiUtil::ThrowParameterError(env);
3802         return;
3803     }
3804     auto asyncContext = (AsyncContext *)data;
3805     std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
3806     asyncContext->errorCode =
3807         DelayedSingleton<CallManagerClient>::GetInstance()->MakeCall(phoneNumber);
3808     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3809         asyncContext->resolved = TELEPHONY_SUCCESS;
3810     }
3811 }
3812 
3813 
NativeAnswerCall(napi_env env, void *data)3814 void NapiCallManager::NativeAnswerCall(napi_env env, void *data)
3815 {
3816     if (data == nullptr) {
3817         TELEPHONY_LOGE("NapiCallManager::NativeAnswerCall data is nullptr");
3818         NapiUtil::ThrowParameterError(env);
3819         return;
3820     }
3821     TELEPHONY_LOGI("NativeAnswerCall enter");
3822     auto asyncContext = (AnswerAsyncContext *)data;
3823     asyncContext->errorCode =
3824         DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(asyncContext->callId, asyncContext->videoState);
3825     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3826         asyncContext->resolved = TELEPHONY_SUCCESS;
3827     }
3828     asyncContext->eventId = CALL_MANAGER_ANSWER_CALL;
3829 }
3830 
NativeRejectCall(napi_env env, void *data)3831 void NapiCallManager::NativeRejectCall(napi_env env, void *data)
3832 {
3833     if (data == nullptr) {
3834         TELEPHONY_LOGE("NapiCallManager::NativeRejectCall data is nullptr");
3835         NapiUtil::ThrowParameterError(env);
3836         return;
3837     }
3838     TELEPHONY_LOGI("NativeRejectCall enter");
3839     auto asyncContext = (RejectAsyncContext *)data;
3840     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->RejectCall(
3841         asyncContext->callId, asyncContext->isSendSms, Str8ToStr16(asyncContext->messageContent));
3842     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3843         asyncContext->resolved = TELEPHONY_SUCCESS;
3844     }
3845     asyncContext->eventId = CALL_MANAGER_REJECT_CALL;
3846 }
3847 
NativeHangUpCall(napi_env env, void *data)3848 void NapiCallManager::NativeHangUpCall(napi_env env, void *data)
3849 {
3850     if (data == nullptr) {
3851         TELEPHONY_LOGE("NapiCallManager::NativeHangUpCall data is nullptr");
3852         NapiUtil::ThrowParameterError(env);
3853         return;
3854     }
3855     TELEPHONY_LOGI("NativeHangUpCall enter");
3856     auto asyncContext = (AsyncContext *)data;
3857     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->HangUpCall(asyncContext->callId);
3858     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3859         asyncContext->resolved = TELEPHONY_SUCCESS;
3860     }
3861     asyncContext->eventId = CALL_MANAGER_DISCONNECT_CALL;
3862 }
3863 
NativeHoldCall(napi_env env, void *data)3864 void NapiCallManager::NativeHoldCall(napi_env env, void *data)
3865 {
3866     if (data == nullptr) {
3867         TELEPHONY_LOGE("NapiCallManager::NativeHoldCall data is nullptr");
3868         NapiUtil::ThrowParameterError(env);
3869         return;
3870     }
3871     TELEPHONY_LOGI("NativeHoldCall enter");
3872     auto asyncContext = (AsyncContext *)data;
3873     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->HoldCall(asyncContext->callId);
3874     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3875         asyncContext->resolved = TELEPHONY_SUCCESS;
3876     }
3877     asyncContext->eventId = CALL_MANAGER_HOLD_CALL;
3878 }
3879 
NativeUnHoldCall(napi_env env, void *data)3880 void NapiCallManager::NativeUnHoldCall(napi_env env, void *data)
3881 {
3882     if (data == nullptr) {
3883         TELEPHONY_LOGE("NapiCallManager::NativeUnHoldCall data is nullptr");
3884         NapiUtil::ThrowParameterError(env);
3885         return;
3886     }
3887     TELEPHONY_LOGI("NativeUnHoldCall enter");
3888     auto asyncContext = (AsyncContext *)data;
3889     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->UnHoldCall(asyncContext->callId);
3890     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3891         asyncContext->resolved = TELEPHONY_SUCCESS;
3892     }
3893     asyncContext->eventId = CALL_MANAGER_UNHOLD_CALL;
3894 }
3895 
NativeSwitchCall(napi_env env, void *data)3896 void NapiCallManager::NativeSwitchCall(napi_env env, void *data)
3897 {
3898     if (data == nullptr) {
3899         TELEPHONY_LOGE("NapiCallManager::NativeSwitchCall data is nullptr");
3900         NapiUtil::ThrowParameterError(env);
3901         return;
3902     }
3903     auto asyncContext = (AsyncContext *)data;
3904     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SwitchCall(asyncContext->callId);
3905     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3906         asyncContext->resolved = TELEPHONY_SUCCESS;
3907     }
3908     asyncContext->eventId = CALL_MANAGER_SWITCH_CALL;
3909 }
3910 
NativeCombineConference(napi_env env, void *data)3911 void NapiCallManager::NativeCombineConference(napi_env env, void *data)
3912 {
3913     if (data == nullptr) {
3914         TELEPHONY_LOGE("NapiCallManager::NativeCombineConference data is nullptr");
3915         NapiUtil::ThrowParameterError(env);
3916         return;
3917     }
3918     auto asyncContext = (AsyncContext *)data;
3919     asyncContext->errorCode =
3920         DelayedSingleton<CallManagerClient>::GetInstance()->CombineConference(asyncContext->callId);
3921     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3922         asyncContext->resolved = TELEPHONY_SUCCESS;
3923     }
3924 }
3925 
NativeSeparateConference(napi_env env, void *data)3926 void NapiCallManager::NativeSeparateConference(napi_env env, void *data)
3927 {
3928     if (data == nullptr) {
3929         TELEPHONY_LOGE("NapiCallManager::NativeSeparateConference data is nullptr");
3930         NapiUtil::ThrowParameterError(env);
3931         return;
3932     }
3933     auto asyncContext = (AsyncContext *)data;
3934     asyncContext->errorCode =
3935         DelayedSingleton<CallManagerClient>::GetInstance()->SeparateConference(asyncContext->callId);
3936     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3937         asyncContext->resolved = TELEPHONY_SUCCESS;
3938     }
3939 }
3940 
NativeKickOutFromConference(napi_env env, void *data)3941 void NapiCallManager::NativeKickOutFromConference(napi_env env, void *data)
3942 {
3943     if (data == nullptr) {
3944         TELEPHONY_LOGE("NapiCallManager::NativeKickOutFromConference data is nullptr");
3945         NapiUtil::ThrowParameterError(env);
3946         return;
3947     }
3948     auto asyncContext = (AsyncContext *)data;
3949     asyncContext->errorCode =
3950         DelayedSingleton<CallManagerClient>::GetInstance()->KickOutFromConference(asyncContext->callId);
3951     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3952         asyncContext->resolved = TELEPHONY_SUCCESS;
3953     }
3954 }
3955 
NativeGetMainCallId(napi_env env, void *data)3956 void NapiCallManager::NativeGetMainCallId(napi_env env, void *data)
3957 {
3958     if (data == nullptr) {
3959         TELEPHONY_LOGE("NapiCallManager::NativeGetMainCallId data is nullptr");
3960         NapiUtil::ThrowParameterError(env);
3961         return;
3962     }
3963     auto asyncContext = (IntResultAsyncContext *)data;
3964     asyncContext->result = 0;
3965     asyncContext->errorCode =
3966         DelayedSingleton<CallManagerClient>::GetInstance()->GetMainCallId(asyncContext->callId, asyncContext->result);
3967     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3968         asyncContext->resolved = TELEPHONY_SUCCESS;
3969     }
3970 }
3971 
NativeGetSubCallIdList(napi_env env, void *data)3972 void NapiCallManager::NativeGetSubCallIdList(napi_env env, void *data)
3973 {
3974     if (data == nullptr) {
3975         TELEPHONY_LOGE("NapiCallManager::NativeGetSubCallIdList data is nullptr");
3976         NapiUtil::ThrowParameterError(env);
3977         return;
3978     }
3979     auto asyncContext = (ListAsyncContext *)data;
3980     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetSubCallIdList(
3981         asyncContext->callId, asyncContext->listResult);
3982     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3983         asyncContext->resolved = TELEPHONY_SUCCESS;
3984     }
3985 }
3986 
NativeGetCallIdListForConference(napi_env env, void *data)3987 void NapiCallManager::NativeGetCallIdListForConference(napi_env env, void *data)
3988 {
3989     if (data == nullptr) {
3990         TELEPHONY_LOGE("NapiCallManager::NativeGetCallIdListForConference data is nullptr");
3991         NapiUtil::ThrowParameterError(env);
3992         return;
3993     }
3994     auto asyncContext = (ListAsyncContext *)data;
3995     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallIdListForConference(
3996         asyncContext->callId, asyncContext->listResult);
3997     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3998         asyncContext->resolved = TELEPHONY_SUCCESS;
3999     }
4000 }
4001 
4002 /**
4003  * Register a callback to NapiCallAbilityCallback. When call_manager has data returned,
4004  * NapiCallAbilityCallback will notify JavaScript via the registered callback.
4005  * The whole process is asynchronous.
4006  */
NativeGetCallWaiting(napi_env env, void *data)4007 void NapiCallManager::NativeGetCallWaiting(napi_env env, void *data)
4008 {
4009     if (data == nullptr) {
4010         TELEPHONY_LOGE("NapiCallManager::NativeGetCallWaiting data is nullptr");
4011         NapiUtil::ThrowParameterError(env);
4012         return;
4013     }
4014     auto asyncContext = (SupplementAsyncContext *)data;
4015     if (!IsValidSlotId(asyncContext->slotId)) {
4016         TELEPHONY_LOGE("NativeGetCallWaiting slotId is invalid");
4017         asyncContext->errorCode = SLOT_ID_INVALID;
4018         return;
4019     }
4020     EventCallback infoListener;
4021     infoListener.env = asyncContext->env;
4022     infoListener.thisVar = asyncContext->thisVar;
4023     infoListener.callbackRef = asyncContext->callbackRef;
4024     infoListener.deferred = asyncContext->deferred;
4025     asyncContext->errorCode =
4026         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetWaitingCallback(infoListener);
4027     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4028         TELEPHONY_LOGE("RegisterGetWaitingCallback failed!");
4029         return;
4030     }
4031     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallWaiting(asyncContext->slotId);
4032     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4033         asyncContext->eventId = CALL_MANAGER_GET_CALL_WAITING;
4034         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetWaitingCallback();
4035         TELEPHONY_LOGE("GetCallWaiting failed!");
4036         return;
4037     }
4038     asyncContext->resolved = TELEPHONY_SUCCESS;
4039     asyncContext->callbackRef = nullptr;
4040     asyncContext->deferred = nullptr;
4041 }
4042 
NativeSetCallWaiting(napi_env env, void *data)4043 void NapiCallManager::NativeSetCallWaiting(napi_env env, void *data)
4044 {
4045     if (data == nullptr) {
4046         TELEPHONY_LOGE("NapiCallManager::NativeSetCallWaiting data is nullptr");
4047         NapiUtil::ThrowParameterError(env);
4048         return;
4049     }
4050     auto asyncContext = (SupplementAsyncContext *)data;
4051     if (!IsValidSlotId(asyncContext->slotId)) {
4052         TELEPHONY_LOGE("NativeSetCallWaiting slotId is invalid");
4053         asyncContext->errorCode = SLOT_ID_INVALID;
4054         return;
4055     }
4056 
4057     EventCallback infoListener;
4058     infoListener.env = asyncContext->env;
4059     infoListener.thisVar = asyncContext->thisVar;
4060     infoListener.callbackRef = asyncContext->callbackRef;
4061     infoListener.deferred = asyncContext->deferred;
4062     asyncContext->errorCode =
4063         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetWaitingCallback(infoListener);
4064     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4065         TELEPHONY_LOGE("RegisterSetWaitingCallback failed!");
4066         return;
4067     }
4068     asyncContext->errorCode =
4069         DelayedSingleton<CallManagerClient>::GetInstance()->SetCallWaiting(asyncContext->slotId, asyncContext->flag);
4070     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4071         asyncContext->eventId = CALL_MANAGER_SET_CALL_WAITING;
4072         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetWaitingCallback();
4073         TELEPHONY_LOGE("SetCallWaiting failed!");
4074         return;
4075     }
4076     asyncContext->resolved = TELEPHONY_SUCCESS;
4077     asyncContext->callbackRef = nullptr;
4078     asyncContext->deferred = nullptr;
4079 }
4080 
NativeGetCallRestriction(napi_env env, void *data)4081 void NapiCallManager::NativeGetCallRestriction(napi_env env, void *data)
4082 {
4083     if (data == nullptr) {
4084         TELEPHONY_LOGE("NapiCallManager::NativeGetCallRestriction data is nullptr");
4085         NapiUtil::ThrowParameterError(env);
4086         return;
4087     }
4088     auto asyncContext = (SupplementAsyncContext *)data;
4089     if (!IsValidSlotId(asyncContext->slotId)) {
4090         TELEPHONY_LOGE("NativeGetCallRestriction slotId is invalid");
4091         asyncContext->errorCode = SLOT_ID_INVALID;
4092         return;
4093     }
4094     EventCallback infoListener;
4095     infoListener.env = asyncContext->env;
4096     infoListener.thisVar = asyncContext->thisVar;
4097     infoListener.callbackRef = asyncContext->callbackRef;
4098     infoListener.deferred = asyncContext->deferred;
4099     asyncContext->errorCode =
4100         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetRestrictionCallback(infoListener);
4101     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4102         TELEPHONY_LOGE("RegisterGetRestrictionCallback failed!");
4103         return;
4104     }
4105     CallRestrictionType type = static_cast<CallRestrictionType>(asyncContext->type);
4106     asyncContext->errorCode =
4107         DelayedSingleton<CallManagerClient>::GetInstance()->GetCallRestriction(asyncContext->slotId, type);
4108     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4109         asyncContext->eventId = CALL_MANAGER_GET_CALL_RESTRICTION;
4110         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetRestrictionCallback();
4111         TELEPHONY_LOGE("GetCallRestriction failed!");
4112         return;
4113     }
4114     asyncContext->resolved = TELEPHONY_SUCCESS;
4115     asyncContext->callbackRef = nullptr;
4116     asyncContext->deferred = nullptr;
4117 }
4118 
NativeSetCallRestriction(napi_env env, void *data)4119 void NapiCallManager::NativeSetCallRestriction(napi_env env, void *data)
4120 {
4121     if (data == nullptr) {
4122         TELEPHONY_LOGE("NapiCallManager::NativeSetCallRestriction data is nullptr");
4123         NapiUtil::ThrowParameterError(env);
4124         return;
4125     }
4126     auto asyncContext = (CallRestrictionAsyncContext *)data;
4127     if (!IsValidSlotId(asyncContext->slotId)) {
4128         TELEPHONY_LOGE("NativeSetCallRestriction slotId is invalid");
4129         asyncContext->errorCode = SLOT_ID_INVALID;
4130         return;
4131     }
4132     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4133         TELEPHONY_LOGE("Data acquisition failure!");
4134         return;
4135     }
4136     EventCallback infoListener;
4137     infoListener.env = asyncContext->env;
4138     infoListener.thisVar = asyncContext->thisVar;
4139     infoListener.callbackRef = asyncContext->callbackRef;
4140     infoListener.deferred = asyncContext->deferred;
4141     asyncContext->errorCode =
4142         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetRestrictionCallback(infoListener);
4143     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4144         TELEPHONY_LOGE("RegisterSetRestrictionCallback failed!");
4145         return;
4146     }
4147     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallRestriction(
4148         asyncContext->slotId, asyncContext->info);
4149     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4150         asyncContext->eventId = CALL_MANAGER_SET_CALL_RESTRICTION;
4151         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetRestrictionCallback();
4152         TELEPHONY_LOGE("SetCallRestriction failed!");
4153         return;
4154     }
4155     asyncContext->resolved = TELEPHONY_SUCCESS;
4156     asyncContext->callbackRef = nullptr;
4157     asyncContext->deferred = nullptr;
4158 }
4159 
NativeSetCallRestrictionPassword(napi_env env, void *data)4160 void NapiCallManager::NativeSetCallRestrictionPassword(napi_env env, void *data)
4161 {
4162     if (data == nullptr) {
4163         TELEPHONY_LOGE("data is nullptr");
4164         NapiUtil::ThrowParameterError(env);
4165         return;
4166     }
4167     auto asyncContext = (CallBarringPasswordAsyncContext *)data;
4168     if (!IsValidSlotId(asyncContext->slotId)) {
4169         TELEPHONY_LOGE("slotId is invalid");
4170         asyncContext->errorCode = SLOT_ID_INVALID;
4171         return;
4172     }
4173     EventCallback infoListener;
4174     infoListener.env = asyncContext->env;
4175     infoListener.thisVar = asyncContext->thisVar;
4176     infoListener.callbackRef = asyncContext->callbackRef;
4177     infoListener.deferred = asyncContext->deferred;
4178     asyncContext->errorCode =
4179         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetRestrictionPasswordCallback(infoListener);
4180     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4181         TELEPHONY_LOGE("RegisterSetRestrictionPasswordCallback failed!");
4182         return;
4183     }
4184     asyncContext->errorCode =
4185         DelayedSingleton<CallManagerClient>::GetInstance()->SetCallRestrictionPassword(asyncContext->slotId,
4186         CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, asyncContext->oldPassword, asyncContext->newPassword);
4187     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4188         asyncContext->eventId = CALL_MANAGER_SET_CALL_RESTRICTION_PASSWORD;
4189         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetRestrictionPasswordCallback();
4190         TELEPHONY_LOGE("SetCallRestrictionPassword failed!");
4191         return;
4192     }
4193     asyncContext->resolved = TELEPHONY_SUCCESS;
4194     asyncContext->callbackRef = nullptr;
4195     asyncContext->deferred = nullptr;
4196     (void)memset_s(asyncContext->oldPassword, sizeof(asyncContext->oldPassword), 0, sizeof(asyncContext->oldPassword));
4197     (void)memset_s(asyncContext->newPassword, sizeof(asyncContext->newPassword), 0, sizeof(asyncContext->newPassword));
4198 }
4199 
NativeGetTransferNumber(napi_env env, void *data)4200 void NapiCallManager::NativeGetTransferNumber(napi_env env, void *data)
4201 {
4202     if (data == nullptr) {
4203         TELEPHONY_LOGE("NapiCallManager::NativeGetTransferNumber data is nullptr");
4204         NapiUtil::ThrowParameterError(env);
4205         return;
4206     }
4207     auto asyncContext = (SupplementAsyncContext *)data;
4208     if (!IsValidSlotId(asyncContext->slotId)) {
4209         TELEPHONY_LOGE("NativeGetTransferNumber slotId is invalid");
4210         asyncContext->errorCode = SLOT_ID_INVALID;
4211         return;
4212     }
4213     EventCallback infoListener;
4214     infoListener.env = asyncContext->env;
4215     infoListener.thisVar = asyncContext->thisVar;
4216     infoListener.callbackRef = asyncContext->callbackRef;
4217     infoListener.deferred = asyncContext->deferred;
4218     asyncContext->errorCode = DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetTransferCallback(
4219         infoListener, asyncContext->type);
4220     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4221         TELEPHONY_LOGE("RegisterGetTransferCallback failed!");
4222         return;
4223     }
4224     CallTransferType type = static_cast<CallTransferType>(asyncContext->type);
4225     asyncContext->errorCode =
4226         DelayedSingleton<CallManagerClient>::GetInstance()->GetCallTransferInfo(asyncContext->slotId, type);
4227     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4228         asyncContext->eventId = CALL_MANAGER_GET_CALL_TRANSFER;
4229         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetTransferCallback();
4230         TELEPHONY_LOGE("GetCallTransferInfo failed!");
4231         return;
4232     }
4233     asyncContext->resolved = TELEPHONY_SUCCESS;
4234     asyncContext->callbackRef = nullptr;
4235     asyncContext->deferred = nullptr;
4236 }
4237 
NativeSetTransferNumber(napi_env env, void *data)4238 void NapiCallManager::NativeSetTransferNumber(napi_env env, void *data)
4239 {
4240     if (data == nullptr) {
4241         TELEPHONY_LOGE("NapiCallManager::NativeSetTransferNumber data is nullptr");
4242         NapiUtil::ThrowParameterError(env);
4243         return;
4244     }
4245     auto asyncContext = (CallTransferAsyncContext *)data;
4246     if (!IsValidSlotId(asyncContext->slotId)) {
4247         TELEPHONY_LOGE("NativeSetTransferNumber slotId is invalid");
4248         asyncContext->errorCode = SLOT_ID_INVALID;
4249         return;
4250     }
4251 
4252     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4253         TELEPHONY_LOGE("Data acquisition failure!");
4254         return;
4255     }
4256     EventCallback infoListener;
4257     infoListener.env = asyncContext->env;
4258     infoListener.thisVar = asyncContext->thisVar;
4259     infoListener.callbackRef = asyncContext->callbackRef;
4260     infoListener.deferred = asyncContext->deferred;
4261     asyncContext->errorCode =
4262         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetTransferCallback(infoListener);
4263     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4264         TELEPHONY_LOGE("RegisterSetTransferCallback failed!");
4265         return;
4266     }
4267     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallTransferInfo(
4268         asyncContext->slotId, asyncContext->info);
4269     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4270         asyncContext->eventId = CALL_MANAGER_SET_CALL_TRANSFER;
4271         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetTransferCallback();
4272         TELEPHONY_LOGE("SetCallTransferInfo failed!");
4273         return;
4274     }
4275     asyncContext->resolved = TELEPHONY_SUCCESS;
4276     asyncContext->callbackRef = nullptr;
4277     asyncContext->deferred = nullptr;
4278 }
4279 
NativeCanSetCallTransferTime(napi_env env, void *data)4280 void NapiCallManager::NativeCanSetCallTransferTime(napi_env env, void *data)
4281 {
4282     if (data == nullptr) {
4283         TELEPHONY_LOGE("data is nullptr");
4284         NapiUtil::ThrowParameterError(env);
4285         return;
4286     }
4287     auto asyncContext = (BoolResultAsyncContext *)data;
4288     if (!IsValidSlotId(asyncContext->slotId)) {
4289         TELEPHONY_LOGE("[slot%{public}d]slotId is invalid", asyncContext->slotId);
4290         asyncContext->errorCode = SLOT_ID_INVALID;
4291         return;
4292     }
4293     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->CanSetCallTransferTime(
4294         asyncContext->slotId, asyncContext->enabled);
4295 }
4296 
NativeEnableImsSwitch(napi_env env, void *data)4297 void NapiCallManager::NativeEnableImsSwitch(napi_env env, void *data)
4298 {
4299     if (data == nullptr) {
4300         TELEPHONY_LOGE("NapiCallManager::NativeEnableImsSwitch data is nullptr");
4301         NapiUtil::ThrowParameterError(env);
4302         return;
4303     }
4304     auto asyncContext = (ImsSwitchAsyncContext *)data;
4305     if (!IsValidSlotId(asyncContext->slotId)) {
4306         TELEPHONY_LOGE("NativeEnableImsSwitch slotId is invalid");
4307         asyncContext->errorCode = SLOT_ID_INVALID;
4308         return;
4309     }
4310     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->EnableImsSwitch(asyncContext->slotId);
4311     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4312         asyncContext->resolved = TELEPHONY_SUCCESS;
4313     }
4314     asyncContext->eventId = CALL_MANAGER_ENABLE_IMS_SWITCH;
4315 }
4316 
NativeDisableImsSwitch(napi_env env, void *data)4317 void NapiCallManager::NativeDisableImsSwitch(napi_env env, void *data)
4318 {
4319     if (data == nullptr) {
4320         TELEPHONY_LOGE("NapiCallManager::NativeDisableImsSwitch data is nullptr");
4321         NapiUtil::ThrowParameterError(env);
4322         return;
4323     }
4324     auto asyncContext = (ImsSwitchAsyncContext *)data;
4325     if (!IsValidSlotId(asyncContext->slotId)) {
4326         TELEPHONY_LOGE("NativeDisableImsSwitch slotId is invalid");
4327         asyncContext->errorCode = SLOT_ID_INVALID;
4328         return;
4329     }
4330     asyncContext->errorCode =
4331         DelayedSingleton<CallManagerClient>::GetInstance()->DisableImsSwitch(asyncContext->slotId);
4332     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4333         asyncContext->resolved = TELEPHONY_SUCCESS;
4334     }
4335     asyncContext->eventId = CALL_MANAGER_DISABLE_IMS_SWITCH;
4336 }
4337 
NativeIsImsSwitchEnabled(napi_env env, void *data)4338 void NapiCallManager::NativeIsImsSwitchEnabled(napi_env env, void *data)
4339 {
4340     if (data == nullptr) {
4341         TELEPHONY_LOGE("NapiCallManager::NativeIsImsSwitchEnabled data is nullptr");
4342         NapiUtil::ThrowParameterError(env);
4343         return;
4344     }
4345     auto asyncContext = (ImsSwitchAsyncContext *)data;
4346     if (!IsValidSlotId(asyncContext->slotId)) {
4347         TELEPHONY_LOGE("NativeIsImsSwitchEnabled slotId is invalid");
4348         asyncContext->errorCode = SLOT_ID_INVALID;
4349         return;
4350     }
4351     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsImsSwitchEnabled(
4352         asyncContext->slotId, asyncContext->enabled);
4353     if (asyncContext->enabled) {
4354         asyncContext->resolved = BOOL_VALUE_IS_TRUE;
4355     }
4356 }
4357 
NativeSetVoNRState(napi_env env, void *data)4358 void NapiCallManager::NativeSetVoNRState(napi_env env, void *data)
4359 {
4360     if (data == nullptr) {
4361         TELEPHONY_LOGE("NapiCallManager::NativeSetVoNRState data is nullptr");
4362         NapiUtil::ThrowParameterError(env);
4363         return;
4364     }
4365     auto asyncContext = (VoNRSwitchAsyncContext *)data;
4366     if (!IsValidSlotId(asyncContext->slotId)) {
4367         TELEPHONY_LOGE("NativeSetVoNRState slotId is invalid");
4368         asyncContext->errorCode = SLOT_ID_INVALID;
4369         return;
4370     }
4371     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetVoNRState(
4372         asyncContext->slotId, asyncContext->state);
4373     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4374         asyncContext->resolved = TELEPHONY_SUCCESS;
4375     }
4376     asyncContext->eventId = CALL_MANAGER_SET_VONR_STATE;
4377 }
4378 
NativeGetVoNRState(napi_env env, void *data)4379 void NapiCallManager::NativeGetVoNRState(napi_env env, void *data)
4380 {
4381     if (data == nullptr) {
4382         TELEPHONY_LOGE("NapiCallManager::NativeGetVoNRState data is nullptr");
4383         NapiUtil::ThrowParameterError(env);
4384         return;
4385     }
4386     auto asyncContext = (VoNRSwitchAsyncContext *)data;
4387     if (!IsValidSlotId(asyncContext->slotId)) {
4388         TELEPHONY_LOGE("NativeIsImsSwitchEnabled slotId is invalid");
4389         asyncContext->errorCode = SLOT_ID_INVALID;
4390         return;
4391     }
4392     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetVoNRState(
4393         asyncContext->slotId, asyncContext->state);
4394     asyncContext->eventId = CALL_MANAGER_GET_VONR_STATE;
4395 }
4396 
NativeStartDTMF(napi_env env, void *data)4397 void NapiCallManager::NativeStartDTMF(napi_env env, void *data)
4398 {
4399     if (data == nullptr) {
4400         TELEPHONY_LOGE("NapiCallManager::NativeStartDTMF data is nullptr");
4401         NapiUtil::ThrowParameterError(env);
4402         return;
4403     }
4404     auto asyncContext = (AsyncContext *)data;
4405     if (asyncContext->numberLen < TWO_VALUE_LIMIT) {
4406         asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->StartDtmf(
4407             asyncContext->callId, asyncContext->number[ARRAY_INDEX_FIRST]);
4408     } else {
4409         asyncContext->errorCode = TELEPHONY_ERR_ARGUMENT_INVALID;
4410     }
4411     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4412         asyncContext->resolved = TELEPHONY_SUCCESS;
4413     }
4414 }
4415 
NativeStopDTMF(napi_env env, void *data)4416 void NapiCallManager::NativeStopDTMF(napi_env env, void *data)
4417 {
4418     if (data == nullptr) {
4419         TELEPHONY_LOGE("NapiCallManager::NativeStopDTMF data is nullptr");
4420         NapiUtil::ThrowParameterError(env);
4421         return;
4422     }
4423     auto asyncContext = (AsyncContext *)data;
4424     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->StopDtmf(asyncContext->callId);
4425     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4426         asyncContext->resolved = TELEPHONY_SUCCESS;
4427     }
4428 }
4429 
NativePostDialProceed(napi_env env, void *data)4430 void NapiCallManager::NativePostDialProceed(napi_env env, void *data)
4431 {
4432     if (data == nullptr) {
4433         TELEPHONY_LOGE("NapiCallManager::NativePostDialProceed data is nullptr");
4434         NapiUtil::ThrowParameterError(env);
4435         return;
4436     }
4437     auto asyncContext = (PostDialAsyncContext *)data;
4438     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->PostDialProceed(
4439         asyncContext->callId, asyncContext->proceed);
4440     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4441         asyncContext->resolved = TELEPHONY_SUCCESS;
4442     }
4443 }
4444 
NativeGetCallState(napi_env env, void *data)4445 void NapiCallManager::NativeGetCallState(napi_env env, void *data)
4446 {
4447     if (data == nullptr) {
4448         TELEPHONY_LOGE("data is nullptr");
4449         return;
4450     }
4451     auto asyncContext = (AsyncContext *)data;
4452     asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallState();
4453 }
4454 
NativeIsRinging(napi_env env, void *data)4455 void NapiCallManager::NativeIsRinging(napi_env env, void *data)
4456 {
4457     if (data == nullptr) {
4458         TELEPHONY_LOGE("NapiCallManager::NativeIsRinging data is nullptr");
4459         NapiUtil::ThrowParameterError(env);
4460         return;
4461     }
4462     auto asyncContext = (BoolResultAsyncContext *)data;
4463     asyncContext->enabled = false;
4464     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsRinging(asyncContext->enabled);
4465     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4466         asyncContext->resolved = TELEPHONY_SUCCESS;
4467     }
4468     asyncContext->eventId = CALL_MANAGER_IS_RINGING;
4469 }
4470 
NativeHasCall(napi_env env, void *data)4471 void NapiCallManager::NativeHasCall(napi_env env, void *data)
4472 {
4473     if (data == nullptr) {
4474         TELEPHONY_LOGE("data is nullptr");
4475         return;
4476     }
4477     auto asyncContext = (AsyncContext *)data;
4478     asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->HasCall();
4479 }
4480 
NativeIsNewCallAllowed(napi_env env, void *data)4481 void NapiCallManager::NativeIsNewCallAllowed(napi_env env, void *data)
4482 {
4483     if (data == nullptr) {
4484         TELEPHONY_LOGE("NapiCallManager::NativeIsNewCallAllowed data is nullptr");
4485         NapiUtil::ThrowParameterError(env);
4486         return;
4487     }
4488     auto asyncContext = (BoolResultAsyncContext *)data;
4489     asyncContext->errorCode =
4490         DelayedSingleton<CallManagerClient>::GetInstance()->IsNewCallAllowed(asyncContext->enabled);
4491     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4492         asyncContext->resolved = TELEPHONY_SUCCESS;
4493     }
4494 }
4495 
NativeIsInEmergencyCall(napi_env env, void *data)4496 void NapiCallManager::NativeIsInEmergencyCall(napi_env env, void *data)
4497 {
4498     if (data == nullptr) {
4499         TELEPHONY_LOGE("NapiCallManager::NativeIsInEmergencyCall data is nullptr");
4500         NapiUtil::ThrowParameterError(env);
4501         return;
4502     }
4503     auto asyncContext = (BoolResultAsyncContext *)data;
4504     asyncContext->errorCode =
4505         DelayedSingleton<CallManagerClient>::GetInstance()->IsInEmergencyCall(asyncContext->enabled);
4506     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4507         asyncContext->resolved = TELEPHONY_SUCCESS;
4508     }
4509     asyncContext->eventId = CALL_MANAGER_IS_EMERGENCY_CALL;
4510 }
4511 
NativeIsEmergencyPhoneNumber(napi_env env, void *data)4512 void NapiCallManager::NativeIsEmergencyPhoneNumber(napi_env env, void *data)
4513 {
4514     if (data == nullptr) {
4515         TELEPHONY_LOGE("NapiCallManager::NativeIsEmergencyPhoneNumber data is nullptr");
4516         NapiUtil::ThrowParameterError(env);
4517         return;
4518     }
4519     auto asyncContext = (UtilsAsyncContext *)data;
4520     if (!IsValidSlotId(asyncContext->slotId)) {
4521         TELEPHONY_LOGE("NativeIsEmergencyPhoneNumber slotId is invalid");
4522         asyncContext->errorCode = SLOT_ID_INVALID;
4523         return;
4524     }
4525     std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
4526     std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
4527     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(
4528         phoneNumber, asyncContext->slotId, asyncContext->enabled);
4529     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4530         asyncContext->resolved = TELEPHONY_SUCCESS;
4531     }
4532 }
4533 
NativeFormatPhoneNumber(napi_env env, void *data)4534 void NapiCallManager::NativeFormatPhoneNumber(napi_env env, void *data)
4535 {
4536     if (data == nullptr) {
4537         TELEPHONY_LOGE("NapiCallManager::NativeFormatPhoneNumber data is nullptr");
4538         NapiUtil::ThrowParameterError(env);
4539         return;
4540     }
4541     auto asyncContext = (UtilsAsyncContext *)data;
4542     std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
4543     std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
4544     std::u16string countryCode = Str8ToStr16(asyncContext->code);
4545     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumber(
4546         phoneNumber, countryCode, asyncContext->formatNumber);
4547     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4548         asyncContext->resolved = TELEPHONY_SUCCESS;
4549     }
4550 }
4551 
NativeFormatPhoneNumberToE164(napi_env env, void *data)4552 void NapiCallManager::NativeFormatPhoneNumberToE164(napi_env env, void *data)
4553 {
4554     if (data == nullptr) {
4555         TELEPHONY_LOGE("NapiCallManager::NativeFormatPhoneNumberToE164 data is nullptr");
4556         NapiUtil::ThrowParameterError(env);
4557         return;
4558     }
4559     auto asyncContext = (UtilsAsyncContext *)data;
4560     std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
4561     std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
4562     std::u16string countryCode = Str8ToStr16(asyncContext->code);
4563     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumberToE164(
4564         phoneNumber, countryCode, asyncContext->formatNumber);
4565     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4566         asyncContext->resolved = TELEPHONY_SUCCESS;
4567     }
4568 }
4569 
NativeSetMuted(napi_env env, void *data)4570 void NapiCallManager::NativeSetMuted(napi_env env, void *data)
4571 {
4572     if (data == nullptr) {
4573         TELEPHONY_LOGE("NapiCallManager::NativeSetMuted data is nullptr");
4574         NapiUtil::ThrowParameterError(env);
4575         return;
4576     }
4577     auto asyncContext = (AudioAsyncContext *)data;
4578     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(true);
4579     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4580         asyncContext->resolved = TELEPHONY_SUCCESS;
4581     }
4582 }
4583 
NativeCancelMuted(napi_env env, void *data)4584 void NapiCallManager::NativeCancelMuted(napi_env env, void *data)
4585 {
4586     if (data == nullptr) {
4587         TELEPHONY_LOGE("NapiCallManager::NativeCancelMuted data is nullptr");
4588         NapiUtil::ThrowParameterError(env);
4589         return;
4590     }
4591     auto asyncContext = (AudioAsyncContext *)data;
4592     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(false);
4593     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4594         asyncContext->resolved = TELEPHONY_SUCCESS;
4595     }
4596 }
4597 
NativeMuteRinger(napi_env env, void *data)4598 void NapiCallManager::NativeMuteRinger(napi_env env, void *data)
4599 {
4600     if (data == nullptr) {
4601         TELEPHONY_LOGE("NapiCallManager::NativeMuteRinger data is nullptr");
4602         NapiUtil::ThrowParameterError(env);
4603         return;
4604     }
4605     auto asyncContext = (AudioAsyncContext *)data;
4606     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->MuteRinger();
4607     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4608         asyncContext->resolved = TELEPHONY_SUCCESS;
4609     }
4610     asyncContext->eventId = CALL_MANAGER_MUTE_RINGER;
4611 }
4612 
NativeSetAudioDevice(napi_env env, void *data)4613 void NapiCallManager::NativeSetAudioDevice(napi_env env, void *data)
4614 {
4615     if (data == nullptr) {
4616         TELEPHONY_LOGE("NapiCallManager::NativeSetAudioDevice data is nullptr");
4617         NapiUtil::ThrowParameterError(env);
4618         return;
4619     }
4620     auto asyncContext = (AudioAsyncContext *)data;
4621     AudioDevice device;
4622     if (memset_s(&device, sizeof(AudioDevice), 0, sizeof(AudioDevice)) != EOK) {
4623         TELEPHONY_LOGE("memset_s fail");
4624         return;
4625     }
4626     device.deviceType = static_cast<AudioDeviceType>(asyncContext->deviceType);
4627     if (asyncContext->address.length() > kMaxAddressLen) {
4628         TELEPHONY_LOGE("address is not too long");
4629         return;
4630     }
4631     if (memcpy_s(device.address, kMaxAddressLen, asyncContext->address.c_str(), asyncContext->address.length()) !=
4632         EOK) {
4633         TELEPHONY_LOGE("memcpy_s address fail");
4634         return;
4635     }
4636     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetAudioDevice(device);
4637     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4638         asyncContext->resolved = TELEPHONY_SUCCESS;
4639     }
4640 }
4641 
NativeUpdateImsCallMode(napi_env env, void *data)4642 void NapiCallManager::NativeUpdateImsCallMode(napi_env env, void *data)
4643 {
4644     if (data == nullptr) {
4645         TELEPHONY_LOGE("NapiCallManager::NativeUpdateImsCallMode data is nullptr");
4646         NapiUtil::ThrowParameterError(env);
4647         return;
4648     }
4649     auto asyncContext = (SupplementAsyncContext *)data;
4650     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->UpdateImsCallMode(
4651         asyncContext->callId, (ImsCallMode)asyncContext->type);
4652     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4653         asyncContext->resolved = TELEPHONY_SUCCESS;
4654     }
4655 }
4656 
NativeControlCamera(napi_env env, void *data)4657 void NapiCallManager::NativeControlCamera(napi_env env, void *data)
4658 {
4659     if (data == nullptr) {
4660         TELEPHONY_LOGE("data is nullptr");
4661         return;
4662     }
4663     auto asyncContext = (VideoAsyncContext *)data;
4664     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->ControlCamera(
4665         asyncContext->callId, Str8ToStr16(asyncContext->cameraId));
4666     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4667         asyncContext->resolved = TELEPHONY_SUCCESS;
4668     }
4669 }
4670 
NativeSetPreviewWindow(napi_env env, void *data)4671 void NapiCallManager::NativeSetPreviewWindow(napi_env env, void *data)
4672 {
4673     if (data == nullptr) {
4674         TELEPHONY_LOGE("data is nullptr");
4675         return;
4676     }
4677     auto asyncContext = (VideoAsyncContext *)data;
4678     TELEPHONY_LOGI("surfaceId: %{public}s", asyncContext->surfaceId.c_str());
4679     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetPreviewWindow(
4680         asyncContext->callId, asyncContext->surfaceId);
4681     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4682         asyncContext->resolved = TELEPHONY_SUCCESS;
4683     }
4684 }
4685 
NativeSetDisplayWindow(napi_env env, void *data)4686 void NapiCallManager::NativeSetDisplayWindow(napi_env env, void *data)
4687 {
4688     if (data == nullptr) {
4689         TELEPHONY_LOGE("data is nullptr");
4690         return;
4691     }
4692     auto asyncContext = (VideoAsyncContext *)data;
4693     TELEPHONY_LOGI("surfaceId: %{public}s", asyncContext->surfaceId.c_str());
4694     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetDisplayWindow(
4695         asyncContext->callId, asyncContext->surfaceId);
4696     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4697         asyncContext->resolved = TELEPHONY_SUCCESS;
4698     }
4699 }
4700 
NativeSetCameraZoom(napi_env env, void *data)4701 void NapiCallManager::NativeSetCameraZoom(napi_env env, void *data)
4702 {
4703     if (data == nullptr) {
4704         TELEPHONY_LOGE("data is nullptr");
4705         return;
4706     }
4707     auto asyncContext = (VideoAsyncContext *)data;
4708     asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetCameraZoom(asyncContext->zoomRatio);
4709 }
4710 
NativeSetPausePicture(napi_env env, void *data)4711 void NapiCallManager::NativeSetPausePicture(napi_env env, void *data)
4712 {
4713     if (data == nullptr) {
4714         TELEPHONY_LOGE("data is nullptr");
4715         return;
4716     }
4717     auto asyncContext = (VideoAsyncContext *)data;
4718     asyncContext->errorCode =
4719         DelayedSingleton<CallManagerClient>::GetInstance()->SetPausePicture(
4720             asyncContext->callId, Str8ToStr16(asyncContext->path));
4721     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4722         asyncContext->resolved = TELEPHONY_SUCCESS;
4723     }
4724 }
4725 
NativeSetDeviceDirection(napi_env env, void *data)4726 void NapiCallManager::NativeSetDeviceDirection(napi_env env, void *data)
4727 {
4728     if (data == nullptr) {
4729         TELEPHONY_LOGE("data is nullptr");
4730         return;
4731     }
4732     auto asyncContext = (VideoAsyncContext *)data;
4733     asyncContext->errorCode =
4734         DelayedSingleton<CallManagerClient>::GetInstance()->SetDeviceDirection(
4735             asyncContext->callId, asyncContext->rotation);
4736     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4737         asyncContext->resolved = TELEPHONY_SUCCESS;
4738     }
4739 }
4740 
NativeRequestCameraCapabilities(napi_env env, void *data)4741 void NapiCallManager::NativeRequestCameraCapabilities(napi_env env, void *data)
4742 {
4743     if (data == nullptr) {
4744         TELEPHONY_LOGE("data is nullptr");
4745         return;
4746     }
4747     auto asyncContext = (AsyncContext *)data;
4748     asyncContext->resolved =
4749         DelayedSingleton<CallManagerClient>::GetInstance()->RequestCameraCapabilities(asyncContext->callId);
4750     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4751         asyncContext->resolved = TELEPHONY_SUCCESS;
4752     }
4753 }
4754 
NativeCancelCallUpgrade(napi_env env, void *data)4755 void NapiCallManager::NativeCancelCallUpgrade(napi_env env, void *data)
4756 {
4757     if (data == nullptr) {
4758         TELEPHONY_LOGE("NapiCallManager::NativeCancelCallUpgrade data is nullptr");
4759         NapiUtil::ThrowParameterError(env);
4760         return;
4761     }
4762     auto asyncContext = (AsyncContext *)data;
4763     asyncContext->errorCode =
4764         DelayedSingleton<CallManagerClient>::GetInstance()->CancelCallUpgrade(asyncContext->callId);
4765     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4766         asyncContext->resolved = TELEPHONY_SUCCESS;
4767     }
4768 }
4769 
NativeSetCallPreferenceMode(napi_env env, void *data)4770 void NapiCallManager::NativeSetCallPreferenceMode(napi_env env, void *data)
4771 {
4772     if (data == nullptr) {
4773         TELEPHONY_LOGE("data is nullptr");
4774         return;
4775     }
4776     auto asyncContext = (SupplementAsyncContext *)data;
4777     asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallPreferenceMode(
4778         asyncContext->callId, asyncContext->mode);
4779 }
4780 
NativeStartRTT(napi_env env, void *data)4781 void NapiCallManager::NativeStartRTT(napi_env env, void *data)
4782 {
4783     if (data == nullptr) {
4784         TELEPHONY_LOGE("data is nullptr");
4785         return;
4786     }
4787     auto startRTTContext = (SupplementAsyncContext *)data;
4788     EventCallback infoListener;
4789     infoListener.env = startRTTContext->env;
4790     infoListener.thisVar = startRTTContext->thisVar;
4791     infoListener.callbackRef = startRTTContext->callbackRef;
4792     infoListener.deferred = startRTTContext->deferred;
4793     startRTTContext->resolved =
4794         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterStartRttCallback(infoListener);
4795     if (startRTTContext->resolved != TELEPHONY_SUCCESS) {
4796         TELEPHONY_LOGE("RegisterStartRttCallback failed!");
4797         return;
4798     }
4799 
4800     std::u16string msg = Str8ToStr16(startRTTContext->content);
4801     startRTTContext->resolved =
4802         DelayedSingleton<CallManagerClient>::GetInstance()->StartRtt(startRTTContext->callId, msg);
4803     if (startRTTContext->resolved != TELEPHONY_SUCCESS) {
4804         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterStartRttCallback();
4805         TELEPHONY_LOGE("StartRtt failed!");
4806         return;
4807     }
4808     startRTTContext->callbackRef = nullptr;
4809     startRTTContext->deferred = nullptr;
4810 }
4811 
NativeStopRTT(napi_env env, void *data)4812 void NapiCallManager::NativeStopRTT(napi_env env, void *data)
4813 {
4814     if (data == nullptr) {
4815         TELEPHONY_LOGE("data is nullptr");
4816         return;
4817     }
4818     auto stopRTTContext = (SupplementAsyncContext *)data;
4819     EventCallback infoListener;
4820     infoListener.env = stopRTTContext->env;
4821     infoListener.thisVar = stopRTTContext->thisVar;
4822     infoListener.callbackRef = stopRTTContext->callbackRef;
4823     infoListener.deferred = stopRTTContext->deferred;
4824     stopRTTContext->resolved =
4825         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterStopRttCallback(infoListener);
4826     if (stopRTTContext->resolved != TELEPHONY_SUCCESS) {
4827         TELEPHONY_LOGE("RegisterStopRttCallback failed!");
4828         return;
4829     }
4830     stopRTTContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->StopRtt(stopRTTContext->callId);
4831     if (stopRTTContext->resolved != TELEPHONY_SUCCESS) {
4832         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterStopRttCallback();
4833         TELEPHONY_LOGE("StopRtt failed!");
4834         return;
4835     }
4836     stopRTTContext->callbackRef = nullptr;
4837     stopRTTContext->deferred = nullptr;
4838 }
4839 
NativeJoinConference(napi_env env, void *data)4840 void NapiCallManager::NativeJoinConference(napi_env env, void *data)
4841 {
4842     if (data == nullptr) {
4843         TELEPHONY_LOGE("NapiCallManager::NativeJoinConference data is nullptr");
4844         NapiUtil::ThrowParameterError(env);
4845         return;
4846     }
4847     auto asyncContext = (ListAsyncContext *)data;
4848     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->JoinConference(
4849         asyncContext->callId, asyncContext->listResult);
4850     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4851         asyncContext->resolved = TELEPHONY_SUCCESS;
4852     }
4853 }
4854 
NativeReportOttCallDetailsInfo(napi_env env, void *data)4855 void NapiCallManager::NativeReportOttCallDetailsInfo(napi_env env, void *data)
4856 {
4857     if (data == nullptr) {
4858         TELEPHONY_LOGE("data is nullptr");
4859         return;
4860     }
4861     auto asyncContext = (OttCallAsyncContext *)data;
4862     asyncContext->resolved =
4863         DelayedSingleton<CallManagerClient>::GetInstance()->ReportOttCallDetailsInfo(asyncContext->ottVec);
4864 }
4865 
NativeReportOttCallEventInfo(napi_env env, void *data)4866 void NapiCallManager::NativeReportOttCallEventInfo(napi_env env, void *data)
4867 {
4868     if (data == nullptr) {
4869         TELEPHONY_LOGE("data is nullptr");
4870         return;
4871     }
4872     auto asyncContext = (OttEventAsyncContext *)data;
4873     asyncContext->resolved =
4874         DelayedSingleton<CallManagerClient>::GetInstance()->ReportOttCallEventInfo(asyncContext->eventInfo);
4875 }
4876 
NativeCloseUnFinishedUssd(napi_env env, void *data)4877 void NapiCallManager::NativeCloseUnFinishedUssd(napi_env env, void *data)
4878 {
4879     if (data == nullptr) {
4880         TELEPHONY_LOGE("NapiCallManager::NativeCloseUnFinishedUssd data is nullptr");
4881         NapiUtil::ThrowParameterError(env);
4882         return;
4883     }
4884 
4885     SupplementAsyncContext *asyncContext = static_cast<SupplementAsyncContext *>(data);
4886     if (!IsValidSlotId(asyncContext->slotId)) {
4887         TELEPHONY_LOGE("NativeCloseUnFinishedUssd slotId is invalid");
4888         asyncContext->errorCode = SLOT_ID_INVALID;
4889         return;
4890     }
4891     EventCallback infoListener;
4892     infoListener.env = asyncContext->env;
4893     infoListener.thisVar = asyncContext->thisVar;
4894     infoListener.callbackRef = asyncContext->callbackRef;
4895     infoListener.deferred = asyncContext->deferred;
4896     asyncContext->errorCode =
4897         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCloseUnFinishedUssdCallback(infoListener);
4898     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4899         TELEPHONY_LOGE("RegisterSetWaitingCallback failed!");
4900         return;
4901     }
4902 
4903     asyncContext->errorCode =
4904         DelayedSingleton<CallManagerClient>::GetInstance()->CloseUnFinishedUssd(asyncContext->slotId);
4905     if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
4906         asyncContext->eventId = CALL_MANAGER_CLOSE_UNFINISHED_USSD;
4907         DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCloseUnFinishedUssdCallback();
4908         TELEPHONY_LOGE("NativeCloseUnFinishedUssd failed!");
4909         return;
4910     }
4911     asyncContext->resolved = TELEPHONY_SUCCESS;
4912     asyncContext->callbackRef = nullptr;
4913     asyncContext->deferred = nullptr;
4914 }
4915 
NativeInputDialerSpecialCode(napi_env env, void *data)4916 void NapiCallManager::NativeInputDialerSpecialCode(napi_env env, void *data)
4917 {
4918     if (data == nullptr) {
4919         TELEPHONY_LOGE("NapiCallManager::NativeInputDialerSpecialCode data is nullptr");
4920         NapiUtil::ThrowParameterError(env);
4921         return;
4922     }
4923     AsyncContext *asyncContext = static_cast<AsyncContext *>(data);
4924     std::string specialCode(asyncContext->number, asyncContext->numberLen);
4925     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->InputDialerSpecialCode(specialCode);
4926     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4927         asyncContext->resolved = TELEPHONY_SUCCESS;
4928     }
4929 }
4930 
NativeRemoveMissedIncomingCallNotification(napi_env env, void *data)4931 void NapiCallManager::NativeRemoveMissedIncomingCallNotification(napi_env env, void *data)
4932 {
4933     if (data == nullptr) {
4934         TELEPHONY_LOGE("NapiCallManager::NativeRemoveMissedIncomingCallNotification data is nullptr");
4935         NapiUtil::ThrowParameterError(env);
4936         return;
4937     }
4938     AsyncContext *asyncContext = static_cast<AsyncContext *>(data);
4939     asyncContext->errorCode =
4940         DelayedSingleton<CallManagerClient>::GetInstance()->RemoveMissedIncomingCallNotification();
4941     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4942         asyncContext->resolved = TELEPHONY_SUCCESS;
4943     }
4944 }
4945 
NativeSetVoIPCallState(napi_env env, void *data)4946 void NapiCallManager::NativeSetVoIPCallState(napi_env env, void *data)
4947 {
4948     if (data == nullptr) {
4949         TELEPHONY_LOGE("NapiCallManager::NativeSetVoIPCallState data is nullptr");
4950         NapiUtil::ThrowParameterError(env);
4951         return;
4952     }
4953     auto asyncContext = (VoIPCallStateAsyncContext *)data;
4954     asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetVoIPCallState(
4955         asyncContext->state);
4956     if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
4957         asyncContext->resolved = TELEPHONY_SUCCESS;
4958     }
4959     asyncContext->eventId = CALL_MANAGER_SET_VOIP_CALL_STATE;
4960 }
4961 
RegisterCallBack()4962 void NapiCallManager::RegisterCallBack()
4963 {
4964     if (registerStatus_ == TELEPHONY_SUCCESS) {
4965         TELEPHONY_LOGW("you are already registered!");
4966         return;
4967     }
4968     std::unique_ptr<NapiCallManagerCallback> callbackPtr = std::make_unique<NapiCallManagerCallback>();
4969     if (callbackPtr == nullptr) {
4970         TELEPHONY_LOGE("make_unique NapiCallManagerCallback failed!");
4971         return;
4972     }
4973     registerStatus_ = DelayedSingleton<CallManagerClient>::GetInstance()->RegisterCallBack(std::move(callbackPtr));
4974     if (registerStatus_ != TELEPHONY_SUCCESS) {
4975         TELEPHONY_LOGD("RegisterCallBack failed!");
4976         return;
4977     }
4978 }
4979 
HandleAsyncWork(napi_env env, AsyncContext *context, std::string workName, napi_async_execute_callback execute, napi_async_complete_callback complete)4980 napi_value NapiCallManager::HandleAsyncWork(napi_env env, AsyncContext *context, std::string workName,
4981     napi_async_execute_callback execute, napi_async_complete_callback complete)
4982 {
4983     TELEPHONY_LOGI("HandleAsyncWork start workName = %{public}s", workName.c_str());
4984     napi_value result = nullptr;
4985     if (context->callbackRef == nullptr) {
4986         napi_create_promise(env, &context->deferred, &result);
4987     } else {
4988         napi_get_undefined(env, &result);
4989     }
4990     napi_value resource = NapiCallManagerUtils::CreateUndefined(env);
4991     napi_value resourceName = nullptr;
4992     napi_create_string_utf8(env, workName.data(), NAPI_AUTO_LENGTH, &resourceName);
4993     napi_create_async_work(env, resource, resourceName, execute, complete, (void *)context, &context->work);
4994     napi_queue_async_work_with_qos(env, context->work, napi_qos_default);
4995     return result;
4996 }
4997 } // namespace Telephony
4998 } // namespace OHOS
4999