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