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