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("getMainCallId", GetMainCallId),
86 DECLARE_NAPI_FUNCTION("getSubCallIdList", GetSubCallIdList),
87 DECLARE_NAPI_FUNCTION("getCallIdListForConference", GetCallIdListForConference),
88 };
89 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
90 return exports;
91 }
92
DeclareCallSupplementInterface(napi_env env,napi_value exports)93 napi_value NapiCallManager::DeclareCallSupplementInterface(napi_env env, napi_value exports)
94 {
95 napi_property_descriptor desc[] = {
96 DECLARE_NAPI_FUNCTION("getCallWaitingStatus", GetCallWaiting),
97 DECLARE_NAPI_FUNCTION("setCallWaiting", SetCallWaiting),
98 DECLARE_NAPI_FUNCTION("getCallRestrictionStatus", GetCallRestriction),
99 DECLARE_NAPI_FUNCTION("setCallRestriction", SetCallRestriction),
100 DECLARE_NAPI_FUNCTION("getCallTransferInfo", GetCallTransferInfo),
101 DECLARE_NAPI_FUNCTION("setCallTransfer", SetCallTransferInfo),
102 DECLARE_NAPI_FUNCTION("enableImsSwitch", EnableImsSwitch),
103 DECLARE_NAPI_FUNCTION("disableImsSwitch", DisableImsSwitch),
104 DECLARE_NAPI_FUNCTION("isImsSwitchEnabled", IsImsSwitchEnabled),
105 };
106 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
107 return exports;
108 }
109
DeclareCallExtendInterface(napi_env env,napi_value exports)110 napi_value NapiCallManager::DeclareCallExtendInterface(napi_env env, napi_value exports)
111 {
112 napi_property_descriptor desc[] = {
113 DECLARE_NAPI_FUNCTION("startDTMF", StartDTMF),
114 DECLARE_NAPI_FUNCTION("stopDTMF", StopDTMF),
115 DECLARE_NAPI_FUNCTION("getCallState", GetCallState),
116 DECLARE_NAPI_FUNCTION("isRinging", IsRinging),
117 DECLARE_NAPI_FUNCTION("hasCall", HasCall),
118 DECLARE_NAPI_FUNCTION("isNewCallAllowed", IsNewCallAllowed),
119 DECLARE_NAPI_FUNCTION("isInEmergencyCall", IsInEmergencyCall),
120 DECLARE_NAPI_FUNCTION("isEmergencyPhoneNumber", IsEmergencyPhoneNumber),
121 DECLARE_NAPI_FUNCTION("formatPhoneNumber", FormatPhoneNumber),
122 DECLARE_NAPI_FUNCTION("formatPhoneNumberToE164", FormatPhoneNumberToE164),
123 DECLARE_NAPI_FUNCTION("on", ObserverOn),
124 DECLARE_NAPI_FUNCTION("off", ObserverOff),
125 DECLARE_NAPI_FUNCTION("reportOttCallDetailsInfo", ReportOttCallDetailsInfo),
126 DECLARE_NAPI_FUNCTION("reportOttCallEventInfo", ReportOttCallEventInfo),
127 };
128 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
129 return exports;
130 }
131
DeclareCallMultimediaInterface(napi_env env,napi_value exports)132 napi_value NapiCallManager::DeclareCallMultimediaInterface(napi_env env, napi_value exports)
133 {
134 napi_property_descriptor desc[] = {
135 DECLARE_NAPI_FUNCTION("setMuted", SetMuted),
136 DECLARE_NAPI_FUNCTION("cancelMuted", CancelMuted),
137 DECLARE_NAPI_FUNCTION("muteRinger", MuteRinger),
138 DECLARE_NAPI_FUNCTION("setAudioDevice", SetAudioDevice),
139 DECLARE_NAPI_FUNCTION("controlCamera", ControlCamera),
140 DECLARE_NAPI_FUNCTION("setPreviewWindow", SetPreviewWindow),
141 DECLARE_NAPI_FUNCTION("setDisplayWindow", SetDisplayWindow),
142 DECLARE_NAPI_FUNCTION("setCameraZoom", SetCameraZoom),
143 DECLARE_NAPI_FUNCTION("setPausePicture", SetPausePicture),
144 DECLARE_NAPI_FUNCTION("setDeviceDirection", SetDeviceDirection),
145 };
146 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
147 return exports;
148 }
149
DeclareCallImsInterface(napi_env env,napi_value exports)150 napi_value NapiCallManager::DeclareCallImsInterface(napi_env env, napi_value exports)
151 {
152 napi_property_descriptor desc[] = {
153 DECLARE_NAPI_FUNCTION("startRTT", StartRTT),
154 DECLARE_NAPI_FUNCTION("stopRTT", StopRTT),
155 DECLARE_NAPI_FUNCTION("joinConference", JoinConference),
156 DECLARE_NAPI_FUNCTION("updateImsCallMode", UpdateImsCallMode),
157 };
158 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
159 return exports;
160 }
161
DeclareCallMediaEnum(napi_env env,napi_value exports)162 napi_value NapiCallManager::DeclareCallMediaEnum(napi_env env, napi_value exports)
163 {
164 napi_property_descriptor desc[] = {
165 // AudioDevice
166 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_EARPIECE",
167 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_EARPIECE))),
168 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_SPEAKER",
169 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_SPEAKER))),
170 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_WIRED_HEADSET",
171 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_WIRED_HEADSET))),
172 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_BLUETOOTH_SCO",
173 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_BLUETOOTH_SCO))),
174 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISABLE",
175 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_DISABLE))),
176 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_UNKNOWN",
177 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_UNKNOWN))),
178 // VideoStateType
179 DECLARE_NAPI_STATIC_PROPERTY(
180 "TYPE_VOICE", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VOICE))),
181 DECLARE_NAPI_STATIC_PROPERTY(
182 "TYPE_VIDEO", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VIDEO))),
183 // ImsCallMode
184 DECLARE_NAPI_STATIC_PROPERTY(
185 "CALL_MODE_AUDIO_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_AUDIO_ONLY)),
186 DECLARE_NAPI_STATIC_PROPERTY(
187 "CALL_MODE_SEND_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_SEND_ONLY)),
188 DECLARE_NAPI_STATIC_PROPERTY(
189 "CALL_MODE_RECEIVE_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_RECEIVE_ONLY)),
190 DECLARE_NAPI_STATIC_PROPERTY(
191 "CALL_MODE_SEND_RECEIVE", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_SEND_RECEIVE)),
192 DECLARE_NAPI_STATIC_PROPERTY(
193 "CALL_MODE_VIDEO_PAUSED", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_VIDEO_PAUSED)),
194 };
195 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
196 return exports;
197 }
198
DeclareCallDialEnum(napi_env env,napi_value exports)199 napi_value NapiCallManager::DeclareCallDialEnum(napi_env env, napi_value exports)
200 {
201 napi_property_descriptor desc[] = {
202 // DialScene
203 DECLARE_NAPI_STATIC_PROPERTY(
204 "CALL_NORMAL", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_NORMAL))),
205 DECLARE_NAPI_STATIC_PROPERTY("CALL_PRIVILEGED",
206 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_PRIVILEGED))),
207 DECLARE_NAPI_STATIC_PROPERTY(
208 "CALL_EMERGENCY", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_EMERGENCY))),
209 // CallType
210 DECLARE_NAPI_STATIC_PROPERTY(
211 "TYPE_CS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_CS))),
212 DECLARE_NAPI_STATIC_PROPERTY(
213 "TYPE_IMS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_IMS))),
214 DECLARE_NAPI_STATIC_PROPERTY(
215 "TYPE_OTT", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_OTT))),
216 DECLARE_NAPI_STATIC_PROPERTY(
217 "TYPE_ERR_CALL", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_ERR_CALL))),
218 // DialType
219 DECLARE_NAPI_STATIC_PROPERTY("DIAL_CARRIER_TYPE",
220 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE))),
221 DECLARE_NAPI_STATIC_PROPERTY("DIAL_VOICE_MAIL_TYPE",
222 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE))),
223 DECLARE_NAPI_STATIC_PROPERTY(
224 "DIAL_OTT_TYPE", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_OTT_TYPE))),
225 };
226 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
227 return exports;
228 }
229
DeclareCallStateEnum(napi_env env,napi_value exports)230 napi_value NapiCallManager::DeclareCallStateEnum(napi_env env, napi_value exports)
231 {
232 napi_property_descriptor desc[] = {
233 // TelCallState
234 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ACTIVE",
235 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE))),
236 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_HOLDING",
237 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_HOLDING))),
238 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DIALING",
239 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DIALING))),
240 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ALERTING",
241 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING))),
242 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_INCOMING",
243 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING))),
244 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_WAITING",
245 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_WAITING))),
246 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTED",
247 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED))),
248 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTING",
249 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTING))),
250 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_IDLE",
251 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE))),
252 // TelConferenceState
253 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_IDLE",
254 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_IDLE))),
255 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_ACTIVE",
256 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_ACTIVE))),
257 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_HOLDING",
258 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_HOLDING))),
259 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTING",
260 NapiCallManagerUtils::ToInt32Value(
261 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTING))),
262 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTED",
263 NapiCallManagerUtils::ToInt32Value(
264 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTED))),
265 // CallStateToApp
266 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_UNKNOWN",
267 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN))),
268 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_IDLE",
269 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_IDLE))),
270 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_RINGING",
271 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_RINGING))),
272 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_OFFHOOK",
273 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_OFFHOOK))),
274 };
275 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
276 return exports;
277 }
278
DeclareCallEventEnum(napi_env env,napi_value exports)279 napi_value NapiCallManager::DeclareCallEventEnum(napi_env env, napi_value exports)
280 {
281 napi_property_descriptor desc[] = {
282 // CallAbilityEventId
283 DECLARE_NAPI_STATIC_PROPERTY("EVENT_DIAL_NO_CARRIER",
284 NapiCallManagerUtils::ToInt32Value(
285 env, static_cast<int32_t>(CallAbilityEventId::EVENT_DIAL_NO_CARRIER))),
286 DECLARE_NAPI_STATIC_PROPERTY("EVENT_INVALID_FDN_NUMBER",
287 NapiCallManagerUtils::ToInt32Value(
288 env, static_cast<int32_t>(CallAbilityEventId::EVENT_INVALID_FDN_NUMBER))),
289 };
290 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
291 return exports;
292 }
293
DeclareCallRestrictionEnum(napi_env env,napi_value exports)294 napi_value NapiCallManager::DeclareCallRestrictionEnum(napi_env env, napi_value exports)
295 {
296 napi_property_descriptor desc[] = {
297 // CallRestrictionType
298 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_OUTGOING",
299 NapiCallManagerUtils::ToInt32Value(
300 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING))),
301 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL",
302 NapiCallManagerUtils::ToInt32Value(
303 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL))),
304 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME",
305 NapiCallManagerUtils::ToInt32Value(
306 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME))),
307 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_INCOMING",
308 NapiCallManagerUtils::ToInt32Value(
309 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING))),
310 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ROAMING_INCOMING",
311 NapiCallManagerUtils::ToInt32Value(
312 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ROAMING_INCOMING))),
313 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_CALLS",
314 NapiCallManagerUtils::ToInt32Value(
315 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS))),
316 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_OUTGOING_SERVICES",
317 NapiCallManagerUtils::ToInt32Value(
318 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_OUTGOING_SERVICES))),
319 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INCOMING_SERVICES",
320 NapiCallManagerUtils::ToInt32Value(
321 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INCOMING_SERVICES))),
322 // CallRestrictionMode
323 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_DEACTIVATION",
324 NapiCallManagerUtils::ToInt32Value(
325 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION))),
326 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_ACTIVATION",
327 NapiCallManagerUtils::ToInt32Value(
328 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_ACTIVATION))),
329 // RestrictionStatus
330 DECLARE_NAPI_STATIC_PROPERTY(
331 "RESTRICTION_DISABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_DISABLE)),
332 DECLARE_NAPI_STATIC_PROPERTY(
333 "RESTRICTION_ENABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_ENABLE)),
334 };
335 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
336 return exports;
337 }
338
DeclareCallWaitingEnum(napi_env env,napi_value exports)339 napi_value NapiCallManager::DeclareCallWaitingEnum(napi_env env, napi_value exports)
340 {
341 napi_property_descriptor desc[] = {
342 // CallWaitingStatus
343 DECLARE_NAPI_STATIC_PROPERTY(
344 "CALL_WAITING_DISABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_DISABLE)),
345 DECLARE_NAPI_STATIC_PROPERTY(
346 "CALL_WAITING_ENABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_ENABLE)),
347 };
348 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
349 return exports;
350 }
351
DeclareCallTransferEnum(napi_env env,napi_value exports)352 napi_value NapiCallManager::DeclareCallTransferEnum(napi_env env, napi_value exports)
353 {
354 napi_property_descriptor desc[] = {
355 // TransferStatus
356 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_DISABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_DISABLE)),
357 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_ENABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_ENABLE)),
358 // CallTransferType
359 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_UNCONDITIONAL",
360 NapiCallManagerUtils::ToInt32Value(
361 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL))),
362 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_BUSY",
363 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY))),
364 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NO_REPLY",
365 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY))),
366 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NOT_REACHABLE",
367 NapiCallManagerUtils::ToInt32Value(
368 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE))),
369 // CallTransferSettingType
370 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ENABLE",
371 NapiCallManagerUtils::ToInt32Value(
372 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ENABLE))),
373 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_DISABLE",
374 NapiCallManagerUtils::ToInt32Value(
375 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_DISABLE))),
376 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_REGISTRATION",
377 NapiCallManagerUtils::ToInt32Value(
378 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_REGISTRATION))),
379 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ERASURE",
380 NapiCallManagerUtils::ToInt32Value(
381 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ERASURE))),
382 };
383 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
384 return exports;
385 }
386
387 /**
388 * Enumeration type extension.
389 */
DeclareAudioDeviceEnum(napi_env env,napi_value exports)390 napi_value NapiCallManager::DeclareAudioDeviceEnum(napi_env env, napi_value exports)
391 {
392 // AudioDevice
393 napi_property_descriptor desc[] = {
394 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_EARPIECE",
395 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_EARPIECE))),
396 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_SPEAKER",
397 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_SPEAKER))),
398 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_WIRED_HEADSET",
399 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_WIRED_HEADSET))),
400 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_BLUETOOTH_SCO",
401 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_BLUETOOTH_SCO))),
402 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_DISABLE",
403 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_DISABLE))),
404 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_UNKNOWN",
405 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(AudioDevice::DEVICE_UNKNOWN))),
406 };
407 napi_value result = nullptr;
408 napi_define_class(env, "AudioDevice", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
409 sizeof(desc) / sizeof(*desc), desc, &result);
410 napi_set_named_property(env, exports, "AudioDevice", result);
411 return exports;
412 }
413
DeclareVideoStateTypeEnum(napi_env env,napi_value exports)414 napi_value NapiCallManager::DeclareVideoStateTypeEnum(napi_env env, napi_value exports)
415 {
416 napi_property_descriptor desc[] = {
417 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VOICE",
418 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VOICE))),
419 DECLARE_NAPI_STATIC_PROPERTY("TYPE_VIDEO",
420 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(VideoStateType::TYPE_VIDEO))),
421 };
422 napi_value result = nullptr;
423 napi_define_class(env, "VideoStateType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
424 nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
425 napi_set_named_property(env, exports, "VideoStateType", result);
426 return exports;
427 }
428
DeclareImsCallModeEnum(napi_env env,napi_value exports)429 napi_value NapiCallManager::DeclareImsCallModeEnum(napi_env env, napi_value exports)
430 {
431 napi_property_descriptor desc[] = {
432 DECLARE_NAPI_STATIC_PROPERTY(
433 "CALL_MODE_AUDIO_ONLY", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_AUDIO_ONLY)),
434 DECLARE_NAPI_STATIC_PROPERTY(
435 "CALL_MODE_SEND_RECEIVE", NapiCallManagerUtils::ToInt32Value(env, CALL_MODE_SEND_RECEIVE)),
436 };
437 napi_value result = nullptr;
438 napi_define_class(env, "ImsCallMode", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
439 sizeof(desc) / sizeof(*desc), desc, &result);
440 napi_set_named_property(env, exports, "ImsCallMode", result);
441 return exports;
442 }
443
DeclareDialSceneEnum(napi_env env,napi_value exports)444 napi_value NapiCallManager::DeclareDialSceneEnum(napi_env env, napi_value exports)
445 {
446 napi_property_descriptor desc[] = {
447 DECLARE_NAPI_STATIC_PROPERTY(
448 "CALL_NORMAL", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_NORMAL))),
449 DECLARE_NAPI_STATIC_PROPERTY("CALL_PRIVILEGED",
450 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_PRIVILEGED))),
451 DECLARE_NAPI_STATIC_PROPERTY("CALL_EMERGENCY",
452 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialScene::CALL_EMERGENCY))),
453 };
454 napi_value result = nullptr;
455 napi_define_class(env, "DialScene", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
456 sizeof(desc) / sizeof(*desc), desc, &result);
457 napi_set_named_property(env, exports, "DialScene", result);
458 return exports;
459 }
460
DeclareCallTypeEnum(napi_env env,napi_value exports)461 napi_value NapiCallManager::DeclareCallTypeEnum(napi_env env, napi_value exports)
462 {
463 napi_property_descriptor desc[] = {
464 DECLARE_NAPI_STATIC_PROPERTY(
465 "TYPE_CS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_CS))),
466 DECLARE_NAPI_STATIC_PROPERTY(
467 "TYPE_IMS", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_IMS))),
468 DECLARE_NAPI_STATIC_PROPERTY(
469 "TYPE_OTT", NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_OTT))),
470 DECLARE_NAPI_STATIC_PROPERTY("TYPE_ERR_CALL",
471 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallType::TYPE_ERR_CALL))),
472 };
473 napi_value result = nullptr;
474 napi_define_class(env, "CallType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
475 sizeof(desc) / sizeof(*desc), desc, &result);
476 napi_set_named_property(env, exports, "CallType", result);
477 return exports;
478 }
479
DeclareDialTypeEnum(napi_env env,napi_value exports)480 napi_value NapiCallManager::DeclareDialTypeEnum(napi_env env, napi_value exports)
481 {
482 napi_property_descriptor desc[] = {
483 DECLARE_NAPI_STATIC_PROPERTY("DIAL_CARRIER_TYPE",
484 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE))),
485 DECLARE_NAPI_STATIC_PROPERTY("DIAL_VOICE_MAIL_TYPE",
486 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE))),
487 DECLARE_NAPI_STATIC_PROPERTY("DIAL_OTT_TYPE",
488 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(DialType::DIAL_OTT_TYPE))),
489 };
490 napi_value result = nullptr;
491 napi_define_class(env, "DialType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
492 sizeof(desc) / sizeof(*desc), desc, &result);
493 napi_set_named_property(env, exports, "DialType", result);
494 return exports;
495 }
496
DeclareTelCallStateEnum(napi_env env,napi_value exports)497 napi_value NapiCallManager::DeclareTelCallStateEnum(napi_env env, napi_value exports)
498 {
499 napi_property_descriptor desc[] = {
500 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ACTIVE",
501 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE))),
502 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_HOLDING",
503 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_HOLDING))),
504 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DIALING",
505 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DIALING))),
506 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_ALERTING",
507 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING))),
508 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_INCOMING",
509 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING))),
510 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_WAITING",
511 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_WAITING))),
512 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTED",
513 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED))),
514 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_DISCONNECTING",
515 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTING))),
516 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATUS_IDLE",
517 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE))),
518 };
519 napi_value result = nullptr;
520 napi_define_class(env, "TelCallState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
521 sizeof(desc) / sizeof(*desc), desc, &result);
522 napi_set_named_property(env, exports, "TelCallState", result);
523 return exports;
524 }
525
DeclareConferenceStateEnum(napi_env env,napi_value exports)526 napi_value NapiCallManager::DeclareConferenceStateEnum(napi_env env, napi_value exports)
527 {
528 napi_property_descriptor desc[] = {
529 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_IDLE",
530 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_IDLE))),
531 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_ACTIVE",
532 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_ACTIVE))),
533 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_HOLDING",
534 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_HOLDING))),
535 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTING",
536 NapiCallManagerUtils::ToInt32Value(
537 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTING))),
538 DECLARE_NAPI_STATIC_PROPERTY("TEL_CONFERENCE_DISCONNECTED",
539 NapiCallManagerUtils::ToInt32Value(
540 env, static_cast<int32_t>(TelConferenceState::TEL_CONFERENCE_DISCONNECTED))),
541 };
542 napi_value result = nullptr;
543 napi_define_class(env, "TelConferenceState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
544 sizeof(desc) / sizeof(*desc), desc, &result);
545 napi_set_named_property(env, exports, "TelConferenceState", result);
546 return exports;
547 }
548
DeclareCallStateToAppEnum(napi_env env,napi_value exports)549 napi_value NapiCallManager::DeclareCallStateToAppEnum(napi_env env, napi_value exports)
550 {
551 napi_property_descriptor desc[] = {
552 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_UNKNOWN",
553 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN))),
554 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_IDLE",
555 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_IDLE))),
556 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_RINGING",
557 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_RINGING))),
558 DECLARE_NAPI_STATIC_PROPERTY("CALL_STATE_OFFHOOK",
559 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallStateToApp::CALL_STATE_OFFHOOK))),
560 };
561 napi_value result = nullptr;
562 napi_define_class(env, "CallState", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
563 sizeof(desc) / sizeof(*desc), desc, &result);
564 napi_set_named_property(env, exports, "CallState", result);
565 return exports;
566 }
567
DeclareCallEventEnumEx(napi_env env,napi_value exports)568 napi_value NapiCallManager::DeclareCallEventEnumEx(napi_env env, napi_value exports)
569 {
570 napi_property_descriptor desc[] = {
571 // CallAbilityEventId
572 DECLARE_NAPI_STATIC_PROPERTY("EVENT_DIAL_NO_CARRIER",
573 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallAbilityEventId::EVENT_DIAL_NO_CARRIER))),
574 DECLARE_NAPI_STATIC_PROPERTY("EVENT_INVALID_FDN_NUMBER",
575 NapiCallManagerUtils::ToInt32Value(
576 env, static_cast<int32_t>(CallAbilityEventId::EVENT_INVALID_FDN_NUMBER))),
577 };
578 napi_value result = nullptr;
579 napi_define_class(env, "CallAbilityEventId", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
580 sizeof(desc) / sizeof(*desc), desc, &result);
581 napi_set_named_property(env, exports, "CallAbilityEventId", result);
582 return exports;
583 }
584
DeclareRestrictionTypeEnum(napi_env env,napi_value exports)585 napi_value NapiCallManager::DeclareRestrictionTypeEnum(napi_env env, napi_value exports)
586 {
587 napi_property_descriptor desc[] = {
588 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_OUTGOING",
589 NapiCallManagerUtils::ToInt32Value(
590 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING))),
591 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL",
592 NapiCallManagerUtils::ToInt32Value(
593 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL))),
594 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME",
595 NapiCallManagerUtils::ToInt32Value(
596 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME))),
597 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_INCOMING",
598 NapiCallManagerUtils::ToInt32Value(
599 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING))),
600 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ROAMING_INCOMING",
601 NapiCallManagerUtils::ToInt32Value(
602 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ROAMING_INCOMING))),
603 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_ALL_CALLS",
604 NapiCallManagerUtils::ToInt32Value(
605 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS))),
606 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_OUTGOING_SERVICES",
607 NapiCallManagerUtils::ToInt32Value(
608 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_OUTGOING_SERVICES))),
609 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_TYPE_INCOMING_SERVICES",
610 NapiCallManagerUtils::ToInt32Value(
611 env, static_cast<int32_t>(CallRestrictionType::RESTRICTION_TYPE_INCOMING_SERVICES))),
612 };
613 napi_value result = nullptr;
614 napi_define_class(env, "CallRestrictionType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
615 nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
616 napi_set_named_property(env, exports, "CallRestrictionType", result);
617 return exports;
618 }
619
DeclareRestrictionModeEnum(napi_env env,napi_value exports)620 napi_value NapiCallManager::DeclareRestrictionModeEnum(napi_env env, napi_value exports)
621 {
622 napi_property_descriptor desc[] = {
623 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_DEACTIVATION",
624 NapiCallManagerUtils::ToInt32Value(
625 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION))),
626 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_MODE_ACTIVATION",
627 NapiCallManagerUtils::ToInt32Value(
628 env, static_cast<int32_t>(CallRestrictionMode::RESTRICTION_MODE_ACTIVATION))),
629 };
630 napi_value result = nullptr;
631 napi_define_class(env, "CallRestrictionMode", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
632 nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
633 napi_set_named_property(env, exports, "CallRestrictionMode", result);
634 return exports;
635 }
636
DeclareRestrictionStatusEnum(napi_env env,napi_value exports)637 napi_value NapiCallManager::DeclareRestrictionStatusEnum(napi_env env, napi_value exports)
638 {
639 napi_property_descriptor desc[] = {
640 DECLARE_NAPI_STATIC_PROPERTY(
641 "RESTRICTION_DISABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_DISABLE)),
642 DECLARE_NAPI_STATIC_PROPERTY("RESTRICTION_ENABLE", NapiCallManagerUtils::ToInt32Value(env, RESTRICTION_ENABLE)),
643 };
644 napi_value result = nullptr;
645 napi_define_class(env, "RestrictionStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
646 sizeof(desc) / sizeof(*desc), desc, &result);
647 napi_set_named_property(env, exports, "RestrictionStatus", result);
648 return exports;
649 }
650
DeclareCallWaitingEnumEx(napi_env env,napi_value exports)651 napi_value NapiCallManager::DeclareCallWaitingEnumEx(napi_env env, napi_value exports)
652 {
653 napi_property_descriptor desc[] = {
654 DECLARE_NAPI_STATIC_PROPERTY(
655 "CALL_WAITING_DISABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_DISABLE)),
656 DECLARE_NAPI_STATIC_PROPERTY(
657 "CALL_WAITING_ENABLE", NapiCallManagerUtils::ToInt32Value(env, CALL_WAITING_ENABLE)),
658 };
659 napi_value result = nullptr;
660 napi_define_class(env, "CallWaitingStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
661 sizeof(desc) / sizeof(*desc), desc, &result);
662 napi_set_named_property(env, exports, "CallWaitingStatus", result);
663 return exports;
664 }
665
DeclareTransferStatusEnum(napi_env env,napi_value exports)666 napi_value NapiCallManager::DeclareTransferStatusEnum(napi_env env, napi_value exports)
667 {
668 napi_property_descriptor desc[] = {
669 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_DISABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_DISABLE)),
670 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_ENABLE", NapiCallManagerUtils::ToInt32Value(env, TRANSFER_ENABLE)),
671 };
672 napi_value result = nullptr;
673 napi_define_class(env, "TransferStatus", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
674 sizeof(desc) / sizeof(*desc), desc, &result);
675 napi_set_named_property(env, exports, "TransferStatus", result);
676 return exports;
677 }
678
DeclareTransferTypeEnum(napi_env env,napi_value exports)679 napi_value NapiCallManager::DeclareTransferTypeEnum(napi_env env, napi_value exports)
680 {
681 napi_property_descriptor desc[] = {
682 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_UNCONDITIONAL",
683 NapiCallManagerUtils::ToInt32Value(
684 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL))),
685 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_BUSY",
686 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY))),
687 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NO_REPLY",
688 NapiCallManagerUtils::ToInt32Value(env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY))),
689 DECLARE_NAPI_STATIC_PROPERTY("TRANSFER_TYPE_NOT_REACHABLE",
690 NapiCallManagerUtils::ToInt32Value(
691 env, static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE))),
692 };
693 napi_value result = nullptr;
694 napi_define_class(env, "CallTransferType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor, nullptr,
695 sizeof(desc) / sizeof(*desc), desc, &result);
696 napi_set_named_property(env, exports, "CallTransferType", result);
697 return exports;
698 }
699
DeclareTransferSettingTypeEnum(napi_env env,napi_value exports)700 napi_value NapiCallManager::DeclareTransferSettingTypeEnum(napi_env env, napi_value exports)
701 {
702 napi_property_descriptor desc[] = {
703 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ENABLE",
704 NapiCallManagerUtils::ToInt32Value(
705 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ENABLE))),
706 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_DISABLE",
707 NapiCallManagerUtils::ToInt32Value(
708 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_DISABLE))),
709 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_REGISTRATION",
710 NapiCallManagerUtils::ToInt32Value(
711 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_REGISTRATION))),
712 DECLARE_NAPI_STATIC_PROPERTY("CALL_TRANSFER_ERASURE",
713 NapiCallManagerUtils::ToInt32Value(
714 env, static_cast<int32_t>(CallTransferSettingType::CALL_TRANSFER_ERASURE))),
715 };
716 napi_value result = nullptr;
717 napi_define_class(env, "CallTransferSettingType", NAPI_AUTO_LENGTH, NapiCallManagerUtils::CreateEnumConstructor,
718 nullptr, sizeof(desc) / sizeof(*desc), desc, &result);
719 napi_set_named_property(env, exports, "CallTransferSettingType", result);
720 return exports;
721 }
722
723 /**
724 * The call_manager is initialized.
725 */
RegisterCallManagerFunc(napi_env env,napi_value exports)726 napi_value NapiCallManager::RegisterCallManagerFunc(napi_env env, napi_value exports)
727 {
728 // Interface initialization
729 DeclareCallBasisInterface(env, exports);
730 DeclareCallConferenceInterface(env, exports);
731 DeclareCallSupplementInterface(env, exports);
732 DeclareCallExtendInterface(env, exports);
733 DeclareCallMultimediaInterface(env, exports);
734 // Enumeration class initialization
735 DeclareCallMediaEnum(env, exports);
736 DeclareCallDialEnum(env, exports);
737 DeclareCallStateEnum(env, exports);
738 DeclareCallEventEnum(env, exports);
739 DeclareCallRestrictionEnum(env, exports);
740 DeclareCallWaitingEnum(env, exports);
741 DeclareCallTransferEnum(env, exports);
742 DeclareCallImsInterface(env, exports);
743 // Enumeration class extension initialization
744 DeclareAudioDeviceEnum(env, exports);
745 DeclareVideoStateTypeEnum(env, exports);
746 DeclareImsCallModeEnum(env, exports);
747 DeclareDialSceneEnum(env, exports);
748 DeclareCallTypeEnum(env, exports);
749 DeclareDialTypeEnum(env, exports);
750 DeclareTelCallStateEnum(env, exports);
751 DeclareConferenceStateEnum(env, exports);
752 DeclareCallStateToAppEnum(env, exports);
753 DeclareCallEventEnumEx(env, exports);
754 DeclareRestrictionTypeEnum(env, exports);
755 DeclareRestrictionModeEnum(env, exports);
756 DeclareRestrictionStatusEnum(env, exports);
757 DeclareCallWaitingEnumEx(env, exports);
758 DeclareTransferStatusEnum(env, exports);
759 DeclareTransferTypeEnum(env, exports);
760 DeclareTransferSettingTypeEnum(env, exports);
761 Init();
762 RegisterCallBack();
763 return exports;
764 }
765
Dial(napi_env env,napi_callback_info info)766 napi_value NapiCallManager::Dial(napi_env env, napi_callback_info info)
767 {
768 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
769 NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
770 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string);
771 NAPI_ASSERT(env, matchFlag, "Dial type error, should be string type");
772 auto asyncContext = (std::make_unique<DialAsyncContext>());
773 if (asyncContext == nullptr) {
774 std::string errorCode = std::to_string(napi_generic_failure);
775 std::string errorMessage = "Dial error at baseContext is nullptr";
776 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
777 return nullptr;
778 }
779 napi_get_value_string_utf8(
780 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
781 if (argc == TWO_VALUE_LIMIT) {
782 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
783 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
784 } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_object)) {
785 GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
786 }
787 } else if (argc == VALUE_MAXIMUM_LIMIT &&
788 NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_object)) {
789 GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
790 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
791 }
792 return HandleAsyncWork(env, asyncContext.release(), "Dial", NativeDial, NativeDialCallBack);
793 }
794
MatchStringAndVariableObjectParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)795 bool NapiCallManager::MatchStringAndVariableObjectParameters(
796 napi_env env, const napi_value parameters[], const size_t parameterCount)
797 {
798 TELEPHONY_LOGI("Telephony_CallManager MatchStringAndVariableObjectParameters %{public}zu", parameterCount);
799 switch (parameterCount) {
800 case ONLY_ONE_VALUE:
801 return NapiUtil::MatchParameters(env, parameters, { napi_string });
802 case TWO_VALUE_LIMIT:
803 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_function }) ||
804 NapiUtil::MatchParameters(env, parameters, { napi_string, napi_object });
805 case VALUE_MAXIMUM_LIMIT:
806 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_object, napi_function });
807 default:
808 return false;
809 }
810 }
811
DialCall(napi_env env,napi_callback_info info)812 napi_value NapiCallManager::DialCall(napi_env env, napi_callback_info info)
813 {
814 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
815 if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
816 TELEPHONY_LOGE("NapiCallManager::DialCall MatchStringAndVariableObjectParameters failed.");
817 NapiUtil::ThrowParameterError(env);
818 return nullptr;
819 }
820 auto asyncContext = (std::make_unique<DialAsyncContext>());
821 if (asyncContext == nullptr) {
822 NapiUtil::ThrowParameterError(env);
823 TELEPHONY_LOGE("NapiCallManager::DialCall asyncContext is nullptr.");
824 return nullptr;
825 }
826 napi_get_value_string_utf8(
827 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
828 if (argc == TWO_VALUE_LIMIT) {
829 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
830 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
831 } else {
832 GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
833 }
834 } else {
835 GetDialInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
836 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
837 }
838 return HandleAsyncWork(env, asyncContext.release(), "DialCall", NativeDialCall, NativeVoidCallBackWithErrorCode);
839 }
840
MakeCall(napi_env env,napi_callback_info info)841 napi_value NapiCallManager::MakeCall(napi_env env, napi_callback_info info)
842 {
843 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
844 if (!MatchOneStringParameter(env, argv, argc)) {
845 TELEPHONY_LOGE("NapiCallManager::MakeCall MatchOneStringParameter failed.");
846 NapiUtil::ThrowParameterError(env);
847 return nullptr;
848 }
849 auto asyncContext = std::make_unique<AsyncContext>();
850 if (asyncContext == nullptr) {
851 NapiUtil::ThrowParameterError(env);
852 return nullptr;
853 }
854 napi_get_value_string_utf8(
855 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
856 if (argc == TWO_VALUE_LIMIT) {
857 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
858 }
859 return HandleAsyncWork(env, asyncContext.release(), "MakeCall", NativeMakeCall, NativeVoidCallBackWithErrorCode);
860 }
861
AnswerCall(napi_env env,napi_callback_info info)862 napi_value NapiCallManager::AnswerCall(napi_env env, napi_callback_info info)
863 {
864 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
865 if (!MatchOneOptionalNumberParameter(env, argv, argc)) {
866 TELEPHONY_LOGE("NapiCallManager::AnswerCall MatchOneOptionalNumberParameter failed.");
867 NapiUtil::ThrowParameterError(env);
868 return nullptr;
869 }
870 auto asyncContext = std::make_unique<AnswerAsyncContext>();
871 if (asyncContext == nullptr) {
872 TELEPHONY_LOGE("NapiCallManager::AnswerCall asyncContext is nullptr.");
873 NapiUtil::ThrowParameterError(env);
874 return nullptr;
875 }
876
877 if (argc == ZERO_VALUE) {
878 TELEPHONY_LOGI("no param input");
879 } else if (argc == ONLY_ONE_VALUE) {
880 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_function)) {
881 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
882 } else {
883 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
884 }
885 } else {
886 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
887 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
888 }
889
890 return HandleAsyncWork(
891 env, asyncContext.release(), "AnswerCall", NativeAnswerCall, NativeVoidCallBackWithErrorCode);
892 }
893
RejectCall(napi_env env,napi_callback_info info)894 napi_value NapiCallManager::RejectCall(napi_env env, napi_callback_info info)
895 {
896 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
897 if (!MatchRejectCallParameters(env, argv, argc)) {
898 TELEPHONY_LOGE("NapiCallManager::RejectCall MatchRejectCallParameters failed.");
899 NapiUtil::ThrowParameterError(env);
900 return nullptr;
901 }
902 auto asyncContext = std::make_unique<RejectAsyncContext>();
903 if (asyncContext == nullptr) {
904 TELEPHONY_LOGE("NapiCallManager::RejectCall asyncContext is nullptr.");
905 NapiUtil::ThrowParameterError(env);
906 return nullptr;
907 }
908 asyncContext->isSendSms = false;
909 if (argc == ZERO_VALUE) {
910 TELEPHONY_LOGI("NapiCallManager::RejectCall no param input.");
911 } else if (argc == ONLY_ONE_VALUE) {
912 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_function)) {
913 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
914 } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number)) {
915 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
916 } else {
917 GetSmsInfo(env, argv[ARRAY_INDEX_FIRST], *asyncContext);
918 }
919 } else if (argc == TWO_VALUE_LIMIT) {
920 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_object) &&
921 NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
922 GetSmsInfo(env, argv[ARRAY_INDEX_FIRST], *asyncContext);
923 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
924 } else if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number) &&
925 NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
926 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
927 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
928 } else {
929 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
930 GetSmsInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
931 }
932 } else {
933 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
934 GetSmsInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
935 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
936 }
937
938 return HandleAsyncWork(
939 env, asyncContext.release(), "RejectCall", NativeRejectCall, NativeVoidCallBackWithErrorCode);
940 }
941
HangUpCall(napi_env env,napi_callback_info info)942 napi_value NapiCallManager::HangUpCall(napi_env env, napi_callback_info info)
943 {
944 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
945 if (!MatchOneOptionalNumberParameter(env, argv, argc)) {
946 TELEPHONY_LOGE("NapiCallManager::HangUpCall MatchOneOptionalNumberParameter failed.");
947 NapiUtil::ThrowParameterError(env);
948 return nullptr;
949 }
950 auto asyncContext = std::make_unique<AsyncContext>();
951 if (asyncContext == nullptr) {
952 TELEPHONY_LOGE("NapiCallManager::HangUpCall asyncContext is nullptr.");
953 NapiUtil::ThrowParameterError(env);
954 return nullptr;
955 }
956
957 if (argc == ZERO_VALUE) {
958 TELEPHONY_LOGI("no param input");
959 } else if (argc == ONLY_ONE_VALUE) {
960 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_function)) {
961 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
962 } else {
963 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
964 }
965 } else {
966 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
967 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
968 }
969
970 return HandleAsyncWork(
971 env, asyncContext.release(), "HangUpCall", NativeHangUpCall, NativeVoidCallBackWithErrorCode);
972 }
973
HoldCall(napi_env env,napi_callback_info info)974 napi_value NapiCallManager::HoldCall(napi_env env, napi_callback_info info)
975 {
976 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
977 if (!MatchOneNumberParameter(env, argv, argc)) {
978 TELEPHONY_LOGE("NapiCallManager::HoldCall MatchOneNumberParameter failed.");
979 NapiUtil::ThrowParameterError(env);
980 return nullptr;
981 }
982 auto asyncContext = std::make_unique<AsyncContext>();
983 if (asyncContext == nullptr) {
984 TELEPHONY_LOGE("NapiCallManager::HoldCall asyncContext is nullptr.");
985 NapiUtil::ThrowParameterError(env);
986 return nullptr;
987 }
988 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
989 if (argc == TWO_VALUE_LIMIT) {
990 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
991 }
992 return HandleAsyncWork(env, asyncContext.release(), "HoldCall", NativeHoldCall, NativeVoidCallBackWithErrorCode);
993 }
994
UnHoldCall(napi_env env,napi_callback_info info)995 napi_value NapiCallManager::UnHoldCall(napi_env env, napi_callback_info info)
996 {
997 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
998 if (!MatchOneNumberParameter(env, argv, argc)) {
999 TELEPHONY_LOGE("NapiCallManager::UnHoldCall MatchOneNumberParameter failed.");
1000 NapiUtil::ThrowParameterError(env);
1001 return nullptr;
1002 }
1003 auto asyncContext = std::make_unique<AsyncContext>();
1004 if (asyncContext == nullptr) {
1005 TELEPHONY_LOGE("NapiCallManager::UnHoldCall asyncContext is nullptr.");
1006 NapiUtil::ThrowParameterError(env);
1007 return nullptr;
1008 }
1009 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1010 if (argc == TWO_VALUE_LIMIT) {
1011 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1012 }
1013 return HandleAsyncWork(
1014 env, asyncContext.release(), "UnHoldCall", NativeUnHoldCall, NativeVoidCallBackWithErrorCode);
1015 }
1016
SwitchCall(napi_env env,napi_callback_info info)1017 napi_value NapiCallManager::SwitchCall(napi_env env, napi_callback_info info)
1018 {
1019 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1020 if (!MatchOneNumberParameter(env, argv, argc)) {
1021 TELEPHONY_LOGE("NapiCallManager::SwitchCall MatchOneNumberParameter failed.");
1022 NapiUtil::ThrowParameterError(env);
1023 return nullptr;
1024 }
1025 auto asyncContext = std::make_unique<AsyncContext>();
1026 if (asyncContext == nullptr) {
1027 TELEPHONY_LOGE("NapiCallManager::SwitchCall asyncContext is nullptr.");
1028 NapiUtil::ThrowParameterError(env);
1029 return nullptr;
1030 }
1031 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1032 if (argc == TWO_VALUE_LIMIT) {
1033 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1034 }
1035
1036 return HandleAsyncWork(
1037 env, asyncContext.release(), "SwitchCall", NativeSwitchCall, NativeVoidCallBackWithErrorCode);
1038 }
1039
CombineConference(napi_env env,napi_callback_info info)1040 napi_value NapiCallManager::CombineConference(napi_env env, napi_callback_info info)
1041 {
1042 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1043 if (!MatchOneNumberParameter(env, argv, argc)) {
1044 TELEPHONY_LOGE("NapiCallManager::CombineConference MatchOneNumberParameter failed.");
1045 NapiUtil::ThrowParameterError(env);
1046 return nullptr;
1047 }
1048 auto asyncContext = std::make_unique<AsyncContext>();
1049 if (asyncContext == nullptr) {
1050 TELEPHONY_LOGE("NapiCallManager::CombineConference asyncContext is nullptr.");
1051 NapiUtil::ThrowParameterError(env);
1052 return nullptr;
1053 }
1054 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1055 if (argc == TWO_VALUE_LIMIT) {
1056 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1057 }
1058
1059 return HandleAsyncWork(
1060 env, asyncContext.release(), "CombineConference", NativeCombineConference, NativeVoidCallBackWithErrorCode);
1061 }
1062
SeparateConference(napi_env env,napi_callback_info info)1063 napi_value NapiCallManager::SeparateConference(napi_env env, napi_callback_info info)
1064 {
1065 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1066 if (!MatchOneNumberParameter(env, argv, argc)) {
1067 TELEPHONY_LOGE("NapiCallManager::SeparateConference MatchOneNumberParameter failed.");
1068 NapiUtil::ThrowParameterError(env);
1069 return nullptr;
1070 }
1071 auto asyncContext = std::make_unique<AsyncContext>();
1072 if (asyncContext == nullptr) {
1073 TELEPHONY_LOGE("NapiCallManager::SeparateConference asyncContext is nullptr.");
1074 NapiUtil::ThrowParameterError(env);
1075 return nullptr;
1076 }
1077 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1078 if (argc == TWO_VALUE_LIMIT) {
1079 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1080 }
1081 return HandleAsyncWork(
1082 env, asyncContext.release(), "SeparateConference", NativeSeparateConference, NativeVoidCallBackWithErrorCode);
1083 }
1084
GetMainCallId(napi_env env,napi_callback_info info)1085 napi_value NapiCallManager::GetMainCallId(napi_env env, napi_callback_info info)
1086 {
1087 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1088 if (!MatchOneNumberParameter(env, argv, argc)) {
1089 TELEPHONY_LOGE("NapiCallManager::GetMainCallId MatchOneNumberParameter failed.");
1090 NapiUtil::ThrowParameterError(env);
1091 return nullptr;
1092 }
1093 auto asyncContext = std::make_unique<IntResultAsyncContext>();
1094 if (asyncContext == nullptr) {
1095 TELEPHONY_LOGE("NapiCallManager::GetMainCallId asyncContext is nullptr.");
1096 NapiUtil::ThrowParameterError(env);
1097 return nullptr;
1098 }
1099 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1100 if (argc == TWO_VALUE_LIMIT) {
1101 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1102 }
1103 return HandleAsyncWork(
1104 env, asyncContext.release(), "GetMainCallId", NativeGetMainCallId, NativeGetMainCallIdCallBack);
1105 }
1106
GetSubCallIdList(napi_env env,napi_callback_info info)1107 napi_value NapiCallManager::GetSubCallIdList(napi_env env, napi_callback_info info)
1108 {
1109 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1110 if (!MatchOneNumberParameter(env, argv, argc)) {
1111 TELEPHONY_LOGE("NapiCallManager::GetSubCallIdList MatchOneNumberParameter failed.");
1112 NapiUtil::ThrowParameterError(env);
1113 return nullptr;
1114 }
1115 auto asyncContext = std::make_unique<ListAsyncContext>();
1116 if (asyncContext == nullptr) {
1117 TELEPHONY_LOGE("NapiCallManager::GetSubCallIdList asyncContext is nullptr.");
1118 NapiUtil::ThrowParameterError(env);
1119 return nullptr;
1120 }
1121 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1122 if (argc == TWO_VALUE_LIMIT) {
1123 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1124 }
1125 return HandleAsyncWork(env, asyncContext.release(), "GetSubCallIdList", NativeGetSubCallIdList, NativeListCallBack);
1126 }
1127
GetCallIdListForConference(napi_env env,napi_callback_info info)1128 napi_value NapiCallManager::GetCallIdListForConference(napi_env env, napi_callback_info info)
1129 {
1130 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1131 if (!MatchOneNumberParameter(env, argv, argc)) {
1132 TELEPHONY_LOGE("NapiCallManager::GetCallIdListForConference MatchOneNumberParameter failed.");
1133 NapiUtil::ThrowParameterError(env);
1134 return nullptr;
1135 }
1136 auto asyncContext = std::make_unique<ListAsyncContext>();
1137 if (asyncContext == nullptr) {
1138 TELEPHONY_LOGE("NapiCallManager::GetCallIdListForConference asyncContext is nullptr.");
1139 NapiUtil::ThrowParameterError(env);
1140 return nullptr;
1141 }
1142 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1143 if (argc == TWO_VALUE_LIMIT) {
1144 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1145 }
1146 return HandleAsyncWork(env, asyncContext.release(), "GetCallIdListForConference", NativeGetCallIdListForConference,
1147 NativeListCallBack);
1148 }
1149
MatchEmptyParameter(napi_env env,const napi_value parameters[],const size_t parameterCount)1150 bool NapiCallManager::MatchEmptyParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1151 {
1152 TELEPHONY_LOGI("Telephony_CallManager MatchEmptyParameter %{public}zu", parameterCount);
1153 switch (parameterCount) {
1154 case ZERO_VALUE:
1155 return true;
1156 case ONLY_ONE_VALUE:
1157 return NapiUtil::MatchParameters(env, parameters, { napi_function });
1158 default:
1159 return false;
1160 }
1161 }
1162
MatchOneOptionalNumberParameter(napi_env env,const napi_value parameters[],const size_t parameterCount)1163 bool NapiCallManager::MatchOneOptionalNumberParameter(
1164 napi_env env, const napi_value parameters[], const size_t parameterCount)
1165 {
1166 TELEPHONY_LOGI("Telephony_CallManager MatchAnswerParameters %{public}zu", parameterCount);
1167 switch (parameterCount) {
1168 case ZERO_VALUE:
1169 return true;
1170 case ONLY_ONE_VALUE:
1171 return NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1172 NapiUtil::MatchParameters(env, parameters, { napi_function });
1173 case TWO_VALUE_LIMIT:
1174 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1175 default:
1176 return false;
1177 }
1178 }
1179
MatchOneStringParameter(napi_env env,const napi_value parameters[],const size_t parameterCount)1180 bool NapiCallManager::MatchOneStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1181 {
1182 TELEPHONY_LOGI("Telephony_CallManager MatchOneNumberParameter %{public}zu", parameterCount);
1183 switch (parameterCount) {
1184 case ONLY_ONE_VALUE:
1185 return NapiUtil::MatchParameters(env, parameters, { napi_string });
1186 case TWO_VALUE_LIMIT:
1187 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_function });
1188 default:
1189 return false;
1190 }
1191 }
1192
MatchOneNumberParameter(napi_env env,const napi_value parameters[],const size_t parameterCount)1193 bool NapiCallManager::MatchOneNumberParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1194 {
1195 TELEPHONY_LOGI("Telephony_CallManager MatchOneNumberParameter %{public}zu", parameterCount);
1196 switch (parameterCount) {
1197 case ONLY_ONE_VALUE:
1198 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1199 case TWO_VALUE_LIMIT:
1200 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1201 default:
1202 return false;
1203 }
1204 }
1205
MatchTwoNumberParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1206 bool NapiCallManager::MatchTwoNumberParameters(napi_env env, const napi_value parameters[], const size_t parameterCount)
1207 {
1208 TELEPHONY_LOGI("Telephony_CallManager MatchTwoNumberParameters %{public}zu", parameterCount);
1209 switch (parameterCount) {
1210 case TWO_VALUE_LIMIT:
1211 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number });
1212 case THREE_VALUE_MAXIMUM_LIMIT:
1213 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_number, napi_function });
1214 default:
1215 return false;
1216 }
1217 }
1218
MatchTwoStringParameter(napi_env env,const napi_value parameters[],const size_t parameterCount)1219 bool NapiCallManager::MatchTwoStringParameter(napi_env env, const napi_value parameters[], const size_t parameterCount)
1220 {
1221 TELEPHONY_LOGI("Telephony_CallManager MatchTwoStringParameter %{public}zu", parameterCount);
1222 switch (parameterCount) {
1223 case TWO_VALUE_LIMIT:
1224 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_string });
1225 case THREE_VALUE_MAXIMUM_LIMIT:
1226 return NapiUtil::MatchParameters(env, parameters, { napi_string, napi_string, napi_function });
1227 default:
1228 return false;
1229 }
1230 }
1231
MatchNumberAndBoolParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1232 bool NapiCallManager::MatchNumberAndBoolParameters(
1233 napi_env env, const napi_value parameters[], const size_t parameterCount)
1234 {
1235 TELEPHONY_LOGI("Telephony_CallManager MatchNumberAndBoolParameters %{public}zu", parameterCount);
1236 switch (parameterCount) {
1237 case TWO_VALUE_LIMIT:
1238 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_boolean });
1239 case THREE_VALUE_MAXIMUM_LIMIT:
1240 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_boolean, napi_function });
1241 default:
1242 return false;
1243 }
1244 }
1245
MatchNumberAndStringParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1246 bool NapiCallManager::MatchNumberAndStringParameters(
1247 napi_env env, const napi_value parameters[], const size_t parameterCount)
1248 {
1249 TELEPHONY_LOGI("Telephony_CallManager MatchNumberAndBoolParameters %{public}zu", parameterCount);
1250 switch (parameterCount) {
1251 case TWO_VALUE_LIMIT:
1252 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string });
1253 case THREE_VALUE_MAXIMUM_LIMIT:
1254 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_string, napi_function });
1255 default:
1256 return false;
1257 }
1258 }
1259
MatchAudioDeviceParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1260 bool NapiCallManager::MatchAudioDeviceParameters(
1261 napi_env env, const napi_value parameters[], const size_t parameterCount)
1262 {
1263 TELEPHONY_LOGI("Telephony_CallManager MatchNumberAndBoolParameters %{public}zu", parameterCount);
1264 switch (parameterCount) {
1265 case ONLY_ONE_VALUE:
1266 return NapiUtil::MatchParameters(env, parameters, { napi_number });
1267 case TWO_VALUE_LIMIT:
1268 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object }) ||
1269 NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function });
1270 case THREE_VALUE_MAXIMUM_LIMIT:
1271 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object, napi_function });
1272 default:
1273 return false;
1274 }
1275 }
1276
MatchRejectCallParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1277 bool NapiCallManager::MatchRejectCallParameters(
1278 napi_env env, const napi_value parameters[], const size_t parameterCount)
1279 {
1280 TELEPHONY_LOGI("Telephony_CallManager MatchNumberAndBoolParameters %{public}zu", parameterCount);
1281 switch (parameterCount) {
1282 case ZERO_VALUE:
1283 return true;
1284 case ONLY_ONE_VALUE:
1285 return NapiUtil::MatchParameters(env, parameters, { napi_number }) ||
1286 NapiUtil::MatchParameters(env, parameters, { napi_object }) ||
1287 NapiUtil::MatchParameters(env, parameters, { napi_function });
1288 case TWO_VALUE_LIMIT:
1289 return NapiUtil::MatchParameters(env, parameters, { napi_object, napi_function }) ||
1290 NapiUtil::MatchParameters(env, parameters, { napi_number, napi_function }) ||
1291 NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object });
1292 case THREE_VALUE_MAXIMUM_LIMIT:
1293 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object, napi_function });
1294 default:
1295 return false;
1296 }
1297 }
1298
MatchNumberAndObjectParameters(napi_env env,const napi_value parameters[],const size_t parameterCount)1299 bool NapiCallManager::MatchNumberAndObjectParameters(
1300 napi_env env, const napi_value parameters[], const size_t parameterCount)
1301 {
1302 TELEPHONY_LOGI("Telephony_CallManager MatchNumberAndObjectParameters %{public}zu", parameterCount);
1303 switch (parameterCount) {
1304 case TWO_VALUE_LIMIT:
1305 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object });
1306 case THREE_VALUE_MAXIMUM_LIMIT:
1307 return NapiUtil::MatchParameters(env, parameters, { napi_number, napi_object, napi_function });
1308 default:
1309 return false;
1310 }
1311 }
1312
GetCallWaiting(napi_env env,napi_callback_info info)1313 napi_value NapiCallManager::GetCallWaiting(napi_env env, napi_callback_info info)
1314 {
1315 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1316 if (!MatchOneNumberParameter(env, argv, argc)) {
1317 TELEPHONY_LOGE("NapiCallManager::GetCallWaiting MatchOneNumberParameter failed.");
1318 NapiUtil::ThrowParameterError(env);
1319 return nullptr;
1320 }
1321 auto asyncContext = std::make_unique<SupplementAsyncContext>();
1322 if (asyncContext == nullptr) {
1323 TELEPHONY_LOGE("NapiCallManager::GetCallWaiting asyncContext is nullptr.");
1324 NapiUtil::ThrowParameterError(env);
1325 return nullptr;
1326 }
1327 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1328 if (argc == TWO_VALUE_LIMIT) {
1329 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1330 }
1331 asyncContext->env = env;
1332 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1333 return HandleAsyncWork(env, asyncContext.release(), "GetCallWaiting", NativeGetCallWaiting, NativeCallBack);
1334 }
1335
SetCallWaiting(napi_env env,napi_callback_info info)1336 napi_value NapiCallManager::SetCallWaiting(napi_env env, napi_callback_info info)
1337 {
1338 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1339 if (!MatchNumberAndBoolParameters(env, argv, argc)) {
1340 TELEPHONY_LOGE("NapiCallManager::SetCallWaiting MatchNumberAndBoolParameters failed.");
1341 NapiUtil::ThrowParameterError(env);
1342 return nullptr;
1343 }
1344 auto asyncContext = std::make_unique<SupplementAsyncContext>();
1345 if (asyncContext == nullptr) {
1346 TELEPHONY_LOGE("NapiCallManager::SetCallWaiting asyncContext is nullptr.");
1347 NapiUtil::ThrowParameterError(env);
1348 return nullptr;
1349 }
1350 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1351 napi_get_value_bool(env, argv[ARRAY_INDEX_SECOND], &asyncContext->flag);
1352 if (argc == VALUE_MAXIMUM_LIMIT) {
1353 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1354 }
1355 asyncContext->env = env;
1356 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1357 return HandleAsyncWork(env, asyncContext.release(), "SetCallWaiting", NativeSetCallWaiting, NativeCallBack);
1358 }
1359
GetCallRestriction(napi_env env,napi_callback_info info)1360 napi_value NapiCallManager::GetCallRestriction(napi_env env, napi_callback_info info)
1361 {
1362 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1363 if (!MatchTwoNumberParameters(env, argv, argc)) {
1364 TELEPHONY_LOGE("NapiCallManager::GetCallRestriction MatchTwoNumberParameters failed.");
1365 NapiUtil::ThrowParameterError(env);
1366 return nullptr;
1367 }
1368 auto asyncContext = std::make_unique<SupplementAsyncContext>();
1369 if (asyncContext == nullptr) {
1370 TELEPHONY_LOGE("NapiCallManager::GetCallRestriction asyncContext is nullptr.");
1371 NapiUtil::ThrowParameterError(env);
1372 return nullptr;
1373 }
1374 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1375 napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->type);
1376 if (argc == VALUE_MAXIMUM_LIMIT) {
1377 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1378 }
1379 asyncContext->env = env;
1380 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1381 return HandleAsyncWork(env, asyncContext.release(), "GetCallRestriction", NativeGetCallRestriction, NativeCallBack);
1382 }
1383
SetCallRestriction(napi_env env,napi_callback_info info)1384 napi_value NapiCallManager::SetCallRestriction(napi_env env, napi_callback_info info)
1385 {
1386 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1387 if (!MatchNumberAndObjectParameters(env, argv, argc)) {
1388 TELEPHONY_LOGE("NapiCallManager::SetCallRestriction MatchNumberAndObjectParameters failed.");
1389 NapiUtil::ThrowParameterError(env);
1390 return nullptr;
1391 }
1392 auto asyncContext = std::make_unique<CallRestrictionAsyncContext>();
1393 if (asyncContext == nullptr) {
1394 TELEPHONY_LOGE("NapiCallManager::SetCallRestriction asyncContext is nullptr.");
1395 NapiUtil::ThrowParameterError(env);
1396 return nullptr;
1397 }
1398 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1399 asyncContext->errorCode = GetRestrictionInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1400 if (asyncContext->errorCode == ERROR_PARAMETER_TYPE_INVALID) {
1401 NapiUtil::ThrowParameterError(env);
1402 return nullptr;
1403 }
1404 if (argc == VALUE_MAXIMUM_LIMIT) {
1405 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1406 }
1407 asyncContext->env = env;
1408 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1409 return HandleAsyncWork(env, asyncContext.release(), "SetCallRestriction", NativeSetCallRestriction, NativeCallBack);
1410 }
1411
GetCallTransferInfo(napi_env env,napi_callback_info info)1412 napi_value NapiCallManager::GetCallTransferInfo(napi_env env, napi_callback_info info)
1413 {
1414 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1415 if (!MatchTwoNumberParameters(env, argv, argc)) {
1416 TELEPHONY_LOGE("NapiCallManager::GetCallTransferInfo MatchTwoNumberParameters failed.");
1417 NapiUtil::ThrowParameterError(env);
1418 return nullptr;
1419 }
1420 auto asyncContext = std::make_unique<SupplementAsyncContext>();
1421 if (asyncContext == nullptr) {
1422 TELEPHONY_LOGE("NapiCallManager::GetCallTransferInfo asyncContext is nullptr.");
1423 NapiUtil::ThrowParameterError(env);
1424 return nullptr;
1425 }
1426 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1427 napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->type);
1428 if (argc == VALUE_MAXIMUM_LIMIT) {
1429 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1430 }
1431 asyncContext->env = env;
1432 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1433 return HandleAsyncWork(env, asyncContext.release(), "GetCallTransferInfo", NativeGetTransferNumber, NativeCallBack);
1434 }
1435
SetCallTransferInfo(napi_env env,napi_callback_info info)1436 napi_value NapiCallManager::SetCallTransferInfo(napi_env env, napi_callback_info info)
1437 {
1438 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1439 if (!MatchNumberAndObjectParameters(env, argv, argc)) {
1440 TELEPHONY_LOGE("NapiCallManager::SetCallTransferInfo MatchNumberAndObjectParameters failed.");
1441 NapiUtil::ThrowParameterError(env);
1442 return nullptr;
1443 }
1444 auto asyncContext = std::make_unique<CallTransferAsyncContext>();
1445 if (asyncContext == nullptr) {
1446 TELEPHONY_LOGE("NapiCallManager::SetCallTransferInfo asyncContext is nullptr.");
1447 NapiUtil::ThrowParameterError(env);
1448 return nullptr;
1449 }
1450 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1451 asyncContext->errorCode = GetTransferInfo(env, argv[ARRAY_INDEX_SECOND], *asyncContext);
1452 if (asyncContext->errorCode == ERROR_PARAMETER_TYPE_INVALID) {
1453 NapiUtil::ThrowParameterError(env);
1454 return nullptr;
1455 }
1456 if (argc == VALUE_MAXIMUM_LIMIT) {
1457 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1458 }
1459 asyncContext->env = env;
1460 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
1461 return HandleAsyncWork(env, asyncContext.release(), "SetCallTransferInfo", NativeSetTransferNumber, NativeCallBack);
1462 }
1463
EnableImsSwitch(napi_env env,napi_callback_info info)1464 napi_value NapiCallManager::EnableImsSwitch(napi_env env, napi_callback_info info)
1465 {
1466 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1467 if (!MatchOneNumberParameter(env, argv, argc)) {
1468 TELEPHONY_LOGE("NapiCallManager::EnableImsSwitch MatchOneNumberParameter failed.");
1469 NapiUtil::ThrowParameterError(env);
1470 return nullptr;
1471 }
1472 auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1473 if (asyncContext == nullptr) {
1474 TELEPHONY_LOGE("NapiCallManager::EnableImsSwitch asyncContext is nullptr.");
1475 NapiUtil::ThrowParameterError(env);
1476 return nullptr;
1477 }
1478 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1479 if (argc == TWO_VALUE_LIMIT) {
1480 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1481 }
1482
1483 return HandleAsyncWork(
1484 env, asyncContext.release(), "EnableImsSwitch", NativeEnableImsSwitch, NativeVoidCallBackWithErrorCode);
1485 }
1486
DisableImsSwitch(napi_env env,napi_callback_info info)1487 napi_value NapiCallManager::DisableImsSwitch(napi_env env, napi_callback_info info)
1488 {
1489 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1490 if (!MatchOneNumberParameter(env, argv, argc)) {
1491 TELEPHONY_LOGE("NapiCallManager::DisableImsSwitch MatchOneNumberParameter failed.");
1492 NapiUtil::ThrowParameterError(env);
1493 return nullptr;
1494 }
1495 auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1496 if (asyncContext == nullptr) {
1497 TELEPHONY_LOGE("NapiCallManager::DisableImsSwitch asyncContext is nullptr.");
1498 NapiUtil::ThrowParameterError(env);
1499 return nullptr;
1500 }
1501 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1502 if (argc == TWO_VALUE_LIMIT) {
1503 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1504 }
1505
1506 return HandleAsyncWork(
1507 env, asyncContext.release(), "DisableImsSwitch", NativeDisableImsSwitch, NativeVoidCallBackWithErrorCode);
1508 }
1509
IsImsSwitchEnabled(napi_env env,napi_callback_info info)1510 napi_value NapiCallManager::IsImsSwitchEnabled(napi_env env, napi_callback_info info)
1511 {
1512 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1513 if (!MatchOneNumberParameter(env, argv, argc)) {
1514 TELEPHONY_LOGE("NapiCallManager::IsImsSwitchEnabled MatchOneNumberParameter failed.");
1515 NapiUtil::ThrowParameterError(env);
1516 return nullptr;
1517 }
1518 auto asyncContext = std::make_unique<ImsSwitchAsyncContext>();
1519 if (asyncContext == nullptr) {
1520 TELEPHONY_LOGE("NapiCallManager::IsImsSwitchEnabled asyncContext is nullptr.");
1521 NapiUtil::ThrowParameterError(env);
1522 return nullptr;
1523 }
1524 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->slotId);
1525 if (argc == TWO_VALUE_LIMIT) {
1526 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1527 }
1528 return HandleAsyncWork(
1529 env, asyncContext.release(), "IsImsSwitchEnabled", NativeIsImsSwitchEnabled, NativeIsImsSwitchEnabledCallBack);
1530 }
1531
StartDTMF(napi_env env,napi_callback_info info)1532 napi_value NapiCallManager::StartDTMF(napi_env env, napi_callback_info info)
1533 {
1534 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1535 if (!MatchNumberAndStringParameters(env, argv, argc)) {
1536 TELEPHONY_LOGE("NapiCallManager::StartDTMF MatchNumberAndStringParameters failed.");
1537 NapiUtil::ThrowParameterError(env);
1538 return nullptr;
1539 }
1540 auto asyncContext = std::make_unique<SupplementAsyncContext>();
1541 if (asyncContext == nullptr) {
1542 TELEPHONY_LOGE("NapiCallManager::StartDTMF asyncContext is nullptr.");
1543 NapiUtil::ThrowParameterError(env);
1544 return nullptr;
1545 }
1546 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1547 napi_get_value_string_utf8(
1548 env, argv[ARRAY_INDEX_SECOND], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1549 if (argc == VALUE_MAXIMUM_LIMIT) {
1550 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1551 }
1552 return HandleAsyncWork(env, asyncContext.release(), "StartDTMF", NativeStartDTMF, NativeVoidCallBackWithErrorCode);
1553 }
1554
StopDTMF(napi_env env,napi_callback_info info)1555 napi_value NapiCallManager::StopDTMF(napi_env env, napi_callback_info info)
1556 {
1557 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1558 if (!MatchOneNumberParameter(env, argv, argc)) {
1559 TELEPHONY_LOGE("NapiCallManager::StopDTMF MatchOneNumberParameter failed.");
1560 NapiUtil::ThrowParameterError(env);
1561 return nullptr;
1562 }
1563 auto asyncContext = std::make_unique<AsyncContext>();
1564 if (asyncContext == nullptr) {
1565 TELEPHONY_LOGE("NapiCallManager::StopDTMF asyncContext is nullptr.");
1566 NapiUtil::ThrowParameterError(env);
1567 return nullptr;
1568 }
1569 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
1570 if (argc == TWO_VALUE_LIMIT) {
1571 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1572 }
1573 return HandleAsyncWork(env, asyncContext.release(), "StopDTMF", NativeStopDTMF, NativeVoidCallBackWithErrorCode);
1574 }
1575
GetCallState(napi_env env,napi_callback_info info)1576 napi_value NapiCallManager::GetCallState(napi_env env, napi_callback_info info)
1577 {
1578 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1579 NAPI_ASSERT(env, argc < TWO_VALUE_LIMIT, "parameter error!");
1580 auto asyncContext = std::make_unique<AsyncContext>();
1581 if (asyncContext == nullptr) {
1582 std::string errorCode = std::to_string(napi_generic_failure);
1583 std::string errorMessage = "GetCallState error at asyncContext is nullptr";
1584 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
1585 return nullptr;
1586 }
1587 if (argc == ONLY_ONE_VALUE) {
1588 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1589 }
1590 return HandleAsyncWork(env, asyncContext.release(), "GetCallState", NativeGetCallState, NativePropertyCallBack);
1591 }
1592
IsRinging(napi_env env,napi_callback_info info)1593 napi_value NapiCallManager::IsRinging(napi_env env, napi_callback_info info)
1594 {
1595 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1596 if (!MatchEmptyParameter(env, argv, argc)) {
1597 TELEPHONY_LOGE("NapiCallManager::IsRinging MatchEmptyParameter failed.");
1598 NapiUtil::ThrowParameterError(env);
1599 return nullptr;
1600 }
1601 auto asyncContext = std::make_unique<BoolResultAsyncContext>();
1602 if (asyncContext == nullptr) {
1603 TELEPHONY_LOGE("NapiCallManager::IsRinging asyncContext is nullptr.");
1604 NapiUtil::ThrowParameterError(env);
1605 return nullptr;
1606 }
1607 if (argc == ONLY_ONE_VALUE) {
1608 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1609 }
1610 return HandleAsyncWork(env, asyncContext.release(), "IsRinging", NativeIsRinging, NativeBoolCallBackWithErrorCode);
1611 }
1612
HasCall(napi_env env,napi_callback_info info)1613 napi_value NapiCallManager::HasCall(napi_env env, napi_callback_info info)
1614 {
1615 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1616 NAPI_ASSERT(env, argc < TWO_VALUE_LIMIT, "parameter error!");
1617 auto asyncContext = std::make_unique<AsyncContext>();
1618 if (asyncContext == nullptr) {
1619 std::string errorCode = std::to_string(napi_generic_failure);
1620 std::string errorMessage = "HasCall error at asyncContext is nullptr";
1621 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
1622 return nullptr;
1623 }
1624 if (argc == ONLY_ONE_VALUE) {
1625 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1626 }
1627 return HandleAsyncWork(env, asyncContext.release(), "HasCall", NativeHasCall, NativeBoolCallBack);
1628 }
1629
IsNewCallAllowed(napi_env env,napi_callback_info info)1630 napi_value NapiCallManager::IsNewCallAllowed(napi_env env, napi_callback_info info)
1631 {
1632 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1633 if (!MatchEmptyParameter(env, argv, argc)) {
1634 TELEPHONY_LOGE("NapiCallManager::IsNewCallAllowed MatchEmptyParameter failed.");
1635 NapiUtil::ThrowParameterError(env);
1636 return nullptr;
1637 }
1638 auto asyncContext = std::make_unique<BoolResultAsyncContext>();
1639 if (asyncContext == nullptr) {
1640 TELEPHONY_LOGE("NapiCallManager::IsNewCallAllowed asyncContext is nullptr.");
1641 NapiUtil::ThrowParameterError(env);
1642 return nullptr;
1643 }
1644 if (argc == ONLY_ONE_VALUE) {
1645 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1646 }
1647 return HandleAsyncWork(
1648 env, asyncContext.release(), "IsNewCallAllowed", NativeIsNewCallAllowed, NativeBoolCallBackWithErrorCode);
1649 }
1650
IsInEmergencyCall(napi_env env,napi_callback_info info)1651 napi_value NapiCallManager::IsInEmergencyCall(napi_env env, napi_callback_info info)
1652 {
1653 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1654 if (!MatchEmptyParameter(env, argv, argc)) {
1655 TELEPHONY_LOGE("NapiCallManager::IsInEmergencyCall MatchEmptyParameter failed.");
1656 NapiUtil::ThrowParameterError(env);
1657 return nullptr;
1658 }
1659 auto asyncContext = std::make_unique<BoolResultAsyncContext>();
1660 if (asyncContext == nullptr) {
1661 TELEPHONY_LOGE("NapiCallManager::IsInEmergencyCall asyncContext is nullptr.");
1662 NapiUtil::ThrowParameterError(env);
1663 return nullptr;
1664 }
1665 if (argc == ONLY_ONE_VALUE) {
1666 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1667 }
1668 return HandleAsyncWork(
1669 env, asyncContext.release(), "IsInEmergencyCall", NativeIsInEmergencyCall, NativeBoolCallBackWithErrorCode);
1670 }
1671
IsEmergencyPhoneNumber(napi_env env,napi_callback_info info)1672 napi_value NapiCallManager::IsEmergencyPhoneNumber(napi_env env, napi_callback_info info)
1673 {
1674 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1675 if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
1676 TELEPHONY_LOGE("NapiCallManager::IsEmergencyPhoneNumber MatchStringAndVariableObjectParameters failed.");
1677 NapiUtil::ThrowParameterError(env);
1678 return nullptr;
1679 }
1680 auto asyncContext = std::make_unique<UtilsAsyncContext>();
1681 if (asyncContext == nullptr) {
1682 TELEPHONY_LOGE("NapiCallManager::IsEmergencyPhoneNumber asyncContext is nullptr.");
1683 NapiUtil::ThrowParameterError(env);
1684 return nullptr;
1685 }
1686 napi_get_value_string_utf8(
1687 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1688 asyncContext->slotId = 0;
1689 if (argc == TWO_VALUE_LIMIT) {
1690 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1691 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1692 } else {
1693 asyncContext->slotId = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_SECOND], "slotId");
1694 }
1695 }
1696 if (argc == VALUE_MAXIMUM_LIMIT) {
1697 asyncContext->slotId = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_SECOND], "slotId");
1698 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1699 }
1700 return HandleAsyncWork(env, asyncContext.release(), "IsEmergencyPhoneNumber", NativeIsEmergencyPhoneNumber,
1701 NativeIsEmergencyPhoneNumberCallBack);
1702 }
1703
FormatPhoneNumber(napi_env env,napi_callback_info info)1704 napi_value NapiCallManager::FormatPhoneNumber(napi_env env, napi_callback_info info)
1705 {
1706 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1707 if (!MatchStringAndVariableObjectParameters(env, argv, argc)) {
1708 TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumber MatchStringAndVariableObjectParameters failed.");
1709 NapiUtil::ThrowParameterError(env);
1710 return nullptr;
1711 }
1712 auto asyncContext = std::make_unique<UtilsAsyncContext>();
1713 if (asyncContext == nullptr) {
1714 TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumber asyncContext is nullptr.");
1715 NapiUtil::ThrowParameterError(env);
1716 return nullptr;
1717 }
1718 asyncContext->code = "cn";
1719 napi_get_value_string_utf8(
1720 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1721 if (argc == TWO_VALUE_LIMIT) {
1722 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1723 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1724 } else {
1725 asyncContext->code = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "countryCode");
1726 }
1727 }
1728 if (argc == VALUE_MAXIMUM_LIMIT) {
1729 asyncContext->code = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "countryCode");
1730 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1731 }
1732 return HandleAsyncWork(
1733 env, asyncContext.release(), "FormatPhoneNumber", NativeFormatPhoneNumber, NativeFormatNumberCallBack);
1734 }
1735
FormatPhoneNumberToE164(napi_env env,napi_callback_info info)1736 napi_value NapiCallManager::FormatPhoneNumberToE164(napi_env env, napi_callback_info info)
1737 {
1738 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1739 if (!MatchTwoStringParameter(env, argv, argc)) {
1740 TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumberToE164 MatchTwoStringParameter failed.");
1741 NapiUtil::ThrowParameterError(env);
1742 return nullptr;
1743 }
1744 auto asyncContext = std::make_unique<UtilsAsyncContext>();
1745 if (asyncContext == nullptr) {
1746 TELEPHONY_LOGE("NapiCallManager::FormatPhoneNumberToE164 asyncContext is nullptr.");
1747 NapiUtil::ThrowParameterError(env);
1748 return nullptr;
1749 }
1750 napi_get_value_string_utf8(
1751 env, argv[ARRAY_INDEX_FIRST], asyncContext->number, PHONE_NUMBER_MAXIMUM_LIMIT, &(asyncContext->numberLen));
1752 char tmpStr[kMaxNumberLen + 1] = {0};
1753 size_t strLen = 0;
1754 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
1755 std::string tmpCode(tmpStr, strLen);
1756 asyncContext->code = tmpCode;
1757 if (argc == VALUE_MAXIMUM_LIMIT) {
1758 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1759 }
1760 return HandleAsyncWork(env, asyncContext.release(), "FormatPhoneNumberToE164", NativeFormatPhoneNumberToE164,
1761 NativeFormatNumberCallBack);
1762 }
1763
ObserverOn(napi_env env,napi_callback_info info)1764 napi_value NapiCallManager::ObserverOn(napi_env env, napi_callback_info info)
1765 {
1766 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1767 if ((argc != TWO_VALUE_LIMIT) ||
1768 (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string)) ||
1769 (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function))) {
1770 NapiUtil::ThrowParameterError(env);
1771 return nullptr;
1772 }
1773 if (registerStatus_ != TELEPHONY_SUCCESS) {
1774 TELEPHONY_LOGE("RegisterCallBack failed!");
1775 if (registerStatus_ == TELEPHONY_ERR_PERMISSION_ERR) {
1776 NapiUtil::ThrowError(env, JS_ERROR_TELEPHONY_PERMISSION_DENIED, OBSERVER_ON_JS_PERMISSION_ERROR_STRING);
1777 return nullptr;
1778 }
1779 JsError error = NapiUtil::ConverErrorMessageForJs(registerStatus_);
1780 NapiUtil::ThrowError(env, error.errorCode, error.errorMessage);
1781 return nullptr;
1782 }
1783 char listenerType[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
1784 size_t strLength = 0;
1785 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], listenerType, PHONE_NUMBER_MAXIMUM_LIMIT, &strLength);
1786 std::string tmpStr = listenerType;
1787 TELEPHONY_LOGI("listenerType == %{public}s", tmpStr.c_str());
1788 EventCallback stateCallback;
1789 (void)memset_s(&stateCallback, sizeof(EventCallback), 0, sizeof(EventCallback));
1790 stateCallback.env = env;
1791 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &stateCallback.thisVar);
1792 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &stateCallback.callbackRef);
1793 if (tmpStr == "callDetailsChange") {
1794 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallStateCallback(stateCallback);
1795 } else if (tmpStr == "callEventChange") {
1796 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallEventCallback(stateCallback);
1797 } else if (tmpStr == "callOttRequest") {
1798 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterCallOttRequestCallback(stateCallback);
1799 } else if (tmpStr == "callDisconnectedCause") {
1800 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterDisconnectedCauseCallback(stateCallback);
1801 } else if (tmpStr == "mmiCodeResult") {
1802 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterMmiCodeCallback(stateCallback);
1803 }
1804 napi_value result = nullptr;
1805 return result;
1806 }
1807
ObserverOff(napi_env env,napi_callback_info info)1808 napi_value NapiCallManager::ObserverOff(napi_env env, napi_callback_info info)
1809 {
1810 GET_PARAMS(env, info, TWO_VALUE_LIMIT);
1811 if (!MatchOneStringParameter(env, argv, argc)) {
1812 TELEPHONY_LOGE("NapiCallManager::ObserverOff MatchOneStringParameter failed.");
1813 NapiUtil::ThrowParameterError(env);
1814 return nullptr;
1815 }
1816 auto asyncContext = std::make_unique<AsyncContext>();
1817 if (asyncContext == nullptr) {
1818 TELEPHONY_LOGE("NapiCallManager::ObserverOff asyncContext is nullptr.");
1819 NapiUtil::ThrowParameterError(env);
1820 return nullptr;
1821 }
1822 asyncContext->errorCode = registerStatus_;
1823 if (asyncContext->errorCode == TELEPHONY_ERR_PERMISSION_ERR) {
1824 NapiUtil::ThrowError(env, JS_ERROR_TELEPHONY_PERMISSION_DENIED, OBSERVER_OFF_JS_PERMISSION_ERROR_STRING);
1825 return nullptr;
1826 }
1827 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
1828 asyncContext->resolved = TELEPHONY_SUCCESS;
1829 }
1830 char listenerType[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
1831 size_t strLength = 0;
1832 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], listenerType, PHONE_NUMBER_MAXIMUM_LIMIT, &strLength);
1833 std::string tmpStr = listenerType;
1834 TELEPHONY_LOGI("listenerType == %{public}s", tmpStr.c_str());
1835 if (tmpStr == "callDetailsChange") {
1836 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallStateCallback();
1837 } else if (tmpStr == "callEventChange") {
1838 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallEventCallback();
1839 } else if (tmpStr == "callOttRequest") {
1840 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterCallOttRequestCallback();
1841 } else if (tmpStr == "callDisconnectedCause") {
1842 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterDisconnectedCauseCallback();
1843 } else if (tmpStr == "mmiCodeResult") {
1844 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterMmiCodeCallback();
1845 }
1846 if (argc == TWO_VALUE_LIMIT) {
1847 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1848 }
1849 return HandleAsyncWork(
1850 env, asyncContext.release(), "Off", [](napi_env env, void *data) {}, NativeVoidCallBackWithErrorCode);
1851 }
1852
SetMuted(napi_env env,napi_callback_info info)1853 napi_value NapiCallManager::SetMuted(napi_env env, napi_callback_info info)
1854 {
1855 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1856 if (!MatchEmptyParameter(env, argv, argc)) {
1857 TELEPHONY_LOGE("NapiCallManager::SetMuted MatchEmptyParameter failed.");
1858 NapiUtil::ThrowParameterError(env);
1859 return nullptr;
1860 }
1861 auto asyncContext = std::make_unique<AudioAsyncContext>();
1862 if (asyncContext == nullptr) {
1863 TELEPHONY_LOGE("NapiCallManager::SetMuted asyncContext is nullptr.");
1864 NapiUtil::ThrowParameterError(env);
1865 return nullptr;
1866 }
1867 if (argc == ONLY_ONE_VALUE) {
1868 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1869 }
1870 return HandleAsyncWork(env, asyncContext.release(), "SetMuted", NativeSetMuted, NativeVoidCallBackWithErrorCode);
1871 }
1872
CancelMuted(napi_env env,napi_callback_info info)1873 napi_value NapiCallManager::CancelMuted(napi_env env, napi_callback_info info)
1874 {
1875 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1876 if (!MatchEmptyParameter(env, argv, argc)) {
1877 TELEPHONY_LOGE("NapiCallManager::CancelMuted MatchEmptyParameter failed.");
1878 NapiUtil::ThrowParameterError(env);
1879 return nullptr;
1880 }
1881 auto asyncContext = std::make_unique<AudioAsyncContext>();
1882 if (asyncContext == nullptr) {
1883 TELEPHONY_LOGE("NapiCallManager::CancelMuted asyncContext is nullptr.");
1884 NapiUtil::ThrowParameterError(env);
1885 return nullptr;
1886 }
1887 if (argc == ONLY_ONE_VALUE) {
1888 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1889 }
1890 return HandleAsyncWork(
1891 env, asyncContext.release(), "CancelMuted", NativeCancelMuted, NativeVoidCallBackWithErrorCode);
1892 }
1893
MuteRinger(napi_env env,napi_callback_info info)1894 napi_value NapiCallManager::MuteRinger(napi_env env, napi_callback_info info)
1895 {
1896 GET_PARAMS(env, info, ONLY_ONE_VALUE);
1897 if (!MatchEmptyParameter(env, argv, argc)) {
1898 TELEPHONY_LOGE("NapiCallManager::MuteRinger MatchEmptyParameter failed.");
1899 NapiUtil::ThrowParameterError(env);
1900 return nullptr;
1901 }
1902 auto asyncContext = std::make_unique<AudioAsyncContext>();
1903 if (asyncContext == nullptr) {
1904 TELEPHONY_LOGE("NapiCallManager::MuteRinger asyncContext is nullptr.");
1905 NapiUtil::ThrowParameterError(env);
1906 return nullptr;
1907 }
1908 if (argc == ONLY_ONE_VALUE) {
1909 napi_create_reference(env, argv[ARRAY_INDEX_FIRST], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1910 }
1911 return HandleAsyncWork(
1912 env, asyncContext.release(), "MuteRinger", NativeMuteRinger, NativeVoidCallBackWithErrorCode);
1913 }
1914
SetAudioDevice(napi_env env,napi_callback_info info)1915 napi_value NapiCallManager::SetAudioDevice(napi_env env, napi_callback_info info)
1916 {
1917 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
1918 if (!MatchAudioDeviceParameters(env, argv, argc)) {
1919 TELEPHONY_LOGE("NapiCallManager::SetAudioDevice MatchAudioDeviceParameters failed.");
1920 NapiUtil::ThrowParameterError(env);
1921 return nullptr;
1922 }
1923 auto asyncContext = std::make_unique<AudioAsyncContext>();
1924 if (asyncContext == nullptr) {
1925 TELEPHONY_LOGE("NapiCallManager::SetAudioDevice asyncContext is nullptr.");
1926 NapiUtil::ThrowParameterError(env);
1927 return nullptr;
1928 }
1929 if (argc == ONLY_ONE_VALUE) {
1930 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->audioDevice);
1931 } else if (argc == TWO_VALUE_LIMIT) {
1932 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->audioDevice);
1933 if (NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_function)) {
1934 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1935 } else {
1936 asyncContext->address =
1937 NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "bluetoothAddress");
1938 }
1939 } else {
1940 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->audioDevice);
1941 asyncContext->address =
1942 NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_SECOND], "bluetoothAddress");
1943 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1944 }
1945
1946 return HandleAsyncWork(
1947 env, asyncContext.release(), "SetAudioDevice", NativeSetAudioDevice, NativeVoidCallBackWithErrorCode);
1948 }
1949
ControlCamera(napi_env env,napi_callback_info info)1950 napi_value NapiCallManager::ControlCamera(napi_env env, napi_callback_info info)
1951 {
1952 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1953 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
1954 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string);
1955 NAPI_ASSERT(env, matchFlag, "ControlCamera type error, should be string type");
1956
1957 auto asyncContext = std::make_unique<VideoAsyncContext>();
1958 if (asyncContext == nullptr) {
1959 std::string errorCode = std::to_string(napi_generic_failure);
1960 std::string errorMessage = "ControlCamera error at baseContext is nullptr";
1961 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
1962 return nullptr;
1963 }
1964 char tmpStr[kMaxNumberLen + 1] = {0};
1965 size_t strLen = 0;
1966 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
1967 std::string tmpCode(tmpStr, strLen);
1968 asyncContext->cameraId = tmpCode;
1969 if (argc == TWO_VALUE_LIMIT) {
1970 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1971 }
1972 return HandleAsyncWork(env, asyncContext.release(), "ControlCamera", NativeControlCamera, NativeVoidCallBack);
1973 }
1974
SetPreviewWindow(napi_env env,napi_callback_info info)1975 napi_value NapiCallManager::SetPreviewWindow(napi_env env, napi_callback_info info)
1976 {
1977 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
1978 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
1979 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_object);
1980 NAPI_ASSERT(env, matchFlag, "SetPreviewWindow type error, should be object type");
1981
1982 auto asyncContext = std::make_unique<VideoAsyncContext>();
1983 if (asyncContext == nullptr) {
1984 std::string errorCode = std::to_string(napi_generic_failure);
1985 std::string errorMessage = "SetPreviewWindow error at baseContext is nullptr";
1986 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
1987 return nullptr;
1988 }
1989 asyncContext->x = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "x");
1990 asyncContext->y = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "y");
1991 asyncContext->z = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "z");
1992 asyncContext->width = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "width");
1993 asyncContext->height = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "height");
1994 if (argc == TWO_VALUE_LIMIT) {
1995 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
1996 }
1997 return HandleAsyncWork(env, asyncContext.release(), "SetPreviewWindow", NativeSetPreviewWindow, NativeVoidCallBack);
1998 }
1999
SetDisplayWindow(napi_env env,napi_callback_info info)2000 napi_value NapiCallManager::SetDisplayWindow(napi_env env, napi_callback_info info)
2001 {
2002 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2003 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2004 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_object);
2005 NAPI_ASSERT(env, matchFlag, "SetDisplayWindow type error, should be object type");
2006
2007 auto asyncContext = std::make_unique<VideoAsyncContext>();
2008 if (asyncContext == nullptr) {
2009 std::string errorCode = std::to_string(napi_generic_failure);
2010 std::string errorMessage = "SetDisplayWindow error at baseContext is nullptr";
2011 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2012 return nullptr;
2013 }
2014 asyncContext->x = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "x");
2015 asyncContext->y = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "y");
2016 asyncContext->z = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "z");
2017 asyncContext->width = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "width");
2018 asyncContext->height = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "height");
2019 if (argc == TWO_VALUE_LIMIT) {
2020 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2021 }
2022 return HandleAsyncWork(env, asyncContext.release(), "SetDisplayWindow", NativeSetDisplayWindow, NativeVoidCallBack);
2023 }
2024
SetCameraZoom(napi_env env,napi_callback_info info)2025 napi_value NapiCallManager::SetCameraZoom(napi_env env, napi_callback_info info)
2026 {
2027 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2028 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2029 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2030 NAPI_ASSERT(env, matchFlag, "SetCameraZoom type error, should be number type");
2031
2032 auto asyncContext = std::make_unique<VideoAsyncContext>();
2033 if (asyncContext == nullptr) {
2034 std::string errorCode = std::to_string(napi_generic_failure);
2035 std::string errorMessage = "SetCameraZoom error at baseContext is nullptr";
2036 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2037 return nullptr;
2038 }
2039 napi_get_value_double(env, argv[ARRAY_INDEX_FIRST], &asyncContext->zoomRatio);
2040 if (argc == TWO_VALUE_LIMIT) {
2041 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2042 }
2043 return HandleAsyncWork(env, asyncContext.release(), "SetCameraZoom", NativeSetCameraZoom, NativeVoidCallBack);
2044 }
2045
SetPausePicture(napi_env env,napi_callback_info info)2046 napi_value NapiCallManager::SetPausePicture(napi_env env, napi_callback_info info)
2047 {
2048 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2049 NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2050 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_string);
2051 NAPI_ASSERT(env, matchFlag, "SetPausePicture type error, should be string type");
2052 size_t result = 0;
2053 auto asyncContext = std::make_unique<VideoAsyncContext>();
2054 if (asyncContext == nullptr) {
2055 std::string errorCode = std::to_string(napi_generic_failure);
2056 std::string errorMessage = "SetPausePicture error at baseContext is nullptr";
2057 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2058 return nullptr;
2059 }
2060 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_FIRST], asyncContext->path, PHONE_NUMBER_MAXIMUM_LIMIT, &result);
2061 if (argc == TWO_VALUE_LIMIT) {
2062 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2063 }
2064 return HandleAsyncWork(env, asyncContext.release(), "SetPausePicture", NativeSetPausePicture, NativeVoidCallBack);
2065 }
2066
SetDeviceDirection(napi_env env,napi_callback_info info)2067 napi_value NapiCallManager::SetDeviceDirection(napi_env env, napi_callback_info info)
2068 {
2069 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2070 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2071 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2072 NAPI_ASSERT(env, matchFlag, "SetDeviceDirection type error, should be number type");
2073 auto asyncContext = std::make_unique<VideoAsyncContext>();
2074 if (asyncContext == nullptr) {
2075 std::string errorCode = std::to_string(napi_generic_failure);
2076 std::string errorMessage = "SetDeviceDirection error at baseContext is nullptr";
2077 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2078 return nullptr;
2079 }
2080 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->rotation);
2081 if (argc == TWO_VALUE_LIMIT) {
2082 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2083 }
2084 return HandleAsyncWork(
2085 env, asyncContext.release(), "SetDeviceDirection", NativeSetDeviceDirection, NativeVoidCallBack);
2086 }
2087
SetCallPreferenceMode(napi_env env,napi_callback_info info)2088 napi_value NapiCallManager::SetCallPreferenceMode(napi_env env, napi_callback_info info)
2089 {
2090 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2091 NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2092 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2093 NAPI_ASSERT(env, matchFlag, "SetCallPreferenceMode type error, should be number type");
2094 matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_number);
2095 NAPI_ASSERT(env, matchFlag, "SetCallPreferenceMode type error, should be number type");
2096 auto asyncContext = std::make_unique<SupplementAsyncContext>();
2097 if (asyncContext == nullptr) {
2098 std::string errorCode = std::to_string(napi_generic_failure);
2099 std::string errorMessage = "SetCallPreferenceMode error at baseContext is nullptr";
2100 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2101 return nullptr;
2102 }
2103 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2104 napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->mode);
2105 if (argc == VALUE_MAXIMUM_LIMIT) {
2106 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2107 }
2108 return HandleAsyncWork(
2109 env, asyncContext.release(), "SetCallPreferenceMode", NativeSetCallPreferenceMode, NativeVoidCallBack);
2110 }
2111
StartRTT(napi_env env,napi_callback_info info)2112 napi_value NapiCallManager::StartRTT(napi_env env, napi_callback_info info)
2113 {
2114 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2115 NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2116 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2117 NAPI_ASSERT(env, matchFlag, "StartRTT type error, should be number type");
2118 matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_SECOND], napi_string);
2119 NAPI_ASSERT(env, matchFlag, "StartRTT type error, should be string type");
2120 auto asyncContext = std::make_unique<SupplementAsyncContext>();
2121 if (asyncContext == nullptr) {
2122 std::string errorCode = std::to_string(napi_generic_failure);
2123 std::string errorMessage = "StartRTT error at supplementAsyncContext is nullptr";
2124 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2125 return nullptr;
2126 }
2127 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2128 char tmpStr[kMaxNumberLen + 1] = {0};
2129 size_t strLen = 0;
2130 napi_get_value_string_utf8(env, argv[ARRAY_INDEX_SECOND], tmpStr, PHONE_NUMBER_MAXIMUM_LIMIT, &strLen);
2131 std::string tmpCode(tmpStr, strLen);
2132 asyncContext->content = tmpCode;
2133 if (argc == VALUE_MAXIMUM_LIMIT) {
2134 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2135 }
2136 asyncContext->env = env;
2137 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2138 return HandleAsyncWork(env, asyncContext.release(), "StartRTT", NativeStartRTT, NativeVoidCallBack);
2139 }
2140
StopRTT(napi_env env,napi_callback_info info)2141 napi_value NapiCallManager::StopRTT(napi_env env, napi_callback_info info)
2142 {
2143 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2144 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2145 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number);
2146 NAPI_ASSERT(env, matchFlag, "StopRTT type error, should be number type");
2147 auto asyncContext = std::make_unique<SupplementAsyncContext>();
2148 if (asyncContext == nullptr) {
2149 std::string errorCode = std::to_string(napi_generic_failure);
2150 std::string errorMessage = "StopRTT error at supplementAsyncContext is nullptr";
2151 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2152 return nullptr;
2153 }
2154 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2155 if (argc == TWO_VALUE_LIMIT) {
2156 napi_create_reference(env, argv[ARRAY_INDEX_SECOND], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2157 }
2158 asyncContext->env = env;
2159 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2160 return HandleAsyncWork(env, asyncContext.release(), "StopRTT", NativeStopRTT, NativeVoidCallBack);
2161 }
2162
JoinConference(napi_env env,napi_callback_info info)2163 napi_value NapiCallManager::JoinConference(napi_env env, napi_callback_info info)
2164 {
2165 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2166 if (!MatchNumberAndObjectParameters(env, argv, argc)) {
2167 TELEPHONY_LOGE("NapiCallManager::JoinConference MatchNumberAndObjectParameters failed.");
2168 NapiUtil::ThrowParameterError(env);
2169 return nullptr;
2170 }
2171 uint32_t arrayLength = 0;
2172 NAPI_CALL(env, napi_get_array_length(env, argv[ARRAY_INDEX_SECOND], &arrayLength));
2173 if (!NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_number) || arrayLength == 0) {
2174 TELEPHONY_LOGE("NapiCallManager::JoinConference parameter type matching failed.");
2175 NapiUtil::ThrowParameterError(env);
2176 return nullptr;
2177 }
2178 auto asyncContext = std::make_unique<ListAsyncContext>();
2179 if (asyncContext == nullptr) {
2180 TELEPHONY_LOGE("NapiCallManager::JoinConference asyncContext is nullptr.");
2181 NapiUtil::ThrowParameterError(env);
2182 return nullptr;
2183 }
2184 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2185 (asyncContext->listResult).clear();
2186
2187 napi_value napiFormId;
2188 std::string str = "";
2189 size_t len = 0;
2190 char chars[PHONE_NUMBER_MAXIMUM_LIMIT + 1] = { 0 };
2191 napi_status getStringStatus = napi_invalid_arg;
2192 for (uint32_t i = 0; i < arrayLength; i++) {
2193 napi_get_element(env, argv[ARRAY_INDEX_SECOND], i, &napiFormId);
2194 if (!NapiCallManagerUtils::MatchValueType(env, napiFormId, napi_string)) {
2195 TELEPHONY_LOGE("NapiCallManager::JoinConference parameter type matching failed.");
2196 NapiUtil::ThrowParameterError(env);
2197 return nullptr;
2198 }
2199 getStringStatus = napi_get_value_string_utf8(env, napiFormId, chars, PHONE_NUMBER_MAXIMUM_LIMIT, &len);
2200 if (getStringStatus == napi_ok && len > 0) {
2201 str = std::string(chars, len);
2202 (asyncContext->listResult).push_back(Str8ToStr16(str));
2203 TELEPHONY_LOGI("napi_string %{public}s", str.c_str());
2204 }
2205 }
2206
2207 if (argc == VALUE_MAXIMUM_LIMIT) {
2208 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2209 }
2210 return HandleAsyncWork(
2211 env, asyncContext.release(), "JoinConference", NativeJoinConference, NativeVoidCallBackWithErrorCode);
2212 }
2213
UpdateImsCallMode(napi_env env,napi_callback_info info)2214 napi_value NapiCallManager::UpdateImsCallMode(napi_env env, napi_callback_info info)
2215 {
2216 GET_PARAMS(env, info, THREE_VALUE_MAXIMUM_LIMIT);
2217 if (!MatchTwoNumberParameters(env, argv, argc)) {
2218 TELEPHONY_LOGE("NapiCallManager::UpdateImsCallMode MatchTwoNumberParameters failed.");
2219 NapiUtil::ThrowParameterError(env);
2220 return nullptr;
2221 }
2222 auto asyncContext = std::make_unique<SupplementAsyncContext>();
2223 if (asyncContext == nullptr) {
2224 TELEPHONY_LOGE("NapiCallManager::UpdateImsCallMode asyncContext is nullptr.");
2225 NapiUtil::ThrowParameterError(env);
2226 return nullptr;
2227 }
2228 napi_get_value_int32(env, argv[ARRAY_INDEX_FIRST], &asyncContext->callId);
2229 napi_get_value_int32(env, argv[ARRAY_INDEX_SECOND], &asyncContext->type);
2230 if (argc == VALUE_MAXIMUM_LIMIT) {
2231 napi_create_reference(env, argv[ARRAY_INDEX_THIRD], DATA_LENGTH_ONE, &(asyncContext->callbackRef));
2232 }
2233 asyncContext->env = env;
2234 napi_create_reference(env, thisVar, DATA_LENGTH_ONE, &(asyncContext->thisVar));
2235 return HandleAsyncWork(
2236 env, asyncContext.release(), "UpdateImsCallMode", NativeUpdateImsCallMode, NativeVoidCallBackWithErrorCode);
2237 }
2238
ReportOttCallDetailsInfo(napi_env env,napi_callback_info info)2239 napi_value NapiCallManager::ReportOttCallDetailsInfo(napi_env env, napi_callback_info info)
2240 {
2241 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2242 NAPI_ASSERT(env, argc <= VALUE_MAXIMUM_LIMIT, "parameter error!");
2243 uint32_t arrayLength = 0;
2244 NAPI_CALL(env, napi_get_array_length(env, argv[ARRAY_INDEX_FIRST], &arrayLength));
2245 NAPI_ASSERT(env, arrayLength > 0, "Parameter cannot be empty");
2246 auto asyncContext = std::make_unique<OttCallAsyncContext>();
2247 if (asyncContext == nullptr) {
2248 std::string errorCode = std::to_string(napi_generic_failure);
2249 std::string errorMessage = "ReportOttCallDetailsInfo error at baseContext is nullptr";
2250 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2251 return nullptr;
2252 }
2253 (asyncContext->ottVec).clear();
2254
2255 napi_value napiFormId;
2256 OttCallDetailsInfo tmpOttVec;
2257 (void)memset_s(&tmpOttVec, sizeof(OttCallDetailsInfo), 0, sizeof(OttCallDetailsInfo));
2258 for (uint32_t i = 0; i < arrayLength; i++) {
2259 napi_get_element(env, argv[ARRAY_INDEX_FIRST], i, &napiFormId);
2260 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, napiFormId, napi_object);
2261 NAPI_ASSERT(env, matchFlag, "ReportOttCallDetailsInfo type error, should be napi_object type");
2262 std::string tmpStr = NapiCallManagerUtils::GetStringProperty(env, napiFormId, "phoneNumber");
2263 if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2264 TELEPHONY_LOGE("Number out of limit!");
2265 return (napi_value) nullptr;
2266 }
2267 if (memcpy_s(tmpOttVec.phoneNum, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2268 return (napi_value) nullptr;
2269 }
2270 tmpStr = NapiCallManagerUtils::GetStringProperty(env, napiFormId, "bundleName");
2271 if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2272 TELEPHONY_LOGE("Number out of limit!");
2273 return (napi_value) nullptr;
2274 }
2275 if (memcpy_s(tmpOttVec.bundleName, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2276 return (napi_value) nullptr;
2277 }
2278 int32_t tmpValue = NapiCallManagerUtils::GetIntProperty(env, napiFormId, "videoState");
2279 tmpOttVec.videoState = static_cast<VideoStateType>(tmpValue);
2280 tmpValue = NapiCallManagerUtils::GetIntProperty(env, napiFormId, "callState");
2281 tmpOttVec.callState = static_cast<TelCallState>(tmpValue);
2282 (asyncContext->ottVec).push_back(tmpOttVec);
2283 }
2284
2285 return HandleAsyncWork(
2286 env, asyncContext.release(), "ReportOttCallDetailsInfo", NativeReportOttCallDetailsInfo, NativeVoidCallBack);
2287 }
2288
ReportOttCallEventInfo(napi_env env,napi_callback_info info)2289 napi_value NapiCallManager::ReportOttCallEventInfo(napi_env env, napi_callback_info info)
2290 {
2291 GET_PARAMS(env, info, VALUE_MAXIMUM_LIMIT);
2292 NAPI_ASSERT(env, argc < VALUE_MAXIMUM_LIMIT, "parameter error!");
2293 bool matchFlag = NapiCallManagerUtils::MatchValueType(env, argv[ARRAY_INDEX_FIRST], napi_object);
2294 NAPI_ASSERT(env, matchFlag, "ReportOttCallEventInfo type error, should be object type");
2295 auto asyncContext = std::make_unique<OttEventAsyncContext>();
2296 if (asyncContext == nullptr) {
2297 std::string errorCode = std::to_string(napi_generic_failure);
2298 std::string errorMessage = "ReportOttCallEventInfo error at baseContext is nullptr";
2299 NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));
2300 return nullptr;
2301 }
2302 (void)memset_s(&asyncContext->eventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
2303 int32_t eventId = NapiCallManagerUtils::GetIntProperty(env, argv[ARRAY_INDEX_FIRST], "eventId");
2304 std::string tmpStr = NapiCallManagerUtils::GetStringProperty(env, argv[ARRAY_INDEX_FIRST], "bundleName");
2305 if (tmpStr.length() > static_cast<size_t>(kMaxNumberLen)) {
2306 TELEPHONY_LOGE("Number out of limit!");
2307 return (napi_value) nullptr;
2308 }
2309 asyncContext->eventInfo.ottCallEventId = static_cast<OttCallEventId>(eventId);
2310 if (memcpy_s(asyncContext->eventInfo.bundleName, kMaxNumberLen, tmpStr.c_str(), tmpStr.length()) != EOK) {
2311 return (napi_value) nullptr;
2312 }
2313 return HandleAsyncWork(
2314 env, asyncContext.release(), "ReportOttCallEventInfo", NativeReportOttCallEventInfo, NativeVoidCallBack);
2315 }
2316
HasVoiceCapability(napi_env env,napi_callback_info)2317 napi_value NapiCallManager::HasVoiceCapability(napi_env env, napi_callback_info)
2318 {
2319 TELEPHONY_LOGI("napi_call HasVoiceCapability");
2320 napi_value result = nullptr;
2321 napi_get_boolean(env, DelayedSingleton<CallManagerClient>::GetInstance()->HasVoiceCapability(), &result);
2322 return result;
2323 }
2324
NativeCallBack(napi_env env,napi_status status,void * data)2325 void NapiCallManager::NativeCallBack(napi_env env, napi_status status, void *data)
2326 {
2327 if (data == nullptr) {
2328 TELEPHONY_LOGE("data is nullptr");
2329 NapiUtil::ThrowParameterError(env);
2330 return;
2331 }
2332 auto asyncContext = (AsyncContext *)data;
2333 if (asyncContext->deferred != nullptr) {
2334 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2335 napi_value promiseValue = nullptr;
2336 napi_create_int32(env, asyncContext->resolved, &promiseValue);
2337 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2338 } else {
2339 napi_reject_deferred(env, asyncContext->deferred,
2340 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2341 env, asyncContext->errorCode, asyncContext->eventId));
2342 }
2343 } else if (asyncContext->callbackRef != nullptr) {
2344 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2345 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2346 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2347 napi_create_int32(env, asyncContext->resolved, &callbackValue[ARRAY_INDEX_SECOND]);
2348 } else {
2349 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2350 env, asyncContext->errorCode, asyncContext->eventId);
2351 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2352 }
2353 napi_value callback = nullptr;
2354 napi_value result = nullptr;
2355 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2356 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2357 napi_delete_reference(env, asyncContext->callbackRef);
2358 }
2359 napi_delete_async_work(env, asyncContext->work);
2360 delete asyncContext;
2361 asyncContext = nullptr;
2362 }
2363
NativeDialCallBack(napi_env env,napi_status status,void * data)2364 void NapiCallManager::NativeDialCallBack(napi_env env, napi_status status, void *data)
2365 {
2366 if (data == nullptr) {
2367 TELEPHONY_LOGE("data is nullptr");
2368 NapiUtil::ThrowParameterError(env);
2369 return;
2370 }
2371 auto asyncContext = (AsyncContext *)data;
2372 if (asyncContext->deferred != nullptr) {
2373 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2374 napi_value promiseValue = nullptr;
2375 napi_get_boolean(env, true, &promiseValue);
2376 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2377 } else {
2378 napi_reject_deferred(env, asyncContext->deferred,
2379 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2380 env, asyncContext->errorCode, asyncContext->eventId));
2381 }
2382 } else if (asyncContext->callbackRef != nullptr) {
2383 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2384 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2385 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2386 napi_get_boolean(env, true, &callbackValue[ARRAY_INDEX_SECOND]);
2387 } else {
2388 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2389 env, asyncContext->errorCode, asyncContext->eventId);
2390 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2391 }
2392 napi_value callback = nullptr;
2393 napi_value result = nullptr;
2394 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2395 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2396 napi_delete_reference(env, asyncContext->callbackRef);
2397 }
2398 napi_delete_async_work(env, asyncContext->work);
2399 delete asyncContext;
2400 asyncContext = nullptr;
2401 }
2402
NativeVoidCallBack(napi_env env,napi_status status,void * data)2403 void NapiCallManager::NativeVoidCallBack(napi_env env, napi_status status, void *data)
2404 {
2405 if (data == nullptr) {
2406 TELEPHONY_LOGE("data is nullptr");
2407 return;
2408 }
2409 auto asyncContext = (AsyncContext *)data;
2410 if (asyncContext->deferred != nullptr) {
2411 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2412 napi_value promiseValue = nullptr;
2413 napi_get_null(env, &promiseValue);
2414 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2415 TELEPHONY_LOGI("promise successful result = %{public}d", ret);
2416 } else {
2417 std::string errTip = std::to_string(asyncContext->resolved);
2418 napi_status ret = napi_reject_deferred(
2419 env, asyncContext->deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
2420 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2421 }
2422 } else if (asyncContext->callbackRef != nullptr) {
2423 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2424 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2425 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2426 napi_get_null(env, &callbackValue[ARRAY_INDEX_SECOND]);
2427 } else {
2428 std::string errTip = std::to_string(asyncContext->resolved);
2429 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
2430 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2431 }
2432 napi_value callback = nullptr;
2433 napi_value result = nullptr;
2434 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2435 napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2436 TELEPHONY_LOGI("callback result = %{public}d", ret);
2437 napi_delete_reference(env, asyncContext->callbackRef);
2438 }
2439 napi_delete_async_work(env, asyncContext->work);
2440 delete asyncContext;
2441 asyncContext = nullptr;
2442 }
2443
NativeVoidCallBackWithErrorCode(napi_env env,napi_status status,void * data)2444 void NapiCallManager::NativeVoidCallBackWithErrorCode(napi_env env, napi_status status, void *data)
2445 {
2446 if (data == nullptr) {
2447 TELEPHONY_LOGE("NapiCallManager::NativeVoidCallBackWithErrorCode data is nullptr");
2448 NapiUtil::ThrowParameterError(env);
2449 return;
2450 }
2451 auto asyncContext = (AsyncContext *)data;
2452 if (asyncContext->deferred != nullptr) {
2453 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2454 napi_value promiseValue = nullptr;
2455 napi_get_null(env, &promiseValue);
2456 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2457 TELEPHONY_LOGI("promise successful result = %{public}d", ret);
2458 } else {
2459 napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
2460 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2461 env, asyncContext->errorCode, asyncContext->eventId));
2462 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2463 }
2464 } else if (asyncContext->callbackRef != nullptr) {
2465 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2466 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2467 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2468 napi_get_null(env, &callbackValue[ARRAY_INDEX_SECOND]);
2469 } else {
2470 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2471 env, asyncContext->errorCode, asyncContext->eventId);
2472 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2473 }
2474 napi_value callback = nullptr;
2475 napi_value result = nullptr;
2476 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2477 napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2478 TELEPHONY_LOGI("callback result = %{public}d", ret);
2479 napi_delete_reference(env, asyncContext->callbackRef);
2480 }
2481 napi_delete_async_work(env, asyncContext->work);
2482 delete asyncContext;
2483 asyncContext = nullptr;
2484 }
2485
NativePropertyCallBack(napi_env env,napi_status status,void * data)2486 void NapiCallManager::NativePropertyCallBack(napi_env env, napi_status status, void *data)
2487 {
2488 if (data == nullptr) {
2489 TELEPHONY_LOGE("data is nullptr");
2490 return;
2491 }
2492 auto asyncContext = (AsyncContext *)data;
2493 if (asyncContext->deferred != nullptr) {
2494 napi_value promiseValue = nullptr;
2495 napi_create_int32(env, asyncContext->resolved, &promiseValue);
2496 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2497 } else {
2498 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2499 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2500 napi_create_int32(env, asyncContext->resolved, &callbackValue[ARRAY_INDEX_SECOND]);
2501 napi_value callback = nullptr;
2502 napi_value result = nullptr;
2503 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2504 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2505 napi_delete_reference(env, asyncContext->callbackRef);
2506 }
2507 napi_delete_async_work(env, asyncContext->work);
2508 delete asyncContext;
2509 asyncContext = nullptr;
2510 }
2511
NativeGetMainCallIdCallBack(napi_env env,napi_status status,void * data)2512 void NapiCallManager::NativeGetMainCallIdCallBack(napi_env env, napi_status status, void *data)
2513 {
2514 if (data == nullptr) {
2515 TELEPHONY_LOGE("NapiCallManager::NativeGetMainCallIdCallBack data is nullptr");
2516 NapiUtil::ThrowParameterError(env);
2517 return;
2518 }
2519 auto asyncContext = (IntResultAsyncContext *)data;
2520 if (asyncContext->deferred != nullptr) {
2521 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2522 napi_value promiseValue = nullptr;
2523 napi_create_int32(env, asyncContext->result, &promiseValue);
2524 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2525 TELEPHONY_LOGI("promise successful result = %{public}d", ret);
2526 } else {
2527 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2528 napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
2529 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
2530 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2531 }
2532 } else if (asyncContext->callbackRef != nullptr) {
2533 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2534 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2535 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2536 napi_create_int32(env, asyncContext->result, &callbackValue[ARRAY_INDEX_SECOND]);
2537 } else {
2538 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2539 callbackValue[ARRAY_INDEX_FIRST] =
2540 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
2541 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2542 }
2543 napi_value callback = nullptr;
2544 napi_value result = nullptr;
2545 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2546 napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2547 TELEPHONY_LOGI("callback result = %{public}d", ret);
2548 napi_delete_reference(env, asyncContext->callbackRef);
2549 }
2550 napi_delete_async_work(env, asyncContext->work);
2551 delete asyncContext;
2552 asyncContext = nullptr;
2553 }
2554
NativeIsImsSwitchEnabledCallBack(napi_env env,napi_status status,void * data)2555 void NapiCallManager::NativeIsImsSwitchEnabledCallBack(napi_env env, napi_status status, void *data)
2556 {
2557 if (data == nullptr) {
2558 TELEPHONY_LOGE("NapiCallManager::NativeIsImsSwitchEnabledCallBack data is nullptr");
2559 NapiUtil::ThrowParameterError(env);
2560 return;
2561 }
2562 auto asyncContext = (ImsSwitchAsyncContext *)data;
2563 if (asyncContext->deferred != nullptr) {
2564 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2565 napi_value promiseValue = nullptr;
2566 napi_get_boolean(env, asyncContext->enabled, &promiseValue);
2567 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2568 } else {
2569 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2570 napi_reject_deferred(env, asyncContext->deferred,
2571 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
2572 }
2573 } else {
2574 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2575 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2576 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2577 napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
2578 } else {
2579 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2580 callbackValue[ARRAY_INDEX_FIRST] =
2581 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
2582 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2583 }
2584 napi_value callback = nullptr;
2585 napi_value result = nullptr;
2586 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2587 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2588 napi_delete_reference(env, asyncContext->callbackRef);
2589 }
2590 napi_delete_async_work(env, asyncContext->work);
2591 delete asyncContext;
2592 asyncContext = nullptr;
2593 }
2594
NativeBoolCallBack(napi_env env,napi_status status,void * data)2595 void NapiCallManager::NativeBoolCallBack(napi_env env, napi_status status, void *data)
2596 {
2597 if (data == nullptr) {
2598 TELEPHONY_LOGE("data is nullptr");
2599 return;
2600 }
2601 auto asyncContext = (AsyncContext *)data;
2602 if (asyncContext->deferred != nullptr) {
2603 if (asyncContext->resolved == BOOL_VALUE_IS_TRUE) {
2604 napi_value promiseValue = nullptr;
2605 napi_get_boolean(env, true, &promiseValue);
2606 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2607 } else if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2608 napi_value promiseValue = nullptr;
2609 napi_get_boolean(env, false, &promiseValue);
2610 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2611 } else if (asyncContext->errorCode == SLOT_ID_INVALID) {
2612 napi_reject_deferred(env, asyncContext->deferred,
2613 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID));
2614 } else {
2615 std::string errTip = std::to_string(asyncContext->errorCode);
2616 napi_reject_deferred(env, asyncContext->deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
2617 }
2618 } else {
2619 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2620 if (asyncContext->resolved == BOOL_VALUE_IS_TRUE) {
2621 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2622 napi_get_boolean(env, true, &callbackValue[ARRAY_INDEX_SECOND]);
2623 } else if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2624 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2625 napi_get_boolean(env, false, &callbackValue[ARRAY_INDEX_SECOND]);
2626 } else if (asyncContext->errorCode == SLOT_ID_INVALID) {
2627 callbackValue[ARRAY_INDEX_FIRST] =
2628 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, "slotId is invalid", SLOT_ID_INVALID);
2629 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2630 } else {
2631 std::string errTip = std::to_string(asyncContext->errorCode);
2632 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
2633 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2634 }
2635 napi_value callback = nullptr;
2636 napi_value result = nullptr;
2637 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2638 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2639 napi_delete_reference(env, asyncContext->callbackRef);
2640 }
2641 napi_delete_async_work(env, asyncContext->work);
2642 delete asyncContext;
2643 asyncContext = nullptr;
2644 }
2645
NativeIsEmergencyPhoneNumberCallBack(napi_env env,napi_status status,void * data)2646 void NapiCallManager::NativeIsEmergencyPhoneNumberCallBack(napi_env env, napi_status status, void *data)
2647 {
2648 if (data == nullptr) {
2649 TELEPHONY_LOGE("NapiCallManager::NativeIsEmergencyPhoneNumberCallBack data is nullptr");
2650 NapiUtil::ThrowParameterError(env);
2651 return;
2652 }
2653 auto asyncContext = (UtilsAsyncContext *)data;
2654 if (asyncContext->deferred != nullptr) {
2655 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2656 napi_value promiseValue = nullptr;
2657 napi_get_boolean(env, asyncContext->enabled, &promiseValue);
2658 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2659 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2660 } else {
2661 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2662 napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
2663 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
2664 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2665 }
2666 } else if (asyncContext->callbackRef != nullptr) {
2667 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2668 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2669 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2670 napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
2671 } else {
2672 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2673 callbackValue[ARRAY_INDEX_FIRST] =
2674 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
2675 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2676 }
2677 napi_value callback = nullptr;
2678 napi_value result = nullptr;
2679 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2680 napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2681 TELEPHONY_LOGI("callback result = %{public}d", ret);
2682 napi_delete_reference(env, asyncContext->callbackRef);
2683 }
2684 napi_delete_async_work(env, asyncContext->work);
2685 delete asyncContext;
2686 asyncContext = nullptr;
2687 }
2688
NativeBoolCallBackWithErrorCode(napi_env env,napi_status status,void * data)2689 void NapiCallManager::NativeBoolCallBackWithErrorCode(napi_env env, napi_status status, void *data)
2690 {
2691 if (data == nullptr) {
2692 TELEPHONY_LOGE("NapiCallManager::NativeBoolCallBackWithErrorCode data is nullptr");
2693 NapiUtil::ThrowParameterError(env);
2694 return;
2695 }
2696 auto asyncContext = (BoolResultAsyncContext *)data;
2697 if (asyncContext->deferred != nullptr) {
2698 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2699 napi_value promiseValue = nullptr;
2700 napi_get_boolean(env, asyncContext->enabled, &promiseValue);
2701 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2702 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2703 } else {
2704 napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
2705 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2706 env, asyncContext->errorCode, asyncContext->eventId));
2707 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2708 }
2709 } else if (asyncContext->callbackRef != nullptr) {
2710 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2711 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2712 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2713 napi_get_boolean(env, asyncContext->enabled, &callbackValue[ARRAY_INDEX_SECOND]);
2714 } else {
2715 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2716 env, asyncContext->errorCode, asyncContext->eventId);
2717 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2718 }
2719 napi_value callback = nullptr;
2720 napi_value result = nullptr;
2721 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2722 napi_status ret = napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2723 TELEPHONY_LOGI("callback result = %{public}d", ret);
2724 napi_delete_reference(env, asyncContext->callbackRef);
2725 }
2726 napi_delete_async_work(env, asyncContext->work);
2727 delete asyncContext;
2728 asyncContext = nullptr;
2729 }
2730
NativeFormatNumberCallBack(napi_env env,napi_status status,void * data)2731 void NapiCallManager::NativeFormatNumberCallBack(napi_env env, napi_status status, void *data)
2732 {
2733 if (data == nullptr) {
2734 TELEPHONY_LOGE("NapiCallManager::NativeFormatNumberCallBack data is nullptr");
2735 NapiUtil::ThrowParameterError(env);
2736 return;
2737 }
2738 auto asyncContext = (UtilsAsyncContext *)data;
2739 if (asyncContext->deferred != nullptr) {
2740 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2741 napi_value promiseValue = nullptr;
2742 napi_create_string_utf8(env, Str16ToStr8(asyncContext->formatNumber).data(),
2743 asyncContext->formatNumber.length(), &promiseValue);
2744 napi_status ret = napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2745 TELEPHONY_LOGI("promise successful result = %{public}d", ret);
2746 } else {
2747 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2748 napi_status ret = napi_reject_deferred(env, asyncContext->deferred,
2749 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
2750 TELEPHONY_LOGI("promise failed result = %{public}d", ret);
2751 }
2752 } else if (asyncContext->callbackRef != nullptr) {
2753 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2754 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2755 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2756 napi_create_string_utf8(env, Str16ToStr8(asyncContext->formatNumber).data(),
2757 asyncContext->formatNumber.length(), &callbackValue[ARRAY_INDEX_SECOND]);
2758 } else {
2759 JsError error = NapiUtil::ConverErrorMessageForJs(asyncContext->errorCode);
2760 callbackValue[ARRAY_INDEX_FIRST] =
2761 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
2762 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2763 }
2764 napi_value callback = nullptr;
2765 napi_value result = nullptr;
2766 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2767 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2768 napi_delete_reference(env, asyncContext->callbackRef);
2769 }
2770 napi_delete_async_work(env, asyncContext->work);
2771 delete asyncContext;
2772 asyncContext = nullptr;
2773 }
2774
NativeListCallBack(napi_env env,napi_status status,void * data)2775 void NapiCallManager::NativeListCallBack(napi_env env, napi_status status, void *data)
2776 {
2777 if (data == nullptr) {
2778 NapiUtil::ThrowParameterError(env);
2779 return;
2780 }
2781 int32_t i = 0;
2782 napi_value info = nullptr;
2783 auto asyncContext = (ListAsyncContext *)data;
2784 std::vector<std::u16string>::iterator it = asyncContext->listResult.begin();
2785 if (asyncContext->deferred != nullptr) {
2786 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2787 napi_value promiseValue = nullptr;
2788 napi_create_array(env, &promiseValue);
2789 for (; it != asyncContext->listResult.end(); ++it) {
2790 napi_create_string_utf8(env, Str16ToStr8(*it).data(), (*it).length(), &info);
2791 napi_set_element(env, promiseValue, i, info);
2792 ++i;
2793 }
2794 napi_resolve_deferred(env, asyncContext->deferred, promiseValue);
2795 } else {
2796 napi_reject_deferred(env, asyncContext->deferred,
2797 NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2798 env, asyncContext->errorCode, asyncContext->eventId));
2799 }
2800 } else if (asyncContext->callbackRef != nullptr) {
2801 napi_value callbackValue[ARRAY_INDEX_THIRD] = { 0 };
2802 if (asyncContext->resolved == TELEPHONY_SUCCESS) {
2803 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
2804 napi_create_array(env, &callbackValue[ARRAY_INDEX_SECOND]);
2805 for (; it != asyncContext->listResult.end(); ++it) {
2806 napi_create_string_utf8(env, Str16ToStr8(*it).data(), (*it).length(), &info);
2807 napi_set_element(env, callbackValue[ARRAY_INDEX_SECOND], i, info);
2808 ++i;
2809 }
2810 } else {
2811 callbackValue[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(
2812 env, asyncContext->errorCode, asyncContext->eventId);
2813 callbackValue[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
2814 }
2815 napi_value callback = nullptr;
2816 napi_value result = nullptr;
2817 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
2818 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
2819 napi_delete_reference(env, asyncContext->callbackRef);
2820 }
2821 napi_delete_async_work(env, asyncContext->work);
2822 delete asyncContext;
2823 asyncContext = nullptr;
2824 }
2825
GetDialInfo(napi_env env,napi_value objValue,DialAsyncContext & asyncContext)2826 void NapiCallManager::GetDialInfo(napi_env env, napi_value objValue, DialAsyncContext &asyncContext)
2827 {
2828 asyncContext.accountId = NapiCallManagerUtils::GetIntProperty(env, objValue, "accountId");
2829 asyncContext.videoState = NapiCallManagerUtils::GetIntProperty(env, objValue, "videoState");
2830 asyncContext.dialScene = NapiCallManagerUtils::GetIntProperty(env, objValue, "dialScene");
2831 asyncContext.dialType = NapiCallManagerUtils::GetIntProperty(env, objValue, "dialType");
2832 }
2833
GetSmsInfo(napi_env env,napi_value objValue,RejectAsyncContext & asyncContext)2834 void NapiCallManager::GetSmsInfo(napi_env env, napi_value objValue, RejectAsyncContext &asyncContext)
2835 {
2836 asyncContext.isSendSms = true;
2837 asyncContext.messageContent = NapiCallManagerUtils::GetStringProperty(env, objValue, "messageContent");
2838 }
2839
GetRestrictionInfo(napi_env env,napi_value objValue,CallRestrictionAsyncContext & asyncContext)2840 int32_t NapiCallManager::GetRestrictionInfo(
2841 napi_env env, napi_value objValue, CallRestrictionAsyncContext &asyncContext)
2842 {
2843 int32_t type = 0;
2844 int32_t mode = 0;
2845 std::string pw = "";
2846 if (!NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "type", type) ||
2847 !NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "mode", mode) ||
2848 !NapiCallManagerUtils::GetUssdStringProperty(env, objValue, "password", pw)) {
2849 NapiUtil::ThrowParameterError(env);
2850 return ERROR_PARAMETER_TYPE_INVALID;
2851 }
2852 if (pw.length() > static_cast<size_t>(kMaxNumberLen)) {
2853 TELEPHONY_LOGE("Number out of limit!");
2854 return TELEPHONY_ERR_ARGUMENT_INVALID;
2855 }
2856 if (memcpy_s(asyncContext.info.password, kMaxNumberLen, pw.c_str(), pw.length()) != EOK) {
2857 TELEPHONY_LOGE("memcpy_s failed!");
2858 return TELEPHONY_ERR_MEMCPY_FAIL;
2859 }
2860 asyncContext.info.fac = static_cast<CallRestrictionType>(type);
2861 asyncContext.info.mode = static_cast<CallRestrictionMode>(mode);
2862 TELEPHONY_LOGI("GetRestrictionInfo: type = %{public}d, mode = %{public}d",
2863 asyncContext.info.fac, asyncContext.info.mode);
2864 return TELEPHONY_SUCCESS;
2865 }
2866
GetTransferInfo(napi_env env,napi_value objValue,CallTransferAsyncContext & asyncContext)2867 int32_t NapiCallManager::GetTransferInfo(napi_env env, napi_value objValue, CallTransferAsyncContext &asyncContext)
2868 {
2869 int32_t type = 0;
2870 int32_t settingType = 0;
2871 std::string transferNum = "";
2872 if (!NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "type", type) ||
2873 !NapiCallManagerUtils::GetUssdIntProperty(env, objValue, "settingType", settingType) ||
2874 !NapiCallManagerUtils::GetUssdStringProperty(env, objValue, "transferNum", transferNum)) {
2875 return ERROR_PARAMETER_TYPE_INVALID;
2876 }
2877 if (transferNum.length() > static_cast<size_t>(kMaxNumberLen)) {
2878 TELEPHONY_LOGE("Number out of limit!");
2879 return TELEPHONY_ERR_ARGUMENT_INVALID;
2880 }
2881 if (memcpy_s(asyncContext.info.transferNum, kMaxNumberLen, transferNum.c_str(), transferNum.length()) != EOK) {
2882 TELEPHONY_LOGE("memcpy_s failed!");
2883 return TELEPHONY_ERR_MEMCPY_FAIL;
2884 }
2885 asyncContext.info.settingType = static_cast<CallTransferSettingType>(settingType);
2886 asyncContext.info.type = static_cast<CallTransferType>(type);
2887 TELEPHONY_LOGI("GetTransferInfo: type = %{public}d, settingType = %{public}d, transferNum = %{public}s",
2888 asyncContext.info.type, asyncContext.info.settingType, asyncContext.info.transferNum);
2889 return TELEPHONY_SUCCESS;
2890 }
2891
IsValidSlotId(int32_t slotId)2892 static inline bool IsValidSlotId(int32_t slotId)
2893 {
2894 return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
2895 }
2896
NativeDial(napi_env env,void * data)2897 void NapiCallManager::NativeDial(napi_env env, void *data)
2898 {
2899 if (data == nullptr) {
2900 TELEPHONY_LOGE("data is nullptr");
2901 NapiUtil::ThrowParameterError(env);
2902 return;
2903 }
2904 auto asyncContext = (DialAsyncContext *)data;
2905 if (!IsValidSlotId(asyncContext->accountId)) {
2906 TELEPHONY_LOGE("NativeDial slotId is invalid");
2907 asyncContext->errorCode = SLOT_ID_INVALID;
2908 return;
2909 }
2910 std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
2911 OHOS::AppExecFwk::PacMap dialInfo;
2912 dialInfo.PutIntValue("accountId", asyncContext->accountId);
2913 dialInfo.PutIntValue("videoState", asyncContext->videoState);
2914 dialInfo.PutIntValue("dialScene", asyncContext->dialScene);
2915 dialInfo.PutIntValue("dialType", asyncContext->dialType);
2916 asyncContext->errorCode =
2917 DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(Str8ToStr16(phoneNumber), dialInfo);
2918 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2919 asyncContext->resolved = TELEPHONY_SUCCESS;
2920 }
2921 asyncContext->eventId = CALL_MANAGER_DIAL_CALL;
2922 }
2923
NativeDialCall(napi_env env,void * data)2924 void NapiCallManager::NativeDialCall(napi_env env, void *data)
2925 {
2926 if (data == nullptr) {
2927 TELEPHONY_LOGE("NapiCallManager::NativeDialCall data is nullptr");
2928 NapiUtil::ThrowParameterError(env);
2929 return;
2930 }
2931 auto asyncContext = (DialAsyncContext *)data;
2932 if (!IsValidSlotId(asyncContext->accountId)) {
2933 TELEPHONY_LOGE("NativeDialCall slotId is invalid");
2934 asyncContext->errorCode = SLOT_ID_INVALID;
2935 return;
2936 }
2937 std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
2938 OHOS::AppExecFwk::PacMap dialInfo;
2939 dialInfo.PutIntValue("accountId", asyncContext->accountId);
2940 dialInfo.PutIntValue("videoState", asyncContext->videoState);
2941 dialInfo.PutIntValue("dialScene", asyncContext->dialScene);
2942 dialInfo.PutIntValue("dialType", asyncContext->dialType);
2943 asyncContext->errorCode =
2944 DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(Str8ToStr16(phoneNumber), dialInfo);
2945 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2946 asyncContext->resolved = TELEPHONY_SUCCESS;
2947 }
2948 asyncContext->eventId = CALL_MANAGER_DIAL_CALL;
2949 }
2950
NativeMakeCall(napi_env env,void * data)2951 void NapiCallManager::NativeMakeCall(napi_env env, void *data)
2952 {
2953 if (data == nullptr) {
2954 TELEPHONY_LOGE("NapiCallManager::NativeMakeCall data is nullptr");
2955 NapiUtil::ThrowParameterError(env);
2956 return;
2957 }
2958 auto asyncContext = (AsyncContext *)data;
2959 std::string phoneNumber(asyncContext->number, asyncContext->numberLen);
2960 AAFwk::Want want;
2961 AppExecFwk::ElementName element("", "com.ohos.contacts", "com.ohos.contacts.MainAbility");
2962 want.SetElement(element);
2963 AAFwk::WantParams wantParams;
2964 wantParams.SetParam("phoneNumber", AAFwk::String::Box(phoneNumber));
2965 wantParams.SetParam("pageFlag", AAFwk::String::Box("page_flag_edit_before_calling"));
2966 want.SetParams(wantParams);
2967 ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want);
2968 if (err != ERR_OK) {
2969 TELEPHONY_LOGE("Fail to make call, err:%{public}d", err);
2970 asyncContext->errorCode = TELEPHONY_ERR_UNINIT;
2971 return;
2972 }
2973 asyncContext->resolved = TELEPHONY_SUCCESS;
2974 }
2975
NativeAnswerCall(napi_env env,void * data)2976 void NapiCallManager::NativeAnswerCall(napi_env env, void *data)
2977 {
2978 if (data == nullptr) {
2979 TELEPHONY_LOGE("NapiCallManager::NativeAnswerCall data is nullptr");
2980 NapiUtil::ThrowParameterError(env);
2981 return;
2982 }
2983 auto asyncContext = (AnswerAsyncContext *)data;
2984 asyncContext->errorCode =
2985 DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(asyncContext->callId, asyncContext->videoState);
2986 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
2987 asyncContext->resolved = TELEPHONY_SUCCESS;
2988 }
2989 asyncContext->eventId = CALL_MANAGER_ANSWER_CALL;
2990 }
2991
NativeRejectCall(napi_env env,void * data)2992 void NapiCallManager::NativeRejectCall(napi_env env, void *data)
2993 {
2994 if (data == nullptr) {
2995 TELEPHONY_LOGE("NapiCallManager::NativeRejectCall data is nullptr");
2996 NapiUtil::ThrowParameterError(env);
2997 return;
2998 }
2999 auto asyncContext = (RejectAsyncContext *)data;
3000 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->RejectCall(
3001 asyncContext->callId, asyncContext->isSendSms, Str8ToStr16(asyncContext->messageContent));
3002 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3003 asyncContext->resolved = TELEPHONY_SUCCESS;
3004 }
3005 asyncContext->eventId = CALL_MANAGER_REJECT_CALL;
3006 }
3007
NativeHangUpCall(napi_env env,void * data)3008 void NapiCallManager::NativeHangUpCall(napi_env env, void *data)
3009 {
3010 if (data == nullptr) {
3011 TELEPHONY_LOGE("NapiCallManager::NativeHangUpCall data is nullptr");
3012 NapiUtil::ThrowParameterError(env);
3013 return;
3014 }
3015 auto asyncContext = (AsyncContext *)data;
3016 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->HangUpCall(asyncContext->callId);
3017 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3018 asyncContext->resolved = TELEPHONY_SUCCESS;
3019 }
3020 asyncContext->eventId = CALL_MANAGER_DISCONNECT_CALL;
3021 }
3022
NativeHoldCall(napi_env env,void * data)3023 void NapiCallManager::NativeHoldCall(napi_env env, void *data)
3024 {
3025 if (data == nullptr) {
3026 TELEPHONY_LOGE("NapiCallManager::NativeHoldCall data is nullptr");
3027 NapiUtil::ThrowParameterError(env);
3028 return;
3029 }
3030 auto asyncContext = (AsyncContext *)data;
3031 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->HoldCall(asyncContext->callId);
3032 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3033 asyncContext->resolved = TELEPHONY_SUCCESS;
3034 }
3035 asyncContext->eventId = CALL_MANAGER_HOLD_CALL;
3036 }
3037
NativeUnHoldCall(napi_env env,void * data)3038 void NapiCallManager::NativeUnHoldCall(napi_env env, void *data)
3039 {
3040 if (data == nullptr) {
3041 TELEPHONY_LOGE("NapiCallManager::NativeUnHoldCall data is nullptr");
3042 NapiUtil::ThrowParameterError(env);
3043 return;
3044 }
3045 auto asyncContext = (AsyncContext *)data;
3046 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->UnHoldCall(asyncContext->callId);
3047 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3048 asyncContext->resolved = TELEPHONY_SUCCESS;
3049 }
3050 asyncContext->eventId = CALL_MANAGER_UNHOLD_CALL;
3051 }
3052
NativeSwitchCall(napi_env env,void * data)3053 void NapiCallManager::NativeSwitchCall(napi_env env, void *data)
3054 {
3055 if (data == nullptr) {
3056 TELEPHONY_LOGE("NapiCallManager::NativeSwitchCall data is nullptr");
3057 NapiUtil::ThrowParameterError(env);
3058 return;
3059 }
3060 auto asyncContext = (AsyncContext *)data;
3061 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SwitchCall(asyncContext->callId);
3062 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3063 asyncContext->resolved = TELEPHONY_SUCCESS;
3064 }
3065 asyncContext->eventId = CALL_MANAGER_SWITCH_CALL;
3066 }
3067
NativeCombineConference(napi_env env,void * data)3068 void NapiCallManager::NativeCombineConference(napi_env env, void *data)
3069 {
3070 if (data == nullptr) {
3071 TELEPHONY_LOGE("NapiCallManager::NativeCombineConference data is nullptr");
3072 NapiUtil::ThrowParameterError(env);
3073 return;
3074 }
3075 auto asyncContext = (AsyncContext *)data;
3076 asyncContext->errorCode =
3077 DelayedSingleton<CallManagerClient>::GetInstance()->CombineConference(asyncContext->callId);
3078 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3079 asyncContext->resolved = TELEPHONY_SUCCESS;
3080 }
3081 }
3082
NativeSeparateConference(napi_env env,void * data)3083 void NapiCallManager::NativeSeparateConference(napi_env env, void *data)
3084 {
3085 if (data == nullptr) {
3086 TELEPHONY_LOGE("NapiCallManager::NativeSeparateConference data is nullptr");
3087 NapiUtil::ThrowParameterError(env);
3088 return;
3089 }
3090 auto asyncContext = (AsyncContext *)data;
3091 asyncContext->errorCode =
3092 DelayedSingleton<CallManagerClient>::GetInstance()->SeparateConference(asyncContext->callId);
3093 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3094 asyncContext->resolved = TELEPHONY_SUCCESS;
3095 }
3096 }
3097
NativeGetMainCallId(napi_env env,void * data)3098 void NapiCallManager::NativeGetMainCallId(napi_env env, void *data)
3099 {
3100 if (data == nullptr) {
3101 TELEPHONY_LOGE("NapiCallManager::NativeGetMainCallId data is nullptr");
3102 NapiUtil::ThrowParameterError(env);
3103 return;
3104 }
3105 auto asyncContext = (IntResultAsyncContext *)data;
3106 asyncContext->result = 0;
3107 asyncContext->errorCode =
3108 DelayedSingleton<CallManagerClient>::GetInstance()->GetMainCallId(asyncContext->callId, asyncContext->result);
3109 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3110 asyncContext->resolved = TELEPHONY_SUCCESS;
3111 }
3112 }
3113
NativeGetSubCallIdList(napi_env env,void * data)3114 void NapiCallManager::NativeGetSubCallIdList(napi_env env, void *data)
3115 {
3116 if (data == nullptr) {
3117 TELEPHONY_LOGE("NapiCallManager::NativeGetSubCallIdList data is nullptr");
3118 NapiUtil::ThrowParameterError(env);
3119 return;
3120 }
3121 auto asyncContext = (ListAsyncContext *)data;
3122 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetSubCallIdList(
3123 asyncContext->callId, asyncContext->listResult);
3124 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3125 asyncContext->resolved = TELEPHONY_SUCCESS;
3126 }
3127 }
3128
NativeGetCallIdListForConference(napi_env env,void * data)3129 void NapiCallManager::NativeGetCallIdListForConference(napi_env env, void *data)
3130 {
3131 if (data == nullptr) {
3132 TELEPHONY_LOGE("NapiCallManager::NativeGetCallIdListForConference data is nullptr");
3133 NapiUtil::ThrowParameterError(env);
3134 return;
3135 }
3136 auto asyncContext = (ListAsyncContext *)data;
3137 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallIdListForConference(
3138 asyncContext->callId, asyncContext->listResult);
3139 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3140 asyncContext->resolved = TELEPHONY_SUCCESS;
3141 }
3142 }
3143
3144 /**
3145 * Register a callback to NapiCallAbilityCallback. When call_manager has data returned,
3146 * NapiCallAbilityCallback will notify JavaScript via the registered callback.
3147 * The whole process is asynchronous.
3148 */
NativeGetCallWaiting(napi_env env,void * data)3149 void NapiCallManager::NativeGetCallWaiting(napi_env env, void *data)
3150 {
3151 if (data == nullptr) {
3152 TELEPHONY_LOGE("NapiCallManager::NativeGetCallWaiting data is nullptr");
3153 NapiUtil::ThrowParameterError(env);
3154 return;
3155 }
3156 auto asyncContext = (SupplementAsyncContext *)data;
3157 if (!IsValidSlotId(asyncContext->slotId)) {
3158 TELEPHONY_LOGE("NativeGetCallWaiting slotId is invalid");
3159 asyncContext->errorCode = SLOT_ID_INVALID;
3160 return;
3161 }
3162 EventCallback infoListener;
3163 infoListener.env = asyncContext->env;
3164 infoListener.thisVar = asyncContext->thisVar;
3165 infoListener.callbackRef = asyncContext->callbackRef;
3166 infoListener.deferred = asyncContext->deferred;
3167 asyncContext->errorCode =
3168 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetWaitingCallback(infoListener);
3169 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3170 TELEPHONY_LOGE("RegisterGetWaitingCallback failed!");
3171 return;
3172 }
3173 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallWaiting(asyncContext->slotId);
3174 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3175 asyncContext->eventId = CALL_MANAGER_GET_CALL_WAITING;
3176 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetWaitingCallback();
3177 TELEPHONY_LOGE("GetCallWaiting failed!");
3178 return;
3179 }
3180 asyncContext->resolved = TELEPHONY_SUCCESS;
3181 asyncContext->callbackRef = nullptr;
3182 asyncContext->deferred = nullptr;
3183 }
3184
NativeSetCallWaiting(napi_env env,void * data)3185 void NapiCallManager::NativeSetCallWaiting(napi_env env, void *data)
3186 {
3187 if (data == nullptr) {
3188 TELEPHONY_LOGE("NapiCallManager::NativeSetCallWaiting data is nullptr");
3189 NapiUtil::ThrowParameterError(env);
3190 return;
3191 }
3192 auto asyncContext = (SupplementAsyncContext *)data;
3193 if (!IsValidSlotId(asyncContext->slotId)) {
3194 TELEPHONY_LOGE("NativeSetCallWaiting slotId is invalid");
3195 asyncContext->errorCode = SLOT_ID_INVALID;
3196 return;
3197 }
3198
3199 EventCallback infoListener;
3200 infoListener.env = asyncContext->env;
3201 infoListener.thisVar = asyncContext->thisVar;
3202 infoListener.callbackRef = asyncContext->callbackRef;
3203 infoListener.deferred = asyncContext->deferred;
3204 asyncContext->errorCode =
3205 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetWaitingCallback(infoListener);
3206 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3207 TELEPHONY_LOGE("RegisterSetWaitingCallback failed!");
3208 return;
3209 }
3210 asyncContext->errorCode =
3211 DelayedSingleton<CallManagerClient>::GetInstance()->SetCallWaiting(asyncContext->slotId, asyncContext->flag);
3212 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3213 asyncContext->eventId = CALL_MANAGER_SET_CALL_WAITING;
3214 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetWaitingCallback();
3215 TELEPHONY_LOGE("SetCallWaiting failed!");
3216 return;
3217 }
3218 asyncContext->resolved = TELEPHONY_SUCCESS;
3219 asyncContext->callbackRef = nullptr;
3220 asyncContext->deferred = nullptr;
3221 }
3222
NativeGetCallRestriction(napi_env env,void * data)3223 void NapiCallManager::NativeGetCallRestriction(napi_env env, void *data)
3224 {
3225 if (data == nullptr) {
3226 TELEPHONY_LOGE("NapiCallManager::NativeGetCallRestriction data is nullptr");
3227 NapiUtil::ThrowParameterError(env);
3228 return;
3229 }
3230 auto asyncContext = (SupplementAsyncContext *)data;
3231 if (!IsValidSlotId(asyncContext->slotId)) {
3232 TELEPHONY_LOGE("NativeGetCallRestriction slotId is invalid");
3233 asyncContext->errorCode = SLOT_ID_INVALID;
3234 return;
3235 }
3236 EventCallback infoListener;
3237 infoListener.env = asyncContext->env;
3238 infoListener.thisVar = asyncContext->thisVar;
3239 infoListener.callbackRef = asyncContext->callbackRef;
3240 infoListener.deferred = asyncContext->deferred;
3241 asyncContext->errorCode =
3242 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetRestrictionCallback(infoListener);
3243 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3244 TELEPHONY_LOGE("RegisterGetRestrictionCallback failed!");
3245 return;
3246 }
3247 CallRestrictionType type = static_cast<CallRestrictionType>(asyncContext->type);
3248 asyncContext->errorCode =
3249 DelayedSingleton<CallManagerClient>::GetInstance()->GetCallRestriction(asyncContext->slotId, type);
3250 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3251 asyncContext->eventId = CALL_MANAGER_GET_CALL_RESTRICTION;
3252 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetRestrictionCallback();
3253 TELEPHONY_LOGE("GetCallRestriction failed!");
3254 return;
3255 }
3256 asyncContext->resolved = TELEPHONY_SUCCESS;
3257 asyncContext->callbackRef = nullptr;
3258 asyncContext->deferred = nullptr;
3259 }
3260
NativeSetCallRestriction(napi_env env,void * data)3261 void NapiCallManager::NativeSetCallRestriction(napi_env env, void *data)
3262 {
3263 if (data == nullptr) {
3264 TELEPHONY_LOGE("NapiCallManager::NativeSetCallRestriction data is nullptr");
3265 NapiUtil::ThrowParameterError(env);
3266 return;
3267 }
3268 auto asyncContext = (CallRestrictionAsyncContext *)data;
3269 if (!IsValidSlotId(asyncContext->slotId)) {
3270 TELEPHONY_LOGE("NativeSetCallRestriction slotId is invalid");
3271 asyncContext->errorCode = SLOT_ID_INVALID;
3272 return;
3273 }
3274 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3275 TELEPHONY_LOGE("Data acquisition failure!");
3276 return;
3277 }
3278 EventCallback infoListener;
3279 infoListener.env = asyncContext->env;
3280 infoListener.thisVar = asyncContext->thisVar;
3281 infoListener.callbackRef = asyncContext->callbackRef;
3282 infoListener.deferred = asyncContext->deferred;
3283 asyncContext->errorCode =
3284 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetRestrictionCallback(infoListener);
3285 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3286 TELEPHONY_LOGE("RegisterSetRestrictionCallback failed!");
3287 return;
3288 }
3289 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallRestriction(
3290 asyncContext->slotId, asyncContext->info);
3291 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3292 asyncContext->eventId = CALL_MANAGER_SET_CALL_RESTRICTION;
3293 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetRestrictionCallback();
3294 TELEPHONY_LOGE("SetCallRestriction failed!");
3295 return;
3296 }
3297 asyncContext->resolved = TELEPHONY_SUCCESS;
3298 asyncContext->callbackRef = nullptr;
3299 asyncContext->deferred = nullptr;
3300 }
3301
NativeGetTransferNumber(napi_env env,void * data)3302 void NapiCallManager::NativeGetTransferNumber(napi_env env, void *data)
3303 {
3304 if (data == nullptr) {
3305 TELEPHONY_LOGE("NapiCallManager::NativeGetTransferNumber data is nullptr");
3306 NapiUtil::ThrowParameterError(env);
3307 return;
3308 }
3309 auto asyncContext = (SupplementAsyncContext *)data;
3310 if (!IsValidSlotId(asyncContext->slotId)) {
3311 TELEPHONY_LOGE("NativeGetTransferNumber slotId is invalid");
3312 asyncContext->errorCode = SLOT_ID_INVALID;
3313 return;
3314 }
3315 EventCallback infoListener;
3316 infoListener.env = asyncContext->env;
3317 infoListener.thisVar = asyncContext->thisVar;
3318 infoListener.callbackRef = asyncContext->callbackRef;
3319 infoListener.deferred = asyncContext->deferred;
3320 asyncContext->errorCode =
3321 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterGetTransferCallback(infoListener);
3322 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3323 TELEPHONY_LOGE("RegisterGetTransferCallback failed!");
3324 return;
3325 }
3326 CallTransferType type = static_cast<CallTransferType>(asyncContext->type);
3327 asyncContext->errorCode =
3328 DelayedSingleton<CallManagerClient>::GetInstance()->GetCallTransferInfo(asyncContext->slotId, type);
3329 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3330 asyncContext->eventId = CALL_MANAGER_GET_CALL_TRANSFER;
3331 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterGetTransferCallback();
3332 TELEPHONY_LOGE("GetCallTransferInfo failed!");
3333 return;
3334 }
3335 asyncContext->resolved = TELEPHONY_SUCCESS;
3336 asyncContext->callbackRef = nullptr;
3337 asyncContext->deferred = nullptr;
3338 }
3339
NativeSetTransferNumber(napi_env env,void * data)3340 void NapiCallManager::NativeSetTransferNumber(napi_env env, void *data)
3341 {
3342 if (data == nullptr) {
3343 TELEPHONY_LOGE("NapiCallManager::NativeSetTransferNumber data is nullptr");
3344 NapiUtil::ThrowParameterError(env);
3345 return;
3346 }
3347 auto asyncContext = (CallTransferAsyncContext *)data;
3348 if (!IsValidSlotId(asyncContext->slotId)) {
3349 TELEPHONY_LOGE("NativeSetTransferNumber slotId is invalid");
3350 asyncContext->errorCode = SLOT_ID_INVALID;
3351 return;
3352 }
3353
3354 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3355 TELEPHONY_LOGE("Data acquisition failure!");
3356 return;
3357 }
3358 EventCallback infoListener;
3359 infoListener.env = asyncContext->env;
3360 infoListener.thisVar = asyncContext->thisVar;
3361 infoListener.callbackRef = asyncContext->callbackRef;
3362 infoListener.deferred = asyncContext->deferred;
3363 asyncContext->errorCode =
3364 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterSetTransferCallback(infoListener);
3365 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3366 TELEPHONY_LOGE("RegisterSetTransferCallback failed!");
3367 return;
3368 }
3369 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallTransferInfo(
3370 asyncContext->slotId, asyncContext->info);
3371 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3372 asyncContext->eventId = CALL_MANAGER_SET_CALL_TRANSFER;
3373 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterSetTransferCallback();
3374 TELEPHONY_LOGE("SetCallTransferInfo failed!");
3375 return;
3376 }
3377 asyncContext->resolved = TELEPHONY_SUCCESS;
3378 asyncContext->callbackRef = nullptr;
3379 asyncContext->deferred = nullptr;
3380 }
3381
NativeEnableImsSwitch(napi_env env,void * data)3382 void NapiCallManager::NativeEnableImsSwitch(napi_env env, void *data)
3383 {
3384 if (data == nullptr) {
3385 TELEPHONY_LOGE("NapiCallManager::NativeEnableImsSwitch data is nullptr");
3386 NapiUtil::ThrowParameterError(env);
3387 return;
3388 }
3389 auto asyncContext = (ImsSwitchAsyncContext *)data;
3390 if (!IsValidSlotId(asyncContext->slotId)) {
3391 TELEPHONY_LOGE("NativeEnableImsSwitch slotId is invalid");
3392 asyncContext->errorCode = SLOT_ID_INVALID;
3393 return;
3394 }
3395 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->EnableImsSwitch(asyncContext->slotId);
3396 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3397 asyncContext->resolved = TELEPHONY_SUCCESS;
3398 }
3399 asyncContext->eventId = CALL_MANAGER_ENABLE_IMS_SWITCH;
3400 }
3401
NativeDisableImsSwitch(napi_env env,void * data)3402 void NapiCallManager::NativeDisableImsSwitch(napi_env env, void *data)
3403 {
3404 if (data == nullptr) {
3405 TELEPHONY_LOGE("NapiCallManager::NativeDisableImsSwitch data is nullptr");
3406 NapiUtil::ThrowParameterError(env);
3407 return;
3408 }
3409 auto asyncContext = (ImsSwitchAsyncContext *)data;
3410 if (!IsValidSlotId(asyncContext->slotId)) {
3411 TELEPHONY_LOGE("NativeDisableImsSwitch slotId is invalid");
3412 asyncContext->errorCode = SLOT_ID_INVALID;
3413 return;
3414 }
3415 asyncContext->errorCode =
3416 DelayedSingleton<CallManagerClient>::GetInstance()->DisableImsSwitch(asyncContext->slotId);
3417 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3418 asyncContext->resolved = TELEPHONY_SUCCESS;
3419 }
3420 asyncContext->eventId = CALL_MANAGER_DISABLE_IMS_SWITCH;
3421 }
3422
NativeIsImsSwitchEnabled(napi_env env,void * data)3423 void NapiCallManager::NativeIsImsSwitchEnabled(napi_env env, void *data)
3424 {
3425 if (data == nullptr) {
3426 TELEPHONY_LOGE("NapiCallManager::NativeIsImsSwitchEnabled data is nullptr");
3427 NapiUtil::ThrowParameterError(env);
3428 return;
3429 }
3430 auto asyncContext = (ImsSwitchAsyncContext *)data;
3431 if (!IsValidSlotId(asyncContext->slotId)) {
3432 TELEPHONY_LOGE("NativeIsImsSwitchEnabled slotId is invalid");
3433 asyncContext->errorCode = SLOT_ID_INVALID;
3434 return;
3435 }
3436 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsImsSwitchEnabled(
3437 asyncContext->slotId, asyncContext->enabled);
3438 if (asyncContext->enabled) {
3439 asyncContext->resolved = BOOL_VALUE_IS_TRUE;
3440 }
3441 }
3442
NativeStartDTMF(napi_env env,void * data)3443 void NapiCallManager::NativeStartDTMF(napi_env env, void *data)
3444 {
3445 if (data == nullptr) {
3446 TELEPHONY_LOGE("NapiCallManager::NativeStartDTMF data is nullptr");
3447 NapiUtil::ThrowParameterError(env);
3448 return;
3449 }
3450 auto asyncContext = (AsyncContext *)data;
3451 if (asyncContext->numberLen < TWO_VALUE_LIMIT) {
3452 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->StartDtmf(
3453 asyncContext->callId, asyncContext->number[ARRAY_INDEX_FIRST]);
3454 } else {
3455 asyncContext->errorCode = TELEPHONY_ERR_ARGUMENT_INVALID;
3456 }
3457 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3458 asyncContext->resolved = TELEPHONY_SUCCESS;
3459 }
3460 }
3461
NativeStopDTMF(napi_env env,void * data)3462 void NapiCallManager::NativeStopDTMF(napi_env env, void *data)
3463 {
3464 if (data == nullptr) {
3465 TELEPHONY_LOGE("NapiCallManager::NativeStopDTMF data is nullptr");
3466 NapiUtil::ThrowParameterError(env);
3467 return;
3468 }
3469 auto asyncContext = (AsyncContext *)data;
3470 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->StopDtmf(asyncContext->callId);
3471 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3472 asyncContext->resolved = TELEPHONY_SUCCESS;
3473 }
3474 }
3475
NativeGetCallState(napi_env env,void * data)3476 void NapiCallManager::NativeGetCallState(napi_env env, void *data)
3477 {
3478 if (data == nullptr) {
3479 TELEPHONY_LOGE("data is nullptr");
3480 return;
3481 }
3482 auto asyncContext = (AsyncContext *)data;
3483 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallState();
3484 }
3485
NativeIsRinging(napi_env env,void * data)3486 void NapiCallManager::NativeIsRinging(napi_env env, void *data)
3487 {
3488 if (data == nullptr) {
3489 TELEPHONY_LOGE("NapiCallManager::NativeIsRinging data is nullptr");
3490 NapiUtil::ThrowParameterError(env);
3491 return;
3492 }
3493 auto asyncContext = (BoolResultAsyncContext *)data;
3494 asyncContext->enabled = false;
3495 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsRinging(asyncContext->enabled);
3496 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3497 asyncContext->resolved = TELEPHONY_SUCCESS;
3498 }
3499 asyncContext->eventId = CALL_MANAGER_IS_RINGING;
3500 }
3501
NativeHasCall(napi_env env,void * data)3502 void NapiCallManager::NativeHasCall(napi_env env, void *data)
3503 {
3504 if (data == nullptr) {
3505 TELEPHONY_LOGE("data is nullptr");
3506 return;
3507 }
3508 auto asyncContext = (AsyncContext *)data;
3509 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->HasCall();
3510 }
3511
NativeIsNewCallAllowed(napi_env env,void * data)3512 void NapiCallManager::NativeIsNewCallAllowed(napi_env env, void *data)
3513 {
3514 if (data == nullptr) {
3515 TELEPHONY_LOGE("NapiCallManager::NativeIsNewCallAllowed data is nullptr");
3516 NapiUtil::ThrowParameterError(env);
3517 return;
3518 }
3519 auto asyncContext = (BoolResultAsyncContext *)data;
3520 asyncContext->errorCode =
3521 DelayedSingleton<CallManagerClient>::GetInstance()->IsNewCallAllowed(asyncContext->enabled);
3522 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3523 asyncContext->resolved = TELEPHONY_SUCCESS;
3524 }
3525 }
3526
NativeIsInEmergencyCall(napi_env env,void * data)3527 void NapiCallManager::NativeIsInEmergencyCall(napi_env env, void *data)
3528 {
3529 if (data == nullptr) {
3530 TELEPHONY_LOGE("NapiCallManager::NativeIsInEmergencyCall data is nullptr");
3531 NapiUtil::ThrowParameterError(env);
3532 return;
3533 }
3534 auto asyncContext = (BoolResultAsyncContext *)data;
3535 asyncContext->errorCode =
3536 DelayedSingleton<CallManagerClient>::GetInstance()->IsInEmergencyCall(asyncContext->enabled);
3537 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3538 asyncContext->resolved = TELEPHONY_SUCCESS;
3539 }
3540 asyncContext->eventId = CALL_MANAGER_IS_EMERGENCY_CALL;
3541 }
3542
NativeIsEmergencyPhoneNumber(napi_env env,void * data)3543 void NapiCallManager::NativeIsEmergencyPhoneNumber(napi_env env, void *data)
3544 {
3545 if (data == nullptr) {
3546 TELEPHONY_LOGE("NapiCallManager::NativeIsEmergencyPhoneNumber data is nullptr");
3547 NapiUtil::ThrowParameterError(env);
3548 return;
3549 }
3550 auto asyncContext = (UtilsAsyncContext *)data;
3551 if (!IsValidSlotId(asyncContext->slotId)) {
3552 TELEPHONY_LOGE("NativeIsEmergencyPhoneNumber slotId is invalid");
3553 asyncContext->errorCode = SLOT_ID_INVALID;
3554 return;
3555 }
3556 std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
3557 std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
3558 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(
3559 phoneNumber, asyncContext->slotId, asyncContext->enabled);
3560 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3561 asyncContext->resolved = TELEPHONY_SUCCESS;
3562 }
3563 }
3564
NativeFormatPhoneNumber(napi_env env,void * data)3565 void NapiCallManager::NativeFormatPhoneNumber(napi_env env, void *data)
3566 {
3567 if (data == nullptr) {
3568 TELEPHONY_LOGE("NapiCallManager::NativeFormatPhoneNumber data is nullptr");
3569 NapiUtil::ThrowParameterError(env);
3570 return;
3571 }
3572 auto asyncContext = (UtilsAsyncContext *)data;
3573 std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
3574 std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
3575 std::u16string countryCode = Str8ToStr16(asyncContext->code);
3576 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumber(
3577 phoneNumber, countryCode, asyncContext->formatNumber);
3578 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3579 asyncContext->resolved = TELEPHONY_SUCCESS;
3580 }
3581 }
3582
NativeFormatPhoneNumberToE164(napi_env env,void * data)3583 void NapiCallManager::NativeFormatPhoneNumberToE164(napi_env env, void *data)
3584 {
3585 if (data == nullptr) {
3586 TELEPHONY_LOGE("NapiCallManager::NativeFormatPhoneNumberToE164 data is nullptr");
3587 NapiUtil::ThrowParameterError(env);
3588 return;
3589 }
3590 auto asyncContext = (UtilsAsyncContext *)data;
3591 std::string tmpPhoneNumber(asyncContext->number, asyncContext->numberLen);
3592 std::u16string phoneNumber = Str8ToStr16(tmpPhoneNumber);
3593 std::u16string countryCode = Str8ToStr16(asyncContext->code);
3594 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumberToE164(
3595 phoneNumber, countryCode, asyncContext->formatNumber);
3596 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3597 asyncContext->resolved = TELEPHONY_SUCCESS;
3598 }
3599 }
3600
NativeSetMuted(napi_env env,void * data)3601 void NapiCallManager::NativeSetMuted(napi_env env, void *data)
3602 {
3603 if (data == nullptr) {
3604 TELEPHONY_LOGE("NapiCallManager::NativeSetMuted data is nullptr");
3605 NapiUtil::ThrowParameterError(env);
3606 return;
3607 }
3608 auto asyncContext = (AudioAsyncContext *)data;
3609 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(true);
3610 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3611 asyncContext->resolved = TELEPHONY_SUCCESS;
3612 }
3613 }
3614
NativeCancelMuted(napi_env env,void * data)3615 void NapiCallManager::NativeCancelMuted(napi_env env, void *data)
3616 {
3617 if (data == nullptr) {
3618 TELEPHONY_LOGE("NapiCallManager::NativeCancelMuted data is nullptr");
3619 NapiUtil::ThrowParameterError(env);
3620 return;
3621 }
3622 auto asyncContext = (AudioAsyncContext *)data;
3623 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(false);
3624 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3625 asyncContext->resolved = TELEPHONY_SUCCESS;
3626 }
3627 }
3628
NativeMuteRinger(napi_env env,void * data)3629 void NapiCallManager::NativeMuteRinger(napi_env env, void *data)
3630 {
3631 if (data == nullptr) {
3632 TELEPHONY_LOGE("NapiCallManager::NativeMuteRinger data is nullptr");
3633 NapiUtil::ThrowParameterError(env);
3634 return;
3635 }
3636 auto asyncContext = (AudioAsyncContext *)data;
3637 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->MuteRinger();
3638 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3639 asyncContext->resolved = TELEPHONY_SUCCESS;
3640 }
3641 asyncContext->eventId = CALL_MANAGER_MUTE_RINGER;
3642 }
3643
NativeSetAudioDevice(napi_env env,void * data)3644 void NapiCallManager::NativeSetAudioDevice(napi_env env, void *data)
3645 {
3646 if (data == nullptr) {
3647 TELEPHONY_LOGE("NapiCallManager::NativeSetAudioDevice data is nullptr");
3648 NapiUtil::ThrowParameterError(env);
3649 return;
3650 }
3651 AudioDevice type;
3652 auto asyncContext = (AudioAsyncContext *)data;
3653 type = static_cast<AudioDevice>(asyncContext->audioDevice);
3654 // For interface compatibility, when AudioDevice::DEVICE_MIC is deleted, this code block should also be deleted
3655 // When the parameter passed is DEVICE_MIC, point to DEVICE_EARPIECE
3656 int32_t DEVICE_MIC = 4;
3657 if (static_cast<int32_t>(type) == DEVICE_MIC) {
3658 type = AudioDevice::DEVICE_EARPIECE;
3659 }
3660 asyncContext->errorCode =
3661 DelayedSingleton<CallManagerClient>::GetInstance()->SetAudioDevice(type, asyncContext->address);
3662 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3663 asyncContext->resolved = TELEPHONY_SUCCESS;
3664 }
3665 }
3666
NativeControlCamera(napi_env env,void * data)3667 void NapiCallManager::NativeControlCamera(napi_env env, void *data)
3668 {
3669 if (data == nullptr) {
3670 TELEPHONY_LOGE("data is nullptr");
3671 return;
3672 }
3673 auto asyncContext = (VideoAsyncContext *)data;
3674 asyncContext->resolved =
3675 DelayedSingleton<CallManagerClient>::GetInstance()->ControlCamera(Str8ToStr16(asyncContext->cameraId));
3676 }
3677
NativeSetPreviewWindow(napi_env env,void * data)3678 void NapiCallManager::NativeSetPreviewWindow(napi_env env, void *data)
3679 {
3680 if (data == nullptr) {
3681 TELEPHONY_LOGE("data is nullptr");
3682 return;
3683 }
3684
3685 auto asyncContext = (VideoAsyncContext *)data;
3686 VideoWindow window;
3687 window.x = asyncContext->x;
3688 window.y = asyncContext->y;
3689 window.z = asyncContext->z;
3690 window.width = asyncContext->width;
3691 window.height = asyncContext->height;
3692 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetPreviewWindow(window);
3693 }
3694
NativeSetDisplayWindow(napi_env env,void * data)3695 void NapiCallManager::NativeSetDisplayWindow(napi_env env, void *data)
3696 {
3697 if (data == nullptr) {
3698 TELEPHONY_LOGE("data is nullptr");
3699 return;
3700 }
3701
3702 auto asyncContext = (VideoAsyncContext *)data;
3703 VideoWindow window;
3704 window.x = asyncContext->x;
3705 window.y = asyncContext->y;
3706 window.z = asyncContext->z;
3707 window.width = asyncContext->width;
3708 window.height = asyncContext->height;
3709 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetDisplayWindow(window);
3710 }
3711
NativeSetCameraZoom(napi_env env,void * data)3712 void NapiCallManager::NativeSetCameraZoom(napi_env env, void *data)
3713 {
3714 if (data == nullptr) {
3715 TELEPHONY_LOGE("data is nullptr");
3716 return;
3717 }
3718 auto asyncContext = (VideoAsyncContext *)data;
3719 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetCameraZoom(asyncContext->zoomRatio);
3720 }
3721
NativeSetPausePicture(napi_env env,void * data)3722 void NapiCallManager::NativeSetPausePicture(napi_env env, void *data)
3723 {
3724 if (data == nullptr) {
3725 TELEPHONY_LOGE("data is nullptr");
3726 return;
3727 }
3728 auto asyncContext = (VideoAsyncContext *)data;
3729 asyncContext->resolved =
3730 DelayedSingleton<CallManagerClient>::GetInstance()->SetPausePicture(Str8ToStr16(asyncContext->path));
3731 }
3732
NativeSetDeviceDirection(napi_env env,void * data)3733 void NapiCallManager::NativeSetDeviceDirection(napi_env env, void *data)
3734 {
3735 if (data == nullptr) {
3736 TELEPHONY_LOGE("data is nullptr");
3737 return;
3738 }
3739 auto asyncContext = (VideoAsyncContext *)data;
3740 asyncContext->resolved =
3741 DelayedSingleton<CallManagerClient>::GetInstance()->SetDeviceDirection(asyncContext->rotation);
3742 }
3743
NativeSetCallPreferenceMode(napi_env env,void * data)3744 void NapiCallManager::NativeSetCallPreferenceMode(napi_env env, void *data)
3745 {
3746 if (data == nullptr) {
3747 TELEPHONY_LOGE("data is nullptr");
3748 return;
3749 }
3750 auto asyncContext = (SupplementAsyncContext *)data;
3751 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallPreferenceMode(
3752 asyncContext->callId, asyncContext->mode);
3753 }
3754
NativeStartRTT(napi_env env,void * data)3755 void NapiCallManager::NativeStartRTT(napi_env env, void *data)
3756 {
3757 if (data == nullptr) {
3758 TELEPHONY_LOGE("data is nullptr");
3759 return;
3760 }
3761 auto asyncContext = (SupplementAsyncContext *)data;
3762 EventCallback infoListener;
3763 infoListener.env = asyncContext->env;
3764 infoListener.thisVar = asyncContext->thisVar;
3765 infoListener.callbackRef = asyncContext->callbackRef;
3766 infoListener.deferred = asyncContext->deferred;
3767 asyncContext->resolved =
3768 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterStartRttCallback(infoListener);
3769 if (asyncContext->resolved != TELEPHONY_SUCCESS) {
3770 TELEPHONY_LOGE("RegisterStartRttCallback failed!");
3771 return;
3772 }
3773
3774 std::u16string msg = Str8ToStr16(asyncContext->content);
3775 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->StartRtt(asyncContext->callId, msg);
3776 if (asyncContext->resolved != TELEPHONY_SUCCESS) {
3777 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterStartRttCallback();
3778 TELEPHONY_LOGE("StartRtt failed!");
3779 return;
3780 }
3781 asyncContext->callbackRef = nullptr;
3782 asyncContext->deferred = nullptr;
3783 }
3784
NativeStopRTT(napi_env env,void * data)3785 void NapiCallManager::NativeStopRTT(napi_env env, void *data)
3786 {
3787 if (data == nullptr) {
3788 TELEPHONY_LOGE("data is nullptr");
3789 return;
3790 }
3791 auto asyncContext = (SupplementAsyncContext *)data;
3792 EventCallback infoListener;
3793 infoListener.env = asyncContext->env;
3794 infoListener.thisVar = asyncContext->thisVar;
3795 infoListener.callbackRef = asyncContext->callbackRef;
3796 infoListener.deferred = asyncContext->deferred;
3797 asyncContext->resolved =
3798 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterStopRttCallback(infoListener);
3799 if (asyncContext->resolved != TELEPHONY_SUCCESS) {
3800 TELEPHONY_LOGE("RegisterStopRttCallback failed!");
3801 return;
3802 }
3803 asyncContext->resolved = DelayedSingleton<CallManagerClient>::GetInstance()->StopRtt(asyncContext->callId);
3804 if (asyncContext->resolved != TELEPHONY_SUCCESS) {
3805 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterStopRttCallback();
3806 TELEPHONY_LOGE("StopRtt failed!");
3807 return;
3808 }
3809 asyncContext->callbackRef = nullptr;
3810 asyncContext->deferred = nullptr;
3811 }
3812
NativeJoinConference(napi_env env,void * data)3813 void NapiCallManager::NativeJoinConference(napi_env env, void *data)
3814 {
3815 if (data == nullptr) {
3816 TELEPHONY_LOGE("NapiCallManager::NativeJoinConference data is nullptr");
3817 NapiUtil::ThrowParameterError(env);
3818 return;
3819 }
3820 auto asyncContext = (ListAsyncContext *)data;
3821 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->JoinConference(
3822 asyncContext->callId, asyncContext->listResult);
3823 if (asyncContext->errorCode == TELEPHONY_SUCCESS) {
3824 asyncContext->resolved = TELEPHONY_SUCCESS;
3825 }
3826 }
3827
NativeUpdateImsCallMode(napi_env env,void * data)3828 void NapiCallManager::NativeUpdateImsCallMode(napi_env env, void *data)
3829 {
3830 if (data == nullptr) {
3831 TELEPHONY_LOGE("NapiCallManager::NativeUpdateImsCallMode data is nullptr");
3832 NapiUtil::ThrowParameterError(env);
3833 return;
3834 }
3835 auto asyncContext = (SupplementAsyncContext *)data;
3836 EventCallback infoListener;
3837 infoListener.env = asyncContext->env;
3838 infoListener.thisVar = asyncContext->thisVar;
3839 infoListener.callbackRef = asyncContext->callbackRef;
3840 infoListener.deferred = asyncContext->deferred;
3841 asyncContext->errorCode =
3842 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->RegisterUpdateCallMediaModeCallback(infoListener);
3843 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3844 TELEPHONY_LOGE("RegisterUpdateCallMediaModeCallback failed!");
3845 return;
3846 }
3847 asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->UpdateImsCallMode(
3848 asyncContext->callId, (ImsCallMode)asyncContext->type);
3849 if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
3850 DelayedSingleton<NapiCallAbilityCallback>::GetInstance()->UnRegisterUpdateCallMediaModeCallback();
3851 TELEPHONY_LOGE("UnRegisterUpdateCallMediaModeCallback failed!");
3852 return;
3853 }
3854 asyncContext->resolved = TELEPHONY_SUCCESS;
3855 asyncContext->callbackRef = nullptr;
3856 asyncContext->deferred = nullptr;
3857 }
3858
NativeReportOttCallDetailsInfo(napi_env env,void * data)3859 void NapiCallManager::NativeReportOttCallDetailsInfo(napi_env env, void *data)
3860 {
3861 if (data == nullptr) {
3862 TELEPHONY_LOGE("data is nullptr");
3863 return;
3864 }
3865 auto asyncContext = (OttCallAsyncContext *)data;
3866 asyncContext->resolved =
3867 DelayedSingleton<CallManagerClient>::GetInstance()->ReportOttCallDetailsInfo(asyncContext->ottVec);
3868 }
3869
NativeReportOttCallEventInfo(napi_env env,void * data)3870 void NapiCallManager::NativeReportOttCallEventInfo(napi_env env, void *data)
3871 {
3872 if (data == nullptr) {
3873 TELEPHONY_LOGE("data is nullptr");
3874 return;
3875 }
3876 auto asyncContext = (OttEventAsyncContext *)data;
3877 asyncContext->resolved =
3878 DelayedSingleton<CallManagerClient>::GetInstance()->ReportOttCallEventInfo(asyncContext->eventInfo);
3879 }
3880
RegisterCallBack()3881 void NapiCallManager::RegisterCallBack()
3882 {
3883 if (registerStatus_ == TELEPHONY_SUCCESS) {
3884 TELEPHONY_LOGW("you are already registered!");
3885 return;
3886 }
3887 std::unique_ptr<NapiCallManagerCallback> callbackPtr = std::make_unique<NapiCallManagerCallback>();
3888 if (callbackPtr == nullptr) {
3889 TELEPHONY_LOGE("make_unique NapiCallManagerCallback failed!");
3890 return;
3891 }
3892 registerStatus_ = DelayedSingleton<CallManagerClient>::GetInstance()->RegisterCallBack(std::move(callbackPtr));
3893 if (registerStatus_ != TELEPHONY_SUCCESS) {
3894 TELEPHONY_LOGE("RegisterCallBack failed!");
3895 return;
3896 }
3897 }
3898
HandleAsyncWork(napi_env env,AsyncContext * context,std::string workName,napi_async_execute_callback execute,napi_async_complete_callback complete)3899 napi_value NapiCallManager::HandleAsyncWork(napi_env env, AsyncContext *context, std::string workName,
3900 napi_async_execute_callback execute, napi_async_complete_callback complete)
3901 {
3902 TELEPHONY_LOGI("HandleAsyncWork start workName = %{public}s", workName.c_str());
3903 napi_value result = nullptr;
3904 if (context->callbackRef == nullptr) {
3905 napi_create_promise(env, &context->deferred, &result);
3906 } else {
3907 napi_get_undefined(env, &result);
3908 }
3909 napi_value resource = NapiCallManagerUtils::CreateUndefined(env);
3910 napi_value resourceName = nullptr;
3911 napi_create_string_utf8(env, workName.data(), NAPI_AUTO_LENGTH, &resourceName);
3912 napi_create_async_work(env, resource, resourceName, execute, complete, (void *)context, &context->work);
3913 napi_queue_async_work(env, context->work);
3914 return result;
3915 }
3916
3917 static napi_module g_nativeCallManagerModule = {
3918 .nm_version = NATIVE_VERSION,
3919 .nm_flags = NATIVE_FLAGS,
3920 .nm_filename = nullptr,
3921 .nm_register_func = NapiCallManager::RegisterCallManagerFunc,
3922 .nm_modname = "telephony.call",
3923 .nm_priv = ((void *)0),
3924 .reserved = {0},
3925 };
3926
RegisterModule(void)3927 extern "C" __attribute__((constructor)) void RegisterModule(void)
3928 {
3929 napi_module_register(&g_nativeCallManagerModule);
3930 }
3931 } // namespace Telephony
3932 } // namespace OHOS
3933