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, ¶meterCount, 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, ¶meterCount, 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, ¶meterCount, 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