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