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