• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_ability_callback.h"
17 
18 #include <securec.h>
19 #include <ctime>
20 
21 #include "call_manager_errors.h"
22 #include "napi_call_manager_utils.h"
23 #include "napi_util.h"
24 #include "telephony_log_wrapper.h"
25 
26 namespace OHOS {
27 namespace Telephony {
NapiCallAbilityCallback()28 NapiCallAbilityCallback::NapiCallAbilityCallback()
29 {
30     (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
31     (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
32     (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
33     (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
34     (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
35     (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
36     (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
37     (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
38     (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
39     (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
40     (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
41     (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
42     (void)memset_s(&updateCallMediaModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
43     (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
44     (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
45     (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
46     memberFuncMap_[CallResultReportId::GET_CALL_WAITING_REPORT_ID] = &NapiCallAbilityCallback::ReportGetWaitingInfo;
47     memberFuncMap_[CallResultReportId::SET_CALL_WAITING_REPORT_ID] = &NapiCallAbilityCallback::ReportSetWaitingInfo;
48     memberFuncMap_[CallResultReportId::GET_CALL_RESTRICTION_REPORT_ID] =
49         &NapiCallAbilityCallback::ReportGetRestrictionInfo;
50     memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_REPORT_ID] =
51         &NapiCallAbilityCallback::ReportSetRestrictionInfo;
52     memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_PWD_REPORT_ID] =
53         &NapiCallAbilityCallback::ReportSetRestrictionPassword;
54     memberFuncMap_[CallResultReportId::GET_CALL_TRANSFER_REPORT_ID] =
55         &NapiCallAbilityCallback::ReportGetTransferInfo;
56     memberFuncMap_[CallResultReportId::SET_CALL_TRANSFER_REPORT_ID] =
57         &NapiCallAbilityCallback::ReportSetTransferInfo;
58     memberFuncMap_[CallResultReportId::START_RTT_REPORT_ID] = &NapiCallAbilityCallback::ReportStartRttInfo;
59     memberFuncMap_[CallResultReportId::STOP_RTT_REPORT_ID] = &NapiCallAbilityCallback::ReportStopRttInfo;
60     memberFuncMap_[CallResultReportId::UPDATE_MEDIA_MODE_REPORT_ID] =
61         &NapiCallAbilityCallback::ReportCallMediaModeInfo;
62     memberFuncMap_[CallResultReportId::CLOSE_UNFINISHED_USSD_REPORT_ID] =
63         &NapiCallAbilityCallback::ReportCloseUnFinishedUssdInfo;
64 }
65 
~NapiCallAbilityCallback()66 NapiCallAbilityCallback::~NapiCallAbilityCallback() {}
67 
RegisterCallStateCallback(EventCallback stateCallback)68 void NapiCallAbilityCallback::RegisterCallStateCallback(EventCallback stateCallback)
69 {
70     stateCallback_ = stateCallback;
71 }
72 
UnRegisterCallStateCallback()73 void NapiCallAbilityCallback::UnRegisterCallStateCallback()
74 {
75     if (stateCallback_.callbackRef) {
76         (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
77     }
78 }
79 
RegisterMmiCodeCallback(EventCallback eventCallback)80 void NapiCallAbilityCallback::RegisterMmiCodeCallback(EventCallback eventCallback)
81 {
82     mmiCodeCallback_ = eventCallback;
83 }
84 
UnRegisterMmiCodeCallback()85 void NapiCallAbilityCallback::UnRegisterMmiCodeCallback()
86 {
87     if (mmiCodeCallback_.callbackRef) {
88         (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
89     }
90 }
91 
RegisterAudioDeviceCallback(EventCallback eventCallback)92 void NapiCallAbilityCallback::RegisterAudioDeviceCallback(EventCallback eventCallback)
93 {
94     audioDeviceCallback_ = eventCallback;
95 }
96 
UnRegisterAudioDeviceCallback()97 void NapiCallAbilityCallback::UnRegisterAudioDeviceCallback()
98 {
99     if (audioDeviceCallback_.callbackRef) {
100         (void)memset_s(&audioDeviceCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
101     }
102 }
103 
RegisterPostDialDelay(EventCallback eventCallback)104 void NapiCallAbilityCallback::RegisterPostDialDelay(EventCallback eventCallback)
105 {
106     postDialDelayCallback_ = eventCallback;
107 }
108 
UnRegisterPostDialDelayCallback()109 void NapiCallAbilityCallback::UnRegisterPostDialDelayCallback()
110 {
111     if (postDialDelayCallback_.callbackRef) {
112         (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
113     }
114 }
115 
RegisterCallEventCallback(EventCallback eventCallback)116 void NapiCallAbilityCallback::RegisterCallEventCallback(EventCallback eventCallback)
117 {
118     eventCallback_ = eventCallback;
119 }
120 
UnRegisterCallEventCallback()121 void NapiCallAbilityCallback::UnRegisterCallEventCallback()
122 {
123     if (eventCallback_.callbackRef) {
124         (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
125     }
126 }
127 
RegisterDisconnectedCauseCallback(EventCallback eventCallback)128 void NapiCallAbilityCallback::RegisterDisconnectedCauseCallback(EventCallback eventCallback)
129 {
130     callDisconnectCauseCallback_ = eventCallback;
131 }
132 
UnRegisterDisconnectedCauseCallback()133 void NapiCallAbilityCallback::UnRegisterDisconnectedCauseCallback()
134 {
135     if (callDisconnectCauseCallback_.callbackRef) {
136         (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
137     }
138 }
139 
RegisterCallOttRequestCallback(EventCallback ottRequestCallback)140 void NapiCallAbilityCallback::RegisterCallOttRequestCallback(EventCallback ottRequestCallback)
141 {
142     ottRequestCallback_ = ottRequestCallback;
143 }
144 
UnRegisterCallOttRequestCallback()145 void NapiCallAbilityCallback::UnRegisterCallOttRequestCallback()
146 {
147     if (ottRequestCallback_.callbackRef) {
148         (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
149     }
150 }
151 
RegisterGetWaitingCallback(EventCallback callback)152 int32_t NapiCallAbilityCallback::RegisterGetWaitingCallback(EventCallback callback)
153 {
154     if (getWaitingCallback_.thisVar) {
155         TELEPHONY_LOGE("callback already exist!");
156         return CALL_ERR_CALLBACK_ALREADY_EXIST;
157     }
158     getWaitingCallback_ = callback;
159     return TELEPHONY_SUCCESS;
160 }
161 
UnRegisterGetWaitingCallback()162 void NapiCallAbilityCallback::UnRegisterGetWaitingCallback()
163 {
164     (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
165 }
166 
RegisterCloseUnFinishedUssdCallback(EventCallback callback)167 int32_t NapiCallAbilityCallback::RegisterCloseUnFinishedUssdCallback(EventCallback callback)
168 {
169     if (closeUnfinishedUssdCallback_.thisVar) {
170         TELEPHONY_LOGE("callback already exist!");
171         return CALL_ERR_CALLBACK_ALREADY_EXIST;
172     }
173     closeUnfinishedUssdCallback_ = callback;
174     return TELEPHONY_SUCCESS;
175 }
176 
UnRegisterCloseUnFinishedUssdCallback()177 void NapiCallAbilityCallback::UnRegisterCloseUnFinishedUssdCallback()
178 {
179     (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
180 }
181 
RegisterSetWaitingCallback(EventCallback callback)182 int32_t NapiCallAbilityCallback::RegisterSetWaitingCallback(EventCallback callback)
183 {
184     if (setWaitingCallback_.thisVar) {
185         TELEPHONY_LOGE("callback already exist!");
186         return CALL_ERR_CALLBACK_ALREADY_EXIST;
187     }
188     setWaitingCallback_ = callback;
189     return TELEPHONY_SUCCESS;
190 }
191 
UnRegisterSetWaitingCallback()192 void NapiCallAbilityCallback::UnRegisterSetWaitingCallback()
193 {
194     (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
195 }
196 
RegisterGetRestrictionCallback(EventCallback callback)197 int32_t NapiCallAbilityCallback::RegisterGetRestrictionCallback(EventCallback callback)
198 {
199     if (getRestrictionCallback_.thisVar) {
200         TELEPHONY_LOGE("callback already exist!");
201         return CALL_ERR_CALLBACK_ALREADY_EXIST;
202     }
203     getRestrictionCallback_ = callback;
204     return TELEPHONY_SUCCESS;
205 }
206 
UnRegisterGetRestrictionCallback()207 void NapiCallAbilityCallback::UnRegisterGetRestrictionCallback()
208 {
209     (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
210 }
211 
RegisterSetRestrictionCallback(EventCallback callback)212 int32_t NapiCallAbilityCallback::RegisterSetRestrictionCallback(EventCallback callback)
213 {
214     if (setRestrictionCallback_.thisVar) {
215         TELEPHONY_LOGE("callback already exist!");
216         return CALL_ERR_CALLBACK_ALREADY_EXIST;
217     }
218     setRestrictionCallback_ = callback;
219     return TELEPHONY_SUCCESS;
220 }
221 
UnRegisterSetRestrictionCallback()222 void NapiCallAbilityCallback::UnRegisterSetRestrictionCallback()
223 {
224     (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
225 }
226 
RegisterSetRestrictionPasswordCallback(EventCallback callback)227 int32_t NapiCallAbilityCallback::RegisterSetRestrictionPasswordCallback(EventCallback callback)
228 {
229     if (setRestrictionPasswordCallback_.thisVar) {
230         TELEPHONY_LOGE("callback already exist!");
231         return CALL_ERR_CALLBACK_ALREADY_EXIST;
232     }
233     setRestrictionPasswordCallback_ = callback;
234     return TELEPHONY_SUCCESS;
235 }
236 
UnRegisterSetRestrictionPasswordCallback()237 void NapiCallAbilityCallback::UnRegisterSetRestrictionPasswordCallback()
238 {
239     (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
240 }
241 
RegisterGetTransferCallback(EventCallback callback)242 int32_t NapiCallAbilityCallback::RegisterGetTransferCallback(EventCallback callback)
243 {
244     if (getTransferCallback_.thisVar) {
245         TELEPHONY_LOGE("callback already exist!");
246         return CALL_ERR_CALLBACK_ALREADY_EXIST;
247     }
248     getTransferCallback_ = callback;
249     return TELEPHONY_SUCCESS;
250 }
251 
UnRegisterGetTransferCallback()252 void NapiCallAbilityCallback::UnRegisterGetTransferCallback()
253 {
254     (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
255 }
256 
RegisterSetTransferCallback(EventCallback callback)257 int32_t NapiCallAbilityCallback::RegisterSetTransferCallback(EventCallback callback)
258 {
259     if (setTransferCallback_.thisVar) {
260         TELEPHONY_LOGE("callback already exist!");
261         return CALL_ERR_CALLBACK_ALREADY_EXIST;
262     }
263     setTransferCallback_ = callback;
264     return TELEPHONY_SUCCESS;
265 }
266 
UnRegisterSetTransferCallback()267 void NapiCallAbilityCallback::UnRegisterSetTransferCallback()
268 {
269     (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
270 }
271 
RegisterStartRttCallback(EventCallback callback)272 int32_t NapiCallAbilityCallback::RegisterStartRttCallback(EventCallback callback)
273 {
274     if (startRttCallback_.thisVar) {
275         TELEPHONY_LOGE("callback already exist!");
276         return CALL_ERR_CALLBACK_ALREADY_EXIST;
277     }
278     startRttCallback_ = callback;
279     return TELEPHONY_SUCCESS;
280 }
281 
UnRegisterStartRttCallback()282 void NapiCallAbilityCallback::UnRegisterStartRttCallback()
283 {
284     (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
285 }
286 
RegisterStopRttCallback(EventCallback callback)287 int32_t NapiCallAbilityCallback::RegisterStopRttCallback(EventCallback callback)
288 {
289     if (stopRttCallback_.thisVar) {
290         TELEPHONY_LOGE("callback already exist!");
291         return CALL_ERR_CALLBACK_ALREADY_EXIST;
292     }
293     stopRttCallback_ = callback;
294     return TELEPHONY_SUCCESS;
295 }
296 
UnRegisterStopRttCallback()297 void NapiCallAbilityCallback::UnRegisterStopRttCallback()
298 {
299     (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
300 }
301 
RegisterUpdateCallMediaModeCallback(EventCallback callback)302 int32_t NapiCallAbilityCallback::RegisterUpdateCallMediaModeCallback(EventCallback callback)
303 {
304     if (updateCallMediaModeCallback_.thisVar) {
305         TELEPHONY_LOGE("callback already exist!");
306         return CALL_ERR_CALLBACK_ALREADY_EXIST;
307     }
308     updateCallMediaModeCallback_ = callback;
309     return TELEPHONY_SUCCESS;
310 }
311 
UnRegisterUpdateCallMediaModeCallback()312 void NapiCallAbilityCallback::UnRegisterUpdateCallMediaModeCallback()
313 {
314     (void)memset_s(&updateCallMediaModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
315 }
316 
ReportStartRttInfo(AppExecFwk::PacMap & resultInfo)317 int32_t NapiCallAbilityCallback::ReportStartRttInfo(AppExecFwk::PacMap &resultInfo)
318 {
319     if (startRttCallback_.thisVar == nullptr) {
320         TELEPHONY_LOGE("startRttCallback_ is null!");
321         return CALL_ERR_CALLBACK_NOT_EXIST;
322     }
323     uv_loop_s *loop = nullptr;
324 #if NAPI_VERSION >= 2
325     napi_get_uv_event_loop(startRttCallback_.env, &loop);
326 #endif
327     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
328     if (dataWorker == nullptr) {
329         TELEPHONY_LOGE("dataWorker is nullptr!");
330         return TELEPHONY_ERR_LOCAL_PTR_NULL;
331     }
332     dataWorker->info = resultInfo;
333     dataWorker->callback = startRttCallback_;
334     uv_work_t *work = std::make_unique<uv_work_t>().release();
335     if (work == nullptr) {
336         TELEPHONY_LOGE("work is nullptr!");
337         return TELEPHONY_ERR_LOCAL_PTR_NULL;
338     }
339     work->data = (void *)dataWorker;
340     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportStartRttInfoWork, uv_qos_default);
341     if (startRttCallback_.thisVar) {
342         (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
343     }
344     return TELEPHONY_SUCCESS;
345 }
346 
ReportStopRttInfo(AppExecFwk::PacMap & resultInfo)347 int32_t NapiCallAbilityCallback::ReportStopRttInfo(AppExecFwk::PacMap &resultInfo)
348 {
349     if (stopRttCallback_.thisVar == nullptr) {
350         TELEPHONY_LOGE("startRttCallback_ is null!");
351         return CALL_ERR_CALLBACK_NOT_EXIST;
352     }
353     uv_loop_s *loop = nullptr;
354 #if NAPI_VERSION >= 2
355     napi_get_uv_event_loop(stopRttCallback_.env, &loop);
356 #endif
357     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
358     if (dataWorker == nullptr) {
359         TELEPHONY_LOGE("dataWorker is nullptr!");
360         return TELEPHONY_ERR_LOCAL_PTR_NULL;
361     }
362     dataWorker->info = resultInfo;
363     dataWorker->callback = stopRttCallback_;
364     uv_work_t *work = std::make_unique<uv_work_t>().release();
365     if (work == nullptr) {
366         TELEPHONY_LOGE("work is nullptr!");
367         return TELEPHONY_ERR_LOCAL_PTR_NULL;
368     }
369     work->data = (void *)dataWorker;
370     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportStopRttInfoWork, uv_qos_default);
371     if (stopRttCallback_.thisVar) {
372         (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
373     }
374     return TELEPHONY_SUCCESS;
375 }
376 
ReportCallMediaModeInfo(AppExecFwk::PacMap & resultInfo)377 int32_t NapiCallAbilityCallback::ReportCallMediaModeInfo(AppExecFwk::PacMap &resultInfo)
378 {
379     if (updateCallMediaModeCallback_.thisVar == nullptr) {
380         TELEPHONY_LOGE("updateCallMediaModeCallback_ is null!");
381         return CALL_ERR_CALLBACK_NOT_EXIST;
382     }
383     uv_loop_s *loop = nullptr;
384 #if NAPI_VERSION >= 2
385     napi_get_uv_event_loop(updateCallMediaModeCallback_.env, &loop);
386 #endif
387     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
388     if (dataWorker == nullptr) {
389         TELEPHONY_LOGE("dataWorker is nullptr!");
390         return TELEPHONY_ERR_LOCAL_PTR_NULL;
391     }
392     dataWorker->info = resultInfo;
393     dataWorker->callback = updateCallMediaModeCallback_;
394     uv_work_t *work = std::make_unique<uv_work_t>().release();
395     if (work == nullptr) {
396         TELEPHONY_LOGE("work is nullptr!");
397         return TELEPHONY_ERR_LOCAL_PTR_NULL;
398     }
399     work->data = (void *)dataWorker;
400     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportCallMediaModeInfoWork, uv_qos_default);
401     if (updateCallMediaModeCallback_.thisVar) {
402         (void)memset_s(&updateCallMediaModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
403     }
404     return TELEPHONY_SUCCESS;
405 }
406 
UpdateCallStateInfo(const CallAttributeInfo & info)407 int32_t NapiCallAbilityCallback::UpdateCallStateInfo(const CallAttributeInfo &info)
408 {
409     if (stateCallback_.thisVar == nullptr) {
410         TELEPHONY_LOGE("stateCallback is null!");
411         return CALL_ERR_CALLBACK_NOT_EXIST;
412     }
413     uv_loop_s *loop = nullptr;
414 #if NAPI_VERSION >= 2
415     napi_get_uv_event_loop(stateCallback_.env, &loop);
416 #endif
417     CallStateWorker *dataWorker = std::make_unique<CallStateWorker>().release();
418     if (dataWorker == nullptr) {
419         TELEPHONY_LOGE("dataWorker is nullptr!");
420         return TELEPHONY_ERR_LOCAL_PTR_NULL;
421     }
422     dataWorker->info = info;
423     dataWorker->callback = stateCallback_;
424     uv_work_t *work = std::make_unique<uv_work_t>().release();
425     if (work == nullptr) {
426         TELEPHONY_LOGE("work is nullptr!");
427         return TELEPHONY_ERR_LOCAL_PTR_NULL;
428     }
429     work->data = (void *)dataWorker;
430     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportCallStateWork, uv_qos_default);
431     return TELEPHONY_SUCCESS;
432 }
433 
ReportCallStateWork(uv_work_t * work,int32_t status)434 void NapiCallAbilityCallback::ReportCallStateWork(uv_work_t *work, int32_t status)
435 {
436     CallStateWorker *dataWorkerData = (CallStateWorker *)work->data;
437     if (dataWorkerData == nullptr) {
438         TELEPHONY_LOGE("dataWorkerData is nullptr!");
439         return;
440     }
441     int32_t ret = ReportCallState(dataWorkerData->info, dataWorkerData->callback);
442     TELEPHONY_LOGI("ReportCallState result = %{public}d", ret);
443     delete dataWorkerData;
444     dataWorkerData = nullptr;
445     delete work;
446     work = nullptr;
447 }
448 
449 /**
450  * To notify an application of a call status change, register a callback with on() first.
451  */
ReportCallState(CallAttributeInfo & info,EventCallback stateCallback)452 int32_t NapiCallAbilityCallback::ReportCallState(CallAttributeInfo &info, EventCallback stateCallback)
453 {
454     napi_env env = stateCallback.env;
455     napi_handle_scope scope = nullptr;
456     napi_open_handle_scope(env, &scope);
457     if (scope == nullptr) {
458         TELEPHONY_LOGE("scope is nullptr");
459         napi_close_handle_scope(env, scope);
460         return TELEPHONY_ERROR;
461     }
462     napi_value callbackFunc = nullptr;
463     napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
464     napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
465     NapiCallManagerUtils::SetPropertyStringUtf8(
466         env, callbackValues[ARRAY_INDEX_FIRST], "accountNumber", info.accountNumber);
467     NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "accountId", info.accountId);
468     NapiCallManagerUtils::SetPropertyInt32(
469         env, callbackValues[ARRAY_INDEX_FIRST], "videoState", static_cast<int32_t>(info.videoState));
470     NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "startTime", info.startTime);
471     NapiCallManagerUtils::SetPropertyBoolean(env, callbackValues[ARRAY_INDEX_FIRST], "isEcc", info.isEcc);
472     NapiCallManagerUtils::SetPropertyInt32(
473         env, callbackValues[ARRAY_INDEX_FIRST], "callType", static_cast<int32_t>(info.callType));
474     NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "callId", info.callId);
475     NapiCallManagerUtils::SetPropertyInt32(
476         env, callbackValues[ARRAY_INDEX_FIRST], "callState", static_cast<int32_t>(info.callState));
477     NapiCallManagerUtils::SetPropertyInt32(
478         env, callbackValues[ARRAY_INDEX_FIRST], "conferenceState", static_cast<int32_t>(info.conferenceState));
479     napi_get_reference_value(env, stateCallback.callbackRef, &callbackFunc);
480     if (callbackFunc == nullptr) {
481         TELEPHONY_LOGE("callbackFunc is null!");
482         napi_close_handle_scope(env, scope);
483         return CALL_ERR_CALLBACK_NOT_EXIST;
484     }
485     napi_value thisVar = nullptr;
486     napi_get_reference_value(env, stateCallback.thisVar, &thisVar);
487     napi_value callbackResult = nullptr;
488     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
489     napi_close_handle_scope(env, scope);
490     return TELEPHONY_SUCCESS;
491 }
492 
UpdateCallEvent(const CallEventInfo & info)493 int32_t NapiCallAbilityCallback::UpdateCallEvent(const CallEventInfo &info)
494 {
495     if (eventCallback_.thisVar == nullptr) {
496         TELEPHONY_LOGE("eventCallback is null!");
497         return CALL_ERR_CALLBACK_NOT_EXIST;
498     }
499     uv_loop_s *loop = nullptr;
500 #if NAPI_VERSION >= 2
501     napi_get_uv_event_loop(eventCallback_.env, &loop);
502 #endif
503     CallEventWorker *dataWorker = std::make_unique<CallEventWorker>().release();
504     if (dataWorker == nullptr) {
505         TELEPHONY_LOGE("dataWorker is nullptr!");
506         return TELEPHONY_ERR_LOCAL_PTR_NULL;
507     }
508     dataWorker->info = info;
509     dataWorker->callback = eventCallback_;
510     uv_work_t *work = std::make_unique<uv_work_t>().release();
511     if (work == nullptr) {
512         TELEPHONY_LOGE("work is nullptr!");
513         return TELEPHONY_ERR_LOCAL_PTR_NULL;
514     }
515     work->data = (void *)dataWorker;
516     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportCallEventWork, uv_qos_default);
517     return TELEPHONY_SUCCESS;
518 }
519 
ReportCallEventWork(uv_work_t * work,int32_t status)520 void NapiCallAbilityCallback::ReportCallEventWork(uv_work_t *work, int32_t status)
521 {
522     CallEventWorker *dataWorkerData = (CallEventWorker *)work->data;
523     if (dataWorkerData == nullptr) {
524         TELEPHONY_LOGE("dataWorkerData is nullptr!");
525         return;
526     }
527     int32_t ret = ReportCallEvent(dataWorkerData->info, dataWorkerData->callback);
528     TELEPHONY_LOGI("ReportCallEvent results %{public}d", ret);
529     delete dataWorkerData;
530     dataWorkerData = nullptr;
531     delete work;
532     work = nullptr;
533 }
534 
ReportCallEvent(CallEventInfo & info,EventCallback eventCallback)535 int32_t NapiCallAbilityCallback::ReportCallEvent(CallEventInfo &info, EventCallback eventCallback)
536 {
537     napi_env env = eventCallback.env;
538     napi_handle_scope scope = nullptr;
539     napi_open_handle_scope(env, &scope);
540     if (scope == nullptr) {
541         TELEPHONY_LOGE("scope is nullptr");
542         napi_close_handle_scope(env, scope);
543         return TELEPHONY_ERROR;
544     }
545     napi_value callbackFunc = nullptr;
546     napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
547     napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
548     NapiCallManagerUtils::SetPropertyInt32(
549         env, callbackValues[ARRAY_INDEX_FIRST], "eventId", static_cast<int32_t>(info.eventId));
550     NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_FIRST], "accountNumber", info.phoneNum);
551     NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_FIRST], "bundleName", info.bundleName);
552     napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
553     if (callbackFunc == nullptr) {
554         TELEPHONY_LOGE("callbackFunc is null!");
555         napi_close_handle_scope(env, scope);
556         return CALL_ERR_CALLBACK_NOT_EXIST;
557     }
558     napi_value thisVar = nullptr;
559     napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
560     napi_value callbackResult = nullptr;
561     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
562     napi_close_handle_scope(env, scope);
563     return TELEPHONY_SUCCESS;
564 }
565 
UpdateCallDisconnectedCause(const DisconnectedDetails & details)566 int32_t NapiCallAbilityCallback::UpdateCallDisconnectedCause(const DisconnectedDetails &details)
567 {
568     if (callDisconnectCauseCallback_.thisVar == nullptr) {
569         TELEPHONY_LOGE("callDisconnectCauseCallback_ is null!");
570         return CALL_ERR_CALLBACK_NOT_EXIST;
571     }
572     uv_loop_s *loop = nullptr;
573 #if NAPI_VERSION >= 2
574     napi_get_uv_event_loop(callDisconnectCauseCallback_.env, &loop);
575 #endif
576     CallDisconnectedCauseWorker *dataWorker = std::make_unique<CallDisconnectedCauseWorker>().release();
577     if (dataWorker == nullptr) {
578         TELEPHONY_LOGE("dataWorker is nullptr!");
579         return TELEPHONY_ERR_LOCAL_PTR_NULL;
580     }
581     dataWorker->details = details;
582     dataWorker->callback = callDisconnectCauseCallback_;
583     uv_work_t *work = std::make_unique<uv_work_t>().release();
584     if (work == nullptr) {
585         TELEPHONY_LOGE("work is nullptr!");
586         return TELEPHONY_ERR_LOCAL_PTR_NULL;
587     }
588     work->data = (void *)dataWorker;
589     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportCallDisconnectedCauseWork, uv_qos_default);
590     if (callDisconnectCauseCallback_.thisVar) {
591         (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
592     }
593     return TELEPHONY_SUCCESS;
594 }
595 
ReportCallDisconnectedCauseWork(uv_work_t * work,int32_t status)596 void NapiCallAbilityCallback::ReportCallDisconnectedCauseWork(uv_work_t *work, int32_t status)
597 {
598     CallDisconnectedCauseWorker *dataWorkerData = (CallDisconnectedCauseWorker *)work->data;
599     if (dataWorkerData == nullptr) {
600         TELEPHONY_LOGE("dataWorkerData is nullptr!");
601         return;
602     }
603     int32_t ret = ReportDisconnectedCause(dataWorkerData->details, dataWorkerData->callback);
604     TELEPHONY_LOGI("ReportDisconnectedCause results %{public}d", ret);
605     delete dataWorkerData;
606     dataWorkerData = nullptr;
607     delete work;
608     work = nullptr;
609 }
610 
ReportDisconnectedCause(const DisconnectedDetails & details,EventCallback eventCallback)611 int32_t NapiCallAbilityCallback::ReportDisconnectedCause(
612     const DisconnectedDetails &details, EventCallback eventCallback)
613 {
614     napi_env env = eventCallback.env;
615     napi_handle_scope scope = nullptr;
616     napi_open_handle_scope(env, &scope);
617     if (scope == nullptr) {
618         TELEPHONY_LOGE("scope is nullptr");
619         napi_close_handle_scope(env, scope);
620         return TELEPHONY_ERROR;
621     }
622     napi_value callbackFunc = nullptr;
623     napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
624     napi_create_object(env, &callbackValues[ARRAY_INDEX_SECOND]);
625     NapiCallManagerUtils::SetPropertyInt32(
626         env, callbackValues[ARRAY_INDEX_SECOND], "disconnectedCause", static_cast<int32_t>(details.reason));
627     NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_SECOND], "message", details.message);
628     napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
629     if (callbackFunc == nullptr) {
630         TELEPHONY_LOGE("callbackFunc is null!");
631         napi_close_handle_scope(env, scope);
632         return CALL_ERR_CALLBACK_NOT_EXIST;
633     }
634     napi_value thisVar = nullptr;
635     napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
636     napi_value callbackResult = nullptr;
637     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
638     napi_close_handle_scope(env, scope);
639     return TELEPHONY_SUCCESS;
640 }
641 
UpdateAsyncResultsInfo(const CallResultReportId reportId,AppExecFwk::PacMap & resultInfo)642 int32_t NapiCallAbilityCallback::UpdateAsyncResultsInfo(
643     const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo)
644 {
645     int32_t result = TELEPHONY_ERR_FAIL;
646     TELEPHONY_LOGI("UpdateAsyncResultsInfo reportId = %{public}d", reportId);
647     auto itFunc = memberFuncMap_.find(reportId);
648     if (itFunc != memberFuncMap_.end() && itFunc->second != nullptr) {
649         auto memberFunc = itFunc->second;
650         result = (this->*memberFunc)(resultInfo);
651     }
652     return result;
653 }
654 
UpdateMmiCodeResultsInfo(const MmiCodeInfo & info)655 int32_t NapiCallAbilityCallback::UpdateMmiCodeResultsInfo(const MmiCodeInfo &info)
656 {
657     if (mmiCodeCallback_.thisVar == nullptr) {
658         TELEPHONY_LOGE("mmiCodeCallback is null!");
659         return CALL_ERR_CALLBACK_NOT_EXIST;
660     }
661     uv_loop_s *loop = nullptr;
662 #if NAPI_VERSION >= 2
663     napi_get_uv_event_loop(mmiCodeCallback_.env, &loop);
664 #endif
665     MmiCodeWorker *dataWorker = std::make_unique<MmiCodeWorker>().release();
666     if (dataWorker == nullptr) {
667         TELEPHONY_LOGE("dataWorker is nullptr!");
668         return TELEPHONY_ERR_LOCAL_PTR_NULL;
669     }
670     dataWorker->info = info;
671     dataWorker->callback = mmiCodeCallback_;
672     uv_work_t *work = std::make_unique<uv_work_t>().release();
673     if (work == nullptr) {
674         TELEPHONY_LOGE("work is nullptr!");
675         return TELEPHONY_ERR_LOCAL_PTR_NULL;
676     }
677     work->data = (void *)dataWorker;
678     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportMmiCodeWork, uv_qos_default);
679     return TELEPHONY_SUCCESS;
680 }
681 
ReportMmiCodeWork(uv_work_t * work,int32_t status)682 void NapiCallAbilityCallback::ReportMmiCodeWork(uv_work_t *work, int32_t status)
683 {
684     MmiCodeWorker *dataWorkerData = (MmiCodeWorker *)work->data;
685     if (dataWorkerData == nullptr) {
686         TELEPHONY_LOGE("dataWorkerData is nullptr!");
687         return;
688     }
689     int32_t ret = ReportMmiCode(dataWorkerData->info, dataWorkerData->callback);
690     TELEPHONY_LOGI("ReportMmiCode result = %{public}d", ret);
691     delete dataWorkerData;
692     dataWorkerData = nullptr;
693     delete work;
694     work = nullptr;
695 }
696 
697 /**
698  * To notify an application of MMI code result, register a callback with on() first.
699  */
ReportMmiCode(MmiCodeInfo & info,EventCallback eventCallback)700 int32_t NapiCallAbilityCallback::ReportMmiCode(MmiCodeInfo &info, EventCallback eventCallback)
701 {
702     napi_env env = eventCallback.env;
703     napi_handle_scope scope = nullptr;
704     napi_open_handle_scope(env, &scope);
705     if (scope == nullptr) {
706         TELEPHONY_LOGE("scope is nullptr");
707         napi_close_handle_scope(env, scope);
708         return TELEPHONY_ERROR;
709     }
710     napi_value callbackFunc = nullptr;
711     napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
712     callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
713     napi_create_object(env, &callbackValues[ARRAY_INDEX_SECOND]);
714     NapiCallManagerUtils::SetPropertyInt32(
715         env, callbackValues[ARRAY_INDEX_SECOND], "result", static_cast<int32_t>(info.result));
716     NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_SECOND], "message", info.message);
717     napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
718     if (callbackFunc == nullptr) {
719         TELEPHONY_LOGE("callbackFunc is null!");
720         napi_close_handle_scope(env, scope);
721         return CALL_ERR_CALLBACK_NOT_EXIST;
722     }
723     napi_value thisVar = nullptr;
724     napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
725     napi_value callbackResult = nullptr;
726     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
727     napi_close_handle_scope(env, scope);
728     return TELEPHONY_SUCCESS;
729 }
730 
UpdateAudioDeviceInfo(const AudioDeviceInfo & info)731 int32_t NapiCallAbilityCallback::UpdateAudioDeviceInfo(const AudioDeviceInfo &info)
732 {
733     if (audioDeviceCallback_.thisVar == nullptr) {
734         TELEPHONY_LOGE("audioDeviceCallback_ is null!");
735         return CALL_ERR_CALLBACK_NOT_EXIST;
736     }
737     uv_loop_s *loop = nullptr;
738 #if NAPI_VERSION >= 2
739     napi_get_uv_event_loop(audioDeviceCallback_.env, &loop);
740 #endif
741     AudioDeviceWork *dataWorker = std::make_unique<AudioDeviceWork>().release();
742     if (dataWorker == nullptr) {
743         TELEPHONY_LOGE("dataWorker is nullptr!");
744         return TELEPHONY_ERR_LOCAL_PTR_NULL;
745     }
746     dataWorker->info = info;
747     dataWorker->callback = audioDeviceCallback_;
748     uv_work_t *work = std::make_unique<uv_work_t>().release();
749     if (work == nullptr) {
750         TELEPHONY_LOGE("work is nullptr!");
751         return TELEPHONY_ERR_LOCAL_PTR_NULL;
752     }
753     work->data = (void *)dataWorker;
754     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportAudioDeviceInfoWork, uv_qos_default);
755     return TELEPHONY_SUCCESS;
756 }
757 
ReportAudioDeviceInfoWork(uv_work_t * work,int32_t status)758 void NapiCallAbilityCallback::ReportAudioDeviceInfoWork(uv_work_t *work, int32_t status)
759 {
760     AudioDeviceWork *dataWorkerData = (AudioDeviceWork *)work->data;
761     if (dataWorkerData == nullptr) {
762         TELEPHONY_LOGE("dataWorkerData is nullptr!");
763         return;
764     }
765     int32_t ret = ReportAudioDeviceInfo(dataWorkerData->info, dataWorkerData->callback);
766     TELEPHONY_LOGI("ReportAudioDeviceInfo result = %{public}d", ret);
767     delete dataWorkerData;
768     dataWorkerData = nullptr;
769     delete work;
770     work = nullptr;
771 }
772 
ReportAudioDeviceInfo(AudioDeviceInfo & info,EventCallback eventCallback)773 int32_t NapiCallAbilityCallback::ReportAudioDeviceInfo(AudioDeviceInfo &info, EventCallback eventCallback)
774 {
775     napi_env env = eventCallback.env;
776     napi_handle_scope scope = nullptr;
777     napi_open_handle_scope(env, &scope);
778     if (scope == nullptr) {
779         TELEPHONY_LOGE("scope is nullptr");
780         napi_close_handle_scope(env, scope);
781         return TELEPHONY_ERROR;
782     }
783     napi_value callbackFunc = nullptr;
784     napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
785     napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
786 
787     NapiCallManagerUtils::SetPropertyBoolean(env, callbackValues[ARRAY_INDEX_FIRST], "isMuted", info.isMuted);
788 
789     napi_value currentAudioDeviceValue = nullptr;
790     napi_create_object(env, &currentAudioDeviceValue);
791     NapiCallManagerUtils::SetPropertyInt32(env, currentAudioDeviceValue, "currentDeviceType",
792         static_cast<int32_t>(info.currentAudioDevice.deviceType));
793     NapiCallManagerUtils::SetPropertyStringUtf8(
794         env, currentAudioDeviceValue, "currentDeviceAddress", info.currentAudioDevice.address);
795     napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "currentAudioDevice", currentAudioDeviceValue);
796 
797     napi_value audioDeviceListValue = nullptr;
798     napi_create_array(env, &audioDeviceListValue);
799     std::vector<AudioDevice>::iterator it = info.audioDeviceList.begin();
800     int32_t i = 0;
801     for (; it != info.audioDeviceList.end(); ++it) {
802         napi_value value = nullptr;
803         napi_create_object(env, &value);
804         NapiCallManagerUtils::SetPropertyInt32(env, value, "deviceType", static_cast<int32_t>(it->deviceType));
805         NapiCallManagerUtils::SetPropertyStringUtf8(env, value, "currentDeviceAddress", it->address);
806         napi_set_element(env, audioDeviceListValue, i, value);
807         ++i;
808     }
809     napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "audioDeviceList", audioDeviceListValue);
810 
811     napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
812     if (callbackFunc == nullptr) {
813         TELEPHONY_LOGE("callbackFunc is null!");
814         napi_close_handle_scope(env, scope);
815         return CALL_ERR_CALLBACK_NOT_EXIST;
816     }
817     napi_value thisVar = nullptr;
818     napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
819     napi_value callbackResult = nullptr;
820     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
821     napi_close_handle_scope(env, scope);
822     return TELEPHONY_SUCCESS;
823 }
824 
OttCallRequest(OttCallRequestId requestId,AppExecFwk::PacMap & info)825 int32_t NapiCallAbilityCallback::OttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
826 {
827     if (ottRequestCallback_.thisVar == nullptr) {
828         TELEPHONY_LOGE("stateCallback is null!");
829         return CALL_ERR_CALLBACK_NOT_EXIST;
830     }
831     uv_loop_s *loop = nullptr;
832 #if NAPI_VERSION >= 2
833     napi_get_uv_event_loop(ottRequestCallback_.env, &loop);
834 #endif
835     CallOttWorker *dataWorker = std::make_unique<CallOttWorker>().release();
836     if (dataWorker == nullptr) {
837         TELEPHONY_LOGE("dataWorker is nullptr!");
838         return TELEPHONY_ERR_LOCAL_PTR_NULL;
839     }
840     dataWorker->requestId = requestId;
841     dataWorker->info = info;
842     dataWorker->callback = ottRequestCallback_;
843     uv_work_t *work = std::make_unique<uv_work_t>().release();
844     if (work == nullptr) {
845         TELEPHONY_LOGE("work is nullptr!");
846         return TELEPHONY_ERR_LOCAL_PTR_NULL;
847     }
848     work->data = (void *)dataWorker;
849     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportCallOttWork, uv_qos_default);
850 
851     return TELEPHONY_SUCCESS;
852 }
853 
ReportGetWaitingInfo(AppExecFwk::PacMap & resultInfo)854 int32_t NapiCallAbilityCallback::ReportGetWaitingInfo(AppExecFwk::PacMap &resultInfo)
855 {
856     if (getWaitingCallback_.thisVar == nullptr) {
857         TELEPHONY_LOGE("getWaitingCallback is null!");
858         return CALL_ERR_CALLBACK_NOT_EXIST;
859     }
860     uv_loop_s *loop = nullptr;
861 #if NAPI_VERSION >= 2
862     napi_get_uv_event_loop(getWaitingCallback_.env, &loop);
863 #endif
864     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
865     if (dataWorker == nullptr) {
866         TELEPHONY_LOGE("dataWorker is nullptr!");
867         return TELEPHONY_ERR_LOCAL_PTR_NULL;
868     }
869     dataWorker->info = resultInfo;
870     dataWorker->callback = getWaitingCallback_;
871     uv_work_t *work = std::make_unique<uv_work_t>().release();
872     if (work == nullptr) {
873         TELEPHONY_LOGE("work is nullptr!");
874         return TELEPHONY_ERR_LOCAL_PTR_NULL;
875     }
876     work->data = (void *)dataWorker;
877     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportWaitAndLimitInfoWork, uv_qos_default);
878     if (getWaitingCallback_.thisVar) {
879         (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
880     }
881     return TELEPHONY_SUCCESS;
882 }
883 
ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap & resultInfo)884 int32_t NapiCallAbilityCallback::ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap &resultInfo)
885 {
886     if (closeUnfinishedUssdCallback_.thisVar == nullptr) {
887         TELEPHONY_LOGE("closeUnfinishedUssdCallback is null!");
888         return CALL_ERR_CALLBACK_NOT_EXIST;
889     }
890     uv_loop_s *loop = nullptr;
891 #if NAPI_VERSION >= 2
892     napi_get_uv_event_loop(closeUnfinishedUssdCallback_.env, &loop);
893 #endif
894     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
895     if (dataWorker == nullptr) {
896         TELEPHONY_LOGE("dataWorker is nullptr!");
897         return TELEPHONY_ERR_LOCAL_PTR_NULL;
898     }
899     dataWorker->info = resultInfo;
900     dataWorker->callback = closeUnfinishedUssdCallback_;
901     uv_work_t *work = std::make_unique<uv_work_t>().release();
902     if (work == nullptr) {
903         TELEPHONY_LOGE("work is nullptr!");
904         return TELEPHONY_ERR_LOCAL_PTR_NULL;
905     }
906     work->data = (void *)dataWorker;
907     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportExecutionResultWork, uv_qos_default);
908     if (closeUnfinishedUssdCallback_.thisVar) {
909         (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
910     }
911     return TELEPHONY_SUCCESS;
912 }
913 
ReportSetWaitingInfo(AppExecFwk::PacMap & resultInfo)914 int32_t NapiCallAbilityCallback::ReportSetWaitingInfo(AppExecFwk::PacMap &resultInfo)
915 {
916     if (setWaitingCallback_.thisVar == nullptr) {
917         TELEPHONY_LOGE("setWaitingCallback is null!");
918         return CALL_ERR_CALLBACK_NOT_EXIST;
919     }
920     uv_loop_s *loop = nullptr;
921 #if NAPI_VERSION >= 2
922     napi_get_uv_event_loop(setWaitingCallback_.env, &loop);
923 #endif
924     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
925     if (dataWorker == nullptr) {
926         TELEPHONY_LOGE("dataWorker is nullptr!");
927         return TELEPHONY_ERR_LOCAL_PTR_NULL;
928     }
929     dataWorker->info = resultInfo;
930     dataWorker->callback = setWaitingCallback_;
931     uv_work_t *work = std::make_unique<uv_work_t>().release();
932     if (work == nullptr) {
933         TELEPHONY_LOGE("work is nullptr!");
934         return TELEPHONY_ERR_LOCAL_PTR_NULL;
935     }
936     work->data = (void *)dataWorker;
937     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportExecutionResultWork, uv_qos_default);
938     if (setWaitingCallback_.thisVar) {
939         (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
940     }
941     return TELEPHONY_SUCCESS;
942 }
943 
ReportGetRestrictionInfo(AppExecFwk::PacMap & resultInfo)944 int32_t NapiCallAbilityCallback::ReportGetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
945 {
946     if (getRestrictionCallback_.thisVar == nullptr) {
947         TELEPHONY_LOGE("getRestrictionCallback is null!");
948         return CALL_ERR_CALLBACK_NOT_EXIST;
949     }
950     uv_loop_s *loop = nullptr;
951 #if NAPI_VERSION >= 2
952     napi_get_uv_event_loop(getRestrictionCallback_.env, &loop);
953 #endif
954     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
955     if (dataWorker == nullptr) {
956         TELEPHONY_LOGE("dataWorker is nullptr!");
957         return TELEPHONY_ERR_LOCAL_PTR_NULL;
958     }
959     dataWorker->info = resultInfo;
960     dataWorker->callback = getRestrictionCallback_;
961     uv_work_t *work = std::make_unique<uv_work_t>().release();
962     if (work == nullptr) {
963         TELEPHONY_LOGE("work is nullptr!");
964         return TELEPHONY_ERR_LOCAL_PTR_NULL;
965     }
966     work->data = (void *)dataWorker;
967     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportWaitAndLimitInfoWork, uv_qos_default);
968     if (getRestrictionCallback_.thisVar) {
969         (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
970     }
971     return TELEPHONY_SUCCESS;
972 }
973 
ReportSetRestrictionInfo(AppExecFwk::PacMap & resultInfo)974 int32_t NapiCallAbilityCallback::ReportSetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
975 {
976     if (setRestrictionCallback_.thisVar == nullptr) {
977         TELEPHONY_LOGE("setRestrictionCallback is null!");
978         return CALL_ERR_CALLBACK_NOT_EXIST;
979     }
980     uv_loop_s *loop = nullptr;
981 #if NAPI_VERSION >= 2
982     napi_get_uv_event_loop(setRestrictionCallback_.env, &loop);
983 #endif
984     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
985     if (dataWorker == nullptr) {
986         TELEPHONY_LOGE("dataWorker is nullptr!");
987         return TELEPHONY_ERR_LOCAL_PTR_NULL;
988     }
989     dataWorker->info = resultInfo;
990     dataWorker->callback = setRestrictionCallback_;
991     uv_work_t *work = std::make_unique<uv_work_t>().release();
992     if (work == nullptr) {
993         TELEPHONY_LOGE("work is nullptr!");
994         return TELEPHONY_ERR_LOCAL_PTR_NULL;
995     }
996     work->data = (void *)dataWorker;
997     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportExecutionResultWork, uv_qos_default);
998     if (setRestrictionCallback_.thisVar) {
999         (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1000     }
1001     return TELEPHONY_SUCCESS;
1002 }
1003 
ReportSetRestrictionPassword(AppExecFwk::PacMap & resultInfo)1004 int32_t NapiCallAbilityCallback::ReportSetRestrictionPassword(AppExecFwk::PacMap &resultInfo)
1005 {
1006     if (setRestrictionPasswordCallback_.thisVar == nullptr) {
1007         TELEPHONY_LOGE("setRestrictionPasswordCallback is null!");
1008         return CALL_ERR_CALLBACK_NOT_EXIST;
1009     }
1010     uv_loop_s *loop = nullptr;
1011 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1012     napi_get_uv_event_loop(setRestrictionPasswordCallback_.env, &loop);
1013 #endif
1014     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
1015     if (dataWorker == nullptr) {
1016         TELEPHONY_LOGE("dataWorker is nullptr!");
1017         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1018     }
1019     dataWorker->info = resultInfo;
1020     dataWorker->callback = setRestrictionPasswordCallback_;
1021     uv_work_t *work = std::make_unique<uv_work_t>().release();
1022     if (work == nullptr) {
1023         TELEPHONY_LOGE("work is nullptr!");
1024         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1025     }
1026     work->data = (void *)dataWorker;
1027     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportExecutionResultWork, uv_qos_default);
1028     if (setRestrictionPasswordCallback_.thisVar) {
1029         (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1030     }
1031     return TELEPHONY_SUCCESS;
1032 }
1033 
ReportGetTransferInfo(AppExecFwk::PacMap & resultInfo)1034 int32_t NapiCallAbilityCallback::ReportGetTransferInfo(AppExecFwk::PacMap &resultInfo)
1035 {
1036     if (getTransferCallback_.thisVar == nullptr) {
1037         TELEPHONY_LOGE("getTransferCallback is null!");
1038         return CALL_ERR_CALLBACK_NOT_EXIST;
1039     }
1040     uv_loop_s *loop = nullptr;
1041 #if NAPI_VERSION >= 2
1042     napi_get_uv_event_loop(getTransferCallback_.env, &loop);
1043 #endif
1044     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
1045     if (dataWorker == nullptr) {
1046         TELEPHONY_LOGE("dataWorker is nullptr!");
1047         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1048     }
1049     dataWorker->info = resultInfo;
1050     dataWorker->callback = getTransferCallback_;
1051     uv_work_t *work = std::make_unique<uv_work_t>().release();
1052     if (work == nullptr) {
1053         TELEPHONY_LOGE("work is nullptr!");
1054         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1055     }
1056     work->data = (void *)dataWorker;
1057     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportSupplementInfoWork, uv_qos_default);
1058     if (getTransferCallback_.thisVar) {
1059         (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1060     }
1061     return TELEPHONY_SUCCESS;
1062 }
1063 
ReportSetTransferInfo(AppExecFwk::PacMap & resultInfo)1064 int32_t NapiCallAbilityCallback::ReportSetTransferInfo(AppExecFwk::PacMap &resultInfo)
1065 {
1066     if (setTransferCallback_.thisVar == nullptr) {
1067         TELEPHONY_LOGE("setTransferCallback is null!");
1068         return CALL_ERR_CALLBACK_NOT_EXIST;
1069     }
1070     uv_loop_s *loop = nullptr;
1071 #if NAPI_VERSION >= 2
1072     napi_get_uv_event_loop(setTransferCallback_.env, &loop);
1073 #endif
1074     CallSupplementWorker *dataWorker = std::make_unique<CallSupplementWorker>().release();
1075     if (dataWorker == nullptr) {
1076         TELEPHONY_LOGE("dataWorker is nullptr!");
1077         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1078     }
1079     dataWorker->info = resultInfo;
1080     dataWorker->callback = setTransferCallback_;
1081     uv_work_t *work = std::make_unique<uv_work_t>().release();
1082     if (work == nullptr) {
1083         TELEPHONY_LOGE("work is nullptr!");
1084         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1085     }
1086     work->data = (void *)dataWorker;
1087     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportExecutionResultWork, uv_qos_default);
1088     if (setTransferCallback_.thisVar) {
1089         (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1090     }
1091     return TELEPHONY_SUCCESS;
1092 }
1093 
ReportWaitAndLimitInfoWork(uv_work_t * work,int32_t status)1094 void NapiCallAbilityCallback::ReportWaitAndLimitInfoWork(uv_work_t *work, int32_t status)
1095 {
1096     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1097     if (dataWorkerData == nullptr) {
1098         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1099         return;
1100     }
1101     ReportWaitAndLimitInfo(dataWorkerData->info, dataWorkerData->callback);
1102     delete dataWorkerData;
1103     dataWorkerData = nullptr;
1104     delete work;
1105     work = nullptr;
1106 }
1107 
ReportWaitAndLimitInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1108 void NapiCallAbilityCallback::ReportWaitAndLimitInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1109 {
1110     napi_env env = supplementInfo.env;
1111     int32_t result = resultInfo.GetIntValue("result");
1112     int32_t status = resultInfo.GetIntValue("status");
1113     napi_handle_scope scope = nullptr;
1114     napi_open_handle_scope(env, &scope);
1115     if (scope == nullptr) {
1116         TELEPHONY_LOGE("scope is nullptr");
1117         napi_close_handle_scope(env, scope);
1118         return;
1119     }
1120     if (supplementInfo.callbackRef != nullptr) {
1121         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1122         if (result == TELEPHONY_SUCCESS) {
1123             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1124             napi_create_int32(env, status, &callbackValues[ARRAY_INDEX_SECOND]);
1125         } else {
1126             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1127             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1128             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1129         }
1130         napi_value callbackFunc = nullptr;
1131         napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1132         napi_value thisVar = nullptr;
1133         napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1134         napi_value callbackResult = nullptr;
1135         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1136         napi_delete_reference(env, supplementInfo.callbackRef);
1137         napi_delete_reference(env, supplementInfo.thisVar);
1138     } else if (supplementInfo.deferred != nullptr) {
1139         if (result == TELEPHONY_SUCCESS) {
1140             napi_value promiseValue = nullptr;
1141             napi_create_int32(env, status, &promiseValue);
1142             napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1143         } else {
1144             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1145             napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1146         }
1147     }
1148     napi_close_handle_scope(env, scope);
1149 }
1150 
ReportSupplementInfoWork(uv_work_t * work,int32_t status)1151 void NapiCallAbilityCallback::ReportSupplementInfoWork(uv_work_t *work, int32_t status)
1152 {
1153     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1154     if (dataWorkerData == nullptr) {
1155         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1156         return;
1157     }
1158     ReportSupplementInfo(dataWorkerData->info, dataWorkerData->callback);
1159     delete dataWorkerData;
1160     dataWorkerData = nullptr;
1161     delete work;
1162     work = nullptr;
1163 }
1164 
ReportSupplementInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1165 void NapiCallAbilityCallback::ReportSupplementInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1166 {
1167     napi_env env = supplementInfo.env;
1168     napi_handle_scope scope = nullptr;
1169     napi_open_handle_scope(env, &scope);
1170     if (scope == nullptr) {
1171         TELEPHONY_LOGE("scope is nullptr");
1172         napi_close_handle_scope(env, scope);
1173         return;
1174     }
1175     napi_value callbackValue = nullptr;
1176     napi_create_object(env, &callbackValue);
1177     NapiCallManagerUtils::SetPropertyInt32(env, callbackValue, "status", resultInfo.GetIntValue("status"));
1178     NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValue, "number", resultInfo.GetStringValue("number"));
1179     int32_t result = resultInfo.GetIntValue("result");
1180     if (supplementInfo.callbackRef != nullptr) {
1181         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1182         if (result == TELEPHONY_SUCCESS) {
1183             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1184             callbackValues[ARRAY_INDEX_SECOND] = callbackValue;
1185         } else {
1186             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1187             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1188             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1189         }
1190         napi_value callbackFunc = nullptr;
1191         napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1192         napi_value thisVar = nullptr;
1193         napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1194         napi_value callbackResult = nullptr;
1195         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1196         napi_delete_reference(env, supplementInfo.callbackRef);
1197         napi_delete_reference(env, supplementInfo.thisVar);
1198     } else if (supplementInfo.deferred != nullptr) {
1199         if (result == TELEPHONY_SUCCESS) {
1200             napi_resolve_deferred(env, supplementInfo.deferred, callbackValue);
1201         } else {
1202             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1203             napi_reject_deferred(
1204                 env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1205         }
1206     }
1207     napi_close_handle_scope(env, scope);
1208 }
1209 
ReportExecutionResultWork(uv_work_t * work,int32_t status)1210 void NapiCallAbilityCallback::ReportExecutionResultWork(uv_work_t *work, int32_t status)
1211 {
1212     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1213     if (dataWorkerData == nullptr) {
1214         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1215         return;
1216     }
1217     ReportExecutionResult(dataWorkerData->callback, dataWorkerData->info);
1218     delete dataWorkerData;
1219     dataWorkerData = nullptr;
1220     delete work;
1221     work = nullptr;
1222 }
1223 
ReportExecutionResult(EventCallback & settingInfo,AppExecFwk::PacMap & resultInfo)1224 void NapiCallAbilityCallback::ReportExecutionResult(EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo)
1225 {
1226     napi_env env = settingInfo.env;
1227     napi_handle_scope scope = nullptr;
1228     napi_open_handle_scope(env, &scope);
1229     if (scope == nullptr) {
1230         TELEPHONY_LOGE("scope is nullptr");
1231         napi_close_handle_scope(env, scope);
1232         return;
1233     }
1234     napi_value callbackValue = nullptr;
1235     napi_create_object(env, &callbackValue);
1236     int32_t result = resultInfo.GetIntValue("result");
1237     if (settingInfo.callbackRef != nullptr) {
1238         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1239         if (result == TELEPHONY_SUCCESS) {
1240             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1241             napi_get_null(env, &callbackValues[ARRAY_INDEX_SECOND]);
1242         } else {
1243             JsError error = NapiUtil::ConverErrorMessageForJs(result);
1244             callbackValues[ARRAY_INDEX_FIRST] =
1245                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
1246             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1247         }
1248         napi_value callbackFunc = nullptr;
1249         napi_get_reference_value(env, settingInfo.callbackRef, &callbackFunc);
1250         napi_value thisVar = nullptr;
1251         napi_get_reference_value(env, settingInfo.thisVar, &thisVar);
1252         napi_value callbackResult = nullptr;
1253         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1254         napi_delete_reference(env, settingInfo.callbackRef);
1255         napi_delete_reference(env, settingInfo.thisVar);
1256     } else if (settingInfo.deferred != nullptr) {
1257         if (result == TELEPHONY_SUCCESS) {
1258             napi_value promiseValue = nullptr;
1259             napi_get_null(env, &promiseValue);
1260             napi_resolve_deferred(env, settingInfo.deferred, promiseValue);
1261         } else {
1262             JsError error = NapiUtil::ConverErrorMessageForJs(result);
1263             napi_reject_deferred(env, settingInfo.deferred,
1264                 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
1265         }
1266     }
1267     napi_close_handle_scope(env, scope);
1268 }
1269 
ReportStartRttInfoWork(uv_work_t * work,int32_t status)1270 void NapiCallAbilityCallback::ReportStartRttInfoWork(uv_work_t *work, int32_t status)
1271 {
1272     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1273     if (dataWorkerData == nullptr) {
1274         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1275         return;
1276     }
1277     ReportStartRttInfo(dataWorkerData->info, dataWorkerData->callback);
1278     delete dataWorkerData;
1279     dataWorkerData = nullptr;
1280     delete work;
1281     work = nullptr;
1282 }
1283 
ReportStartRttInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1284 void NapiCallAbilityCallback::ReportStartRttInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1285 {
1286     napi_env env = supplementInfo.env;
1287     int32_t result = resultInfo.GetIntValue("result");
1288     napi_handle_scope scope = nullptr;
1289     napi_open_handle_scope(env, &scope);
1290     if (scope == nullptr) {
1291         TELEPHONY_LOGE("scope is nullptr");
1292         napi_close_handle_scope(env, scope);
1293         return;
1294     }
1295     if (supplementInfo.callbackRef != nullptr) {
1296         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1297         if (result == TELEPHONY_SUCCESS) {
1298             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1299         } else {
1300             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1301             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1302             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1303         }
1304         napi_value callbackFunc = nullptr;
1305         napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1306         napi_value thisVar = nullptr;
1307         napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1308         napi_value callbackResult = nullptr;
1309         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1310         napi_delete_reference(env, supplementInfo.callbackRef);
1311         napi_delete_reference(env, supplementInfo.thisVar);
1312     } else if (supplementInfo.deferred != nullptr) {
1313         if (result == TELEPHONY_SUCCESS) {
1314             napi_value promiseValue = nullptr;
1315             napi_get_null(env, &promiseValue);
1316             napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1317         } else {
1318             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1319             napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1320         }
1321     }
1322     napi_close_handle_scope(env, scope);
1323 }
1324 
ReportStopRttInfoWork(uv_work_t * work,int32_t status)1325 void NapiCallAbilityCallback::ReportStopRttInfoWork(uv_work_t *work, int32_t status)
1326 {
1327     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1328     if (dataWorkerData == nullptr) {
1329         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1330         return;
1331     }
1332     ReportStopRttInfo(dataWorkerData->info, dataWorkerData->callback);
1333     delete dataWorkerData;
1334     dataWorkerData = nullptr;
1335     delete work;
1336     work = nullptr;
1337 }
1338 
ReportStopRttInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1339 void NapiCallAbilityCallback::ReportStopRttInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1340 {
1341     napi_env env = supplementInfo.env;
1342     int32_t result = resultInfo.GetIntValue("result");
1343     napi_handle_scope scope = nullptr;
1344     napi_open_handle_scope(env, &scope);
1345     if (scope == nullptr) {
1346         TELEPHONY_LOGE("scope is nullptr");
1347         napi_close_handle_scope(env, scope);
1348         return;
1349     }
1350     if (supplementInfo.callbackRef != nullptr) {
1351         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1352         if (result == TELEPHONY_SUCCESS) {
1353             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1354         } else {
1355             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1356             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1357             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1358         }
1359         napi_value callbackFunc = nullptr;
1360         napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1361         napi_value thisVar = nullptr;
1362         napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1363         napi_value callbackResult = nullptr;
1364         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1365         napi_delete_reference(env, supplementInfo.callbackRef);
1366         napi_delete_reference(env, supplementInfo.thisVar);
1367     } else if (supplementInfo.deferred != nullptr) {
1368         if (result == TELEPHONY_SUCCESS) {
1369             napi_value promiseValue = nullptr;
1370             napi_get_null(env, &promiseValue);
1371             napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1372         } else {
1373             std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1374             napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1375         }
1376     }
1377     napi_close_handle_scope(env, scope);
1378 }
1379 
ReportCallMediaModeInfoWork(uv_work_t * work,int32_t status)1380 void NapiCallAbilityCallback::ReportCallMediaModeInfoWork(uv_work_t *work, int32_t status)
1381 {
1382     CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1383     if (dataWorkerData == nullptr) {
1384         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1385         return;
1386     }
1387     ReportCallMediaModeInfo(dataWorkerData->info, dataWorkerData->callback);
1388     delete dataWorkerData;
1389     dataWorkerData = nullptr;
1390     delete work;
1391     work = nullptr;
1392 }
1393 
ReportCallMediaModeInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1394 void NapiCallAbilityCallback::ReportCallMediaModeInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1395 {
1396     napi_env env = supplementInfo.env;
1397     int32_t result = resultInfo.GetIntValue("result");
1398     napi_handle_scope scope = nullptr;
1399     napi_open_handle_scope(env, &scope);
1400     if (scope == nullptr) {
1401         TELEPHONY_LOGE("scope is nullptr");
1402         napi_close_handle_scope(env, scope);
1403         return;
1404     }
1405     if (supplementInfo.callbackRef != nullptr) {
1406         napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1407         if (result == TELEPHONY_SUCCESS) {
1408             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1409         } else {
1410             std::string errTip = std::to_string(result);
1411             callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1412             callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1413         }
1414         napi_value callbackFunc = nullptr;
1415         napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1416         napi_value thisVar = nullptr;
1417         napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1418         napi_value callbackResult = nullptr;
1419         napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1420         napi_delete_reference(env, supplementInfo.callbackRef);
1421         napi_delete_reference(env, supplementInfo.thisVar);
1422     } else if (supplementInfo.deferred != nullptr) {
1423         if (result == TELEPHONY_SUCCESS) {
1424             napi_value promiseValue = nullptr;
1425             napi_get_null(env, &promiseValue);
1426             napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1427         } else {
1428             std::string errTip = std::to_string(result);
1429             napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1430         }
1431     }
1432     napi_close_handle_scope(env, scope);
1433 }
1434 
ReportCallOttWork(uv_work_t * work,int32_t status)1435 void NapiCallAbilityCallback::ReportCallOttWork(uv_work_t *work, int32_t status)
1436 {
1437     CallOttWorker *dataWorkerData = (CallOttWorker *)work->data;
1438     if (dataWorkerData == nullptr) {
1439         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1440         return;
1441     }
1442     ReportCallOtt(dataWorkerData->callback, dataWorkerData->info, dataWorkerData->requestId);
1443     delete dataWorkerData;
1444     dataWorkerData = nullptr;
1445     delete work;
1446     work = nullptr;
1447 }
1448 
ReportCallOtt(EventCallback & settingInfo,AppExecFwk::PacMap & resultInfo,OttCallRequestId requestId)1449 int32_t NapiCallAbilityCallback::ReportCallOtt(
1450     EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo, OttCallRequestId requestId)
1451 {
1452     napi_env env = settingInfo.env;
1453     napi_handle_scope scope = nullptr;
1454     napi_open_handle_scope(env, &scope);
1455     if (scope == nullptr) {
1456         TELEPHONY_LOGE("scope is nullptr");
1457         napi_close_handle_scope(env, scope);
1458         return TELEPHONY_ERROR;
1459     }
1460     napi_value callbackFunc = nullptr;
1461     napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1462     napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
1463     NapiCallManagerUtils::SetPropertyInt32(
1464         env, callbackValues[ARRAY_INDEX_FIRST], "requestId", static_cast<int32_t>(requestId));
1465     NapiCallManagerUtils::SetPropertyStringUtf8(
1466         env, callbackValues[ARRAY_INDEX_FIRST], "phoneNumber", resultInfo.GetStringValue("phoneNumber").c_str());
1467     NapiCallManagerUtils::SetPropertyStringUtf8(
1468         env, callbackValues[ARRAY_INDEX_FIRST], "bundleName", resultInfo.GetStringValue("bundleName").c_str());
1469     NapiCallManagerUtils::SetPropertyInt32(
1470         env, callbackValues[ARRAY_INDEX_FIRST], "videoState", resultInfo.GetIntValue("videoState"));
1471     switch (requestId) {
1472         case OttCallRequestId::OTT_REQUEST_INVITE_TO_CONFERENCE:
1473             NapiCallManagerUtils::SetPropertyStringUtf8(
1474                 env, callbackValues[ARRAY_INDEX_FIRST], "number", resultInfo.GetStringValue("number").c_str());
1475             break;
1476         case OttCallRequestId::OTT_REQUEST_UPDATE_CALL_MEDIA_MODE:
1477             NapiCallManagerUtils::SetPropertyInt32(
1478                 env, callbackValues[ARRAY_INDEX_FIRST], "callMediaMode", resultInfo.GetIntValue("callMediaMode"));
1479             break;
1480         default:
1481             break;
1482     }
1483 
1484     napi_get_reference_value(env, settingInfo.callbackRef, &callbackFunc);
1485     if (callbackFunc == nullptr) {
1486         TELEPHONY_LOGE("callbackFunc is null!");
1487         napi_close_handle_scope(env, scope);
1488         return CALL_ERR_CALLBACK_NOT_EXIST;
1489     }
1490     napi_value thisVar = nullptr;
1491     napi_get_reference_value(env, settingInfo.thisVar, &thisVar);
1492     napi_value callbackResult = nullptr;
1493     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1494     napi_close_handle_scope(env, scope);
1495     return TELEPHONY_SUCCESS;
1496 }
1497 
UpdatePostDialDelay(const std::string str)1498 int32_t NapiCallAbilityCallback::UpdatePostDialDelay(const std::string str)
1499 {
1500     if (postDialDelayCallback_.thisVar == nullptr) {
1501         TELEPHONY_LOGE("thisVar is nullptr!");
1502         return CALL_ERR_CALLBACK_NOT_EXIST;
1503     }
1504     uv_loop_s *loop = nullptr;
1505 #if NAPI_VERSION >= 2
1506     napi_get_uv_event_loop(postDialDelayCallback_.env, &loop);
1507 #endif
1508     PostDialDelayWorker *dataWorker = std::make_unique<PostDialDelayWorker>().release();
1509     if (dataWorker == nullptr) {
1510         TELEPHONY_LOGE("dataWorker is nullptr!");
1511         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1512     }
1513     dataWorker->postDialStr = str;
1514     dataWorker->callback = postDialDelayCallback_;
1515     uv_work_t *work = std::make_unique<uv_work_t>().release();
1516     if (work == nullptr) {
1517         TELEPHONY_LOGE("work is nullptr");
1518         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1519     }
1520     work->data = (void *)dataWorker;
1521     uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {}, ReportPostDialDelayWork, uv_qos_default);
1522     return TELEPHONY_SUCCESS;
1523 }
1524 
ReportPostDialDelayWork(uv_work_t * work,int32_t status)1525 void NapiCallAbilityCallback::ReportPostDialDelayWork(uv_work_t *work, int32_t status)
1526 {
1527     PostDialDelayWorker *dataWorkerData = (PostDialDelayWorker *)work->data;
1528     if (dataWorkerData == nullptr) {
1529         TELEPHONY_LOGE("dataWorkerData is nullptr!");
1530         return;
1531     }
1532     int32_t ret = ReportPostDialDelay(dataWorkerData->postDialStr, dataWorkerData->callback);
1533     TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
1534     delete dataWorkerData;
1535     dataWorkerData = nullptr;
1536     delete work;
1537     work = nullptr;
1538 }
1539 
ReportPostDialDelay(std::string postDialStr,EventCallback eventCallback)1540 int32_t NapiCallAbilityCallback::ReportPostDialDelay(std::string postDialStr, EventCallback eventCallback)
1541 {
1542     napi_value callbackFunc = nullptr;
1543     napi_env env = eventCallback.env;
1544     napi_handle_scope scope = nullptr;
1545     napi_open_handle_scope(env, &scope);
1546     if (scope == nullptr) {
1547         TELEPHONY_LOGE("scope is nullptr");
1548         napi_close_handle_scope(env, scope);
1549         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1550     }
1551     napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
1552     callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1553     napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
1554     NapiCallManagerUtils::SetPropertyStringUtf8(
1555         env, callbackValues[ARRAY_INDEX_FIRST], "postDialStr", postDialStr);
1556     napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
1557     if (callbackFunc == nullptr) {
1558         TELEPHONY_LOGE("callbackFunc is null!");
1559         napi_close_handle_scope(env, scope);
1560         return CALL_ERR_CALLBACK_NOT_EXIST;
1561     }
1562     napi_value thisVar = nullptr;
1563     napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
1564     napi_value callbackResult = nullptr;
1565     napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1566     napi_close_handle_scope(env, scope);
1567     return TELEPHONY_SUCCESS;
1568 }
1569 } // namespace Telephony
1570 } // namespace OHOS
1571