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 "pixel_map.h"
25 #include "pixel_map_napi.h"
26 #include "telephony_log_wrapper.h"
27
28 namespace OHOS {
29 namespace Telephony {
NapiCallAbilityCallback()30 NapiCallAbilityCallback::NapiCallAbilityCallback()
31 {
32 (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
33 (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
34 (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
35 (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
36 (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
37 (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
38 (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
39 (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
40 (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
41 (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
42 (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
43 (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
44 (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
45 (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
46 (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
47 (void)memset_s(&imsCallModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
48 (void)memset_s(&peerDimensionsCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
49 (void)memset_s(&callDataUsageCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
50 (void)memset_s(&cameraCapabilitiesCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
51 (void)memset_s(&callSessionEventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
52 memberFuncMap_[CallResultReportId::GET_CALL_WAITING_REPORT_ID] =
53 [this](AppExecFwk::PacMap &resultInfo) { return ReportGetWaitingInfo(resultInfo); };
54 memberFuncMap_[CallResultReportId::SET_CALL_WAITING_REPORT_ID] =
55 [this](AppExecFwk::PacMap &resultInfo) { return ReportSetWaitingInfo(resultInfo); };
56 memberFuncMap_[CallResultReportId::GET_CALL_RESTRICTION_REPORT_ID] =
57 [this](AppExecFwk::PacMap &resultInfo) { return ReportGetRestrictionInfo(resultInfo); };
58 memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_REPORT_ID] =
59 [this](AppExecFwk::PacMap &resultInfo) { return ReportSetRestrictionInfo(resultInfo); };
60 memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_PWD_REPORT_ID] =
61 [this](AppExecFwk::PacMap &resultInfo) { return ReportSetRestrictionPassword(resultInfo); };
62 memberFuncMap_[CallResultReportId::GET_CALL_TRANSFER_REPORT_ID] =
63 [this](AppExecFwk::PacMap &resultInfo) { return ReportGetTransferInfo(resultInfo); };
64 memberFuncMap_[CallResultReportId::SET_CALL_TRANSFER_REPORT_ID] =
65 [this](AppExecFwk::PacMap &resultInfo) { return ReportSetTransferInfo(resultInfo); };
66 memberFuncMap_[CallResultReportId::START_RTT_REPORT_ID] =
67 [this](AppExecFwk::PacMap &resultInfo) { return ReportStartRttInfo(resultInfo); };
68 memberFuncMap_[CallResultReportId::STOP_RTT_REPORT_ID] =
69 [this](AppExecFwk::PacMap &resultInfo) { return ReportStopRttInfo(resultInfo); };
70 memberFuncMap_[CallResultReportId::CLOSE_UNFINISHED_USSD_REPORT_ID] =
71 [this](AppExecFwk::PacMap &resultInfo) { return ReportCloseUnFinishedUssdInfo(resultInfo); };
72 }
73
~NapiCallAbilityCallback()74 NapiCallAbilityCallback::~NapiCallAbilityCallback()
75 {
76 TELEPHONY_LOGI("~NapiCallAbilityCallback");
77 }
78
RegisterCallStateCallback(EventCallback stateCallback)79 void NapiCallAbilityCallback::RegisterCallStateCallback(EventCallback stateCallback)
80 {
81 stateCallback_ = stateCallback;
82 }
83
UnRegisterCallStateCallback()84 void NapiCallAbilityCallback::UnRegisterCallStateCallback()
85 {
86 if (stateCallback_.callbackRef) {
87 (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
88 }
89 }
90
RegisterMmiCodeCallback(EventCallback eventCallback)91 void NapiCallAbilityCallback::RegisterMmiCodeCallback(EventCallback eventCallback)
92 {
93 mmiCodeCallback_ = eventCallback;
94 }
95
UnRegisterMmiCodeCallback()96 void NapiCallAbilityCallback::UnRegisterMmiCodeCallback()
97 {
98 if (mmiCodeCallback_.callbackRef) {
99 (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
100 }
101 }
102
RegisterAudioDeviceCallback(EventCallback eventCallback)103 void NapiCallAbilityCallback::RegisterAudioDeviceCallback(EventCallback eventCallback)
104 {
105 audioDeviceCallback_ = eventCallback;
106 }
107
UnRegisterAudioDeviceCallback()108 void NapiCallAbilityCallback::UnRegisterAudioDeviceCallback()
109 {
110 if (audioDeviceCallback_.callbackRef) {
111 (void)memset_s(&audioDeviceCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
112 }
113 }
114
RegisterPostDialDelay(EventCallback eventCallback)115 void NapiCallAbilityCallback::RegisterPostDialDelay(EventCallback eventCallback)
116 {
117 postDialDelayCallback_ = eventCallback;
118 }
119
UnRegisterPostDialDelayCallback()120 void NapiCallAbilityCallback::UnRegisterPostDialDelayCallback()
121 {
122 if (postDialDelayCallback_.callbackRef) {
123 (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
124 }
125 }
126
RegisterCallEventCallback(EventCallback eventCallback)127 void NapiCallAbilityCallback::RegisterCallEventCallback(EventCallback eventCallback)
128 {
129 eventCallback_ = eventCallback;
130 }
131
UnRegisterCallEventCallback()132 void NapiCallAbilityCallback::UnRegisterCallEventCallback()
133 {
134 if (eventCallback_.callbackRef) {
135 (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
136 }
137 }
138
RegisterImsCallModeChangeCallback(EventCallback eventCallback)139 void NapiCallAbilityCallback::RegisterImsCallModeChangeCallback(EventCallback eventCallback)
140 {
141 imsCallModeCallback_ = eventCallback;
142 }
143
UnRegisterImsCallModeChangeCallback()144 void NapiCallAbilityCallback::UnRegisterImsCallModeChangeCallback()
145 {
146 if (eventCallback_.callbackRef) {
147 (void)memset_s(&imsCallModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
148 }
149 }
150
RegisterPeerDimensionsChangeCallback(EventCallback eventCallback)151 void NapiCallAbilityCallback::RegisterPeerDimensionsChangeCallback(EventCallback eventCallback)
152 {
153 peerDimensionsCallback_ = eventCallback;
154 }
155
UnRegisterPeerDimensionsChangeCallback()156 void NapiCallAbilityCallback::UnRegisterPeerDimensionsChangeCallback()
157 {
158 if (eventCallback_.callbackRef) {
159 (void)memset_s(&peerDimensionsCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
160 }
161 }
162
RegisterCallDataUsageChangeCallback(EventCallback eventCallback)163 void NapiCallAbilityCallback::RegisterCallDataUsageChangeCallback(EventCallback eventCallback)
164 {
165 callDataUsageCallback_ = eventCallback;
166 }
167
UnRegisterCallDataUsageChangeCallback()168 void NapiCallAbilityCallback::UnRegisterCallDataUsageChangeCallback()
169 {
170 if (eventCallback_.callbackRef) {
171 (void)memset_s(&callDataUsageCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
172 }
173 }
174
RegisterCameraCapabilitiesChangeCallback(EventCallback eventCallback)175 void NapiCallAbilityCallback::RegisterCameraCapabilitiesChangeCallback(EventCallback eventCallback)
176 {
177 cameraCapabilitiesCallback_ = eventCallback;
178 }
179
UnRegisterCameraCapabilitiesChangeCallback()180 void NapiCallAbilityCallback::UnRegisterCameraCapabilitiesChangeCallback()
181 {
182 if (eventCallback_.callbackRef) {
183 (void)memset_s(&cameraCapabilitiesCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
184 }
185 }
186
RegisterCallSessionEventChangeCallback(EventCallback eventCallback)187 void NapiCallAbilityCallback::RegisterCallSessionEventChangeCallback(EventCallback eventCallback)
188 {
189 callSessionEventCallback_ = eventCallback;
190 }
191
UnRegisterCallSessionEventChangeCallback()192 void NapiCallAbilityCallback::UnRegisterCallSessionEventChangeCallback()
193 {
194 if (eventCallback_.callbackRef) {
195 (void)memset_s(&callSessionEventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
196 }
197 }
198
RegisterDisconnectedCauseCallback(EventCallback eventCallback)199 void NapiCallAbilityCallback::RegisterDisconnectedCauseCallback(EventCallback eventCallback)
200 {
201 callDisconnectCauseCallback_ = eventCallback;
202 }
203
UnRegisterDisconnectedCauseCallback()204 void NapiCallAbilityCallback::UnRegisterDisconnectedCauseCallback()
205 {
206 if (callDisconnectCauseCallback_.callbackRef) {
207 (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
208 }
209 }
210
RegisterCallOttRequestCallback(EventCallback ottRequestCallback)211 void NapiCallAbilityCallback::RegisterCallOttRequestCallback(EventCallback ottRequestCallback)
212 {
213 ottRequestCallback_ = ottRequestCallback;
214 }
215
UnRegisterCallOttRequestCallback()216 void NapiCallAbilityCallback::UnRegisterCallOttRequestCallback()
217 {
218 if (ottRequestCallback_.callbackRef) {
219 (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
220 }
221 }
222
RegisterGetWaitingCallback(EventCallback callback)223 int32_t NapiCallAbilityCallback::RegisterGetWaitingCallback(EventCallback callback)
224 {
225 if (getWaitingCallback_.thisVar) {
226 TELEPHONY_LOGE("callback already exist!");
227 return CALL_ERR_CALLBACK_ALREADY_EXIST;
228 }
229 getWaitingCallback_ = callback;
230 return TELEPHONY_SUCCESS;
231 }
232
UnRegisterGetWaitingCallback()233 void NapiCallAbilityCallback::UnRegisterGetWaitingCallback()
234 {
235 (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
236 }
237
RegisterCloseUnFinishedUssdCallback(EventCallback callback)238 int32_t NapiCallAbilityCallback::RegisterCloseUnFinishedUssdCallback(EventCallback callback)
239 {
240 if (closeUnfinishedUssdCallback_.thisVar) {
241 TELEPHONY_LOGE("callback already exist!");
242 return CALL_ERR_CALLBACK_ALREADY_EXIST;
243 }
244 closeUnfinishedUssdCallback_ = callback;
245 return TELEPHONY_SUCCESS;
246 }
247
UnRegisterCloseUnFinishedUssdCallback()248 void NapiCallAbilityCallback::UnRegisterCloseUnFinishedUssdCallback()
249 {
250 (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
251 }
252
RegisterSetWaitingCallback(EventCallback callback)253 int32_t NapiCallAbilityCallback::RegisterSetWaitingCallback(EventCallback callback)
254 {
255 if (setWaitingCallback_.thisVar) {
256 TELEPHONY_LOGE("callback already exist!");
257 return CALL_ERR_CALLBACK_ALREADY_EXIST;
258 }
259 setWaitingCallback_ = callback;
260 return TELEPHONY_SUCCESS;
261 }
262
UnRegisterSetWaitingCallback()263 void NapiCallAbilityCallback::UnRegisterSetWaitingCallback()
264 {
265 (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
266 }
267
RegisterGetRestrictionCallback(EventCallback callback)268 int32_t NapiCallAbilityCallback::RegisterGetRestrictionCallback(EventCallback callback)
269 {
270 if (getRestrictionCallback_.thisVar) {
271 TELEPHONY_LOGE("callback already exist!");
272 return CALL_ERR_CALLBACK_ALREADY_EXIST;
273 }
274 getRestrictionCallback_ = callback;
275 return TELEPHONY_SUCCESS;
276 }
277
UnRegisterGetRestrictionCallback()278 void NapiCallAbilityCallback::UnRegisterGetRestrictionCallback()
279 {
280 (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
281 }
282
RegisterSetRestrictionCallback(EventCallback callback)283 int32_t NapiCallAbilityCallback::RegisterSetRestrictionCallback(EventCallback callback)
284 {
285 if (setRestrictionCallback_.thisVar) {
286 TELEPHONY_LOGE("callback already exist!");
287 return CALL_ERR_CALLBACK_ALREADY_EXIST;
288 }
289 setRestrictionCallback_ = callback;
290 return TELEPHONY_SUCCESS;
291 }
292
UnRegisterSetRestrictionCallback()293 void NapiCallAbilityCallback::UnRegisterSetRestrictionCallback()
294 {
295 (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
296 }
297
RegisterSetRestrictionPasswordCallback(EventCallback callback)298 int32_t NapiCallAbilityCallback::RegisterSetRestrictionPasswordCallback(EventCallback callback)
299 {
300 if (setRestrictionPasswordCallback_.thisVar) {
301 TELEPHONY_LOGE("callback already exist!");
302 return CALL_ERR_CALLBACK_ALREADY_EXIST;
303 }
304 setRestrictionPasswordCallback_ = callback;
305 return TELEPHONY_SUCCESS;
306 }
307
UnRegisterSetRestrictionPasswordCallback()308 void NapiCallAbilityCallback::UnRegisterSetRestrictionPasswordCallback()
309 {
310 (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
311 }
312
RegisterGetTransferCallback(EventCallback callback,int32_t type)313 int32_t NapiCallAbilityCallback::RegisterGetTransferCallback(EventCallback callback, int32_t type)
314 {
315 getTransferCallback_ = callback;
316 getCallTransferReason_ = type;
317 return TELEPHONY_SUCCESS;
318 }
319
UnRegisterGetTransferCallback()320 void NapiCallAbilityCallback::UnRegisterGetTransferCallback()
321 {
322 (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
323 }
324
RegisterSetTransferCallback(EventCallback callback)325 int32_t NapiCallAbilityCallback::RegisterSetTransferCallback(EventCallback callback)
326 {
327 if (setTransferCallback_.thisVar) {
328 TELEPHONY_LOGE("callback already exist!");
329 return CALL_ERR_CALLBACK_ALREADY_EXIST;
330 }
331 setTransferCallback_ = callback;
332 return TELEPHONY_SUCCESS;
333 }
334
UnRegisterSetTransferCallback()335 void NapiCallAbilityCallback::UnRegisterSetTransferCallback()
336 {
337 (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
338 }
339
RegisterStartRttCallback(EventCallback callback)340 int32_t NapiCallAbilityCallback::RegisterStartRttCallback(EventCallback callback)
341 {
342 if (startRttCallback_.thisVar) {
343 TELEPHONY_LOGE("callback already exist!");
344 return CALL_ERR_CALLBACK_ALREADY_EXIST;
345 }
346 startRttCallback_ = callback;
347 return TELEPHONY_SUCCESS;
348 }
349
UnRegisterStartRttCallback()350 void NapiCallAbilityCallback::UnRegisterStartRttCallback()
351 {
352 (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
353 }
354
RegisterStopRttCallback(EventCallback callback)355 int32_t NapiCallAbilityCallback::RegisterStopRttCallback(EventCallback callback)
356 {
357 if (stopRttCallback_.thisVar) {
358 TELEPHONY_LOGE("callback already exist!");
359 return CALL_ERR_CALLBACK_ALREADY_EXIST;
360 }
361 stopRttCallback_ = callback;
362 return TELEPHONY_SUCCESS;
363 }
364
UnRegisterStopRttCallback()365 void NapiCallAbilityCallback::UnRegisterStopRttCallback()
366 {
367 (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
368 }
369
ReportStartRttInfo(AppExecFwk::PacMap & resultInfo)370 int32_t NapiCallAbilityCallback::ReportStartRttInfo(AppExecFwk::PacMap &resultInfo)
371 {
372 if (startRttCallback_.thisVar == nullptr) {
373 TELEPHONY_LOGE("startRttCallback_ is null!");
374 return CALL_ERR_CALLBACK_NOT_EXIST;
375 }
376 uv_loop_s *loop = nullptr;
377 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
378 napi_get_uv_event_loop(startRttCallback_.env, &loop);
379 #endif
380 if (loop == nullptr) {
381 return TELEPHONY_ERR_LOCAL_PTR_NULL;
382 }
383 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
384 if (callSupplementWorker == nullptr) {
385 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
386 return TELEPHONY_ERR_LOCAL_PTR_NULL;
387 }
388 callSupplementWorker->info = resultInfo;
389 callSupplementWorker->callback = startRttCallback_;
390 uv_work_t *work = std::make_unique<uv_work_t>().release();
391 if (work == nullptr) {
392 delete callSupplementWorker;
393 callSupplementWorker = nullptr;
394 TELEPHONY_LOGE("work is nullptr!");
395 return TELEPHONY_ERR_LOCAL_PTR_NULL;
396 }
397 work->data = (void *)callSupplementWorker;
398 int32_t errCode = uv_queue_work_with_qos(
399 loop, work, [](uv_work_t *work) {
400 TELEPHONY_LOGD("ReportStartRttInfo uv_queue_work_with_qos");
401 }, ReportStartRttInfoWork, uv_qos_default);
402 if (errCode != 0) {
403 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
404 delete callSupplementWorker;
405 callSupplementWorker = nullptr;
406 delete work;
407 work = nullptr;
408 return TELEPHONY_ERROR;
409 }
410 if (startRttCallback_.thisVar) {
411 (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
412 }
413 return TELEPHONY_SUCCESS;
414 }
415
ReportStopRttInfo(AppExecFwk::PacMap & resultInfo)416 int32_t NapiCallAbilityCallback::ReportStopRttInfo(AppExecFwk::PacMap &resultInfo)
417 {
418 if (stopRttCallback_.thisVar == nullptr) {
419 TELEPHONY_LOGE("startRttCallback_ is null!");
420 return CALL_ERR_CALLBACK_NOT_EXIST;
421 }
422 uv_loop_s *loop = nullptr;
423 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
424 napi_get_uv_event_loop(stopRttCallback_.env, &loop);
425 #endif
426 if (loop == nullptr) {
427 return TELEPHONY_ERR_LOCAL_PTR_NULL;
428 }
429 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
430 if (callSupplementWorker == nullptr) {
431 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
432 return TELEPHONY_ERR_LOCAL_PTR_NULL;
433 }
434 callSupplementWorker->info = resultInfo;
435 callSupplementWorker->callback = stopRttCallback_;
436 uv_work_t *work = std::make_unique<uv_work_t>().release();
437 if (work == nullptr) {
438 delete callSupplementWorker;
439 callSupplementWorker = nullptr;
440 TELEPHONY_LOGE("work is nullptr!");
441 return TELEPHONY_ERR_LOCAL_PTR_NULL;
442 }
443 work->data = (void *)callSupplementWorker;
444 int32_t resultCode = uv_queue_work_with_qos(
445 loop, work, [](uv_work_t *work) {
446 TELEPHONY_LOGD("ReportStopRttInfo uv_queue_work_with_qos");
447 }, ReportStopRttInfoWork, uv_qos_default);
448 if (resultCode != 0) {
449 delete callSupplementWorker;
450 callSupplementWorker = nullptr;
451 TELEPHONY_LOGE("failed to add uv_queue_work_with_qos, resultCode: %{public}d", resultCode);
452 delete work;
453 work = nullptr;
454 return TELEPHONY_ERROR;
455 }
456 if (stopRttCallback_.thisVar) {
457 (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
458 }
459 return TELEPHONY_SUCCESS;
460 }
461
UpdateCallStateInfo(const CallAttributeInfo & info)462 int32_t NapiCallAbilityCallback::UpdateCallStateInfo(const CallAttributeInfo &info)
463 {
464 if (stateCallback_.thisVar == nullptr) {
465 return CALL_ERR_CALLBACK_NOT_EXIST;
466 }
467 uv_loop_s *loop = nullptr;
468 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
469 napi_get_uv_event_loop(stateCallback_.env, &loop);
470 #endif
471 if (loop == nullptr) {
472 return TELEPHONY_ERR_LOCAL_PTR_NULL;
473 }
474 CallStateWorker *callStateWorker = std::make_unique<CallStateWorker>().release();
475 if (callStateWorker == nullptr) {
476 TELEPHONY_LOGE("callStateWorker is nullptr!");
477 return TELEPHONY_ERR_LOCAL_PTR_NULL;
478 }
479 callStateWorker->info = info;
480 callStateWorker->callback = stateCallback_;
481 uv_work_t *work = std::make_unique<uv_work_t>().release();
482 if (work == nullptr) {
483 delete callStateWorker;
484 callStateWorker = nullptr;
485 TELEPHONY_LOGE("work is nullptr!");
486 return TELEPHONY_ERR_LOCAL_PTR_NULL;
487 }
488 work->data = (void *)callStateWorker;
489 int32_t errCode = uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {
490 TELEPHONY_LOGD("UpdateCallStateInfo uv_queue_work_with_qos");
491 }, ReportCallStateWork, uv_qos_default);
492 if (errCode != 0) {
493 delete callStateWorker;
494 callStateWorker = nullptr;
495 delete work;
496 work = nullptr;
497 TELEPHONY_LOGE("failed to add uv_queue_work_with_qos, errCode: %{public}d", errCode);
498 return TELEPHONY_ERROR;
499 }
500 return TELEPHONY_SUCCESS;
501 }
502
ReportCallStateWork(uv_work_t * work,int32_t status)503 void NapiCallAbilityCallback::ReportCallStateWork(uv_work_t *work, int32_t status)
504 {
505 CallStateWorker *dataWorkerData = (CallStateWorker *)work->data;
506 if (dataWorkerData == nullptr) {
507 TELEPHONY_LOGE("dataWorkerData is nullptr!");
508 return;
509 }
510 int32_t ret = ReportCallState(dataWorkerData->info, dataWorkerData->callback);
511 TELEPHONY_LOGI("ReportCallState result = %{public}d", ret);
512 delete dataWorkerData;
513 dataWorkerData = nullptr;
514 delete work;
515 work = nullptr;
516 }
517
518 /**
519 * To notify an application of a call status change, register a callback with on() first.
520 */
ReportCallState(CallAttributeInfo & info,EventCallback stateCallback)521 int32_t NapiCallAbilityCallback::ReportCallState(CallAttributeInfo &info, EventCallback stateCallback)
522 {
523 napi_env env = stateCallback.env;
524 napi_handle_scope scope = nullptr;
525 napi_open_handle_scope(env, &scope);
526 if (scope == nullptr) {
527 TELEPHONY_LOGE("scope is nullptr");
528 napi_close_handle_scope(env, scope);
529 return TELEPHONY_ERROR;
530 }
531 napi_value callbackFunc = nullptr;
532 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
533 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
534 NapiCallManagerUtils::SetPropertyStringUtf8(
535 env, callbackValues[ARRAY_INDEX_FIRST], "accountNumber", info.accountNumber);
536 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "accountId", info.accountId);
537 NapiCallManagerUtils::SetPropertyInt32(
538 env, callbackValues[ARRAY_INDEX_FIRST], "videoState", static_cast<int32_t>(info.videoState));
539 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "startTime", info.startTime);
540 NapiCallManagerUtils::SetPropertyBoolean(env, callbackValues[ARRAY_INDEX_FIRST], "isEcc", info.isEcc);
541 NapiCallManagerUtils::SetPropertyInt32(
542 env, callbackValues[ARRAY_INDEX_FIRST], "callType", static_cast<int32_t>(info.callType));
543 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "callId", info.callId);
544 NapiCallManagerUtils::SetPropertyInt32(
545 env, callbackValues[ARRAY_INDEX_FIRST], "callState", static_cast<int32_t>(info.callState));
546 NapiCallManagerUtils::SetPropertyInt32(
547 env, callbackValues[ARRAY_INDEX_FIRST], "conferenceState", static_cast<int32_t>(info.conferenceState));
548 NapiCallManagerUtils::SetPropertyInt32(
549 env, callbackValues[ARRAY_INDEX_FIRST], "crsType", info.crsType);
550 NapiCallManagerUtils::SetPropertyInt32(
551 env, callbackValues[ARRAY_INDEX_FIRST], "originalCallType", info.originalCallType);
552 ReportCallAttribute(env, callbackValues, ARRAY_INDEX_THIRD, info);
553 napi_get_reference_value(env, stateCallback.callbackRef, &callbackFunc);
554 if (callbackFunc == nullptr) {
555 TELEPHONY_LOGE("callbackFunc is null!");
556 napi_close_handle_scope(env, scope);
557 return CALL_ERR_CALLBACK_NOT_EXIST;
558 }
559 napi_value thisVar = nullptr;
560 napi_get_reference_value(env, stateCallback.thisVar, &thisVar);
561 napi_value callbackResult = nullptr;
562 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
563 napi_close_handle_scope(env, scope);
564 return TELEPHONY_SUCCESS;
565 }
566
ReportCallAttribute(napi_env & env,napi_value callbackValues[],const size_t callbackValuesCount,CallAttributeInfo & info)567 void NapiCallAbilityCallback::ReportCallAttribute(napi_env &env, napi_value callbackValues[],
568 const size_t callbackValuesCount, CallAttributeInfo &info)
569 {
570 std::string str(info.numberLocation);
571 if (str == "default") {
572 TELEPHONY_LOGE("numberLocation is default");
573 (void)memset_s(info.numberLocation, kMaxNumberLen, 0, kMaxNumberLen);
574 }
575 NapiCallManagerUtils::SetPropertyStringUtf8(
576 env, callbackValues[ARRAY_INDEX_FIRST], "numberLocation", info.numberLocation);
577 TELEPHONY_LOGI("ReportCallState crsType = %{public}d", info.crsType);
578 if (info.callType == CallType::TYPE_VOIP) {
579 napi_value voipObject = nullptr;
580 CreateVoipNapiValue(env, voipObject, info);
581 napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "voipCallAttribute", voipObject);
582 }
583 napi_value markInfoObject = nullptr;
584 CreateMarkInfoNapiValue(env, markInfoObject, info);
585 napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "numberMarkInfo", markInfoObject);
586 }
587
CreateVoipNapiValue(napi_env & env,napi_value & voipObject,CallAttributeInfo & info)588 void NapiCallAbilityCallback::CreateVoipNapiValue(napi_env &env, napi_value &voipObject, CallAttributeInfo &info)
589 {
590 napi_create_object(env, &voipObject);
591 NapiCallManagerUtils::SetPropertyStringUtf8(env, voipObject, "userName", info.voipCallInfo.userName);
592 NapiCallManagerUtils::SetPropertyStringUtf8(env, voipObject, "abilityName", info.voipCallInfo.abilityName);
593 NapiCallManagerUtils::SetPropertyStringUtf8(env, voipObject, "extensionId", info.voipCallInfo.extensionId);
594 NapiCallManagerUtils::SetPropertyStringUtf8(env, voipObject, "voipBundleName", info.voipCallInfo.voipBundleName);
595 NapiCallManagerUtils::SetPropertyStringUtf8(env, voipObject, "voipCallId", info.voipCallInfo.voipCallId);
596 NapiCallManagerUtils::SetPropertyBoolean(env, voipObject, "showBannerForIncomingCall",
597 info.voipCallInfo.showBannerForIncomingCall);
598 NapiCallManagerUtils::SetPropertyBoolean(env, voipObject, "isConferenceCall", info.voipCallInfo.isConferenceCall);
599 NapiCallManagerUtils::SetPropertyBoolean(
600 env, voipObject, "isVoiceAnswerSupported", info.voipCallInfo.isVoiceAnswerSupported);
601 NapiCallManagerUtils::SetPropertyBoolean(env, voipObject, "hasMicPermission", info.voipCallInfo.hasMicPermission);
602 NapiCallManagerUtils::SetPropertyInt32(env, voipObject, "uid", info.voipCallInfo.uid);
603 std::shared_ptr<Media::PixelMap> userProfile =
604 std::shared_ptr<Media::PixelMap>(Media::PixelMap::DecodeTlv(info.voipCallInfo.userProfile));
605 napi_value pixelMapObject = Media::PixelMapNapi::CreatePixelMap(env, userProfile);
606 napi_set_named_property(env, voipObject, "userProfile", pixelMapObject);
607 }
608
CreateMarkInfoNapiValue(napi_env & env,napi_value & markInfoObject,CallAttributeInfo & info)609 void NapiCallAbilityCallback::CreateMarkInfoNapiValue(napi_env &env,
610 napi_value &markInfoObject, CallAttributeInfo &info)
611 {
612 napi_create_object(env, &markInfoObject);
613 NapiCallManagerUtils::SetPropertyInt32(env, markInfoObject, "markType",
614 static_cast<int32_t>(info.numberMarkInfo.markType));
615 NapiCallManagerUtils::SetPropertyStringUtf8(env, markInfoObject, "markContent", info.numberMarkInfo.markContent);
616 NapiCallManagerUtils::SetPropertyInt32(env, markInfoObject, "markCount",
617 static_cast<int32_t>(info.numberMarkInfo.markCount));
618 NapiCallManagerUtils::SetPropertyStringUtf8(env, markInfoObject, "markSource", info.numberMarkInfo.markSource);
619 NapiCallManagerUtils::SetPropertyBoolean(env, markInfoObject, "isCloud", info.numberMarkInfo.isCloud);
620 }
621
UpdateCallEvent(const CallEventInfo & info)622 int32_t NapiCallAbilityCallback::UpdateCallEvent(const CallEventInfo &info)
623 {
624 if (eventCallback_.thisVar == nullptr) {
625 TELEPHONY_LOGE("eventCallback is null!");
626 return CALL_ERR_CALLBACK_NOT_EXIST;
627 }
628 uv_loop_s *loop = nullptr;
629 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
630 napi_get_uv_event_loop(eventCallback_.env, &loop);
631 #endif
632 if (loop == nullptr) {
633 return TELEPHONY_ERR_LOCAL_PTR_NULL;
634 }
635 CallEventWorker *callEventWorker = std::make_unique<CallEventWorker>().release();
636 if (callEventWorker == nullptr) {
637 TELEPHONY_LOGE("callEventWorker is nullptr!");
638 return TELEPHONY_ERR_LOCAL_PTR_NULL;
639 }
640 callEventWorker->info = info;
641 callEventWorker->callback = eventCallback_;
642 uv_work_t *work = std::make_unique<uv_work_t>().release();
643 if (work == nullptr) {
644 delete callEventWorker;
645 callEventWorker = nullptr;
646 TELEPHONY_LOGE("work is nullptr!");
647 return TELEPHONY_ERR_LOCAL_PTR_NULL;
648 }
649 work->data = (void *)callEventWorker;
650 int32_t errCode = uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {
651 TELEPHONY_LOGD("UpdateCallEvent uv_queue_work_with_qos");
652 }, ReportCallEventWork, uv_qos_default);
653 if (errCode != 0) {
654 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
655 delete callEventWorker;
656 callEventWorker = nullptr;
657 delete work;
658 work = nullptr;
659 return TELEPHONY_ERROR;
660 }
661 return TELEPHONY_SUCCESS;
662 }
663
ReportCallEventWork(uv_work_t * work,int32_t status)664 void NapiCallAbilityCallback::ReportCallEventWork(uv_work_t *work, int32_t status)
665 {
666 CallEventWorker *dataWorkerData = (CallEventWorker *)work->data;
667 if (dataWorkerData == nullptr) {
668 TELEPHONY_LOGE("dataWorkerData is nullptr!");
669 return;
670 }
671 int32_t ret = ReportCallEvent(dataWorkerData->info, dataWorkerData->callback);
672 TELEPHONY_LOGI("ReportCallEvent results %{public}d", ret);
673 delete dataWorkerData;
674 dataWorkerData = nullptr;
675 delete work;
676 work = nullptr;
677 }
678
ReportCallEvent(CallEventInfo & info,EventCallback eventCallback)679 int32_t NapiCallAbilityCallback::ReportCallEvent(CallEventInfo &info, EventCallback eventCallback)
680 {
681 napi_env env = eventCallback.env;
682 napi_handle_scope scopeCallEvent = nullptr;
683 napi_open_handle_scope(env, &scopeCallEvent);
684 if (scopeCallEvent == nullptr) {
685 TELEPHONY_LOGE("scopeCallEvent is nullptr");
686 napi_close_handle_scope(env, scopeCallEvent);
687 return TELEPHONY_ERROR;
688 }
689 napi_value callEventCallbackFunc = nullptr;
690 napi_value callEventCallbackValues[ARRAY_INDEX_THIRD] = { 0 };
691 napi_create_object(env, &callEventCallbackValues[ARRAY_INDEX_FIRST]);
692 NapiCallManagerUtils::SetPropertyInt32(
693 env, callEventCallbackValues[ARRAY_INDEX_FIRST], "eventId", static_cast<int32_t>(info.eventId));
694 NapiCallManagerUtils::SetPropertyStringUtf8(
695 env, callEventCallbackValues[ARRAY_INDEX_FIRST], "accountNumber", info.phoneNum);
696 NapiCallManagerUtils::SetPropertyStringUtf8(
697 env, callEventCallbackValues[ARRAY_INDEX_FIRST], "bundleName", info.bundleName);
698 napi_get_reference_value(env, eventCallback.callbackRef, &callEventCallbackFunc);
699 if (callEventCallbackFunc == nullptr) {
700 TELEPHONY_LOGE("callEventCallbackFunc is null!");
701 napi_close_handle_scope(env, scopeCallEvent);
702 return CALL_ERR_CALLBACK_NOT_EXIST;
703 }
704 napi_value thisVar = nullptr;
705 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
706 napi_value callbackResult = nullptr;
707 napi_call_function(env, thisVar, callEventCallbackFunc, DATA_LENGTH_ONE, callEventCallbackValues, &callbackResult);
708 napi_close_handle_scope(env, scopeCallEvent);
709 return TELEPHONY_SUCCESS;
710 }
711
UpdateCallDisconnectedCause(const DisconnectedDetails & details)712 int32_t NapiCallAbilityCallback::UpdateCallDisconnectedCause(const DisconnectedDetails &details)
713 {
714 if (callDisconnectCauseCallback_.thisVar == nullptr) {
715 TELEPHONY_LOGE("callDisconnectCauseCallback_ is null!");
716 return CALL_ERR_CALLBACK_NOT_EXIST;
717 }
718 uv_loop_s *loop = nullptr;
719 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
720 napi_get_uv_event_loop(callDisconnectCauseCallback_.env, &loop);
721 #endif
722 if (loop == nullptr) {
723 return TELEPHONY_ERR_LOCAL_PTR_NULL;
724 }
725 CallDisconnectedCauseWorker *callDisconnectedCauseWorker =
726 std::make_unique<CallDisconnectedCauseWorker>().release();
727 if (callDisconnectedCauseWorker == nullptr) {
728 TELEPHONY_LOGE("callDisconnectedCauseWorker is nullptr!");
729 return TELEPHONY_ERR_LOCAL_PTR_NULL;
730 }
731 callDisconnectedCauseWorker->details = details;
732 callDisconnectedCauseWorker->callback = callDisconnectCauseCallback_;
733 uv_work_t *work = std::make_unique<uv_work_t>().release();
734 if (work == nullptr) {
735 delete callDisconnectedCauseWorker;
736 callDisconnectedCauseWorker = nullptr;
737 TELEPHONY_LOGE("work is nullptr!");
738 return TELEPHONY_ERR_LOCAL_PTR_NULL;
739 }
740 work->data = (void *)callDisconnectedCauseWorker;
741 int32_t errCode = uv_queue_work_with_qos(
742 loop, work, [](uv_work_t *work) {
743 TELEPHONY_LOGD("UpdateCallDisconnectedCause uv_queue_work_with_qos");
744 }, ReportCallDisconnectedCauseWork, uv_qos_default);
745 if (errCode != 0) {
746 delete callDisconnectedCauseWorker;
747 callDisconnectedCauseWorker = nullptr;
748 TELEPHONY_LOGE("failed to add uv_queue_work_with_qos, errCode: %{public}d", errCode);
749 delete work;
750 work = nullptr;
751 return TELEPHONY_ERROR;
752 }
753 if (callDisconnectCauseCallback_.thisVar) {
754 (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
755 }
756 return TELEPHONY_SUCCESS;
757 }
758
ReportCallDisconnectedCauseWork(uv_work_t * work,int32_t status)759 void NapiCallAbilityCallback::ReportCallDisconnectedCauseWork(uv_work_t *work, int32_t status)
760 {
761 CallDisconnectedCauseWorker *dataWorkerData = (CallDisconnectedCauseWorker *)work->data;
762 if (dataWorkerData == nullptr) {
763 TELEPHONY_LOGE("dataWorkerData is nullptr!");
764 return;
765 }
766 int32_t ret = ReportDisconnectedCause(dataWorkerData->details, dataWorkerData->callback);
767 TELEPHONY_LOGI("ReportDisconnectedCause results %{public}d", ret);
768 delete dataWorkerData;
769 dataWorkerData = nullptr;
770 delete work;
771 work = nullptr;
772 }
773
ReportDisconnectedCause(const DisconnectedDetails & details,EventCallback eventCallback)774 int32_t NapiCallAbilityCallback::ReportDisconnectedCause(
775 const DisconnectedDetails &details, EventCallback eventCallback)
776 {
777 napi_env env = eventCallback.env;
778 napi_handle_scope disconnectedScope = nullptr;
779 napi_open_handle_scope(env, &disconnectedScope);
780 if (disconnectedScope == nullptr) {
781 TELEPHONY_LOGE("disconnectedScope is nullptr");
782 napi_close_handle_scope(env, disconnectedScope);
783 return TELEPHONY_ERROR;
784 }
785 napi_value callbackFunc = nullptr;
786 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
787 napi_create_object(env, &callbackValues[ARRAY_INDEX_SECOND]);
788 NapiCallManagerUtils::SetPropertyInt32(
789 env, callbackValues[ARRAY_INDEX_SECOND], "disconnectedCause", static_cast<int32_t>(details.reason));
790 NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_SECOND], "message", details.message);
791 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
792 if (callbackFunc == nullptr) {
793 TELEPHONY_LOGE("callbackFunc is null!");
794 napi_close_handle_scope(env, disconnectedScope);
795 return CALL_ERR_CALLBACK_NOT_EXIST;
796 }
797 napi_value thisVar = nullptr;
798 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
799 napi_value callbackResult = nullptr;
800 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
801 napi_close_handle_scope(env, disconnectedScope);
802 return TELEPHONY_SUCCESS;
803 }
804
UpdateAsyncResultsInfo(const CallResultReportId reportId,AppExecFwk::PacMap & resultInfo)805 int32_t NapiCallAbilityCallback::UpdateAsyncResultsInfo(
806 const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo)
807 {
808 int32_t result = TELEPHONY_ERR_FAIL;
809 TELEPHONY_LOGI("UpdateAsyncResultsInfo reportId = %{public}d", reportId);
810 auto itFunc = memberFuncMap_.find(reportId);
811 if (itFunc != memberFuncMap_.end() && itFunc->second != nullptr) {
812 auto memberFunc = itFunc->second;
813 result = memberFunc(resultInfo);
814 }
815 return result;
816 }
817
UpdateMmiCodeResultsInfo(const MmiCodeInfo & info)818 int32_t NapiCallAbilityCallback::UpdateMmiCodeResultsInfo(const MmiCodeInfo &info)
819 {
820 if (mmiCodeCallback_.thisVar == nullptr) {
821 TELEPHONY_LOGE("mmiCodeCallback is null!");
822 return CALL_ERR_CALLBACK_NOT_EXIST;
823 }
824 uv_loop_s *loop = nullptr;
825 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
826 napi_get_uv_event_loop(mmiCodeCallback_.env, &loop);
827 #endif
828 if (loop == nullptr) {
829 return TELEPHONY_ERR_LOCAL_PTR_NULL;
830 }
831 MmiCodeWorker *mmiCodeWorker = std::make_unique<MmiCodeWorker>().release();
832 if (mmiCodeWorker == nullptr) {
833 TELEPHONY_LOGE("mmiCodeWorker is nullptr!");
834 return TELEPHONY_ERR_LOCAL_PTR_NULL;
835 }
836 mmiCodeWorker->info = info;
837 mmiCodeWorker->callback = mmiCodeCallback_;
838 uv_work_t *work = std::make_unique<uv_work_t>().release();
839 if (work == nullptr) {
840 delete mmiCodeWorker;
841 mmiCodeWorker = nullptr;
842 TELEPHONY_LOGE("work is nullptr!");
843 return TELEPHONY_ERR_LOCAL_PTR_NULL;
844 }
845 work->data = (void *)mmiCodeWorker;
846 int32_t errCode = uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {
847 TELEPHONY_LOGD("UpdateMmiCodeResultsInfo uv_queue_work_with_qos");
848 }, ReportMmiCodeWork, uv_qos_default);
849 if (errCode != 0) {
850 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
851 delete mmiCodeWorker;
852 mmiCodeWorker = nullptr;
853 delete work;
854 work = nullptr;
855 return TELEPHONY_ERROR;
856 }
857 return TELEPHONY_SUCCESS;
858 }
859
ReportMmiCodeWork(uv_work_t * work,int32_t status)860 void NapiCallAbilityCallback::ReportMmiCodeWork(uv_work_t *work, int32_t status)
861 {
862 MmiCodeWorker *dataWorkerData = (MmiCodeWorker *)work->data;
863 if (dataWorkerData == nullptr) {
864 TELEPHONY_LOGE("dataWorkerData is nullptr!");
865 return;
866 }
867 int32_t ret = ReportMmiCode(dataWorkerData->info, dataWorkerData->callback);
868 TELEPHONY_LOGI("ReportMmiCode result = %{public}d", ret);
869 delete dataWorkerData;
870 dataWorkerData = nullptr;
871 delete work;
872 work = nullptr;
873 }
874
875 /**
876 * To notify an application of MMI code result, register a callback with on() first.
877 */
ReportMmiCode(MmiCodeInfo & info,EventCallback eventCallback)878 int32_t NapiCallAbilityCallback::ReportMmiCode(MmiCodeInfo &info, EventCallback eventCallback)
879 {
880 napi_env env = eventCallback.env;
881 napi_handle_scope mmiCodeScope = nullptr;
882 napi_open_handle_scope(env, &mmiCodeScope);
883 if (mmiCodeScope == nullptr) {
884 TELEPHONY_LOGE("mmiCodeScope is nullptr");
885 napi_close_handle_scope(env, mmiCodeScope);
886 return TELEPHONY_ERROR;
887 }
888 napi_value callbackFunc = nullptr;
889 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
890 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
891 napi_create_object(env, &callbackValues[ARRAY_INDEX_SECOND]);
892 NapiCallManagerUtils::SetPropertyInt32(
893 env, callbackValues[ARRAY_INDEX_SECOND], "result", static_cast<int32_t>(info.result));
894 NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValues[ARRAY_INDEX_SECOND], "message", info.message);
895 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
896 if (callbackFunc == nullptr) {
897 TELEPHONY_LOGE("callbackFunc is null!");
898 napi_close_handle_scope(env, mmiCodeScope);
899 return CALL_ERR_CALLBACK_NOT_EXIST;
900 }
901 napi_value thisVar = nullptr;
902 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
903 napi_value callbackResult = nullptr;
904 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
905 napi_close_handle_scope(env, mmiCodeScope);
906 return TELEPHONY_SUCCESS;
907 }
908
UpdateAudioDeviceInfo(const AudioDeviceInfo & info)909 int32_t NapiCallAbilityCallback::UpdateAudioDeviceInfo(const AudioDeviceInfo &info)
910 {
911 if (audioDeviceCallback_.thisVar == nullptr) {
912 return CALL_ERR_CALLBACK_NOT_EXIST;
913 }
914 uv_loop_s *loop = nullptr;
915 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
916 napi_get_uv_event_loop(audioDeviceCallback_.env, &loop);
917 #endif
918 if (loop == nullptr) {
919 return TELEPHONY_ERR_LOCAL_PTR_NULL;
920 }
921 AudioDeviceWork *audioDeviceWork = std::make_unique<AudioDeviceWork>().release();
922 if (audioDeviceWork == nullptr) {
923 TELEPHONY_LOGE("audioDeviceWork is nullptr!");
924 return TELEPHONY_ERR_LOCAL_PTR_NULL;
925 }
926 audioDeviceWork->info = info;
927 audioDeviceWork->callback = audioDeviceCallback_;
928 uv_work_t *work = std::make_unique<uv_work_t>().release();
929 if (work == nullptr) {
930 delete audioDeviceWork;
931 audioDeviceWork = nullptr;
932 TELEPHONY_LOGE("work is nullptr!");
933 return TELEPHONY_ERR_LOCAL_PTR_NULL;
934 }
935 work->data = (void *)audioDeviceWork;
936 int32_t errCode = uv_queue_work_with_qos(
937 loop, work, [](uv_work_t *work) {
938 TELEPHONY_LOGD("UpdateAudioDeviceInfo uv_queue_work_with_qos");
939 }, ReportAudioDeviceInfoWork, uv_qos_default);
940 if (errCode != 0) {
941 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
942 delete audioDeviceWork;
943 audioDeviceWork = nullptr;
944 delete work;
945 work = nullptr;
946 return TELEPHONY_ERROR;
947 }
948 return TELEPHONY_SUCCESS;
949 }
950
ReportAudioDeviceInfoWork(uv_work_t * work,int32_t status)951 void NapiCallAbilityCallback::ReportAudioDeviceInfoWork(uv_work_t *work, int32_t status)
952 {
953 AudioDeviceWork *dataWorkerData = (AudioDeviceWork *)work->data;
954 if (dataWorkerData == nullptr) {
955 TELEPHONY_LOGE("dataWorkerData is nullptr!");
956 return;
957 }
958 int32_t ret = ReportAudioDeviceInfo(dataWorkerData->info, dataWorkerData->callback);
959 TELEPHONY_LOGI("ReportAudioDeviceInfo result = %{public}d", ret);
960 delete dataWorkerData;
961 dataWorkerData = nullptr;
962 delete work;
963 work = nullptr;
964 }
965
ReportAudioDeviceInfo(AudioDeviceInfo & info,EventCallback eventCallback)966 int32_t NapiCallAbilityCallback::ReportAudioDeviceInfo(AudioDeviceInfo &info, EventCallback eventCallback)
967 {
968 napi_env env = eventCallback.env;
969 napi_handle_scope AudioDeviceInfoScope = nullptr;
970 napi_open_handle_scope(env, &AudioDeviceInfoScope);
971 if (AudioDeviceInfoScope == nullptr) {
972 TELEPHONY_LOGE("AudioDeviceInfoScope is nullptr");
973 napi_close_handle_scope(env, AudioDeviceInfoScope);
974 return TELEPHONY_ERROR;
975 }
976 napi_value callbackFunc = nullptr;
977 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
978 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
979
980 NapiCallManagerUtils::SetPropertyBoolean(env, callbackValues[ARRAY_INDEX_FIRST], "isMuted", info.isMuted);
981
982 napi_value currentAudioDeviceValue = nullptr;
983 napi_create_object(env, ¤tAudioDeviceValue);
984 NapiCallManagerUtils::SetPropertyInt32(env, currentAudioDeviceValue, "deviceType",
985 static_cast<int32_t>(info.currentAudioDevice.deviceType));
986 NapiCallManagerUtils::SetPropertyStringUtf8(
987 env, currentAudioDeviceValue, "address", info.currentAudioDevice.address);
988 NapiCallManagerUtils::SetPropertyStringUtf8(
989 env, currentAudioDeviceValue, "deviceName", info.currentAudioDevice.deviceName);
990 napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "currentAudioDevice", currentAudioDeviceValue);
991
992 napi_value audioDeviceListValue = nullptr;
993 napi_create_array(env, &audioDeviceListValue);
994 std::vector<AudioDevice>::iterator it = info.audioDeviceList.begin();
995 int32_t i = 0;
996 for (; it != info.audioDeviceList.end(); ++it) {
997 napi_value value = nullptr;
998 napi_create_object(env, &value);
999 NapiCallManagerUtils::SetPropertyInt32(env, value, "deviceType", static_cast<int32_t>(it->deviceType));
1000 NapiCallManagerUtils::SetPropertyStringUtf8(env, value, "address", it->address);
1001 NapiCallManagerUtils::SetPropertyStringUtf8(env, value, "deviceName", it->deviceName);
1002 napi_set_element(env, audioDeviceListValue, i, value);
1003 ++i;
1004 }
1005 napi_set_named_property(env, callbackValues[ARRAY_INDEX_FIRST], "audioDeviceList", audioDeviceListValue);
1006
1007 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
1008 if (callbackFunc == nullptr) {
1009 TELEPHONY_LOGE("callbackFunc is null!");
1010 napi_close_handle_scope(env, AudioDeviceInfoScope);
1011 return CALL_ERR_CALLBACK_NOT_EXIST;
1012 }
1013 napi_value thisVar = nullptr;
1014 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
1015 napi_value callbackResult = nullptr;
1016 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1017 napi_close_handle_scope(env, AudioDeviceInfoScope);
1018 return TELEPHONY_SUCCESS;
1019 }
1020
OttCallRequest(OttCallRequestId requestId,AppExecFwk::PacMap & info)1021 int32_t NapiCallAbilityCallback::OttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
1022 {
1023 if (ottRequestCallback_.thisVar == nullptr) {
1024 TELEPHONY_LOGE("stateCallback is null!");
1025 return CALL_ERR_CALLBACK_NOT_EXIST;
1026 }
1027 uv_loop_s *loop = nullptr;
1028 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1029 napi_get_uv_event_loop(ottRequestCallback_.env, &loop);
1030 #endif
1031 if (loop == nullptr) {
1032 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1033 }
1034 CallOttWorker *callOttWorker = std::make_unique<CallOttWorker>().release();
1035 if (callOttWorker == nullptr) {
1036 TELEPHONY_LOGE("callOttWorker is nullptr!");
1037 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1038 }
1039 callOttWorker->requestId = requestId;
1040 callOttWorker->info = info;
1041 callOttWorker->callback = ottRequestCallback_;
1042 uv_work_t *work = std::make_unique<uv_work_t>().release();
1043 if (work == nullptr) {
1044 delete callOttWorker;
1045 callOttWorker = nullptr;
1046 TELEPHONY_LOGE("work is nullptr!");
1047 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1048 }
1049 work->data = (void *)callOttWorker;
1050 int32_t errCode = uv_queue_work_with_qos(loop, work, [](uv_work_t *work) {
1051 TELEPHONY_LOGD("OttCallRequest uv_queue_work_with_qos");
1052 }, ReportCallOttWork, uv_qos_default);
1053 if (errCode != 0) {
1054 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1055 delete callOttWorker;
1056 callOttWorker = nullptr;
1057 delete work;
1058 work = nullptr;
1059 return TELEPHONY_ERROR;
1060 }
1061 return TELEPHONY_SUCCESS;
1062 }
1063
ReportGetWaitingInfo(AppExecFwk::PacMap & resultInfo)1064 int32_t NapiCallAbilityCallback::ReportGetWaitingInfo(AppExecFwk::PacMap &resultInfo)
1065 {
1066 if (getWaitingCallback_.thisVar == nullptr) {
1067 TELEPHONY_LOGE("getWaitingCallback is null!");
1068 return CALL_ERR_CALLBACK_NOT_EXIST;
1069 }
1070 uv_loop_s *loop = nullptr;
1071 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1072 napi_get_uv_event_loop(getWaitingCallback_.env, &loop);
1073 #endif
1074 if (loop == nullptr) {
1075 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1076 }
1077 CallSupplementWorker *callSupplementWorkerData = std::make_unique<CallSupplementWorker>().release();
1078 if (callSupplementWorkerData == nullptr) {
1079 TELEPHONY_LOGE("callSupplementWorkerData is nullptr!");
1080 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1081 }
1082 callSupplementWorkerData->info = resultInfo;
1083 callSupplementWorkerData->callback = getWaitingCallback_;
1084 uv_work_t *work = std::make_unique<uv_work_t>().release();
1085 if (work == nullptr) {
1086 delete callSupplementWorkerData;
1087 callSupplementWorkerData = nullptr;
1088 TELEPHONY_LOGE("work is nullptr!");
1089 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1090 }
1091 work->data = (void *)callSupplementWorkerData;
1092 int32_t errorCode = uv_queue_work_with_qos(
1093 loop, work, [](uv_work_t *work) {
1094 TELEPHONY_LOGD("ReportGetWaitingInfo uv_queue_work_with_qos");
1095 }, ReportWaitAndLimitInfoWork, uv_qos_default);
1096 if (errorCode != 0) {
1097 delete callSupplementWorkerData;
1098 callSupplementWorkerData = nullptr;
1099 delete work;
1100 work = nullptr;
1101 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errorCode: %{public}d", errorCode);
1102 return TELEPHONY_ERROR;
1103 }
1104 if (getWaitingCallback_.thisVar) {
1105 (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1106 }
1107 return TELEPHONY_SUCCESS;
1108 }
1109
ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap & resultInfo)1110 int32_t NapiCallAbilityCallback::ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap &resultInfo)
1111 {
1112 if (closeUnfinishedUssdCallback_.thisVar == nullptr) {
1113 TELEPHONY_LOGE("closeUnfinishedUssdCallback is null!");
1114 return CALL_ERR_CALLBACK_NOT_EXIST;
1115 }
1116 uv_loop_s *loop = nullptr;
1117 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1118 napi_get_uv_event_loop(closeUnfinishedUssdCallback_.env, &loop);
1119 #endif
1120 if (loop == nullptr) {
1121 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1122 }
1123 CallSupplementWorker *callSupplementDataWorker = std::make_unique<CallSupplementWorker>().release();
1124 if (callSupplementDataWorker == nullptr) {
1125 TELEPHONY_LOGE("callSupplementDataWorker is nullptr!");
1126 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1127 }
1128 callSupplementDataWorker->info = resultInfo;
1129 callSupplementDataWorker->callback = closeUnfinishedUssdCallback_;
1130 uv_work_t *work = std::make_unique<uv_work_t>().release();
1131 if (work == nullptr) {
1132 delete callSupplementDataWorker;
1133 callSupplementDataWorker = nullptr;
1134 TELEPHONY_LOGE("work is nullptr!");
1135 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1136 }
1137 work->data = (void *)callSupplementDataWorker;
1138 int32_t errorCode = uv_queue_work_with_qos(
1139 loop, work, [](uv_work_t *work) {
1140 TELEPHONY_LOGD("ReportCloseUnFinishedUssdInfo uv_queue_work_with_qos");
1141 }, ReportExecutionResultWork, uv_qos_default);
1142 if (errorCode != 0) {
1143 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errorCode: %{public}d", errorCode);
1144 delete callSupplementDataWorker;
1145 callSupplementDataWorker = nullptr;
1146 delete work;
1147 work = nullptr;
1148 return TELEPHONY_ERROR;
1149 }
1150 if (closeUnfinishedUssdCallback_.thisVar) {
1151 (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1152 }
1153 return TELEPHONY_SUCCESS;
1154 }
1155
ReportSetWaitingInfo(AppExecFwk::PacMap & resultInfo)1156 int32_t NapiCallAbilityCallback::ReportSetWaitingInfo(AppExecFwk::PacMap &resultInfo)
1157 {
1158 if (setWaitingCallback_.thisVar == nullptr) {
1159 TELEPHONY_LOGE("setWaitingCallback is null!");
1160 return CALL_ERR_CALLBACK_NOT_EXIST;
1161 }
1162 uv_loop_s *loop = nullptr;
1163 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1164 napi_get_uv_event_loop(setWaitingCallback_.env, &loop);
1165 #endif
1166 if (loop == nullptr) {
1167 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1168 }
1169 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1170 if (callSupplementWorker == nullptr) {
1171 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1172 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1173 }
1174 callSupplementWorker->info = resultInfo;
1175 callSupplementWorker->callback = setWaitingCallback_;
1176 uv_work_t *work = std::make_unique<uv_work_t>().release();
1177 if (work == nullptr) {
1178 delete callSupplementWorker;
1179 callSupplementWorker = nullptr;
1180 TELEPHONY_LOGE("work is nullptr!");
1181 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1182 }
1183 work->data = (void *)callSupplementWorker;
1184 int32_t resultCode = uv_queue_work_with_qos(
1185 loop, work, [](uv_work_t *work) {
1186 TELEPHONY_LOGD("ReportSetWaitingInfo uv_queue_work_with_qos");
1187 }, ReportExecutionResultWork, uv_qos_default);
1188 if (resultCode != 0) {
1189 delete callSupplementWorker;
1190 callSupplementWorker = nullptr;
1191 delete work;
1192 work = nullptr;
1193 TELEPHONY_LOGE("failed to add uv_queue_work_with_qos, resultCode: %{public}d", resultCode);
1194 return TELEPHONY_ERROR;
1195 }
1196 if (setWaitingCallback_.thisVar) {
1197 (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1198 }
1199 return TELEPHONY_SUCCESS;
1200 }
1201
ReportGetRestrictionInfo(AppExecFwk::PacMap & resultInfo)1202 int32_t NapiCallAbilityCallback::ReportGetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
1203 {
1204 if (getRestrictionCallback_.thisVar == nullptr) {
1205 TELEPHONY_LOGE("getRestrictionCallback is null!");
1206 return CALL_ERR_CALLBACK_NOT_EXIST;
1207 }
1208 uv_loop_s *loop = nullptr;
1209 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1210 napi_get_uv_event_loop(getRestrictionCallback_.env, &loop);
1211 #endif
1212 if (loop == nullptr) {
1213 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1214 }
1215 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1216 if (callSupplementWorker == nullptr) {
1217 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1218 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1219 }
1220 callSupplementWorker->info = resultInfo;
1221 callSupplementWorker->callback = getRestrictionCallback_;
1222 uv_work_t *work = std::make_unique<uv_work_t>().release();
1223 if (work == nullptr) {
1224 delete callSupplementWorker;
1225 callSupplementWorker = nullptr;
1226 TELEPHONY_LOGE("work is nullptr!");
1227 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1228 }
1229 work->data = (void *)callSupplementWorker;
1230 int32_t resultCode = uv_queue_work_with_qos(
1231 loop, work, [](uv_work_t *work) {
1232 TELEPHONY_LOGD("ReportGetRestrictionInfo uv_queue_work_with_qos");
1233 }, ReportWaitAndLimitInfoWork, uv_qos_default);
1234 if (resultCode != 0) {
1235 delete callSupplementWorker;
1236 callSupplementWorker = nullptr;
1237 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, resultCode: %{public}d", resultCode);
1238 delete work;
1239 work = nullptr;
1240 return TELEPHONY_ERROR;
1241 }
1242 if (getRestrictionCallback_.thisVar) {
1243 (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1244 }
1245 return TELEPHONY_SUCCESS;
1246 }
1247
ReportSetRestrictionInfo(AppExecFwk::PacMap & resultInfo)1248 int32_t NapiCallAbilityCallback::ReportSetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
1249 {
1250 if (setRestrictionCallback_.thisVar == nullptr) {
1251 TELEPHONY_LOGE("setRestrictionCallback is null!");
1252 return CALL_ERR_CALLBACK_NOT_EXIST;
1253 }
1254 uv_loop_s *loop = nullptr;
1255 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1256 napi_get_uv_event_loop(setRestrictionCallback_.env, &loop);
1257 #endif
1258 if (loop == nullptr) {
1259 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1260 }
1261 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1262 if (callSupplementWorker == nullptr) {
1263 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1264 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1265 }
1266 callSupplementWorker->info = resultInfo;
1267 callSupplementWorker->callback = setRestrictionCallback_;
1268 uv_work_t *work = std::make_unique<uv_work_t>().release();
1269 if (work == nullptr) {
1270 delete callSupplementWorker;
1271 callSupplementWorker = nullptr;
1272 TELEPHONY_LOGE("work is nullptr!");
1273 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1274 }
1275 work->data = (void *)callSupplementWorker;
1276 int32_t resultCode = uv_queue_work_with_qos(
1277 loop, work, [](uv_work_t *work) {
1278 TELEPHONY_LOGD("ReportSetRestrictionInfo uv_queue_work_with_qos");
1279 }, ReportExecutionResultWork, uv_qos_default);
1280 if (resultCode != 0) {
1281 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, resultCode: %{public}d", resultCode);
1282 delete callSupplementWorker;
1283 callSupplementWorker = nullptr;
1284 delete work;
1285 work = nullptr;
1286 return TELEPHONY_ERROR;
1287 }
1288 if (setRestrictionCallback_.thisVar) {
1289 (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1290 }
1291 return TELEPHONY_SUCCESS;
1292 }
1293
ReportSetRestrictionPassword(AppExecFwk::PacMap & resultInfo)1294 int32_t NapiCallAbilityCallback::ReportSetRestrictionPassword(AppExecFwk::PacMap &resultInfo)
1295 {
1296 if (setRestrictionPasswordCallback_.thisVar == nullptr) {
1297 TELEPHONY_LOGE("setRestrictionPasswordCallback is null!");
1298 return CALL_ERR_CALLBACK_NOT_EXIST;
1299 }
1300 uv_loop_s *loop = nullptr;
1301 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1302 napi_get_uv_event_loop(setRestrictionPasswordCallback_.env, &loop);
1303 #endif
1304 if (loop == nullptr) {
1305 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1306 }
1307 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1308 if (callSupplementWorker == nullptr) {
1309 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1310 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1311 }
1312 callSupplementWorker->info = resultInfo;
1313 callSupplementWorker->callback = setRestrictionPasswordCallback_;
1314 uv_work_t *work = std::make_unique<uv_work_t>().release();
1315 if (work == nullptr) {
1316 delete callSupplementWorker;
1317 callSupplementWorker = nullptr;
1318 TELEPHONY_LOGE("work is nullptr!");
1319 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1320 }
1321 work->data = (void *)callSupplementWorker;
1322 int32_t errCode = uv_queue_work_with_qos(
1323 loop, work, [](uv_work_t *work) {
1324 TELEPHONY_LOGD("ReportSetRestrictionPassword uv_queue_work_with_qos");
1325 }, ReportExecutionResultWork, uv_qos_default);
1326 if (errCode != 0) {
1327 delete callSupplementWorker;
1328 callSupplementWorker = nullptr;
1329 delete work;
1330 work = nullptr;
1331 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1332 return TELEPHONY_ERROR;
1333 }
1334 if (setRestrictionPasswordCallback_.thisVar) {
1335 (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1336 }
1337 return TELEPHONY_SUCCESS;
1338 }
1339
ReportGetTransferInfo(AppExecFwk::PacMap & resultInfo)1340 int32_t NapiCallAbilityCallback::ReportGetTransferInfo(AppExecFwk::PacMap &resultInfo)
1341 {
1342 if (getTransferCallback_.thisVar == nullptr) {
1343 TELEPHONY_LOGE("getTransferCallback is null!");
1344 return CALL_ERR_CALLBACK_NOT_EXIST;
1345 }
1346 if (getCallTransferReason_ != resultInfo.GetIntValue("reason")) {
1347 TELEPHONY_LOGE("Transfer reason is different, require is %{public}d, now is %{public}d", getCallTransferReason_,
1348 resultInfo.GetIntValue("reason"));
1349 return CALL_ERR_CALLBACK_NOT_EXIST;
1350 }
1351 uv_loop_s *loop = nullptr;
1352 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1353 napi_get_uv_event_loop(getTransferCallback_.env, &loop);
1354 #endif
1355 if (loop == nullptr) {
1356 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1357 }
1358 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1359 if (callSupplementWorker == nullptr) {
1360 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1361 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1362 }
1363 callSupplementWorker->info = resultInfo;
1364 callSupplementWorker->callback = getTransferCallback_;
1365 uv_work_t *work = std::make_unique<uv_work_t>().release();
1366 if (work == nullptr) {
1367 delete callSupplementWorker;
1368 callSupplementWorker = nullptr;
1369 TELEPHONY_LOGE("work is nullptr!");
1370 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1371 }
1372 work->data = (void *)callSupplementWorker;
1373 int32_t errCode = uv_queue_work_with_qos(
1374 loop, work, [](uv_work_t *work) {
1375 TELEPHONY_LOGD("ReportGetTransferInfo uv_queue_work_with_qos");
1376 }, ReportSupplementInfoWork, uv_qos_default);
1377 if (errCode != 0) {
1378 TELEPHONY_LOGE("failed add to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1379 delete callSupplementWorker;
1380 callSupplementWorker = nullptr;
1381 delete work;
1382 work = nullptr;
1383 return TELEPHONY_ERROR;
1384 }
1385 if (getTransferCallback_.thisVar) {
1386 (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1387 }
1388 return TELEPHONY_SUCCESS;
1389 }
1390
ReportSetTransferInfo(AppExecFwk::PacMap & resultInfo)1391 int32_t NapiCallAbilityCallback::ReportSetTransferInfo(AppExecFwk::PacMap &resultInfo)
1392 {
1393 if (setTransferCallback_.thisVar == nullptr) {
1394 TELEPHONY_LOGE("setTransferCallback is null!");
1395 return CALL_ERR_CALLBACK_NOT_EXIST;
1396 }
1397 uv_loop_s *loop = nullptr;
1398 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1399 napi_get_uv_event_loop(setTransferCallback_.env, &loop);
1400 #endif
1401 if (loop == nullptr) {
1402 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1403 }
1404 CallSupplementWorker *callSupplementWorker = std::make_unique<CallSupplementWorker>().release();
1405 if (callSupplementWorker == nullptr) {
1406 TELEPHONY_LOGE("callSupplementWorker is nullptr!");
1407 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1408 }
1409 callSupplementWorker->info = resultInfo;
1410 callSupplementWorker->callback = setTransferCallback_;
1411 uv_work_t *work = std::make_unique<uv_work_t>().release();
1412 if (work == nullptr) {
1413 delete callSupplementWorker;
1414 callSupplementWorker = nullptr;
1415 TELEPHONY_LOGE("work is nullptr!");
1416 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1417 }
1418 work->data = (void *)callSupplementWorker;
1419 int32_t errCode = uv_queue_work_with_qos(
1420 loop, work, [](uv_work_t *work) {
1421 TELEPHONY_LOGD("ReportSetTransferInfo uv_queue_work_with_qos");
1422 }, ReportExecutionResultWork, uv_qos_default);
1423 if (errCode != 0) {
1424 delete callSupplementWorker;
1425 callSupplementWorker = nullptr;
1426 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1427 delete work;
1428 work = nullptr;
1429 return TELEPHONY_ERROR;
1430 }
1431 if (setTransferCallback_.thisVar) {
1432 (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
1433 }
1434 return TELEPHONY_SUCCESS;
1435 }
1436
ReportWaitAndLimitInfoWork(uv_work_t * work,int32_t status)1437 void NapiCallAbilityCallback::ReportWaitAndLimitInfoWork(uv_work_t *work, int32_t status)
1438 {
1439 CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1440 if (dataWorkerData == nullptr) {
1441 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1442 return;
1443 }
1444 ReportWaitAndLimitInfo(dataWorkerData->info, dataWorkerData->callback);
1445 delete dataWorkerData;
1446 dataWorkerData = nullptr;
1447 delete work;
1448 work = nullptr;
1449 }
1450
ReportWaitAndLimitInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1451 void NapiCallAbilityCallback::ReportWaitAndLimitInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1452 {
1453 napi_env env = supplementInfo.env;
1454 int32_t result = resultInfo.GetIntValue("result");
1455 int32_t status = resultInfo.GetIntValue("status");
1456 napi_handle_scope limitScope = nullptr;
1457 napi_open_handle_scope(env, &limitScope);
1458 if (limitScope == nullptr) {
1459 TELEPHONY_LOGE("limitScope is nullptr");
1460 napi_close_handle_scope(env, limitScope);
1461 return;
1462 }
1463 if (supplementInfo.callbackRef != nullptr) {
1464 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1465 if (result == TELEPHONY_SUCCESS) {
1466 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1467 napi_create_int32(env, status, &callbackValues[ARRAY_INDEX_SECOND]);
1468 } else {
1469 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1470 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1471 callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1472 }
1473 napi_value callbackFunc = nullptr;
1474 napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1475 napi_value thisVar = nullptr;
1476 napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1477 napi_value callbackResult = nullptr;
1478 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1479 napi_delete_reference(env, supplementInfo.callbackRef);
1480 napi_delete_reference(env, supplementInfo.thisVar);
1481 } else if (supplementInfo.deferred != nullptr) {
1482 if (result == TELEPHONY_SUCCESS) {
1483 napi_value promiseValue = nullptr;
1484 napi_create_int32(env, status, &promiseValue);
1485 napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1486 } else {
1487 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1488 napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1489 }
1490 }
1491 napi_close_handle_scope(env, limitScope);
1492 }
1493
ReportSupplementInfoWork(uv_work_t * work,int32_t status)1494 void NapiCallAbilityCallback::ReportSupplementInfoWork(uv_work_t *work, int32_t status)
1495 {
1496 CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1497 if (dataWorkerData == nullptr) {
1498 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1499 return;
1500 }
1501 ReportSupplementInfo(dataWorkerData->info, dataWorkerData->callback);
1502 delete dataWorkerData;
1503 dataWorkerData = nullptr;
1504 delete work;
1505 work = nullptr;
1506 }
1507
ReportSupplementInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1508 void NapiCallAbilityCallback::ReportSupplementInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1509 {
1510 napi_env env = supplementInfo.env;
1511 napi_handle_scope supplementScope = nullptr;
1512 napi_open_handle_scope(env, &supplementScope);
1513 if (supplementScope == nullptr) {
1514 TELEPHONY_LOGE("supplementScope is nullptr");
1515 napi_close_handle_scope(env, supplementScope);
1516 return;
1517 }
1518 napi_value callbackValue = nullptr;
1519 napi_create_object(env, &callbackValue);
1520 NapiCallManagerUtils::SetPropertyInt32(env, callbackValue, "status", resultInfo.GetIntValue("status"));
1521 NapiCallManagerUtils::SetPropertyStringUtf8(env, callbackValue, "number", resultInfo.GetStringValue("number"));
1522 int32_t result = resultInfo.GetIntValue("result");
1523 if (supplementInfo.callbackRef != nullptr) {
1524 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1525 if (result == TELEPHONY_SUCCESS) {
1526 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1527 callbackValues[ARRAY_INDEX_SECOND] = callbackValue;
1528 } else {
1529 JsError error = NapiUtil::ConverErrorMessageForJs(result);
1530 callbackValues[ARRAY_INDEX_FIRST] =
1531 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
1532 callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1533 }
1534 napi_value callbackFunc = nullptr;
1535 napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1536 napi_value thisVar = nullptr;
1537 napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1538 napi_value callbackResult = nullptr;
1539 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1540 napi_delete_reference(env, supplementInfo.callbackRef);
1541 napi_delete_reference(env, supplementInfo.thisVar);
1542 } else if (supplementInfo.deferred != nullptr) {
1543 if (result == TELEPHONY_SUCCESS) {
1544 napi_resolve_deferred(env, supplementInfo.deferred, callbackValue);
1545 } else {
1546 JsError error = NapiUtil::ConverErrorMessageForJs(result);
1547 napi_reject_deferred(env, supplementInfo.deferred,
1548 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
1549 }
1550 }
1551 napi_close_handle_scope(env, supplementScope);
1552 }
1553
ReportExecutionResultWork(uv_work_t * work,int32_t status)1554 void NapiCallAbilityCallback::ReportExecutionResultWork(uv_work_t *work, int32_t status)
1555 {
1556 CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1557 if (dataWorkerData == nullptr) {
1558 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1559 return;
1560 }
1561 ReportExecutionResult(dataWorkerData->callback, dataWorkerData->info);
1562 delete dataWorkerData;
1563 dataWorkerData = nullptr;
1564 delete work;
1565 work = nullptr;
1566 }
1567
ReportExecutionResult(EventCallback & settingInfo,AppExecFwk::PacMap & resultInfo)1568 void NapiCallAbilityCallback::ReportExecutionResult(EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo)
1569 {
1570 napi_env env = settingInfo.env;
1571 napi_handle_scope executionScope = nullptr;
1572 napi_open_handle_scope(env, &executionScope);
1573 if (executionScope == nullptr) {
1574 TELEPHONY_LOGE("executionScope is nullptr");
1575 napi_close_handle_scope(env, executionScope);
1576 return;
1577 }
1578 napi_value callbackValue = nullptr;
1579 napi_create_object(env, &callbackValue);
1580 int32_t result = resultInfo.GetIntValue("result");
1581 if (settingInfo.callbackRef != nullptr) {
1582 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1583 if (result == TELEPHONY_SUCCESS) {
1584 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1585 napi_get_null(env, &callbackValues[ARRAY_INDEX_SECOND]);
1586 } else {
1587 JsError error = NapiUtil::ConverErrorMessageForJs(result);
1588 callbackValues[ARRAY_INDEX_FIRST] =
1589 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
1590 callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1591 }
1592 napi_value callbackFunc = nullptr;
1593 napi_get_reference_value(env, settingInfo.callbackRef, &callbackFunc);
1594 napi_value thisVar = nullptr;
1595 napi_get_reference_value(env, settingInfo.thisVar, &thisVar);
1596 napi_value callbackResult = nullptr;
1597 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1598 napi_delete_reference(env, settingInfo.callbackRef);
1599 napi_delete_reference(env, settingInfo.thisVar);
1600 } else if (settingInfo.deferred != nullptr) {
1601 if (result == TELEPHONY_SUCCESS) {
1602 napi_value promiseValue = nullptr;
1603 napi_get_null(env, &promiseValue);
1604 napi_resolve_deferred(env, settingInfo.deferred, promiseValue);
1605 } else {
1606 JsError error = NapiUtil::ConverErrorMessageForJs(result);
1607 napi_reject_deferred(env, settingInfo.deferred,
1608 NapiCallManagerUtils::CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode));
1609 }
1610 }
1611 napi_close_handle_scope(env, executionScope);
1612 }
1613
ReportStartRttInfoWork(uv_work_t * work,int32_t status)1614 void NapiCallAbilityCallback::ReportStartRttInfoWork(uv_work_t *work, int32_t status)
1615 {
1616 CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1617 if (dataWorkerData == nullptr) {
1618 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1619 return;
1620 }
1621 ReportStartRttInfo(dataWorkerData->info, dataWorkerData->callback);
1622 delete dataWorkerData;
1623 dataWorkerData = nullptr;
1624 delete work;
1625 work = nullptr;
1626 }
1627
ReportStartRttInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1628 void NapiCallAbilityCallback::ReportStartRttInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1629 {
1630 napi_env env = supplementInfo.env;
1631 int32_t result = resultInfo.GetIntValue("result");
1632 napi_handle_scope startRttScope = nullptr;
1633 napi_open_handle_scope(env, &startRttScope);
1634 if (startRttScope == nullptr) {
1635 TELEPHONY_LOGE("startRttScope is nullptr");
1636 napi_close_handle_scope(env, startRttScope);
1637 return;
1638 }
1639 if (supplementInfo.callbackRef != nullptr) {
1640 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1641 if (result == TELEPHONY_SUCCESS) {
1642 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1643 } else {
1644 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1645 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1646 callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1647 }
1648 napi_value callbackFunc = nullptr;
1649 napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1650 napi_value thisVar = nullptr;
1651 napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1652 napi_value callbackResult = nullptr;
1653 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1654 napi_delete_reference(env, supplementInfo.callbackRef);
1655 napi_delete_reference(env, supplementInfo.thisVar);
1656 } else if (supplementInfo.deferred != nullptr) {
1657 if (result == TELEPHONY_SUCCESS) {
1658 napi_value promiseValue = nullptr;
1659 napi_get_null(env, &promiseValue);
1660 napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1661 } else {
1662 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1663 napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1664 }
1665 }
1666 napi_close_handle_scope(env, startRttScope);
1667 }
1668
ReportStopRttInfoWork(uv_work_t * work,int32_t status)1669 void NapiCallAbilityCallback::ReportStopRttInfoWork(uv_work_t *work, int32_t status)
1670 {
1671 CallSupplementWorker *dataWorkerData = (CallSupplementWorker *)work->data;
1672 if (dataWorkerData == nullptr) {
1673 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1674 return;
1675 }
1676 ReportStopRttInfo(dataWorkerData->info, dataWorkerData->callback);
1677 delete dataWorkerData;
1678 dataWorkerData = nullptr;
1679 delete work;
1680 work = nullptr;
1681 }
1682
ReportStopRttInfo(AppExecFwk::PacMap & resultInfo,EventCallback supplementInfo)1683 void NapiCallAbilityCallback::ReportStopRttInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
1684 {
1685 napi_env env = supplementInfo.env;
1686 int32_t result = resultInfo.GetIntValue("result");
1687 napi_handle_scope stopRttScope = nullptr;
1688 napi_open_handle_scope(env, &stopRttScope);
1689 if (stopRttScope == nullptr) {
1690 TELEPHONY_LOGE("stopRttScope is nullptr");
1691 napi_close_handle_scope(env, stopRttScope);
1692 return;
1693 }
1694 if (supplementInfo.callbackRef != nullptr) {
1695 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1696 if (result == TELEPHONY_SUCCESS) {
1697 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateUndefined(env);
1698 } else {
1699 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1700 callbackValues[ARRAY_INDEX_FIRST] = NapiCallManagerUtils::CreateErrorMessage(env, errTip);
1701 callbackValues[ARRAY_INDEX_SECOND] = NapiCallManagerUtils::CreateUndefined(env);
1702 }
1703 napi_value callbackFunc = nullptr;
1704 napi_get_reference_value(env, supplementInfo.callbackRef, &callbackFunc);
1705 napi_value thisVar = nullptr;
1706 napi_get_reference_value(env, supplementInfo.thisVar, &thisVar);
1707 napi_value callbackResult = nullptr;
1708 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_TWO, callbackValues, &callbackResult);
1709 napi_delete_reference(env, supplementInfo.callbackRef);
1710 napi_delete_reference(env, supplementInfo.thisVar);
1711 } else if (supplementInfo.deferred != nullptr) {
1712 if (result == TELEPHONY_SUCCESS) {
1713 napi_value promiseValue = nullptr;
1714 napi_get_null(env, &promiseValue);
1715 napi_resolve_deferred(env, supplementInfo.deferred, promiseValue);
1716 } else {
1717 std::string errTip = std::to_string(CALL_ERR_NAPI_INTERFACE_FAILED);
1718 napi_reject_deferred(env, supplementInfo.deferred, NapiCallManagerUtils::CreateErrorMessage(env, errTip));
1719 }
1720 }
1721 napi_close_handle_scope(env, stopRttScope);
1722 }
1723
ReportCallOttWork(uv_work_t * work,int32_t status)1724 void NapiCallAbilityCallback::ReportCallOttWork(uv_work_t *work, int32_t status)
1725 {
1726 CallOttWorker *dataWorkerData = (CallOttWorker *)work->data;
1727 if (dataWorkerData == nullptr) {
1728 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1729 return;
1730 }
1731 ReportCallOtt(dataWorkerData->callback, dataWorkerData->info, dataWorkerData->requestId);
1732 delete dataWorkerData;
1733 dataWorkerData = nullptr;
1734 delete work;
1735 work = nullptr;
1736 }
1737
ReportCallOtt(EventCallback & settingInfo,AppExecFwk::PacMap & resultInfo,OttCallRequestId requestId)1738 int32_t NapiCallAbilityCallback::ReportCallOtt(
1739 EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo, OttCallRequestId requestId)
1740 {
1741 napi_env env = settingInfo.env;
1742 napi_handle_scope callOttscope = nullptr;
1743 napi_open_handle_scope(env, &callOttscope);
1744 if (callOttscope == nullptr) {
1745 TELEPHONY_LOGE("callOttscope is nullptr");
1746 napi_close_handle_scope(env, callOttscope);
1747 return TELEPHONY_ERROR;
1748 }
1749 napi_value callbackFunc = nullptr;
1750 napi_value callbackValues[ARRAY_INDEX_THIRD] = { 0 };
1751 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
1752 NapiCallManagerUtils::SetPropertyInt32(
1753 env, callbackValues[ARRAY_INDEX_FIRST], "requestId", static_cast<int32_t>(requestId));
1754 NapiCallManagerUtils::SetPropertyStringUtf8(
1755 env, callbackValues[ARRAY_INDEX_FIRST], "phoneNumber", resultInfo.GetStringValue("phoneNumber").c_str());
1756 NapiCallManagerUtils::SetPropertyStringUtf8(
1757 env, callbackValues[ARRAY_INDEX_FIRST], "bundleName", resultInfo.GetStringValue("bundleName").c_str());
1758 NapiCallManagerUtils::SetPropertyInt32(
1759 env, callbackValues[ARRAY_INDEX_FIRST], "videoState", resultInfo.GetIntValue("videoState"));
1760 switch (requestId) {
1761 case OttCallRequestId::OTT_REQUEST_INVITE_TO_CONFERENCE:
1762 NapiCallManagerUtils::SetPropertyStringUtf8(
1763 env, callbackValues[ARRAY_INDEX_FIRST], "number", resultInfo.GetStringValue("number").c_str());
1764 break;
1765 case OttCallRequestId::OTT_REQUEST_UPDATE_CALL_MEDIA_MODE:
1766 NapiCallManagerUtils::SetPropertyInt32(
1767 env, callbackValues[ARRAY_INDEX_FIRST], "callMediaMode", resultInfo.GetIntValue("callMediaMode"));
1768 break;
1769 default:
1770 break;
1771 }
1772
1773 napi_get_reference_value(env, settingInfo.callbackRef, &callbackFunc);
1774 if (callbackFunc == nullptr) {
1775 TELEPHONY_LOGE("callbackFunc is null!");
1776 napi_close_handle_scope(env, callOttscope);
1777 return CALL_ERR_CALLBACK_NOT_EXIST;
1778 }
1779 napi_value thisVar = nullptr;
1780 napi_get_reference_value(env, settingInfo.thisVar, &thisVar);
1781 napi_value callbackResult = nullptr;
1782 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1783 napi_close_handle_scope(env, callOttscope);
1784 return TELEPHONY_SUCCESS;
1785 }
1786
UpdatePostDialDelay(const std::string str)1787 int32_t NapiCallAbilityCallback::UpdatePostDialDelay(const std::string str)
1788 {
1789 if (postDialDelayCallback_.thisVar == nullptr) {
1790 TELEPHONY_LOGE("thisVar is nullptr!");
1791 return CALL_ERR_CALLBACK_NOT_EXIST;
1792 }
1793 uv_loop_s *loop = nullptr;
1794 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1795 napi_get_uv_event_loop(postDialDelayCallback_.env, &loop);
1796 #endif
1797 if (loop == nullptr) {
1798 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1799 }
1800 PostDialDelayWorker *postDialDelayWorker = std::make_unique<PostDialDelayWorker>().release();
1801 if (postDialDelayWorker == nullptr) {
1802 TELEPHONY_LOGE("postDialDelayWorker is nullptr!");
1803 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1804 }
1805 postDialDelayWorker->postDialStr = str;
1806 postDialDelayWorker->callback = postDialDelayCallback_;
1807 uv_work_t *work = std::make_unique<uv_work_t>().release();
1808 if (work == nullptr) {
1809 delete postDialDelayWorker;
1810 postDialDelayWorker = nullptr;
1811 TELEPHONY_LOGE("work is nullptr");
1812 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1813 }
1814 work->data = (void *)postDialDelayWorker;
1815 int32_t errCode = uv_queue_work_with_qos(
1816 loop, work, [](uv_work_t *work) {
1817 TELEPHONY_LOGD("UpdatePostDialDelay uv_queue_work_with_qos");
1818 }, ReportPostDialDelayWork, uv_qos_default);
1819 if (errCode != 0) {
1820 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1821 delete postDialDelayWorker;
1822 postDialDelayWorker = nullptr;
1823 delete work;
1824 work = nullptr;
1825 return TELEPHONY_ERROR;
1826 }
1827 return TELEPHONY_SUCCESS;
1828 }
1829
ReportPostDialDelayWork(uv_work_t * work,int32_t status)1830 void NapiCallAbilityCallback::ReportPostDialDelayWork(uv_work_t *work, int32_t status)
1831 {
1832 PostDialDelayWorker *dataWorkerData = (PostDialDelayWorker *)work->data;
1833 if (dataWorkerData == nullptr) {
1834 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1835 return;
1836 }
1837 int32_t ret = ReportPostDialDelay(dataWorkerData->postDialStr, dataWorkerData->callback);
1838 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
1839 delete dataWorkerData;
1840 dataWorkerData = nullptr;
1841 delete work;
1842 work = nullptr;
1843 }
1844
ReportPostDialDelay(std::string postDialStr,EventCallback eventCallback)1845 int32_t NapiCallAbilityCallback::ReportPostDialDelay(std::string postDialStr, EventCallback eventCallback)
1846 {
1847 napi_env env = eventCallback.env;
1848 napi_handle_scope scope = nullptr;
1849 napi_open_handle_scope(env, &scope);
1850 if (scope == nullptr) {
1851 TELEPHONY_LOGE("scope is nullptr");
1852 napi_close_handle_scope(env, scope);
1853 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1854 }
1855 napi_value callbackFunc = nullptr;
1856 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
1857 napi_create_string_utf8(env, postDialStr.c_str(), postDialStr.length(), &callbackValues[ARRAY_INDEX_FIRST]);
1858 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
1859 if (callbackFunc == nullptr) {
1860 TELEPHONY_LOGE("callbackFunc is null!");
1861 napi_close_handle_scope(env, scope);
1862 return CALL_ERR_CALLBACK_NOT_EXIST;
1863 }
1864 napi_value thisVar = nullptr;
1865 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
1866 napi_value callbackResult = nullptr;
1867 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1868 napi_close_handle_scope(env, scope);
1869 return TELEPHONY_SUCCESS;
1870 }
1871
UpdateImsCallModeChange(const CallMediaModeInfo & imsCallModeInfo)1872 int32_t NapiCallAbilityCallback::UpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo)
1873 {
1874 if (imsCallModeCallback_.thisVar == nullptr) {
1875 TELEPHONY_LOGE("thisVar is nullptr!");
1876 return CALL_ERR_CALLBACK_NOT_EXIST;
1877 }
1878 uv_loop_s *loop = nullptr;
1879 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1880 napi_get_uv_event_loop(imsCallModeCallback_.env, &loop);
1881 #endif
1882 if (loop == nullptr) {
1883 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1884 }
1885 ImsCallModeInfoWorker *imsCallModeInfoWorker = std::make_unique<ImsCallModeInfoWorker>().release();
1886 if (imsCallModeInfoWorker == nullptr) {
1887 TELEPHONY_LOGE("imsCallModeInfoWorker is nullptr!");
1888 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1889 }
1890 imsCallModeInfoWorker->callModeInfo = imsCallModeInfo;
1891 imsCallModeInfoWorker->callback = imsCallModeCallback_;
1892 uv_work_t *work = std::make_unique<uv_work_t>().release();
1893 if (work == nullptr) {
1894 delete imsCallModeInfoWorker;
1895 imsCallModeInfoWorker = nullptr;
1896 TELEPHONY_LOGE("work is nullptr");
1897 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1898 }
1899 work->data = (void *)imsCallModeInfoWorker;
1900 int32_t errCode = uv_queue_work_with_qos(
1901 loop, work, [](uv_work_t *work) {
1902 TELEPHONY_LOGD("UpdateImsCallModeChange uv_queue_work_with_qos");
1903 }, ReportCallMediaModeInfoWork, uv_qos_default);
1904 if (errCode != 0) {
1905 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
1906 delete imsCallModeInfoWorker;
1907 imsCallModeInfoWorker = nullptr;
1908 delete work;
1909 work = nullptr;
1910 return TELEPHONY_ERROR;
1911 }
1912 return TELEPHONY_SUCCESS;
1913 }
1914
ReportCallMediaModeInfoWork(uv_work_t * work,int32_t status)1915 void NapiCallAbilityCallback::ReportCallMediaModeInfoWork(uv_work_t *work, int32_t status)
1916 {
1917 ImsCallModeInfoWorker *dataWorkerData = (ImsCallModeInfoWorker *)work->data;
1918 if (dataWorkerData == nullptr) {
1919 TELEPHONY_LOGE("dataWorkerData is nullptr!");
1920 return;
1921 }
1922 int32_t ret = ReportCallMediaModeInfo(dataWorkerData->callModeInfo, dataWorkerData->callback);
1923 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
1924 delete dataWorkerData;
1925 dataWorkerData = nullptr;
1926 delete work;
1927 work = nullptr;
1928 }
1929
ReportCallMediaModeInfo(CallMediaModeInfo & imsCallModeInfo,EventCallback eventCallback)1930 int32_t NapiCallAbilityCallback::ReportCallMediaModeInfo(
1931 CallMediaModeInfo &imsCallModeInfo, EventCallback eventCallback)
1932 {
1933 napi_env env = eventCallback.env;
1934 napi_handle_scope CallMediaModeInfoScope = nullptr;
1935 napi_open_handle_scope(env, &CallMediaModeInfoScope);
1936 if (CallMediaModeInfoScope == nullptr) {
1937 TELEPHONY_LOGE("CallMediaModeInfoScope is nullptr");
1938 napi_close_handle_scope(env, CallMediaModeInfoScope);
1939 return TELEPHONY_ERROR;
1940 }
1941 napi_value callbackFunc = nullptr;
1942 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
1943
1944 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
1945 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "callId", imsCallModeInfo.callId);
1946 NapiCallManagerUtils::SetPropertyBoolean(
1947 env, callbackValues[ARRAY_INDEX_FIRST], "isRequestInfo", imsCallModeInfo.isRequestInfo);
1948 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "result", imsCallModeInfo.result);
1949 NapiCallManagerUtils::SetPropertyInt32(
1950 env, callbackValues[ARRAY_INDEX_FIRST], "imsCallMode", static_cast<int32_t>(imsCallModeInfo.callMode));
1951
1952 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
1953 if (callbackFunc == nullptr) {
1954 TELEPHONY_LOGE("callbackFunc is null!");
1955 napi_close_handle_scope(env, CallMediaModeInfoScope);
1956 return CALL_ERR_CALLBACK_NOT_EXIST;
1957 }
1958 napi_value thisVar = nullptr;
1959 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
1960 napi_value callbackResult = nullptr;
1961 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
1962 napi_close_handle_scope(env, CallMediaModeInfoScope);
1963 return TELEPHONY_SUCCESS;
1964 }
1965
CallSessionEventChange(const CallSessionEvent & callSessionEvent)1966 int32_t NapiCallAbilityCallback::CallSessionEventChange(const CallSessionEvent &callSessionEvent)
1967 {
1968 if (callSessionEventCallback_.thisVar == nullptr) {
1969 TELEPHONY_LOGE("thisVar is nullptr!");
1970 return CALL_ERR_CALLBACK_NOT_EXIST;
1971 }
1972 uv_loop_s *loop = nullptr;
1973 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
1974 napi_get_uv_event_loop(callSessionEventCallback_.env, &loop);
1975 #endif
1976 if (loop == nullptr) {
1977 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1978 }
1979 CallSessionEventWorker *callSessionEventWorker = std::make_unique<CallSessionEventWorker>().release();
1980 if (callSessionEventWorker == nullptr) {
1981 TELEPHONY_LOGE("callSessionEventWorker is nullptr!");
1982 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1983 }
1984 callSessionEventWorker->sessionEvent = callSessionEvent;
1985 callSessionEventWorker->callback = callSessionEventCallback_;
1986 uv_work_t *work = std::make_unique<uv_work_t>().release();
1987 if (work == nullptr) {
1988 delete callSessionEventWorker;
1989 callSessionEventWorker = nullptr;
1990 TELEPHONY_LOGE("work is nullptr");
1991 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1992 }
1993 work->data = (void *)callSessionEventWorker;
1994 int32_t errCode = uv_queue_work_with_qos(
1995 loop, work, [](uv_work_t *work) {
1996 TELEPHONY_LOGD("CallSessionEventChange uv_queue_work_with_qos");
1997 }, ReportCallSessionEventWork, uv_qos_default);
1998 if (errCode != 0) {
1999 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
2000 delete callSessionEventWorker;
2001 callSessionEventWorker = nullptr;
2002 delete work;
2003 work = nullptr;
2004 return TELEPHONY_ERROR;
2005 }
2006 return TELEPHONY_SUCCESS;
2007 }
2008
ReportCallSessionEventWork(uv_work_t * work,int32_t status)2009 void NapiCallAbilityCallback::ReportCallSessionEventWork(uv_work_t *work, int32_t status)
2010 {
2011 CallSessionEventWorker *dataWorkerData = (CallSessionEventWorker *)work->data;
2012 if (dataWorkerData == nullptr) {
2013 TELEPHONY_LOGE("dataWorkerData is nullptr!");
2014 return;
2015 }
2016 int32_t ret = ReportCallSessionEvent(dataWorkerData->sessionEvent, dataWorkerData->callback);
2017 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
2018 delete dataWorkerData;
2019 dataWorkerData = nullptr;
2020 delete work;
2021 work = nullptr;
2022 }
2023
ReportCallSessionEvent(CallSessionEvent & sessionEvent,EventCallback eventCallback)2024 int32_t NapiCallAbilityCallback::ReportCallSessionEvent(
2025 CallSessionEvent &sessionEvent, EventCallback eventCallback)
2026 {
2027 napi_env env = eventCallback.env;
2028 napi_handle_scope CallSessionEventScope = nullptr;
2029 napi_open_handle_scope(env, &CallSessionEventScope);
2030 if (CallSessionEventScope == nullptr) {
2031 TELEPHONY_LOGE("CallMediaModeInfoScope is nullptr");
2032 napi_close_handle_scope(env, CallSessionEventScope);
2033 return TELEPHONY_ERROR;
2034 }
2035 napi_value callbackFunc = nullptr;
2036 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
2037
2038 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
2039 NapiCallManagerUtils::SetPropertyInt32(env, callbackValues[ARRAY_INDEX_FIRST], "callId", sessionEvent.callId);
2040 NapiCallManagerUtils::SetPropertyInt32(
2041 env, callbackValues[ARRAY_INDEX_FIRST], "eventId", static_cast<int32_t>(sessionEvent.eventId));
2042
2043 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
2044 if (callbackFunc == nullptr) {
2045 TELEPHONY_LOGE("callbackFunc is null!");
2046 napi_close_handle_scope(env, CallSessionEventScope);
2047 return CALL_ERR_CALLBACK_NOT_EXIST;
2048 }
2049 napi_value thisVar = nullptr;
2050 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
2051 napi_value callbackResult = nullptr;
2052 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
2053 napi_close_handle_scope(env, CallSessionEventScope);
2054 return TELEPHONY_SUCCESS;
2055 }
2056
PeerDimensionsChange(const PeerDimensionsDetail & peerDimensionsDetail)2057 int32_t NapiCallAbilityCallback::PeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail)
2058 {
2059 if (peerDimensionsCallback_.thisVar == nullptr) {
2060 TELEPHONY_LOGE("thisVar is nullptr!");
2061 return CALL_ERR_CALLBACK_NOT_EXIST;
2062 }
2063 uv_loop_s *loop = nullptr;
2064 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
2065 napi_get_uv_event_loop(peerDimensionsCallback_.env, &loop);
2066 #endif
2067 if (loop == nullptr) {
2068 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2069 }
2070 PeerDimensionsWorker *peerDimensionsWorker = std::make_unique<PeerDimensionsWorker>().release();
2071 if (peerDimensionsWorker == nullptr) {
2072 TELEPHONY_LOGE("peerDimensionsWorker is nullptr!");
2073 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2074 }
2075 peerDimensionsWorker->peerDimensionsDetail = peerDimensionsDetail;
2076 peerDimensionsWorker->callback = peerDimensionsCallback_;
2077 uv_work_t *work = std::make_unique<uv_work_t>().release();
2078 if (work == nullptr) {
2079 delete peerDimensionsWorker;
2080 peerDimensionsWorker = nullptr;
2081 TELEPHONY_LOGE("work is nullptr");
2082 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2083 }
2084 work->data = (void *)peerDimensionsWorker;
2085 int32_t errCode = uv_queue_work_with_qos(
2086 loop, work, [](uv_work_t *work) {
2087 TELEPHONY_LOGD("PeerDimensionsChange uv_queue_work_with_qos");
2088 }, ReportPeerDimensionsWork, uv_qos_default);
2089 if (errCode != 0) {
2090 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
2091 delete peerDimensionsWorker;
2092 peerDimensionsWorker = nullptr;
2093 delete work;
2094 work = nullptr;
2095 return TELEPHONY_ERROR;
2096 }
2097 return TELEPHONY_SUCCESS;
2098 }
2099
ReportPeerDimensionsWork(uv_work_t * work,int32_t status)2100 void NapiCallAbilityCallback::ReportPeerDimensionsWork(uv_work_t *work, int32_t status)
2101 {
2102 PeerDimensionsWorker *dataWorkerData = (PeerDimensionsWorker *)work->data;
2103 if (dataWorkerData == nullptr) {
2104 TELEPHONY_LOGE("dataWorkerData is nullptr!");
2105 return;
2106 }
2107 int32_t ret = ReportPeerDimensions(dataWorkerData->peerDimensionsDetail, dataWorkerData->callback);
2108 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
2109 delete dataWorkerData;
2110 dataWorkerData = nullptr;
2111 delete work;
2112 work = nullptr;
2113 }
2114
ReportPeerDimensions(PeerDimensionsDetail & peerDimensionsDetail,EventCallback eventCallback)2115 int32_t NapiCallAbilityCallback::ReportPeerDimensions(
2116 PeerDimensionsDetail &peerDimensionsDetail, EventCallback eventCallback)
2117 {
2118 napi_env env = eventCallback.env;
2119 napi_handle_scope PeerDimensionsDetailScope = nullptr;
2120 napi_open_handle_scope(env, &PeerDimensionsDetailScope);
2121 if (PeerDimensionsDetailScope == nullptr) {
2122 TELEPHONY_LOGE("CallMediaModeInfoScope is nullptr");
2123 napi_close_handle_scope(env, PeerDimensionsDetailScope);
2124 return TELEPHONY_ERROR;
2125 }
2126 napi_value callbackFunc = nullptr;
2127 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
2128
2129 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
2130 NapiCallManagerUtils::SetPropertyInt32(
2131 env, callbackValues[ARRAY_INDEX_FIRST], "callId", peerDimensionsDetail.callId);
2132 NapiCallManagerUtils::SetPropertyInt32(
2133 env, callbackValues[ARRAY_INDEX_FIRST], "width", peerDimensionsDetail.width);
2134 NapiCallManagerUtils::SetPropertyInt32(
2135 env, callbackValues[ARRAY_INDEX_FIRST], "height", peerDimensionsDetail.height);
2136
2137 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
2138 if (callbackFunc == nullptr) {
2139 TELEPHONY_LOGE("callbackFunc is null!");
2140 napi_close_handle_scope(env, PeerDimensionsDetailScope);
2141 return CALL_ERR_CALLBACK_NOT_EXIST;
2142 }
2143 napi_value thisVar = nullptr;
2144 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
2145 napi_value callbackResult = nullptr;
2146 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
2147 napi_close_handle_scope(env, PeerDimensionsDetailScope);
2148 return TELEPHONY_SUCCESS;
2149 }
2150
CallDataUsageChange(const int64_t dataUsage)2151 int32_t NapiCallAbilityCallback::CallDataUsageChange(const int64_t dataUsage)
2152 {
2153 if (callDataUsageCallback_.thisVar == nullptr) {
2154 TELEPHONY_LOGE("thisVar is nullptr!");
2155 return CALL_ERR_CALLBACK_NOT_EXIST;
2156 }
2157 uv_loop_s *loop = nullptr;
2158 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
2159 napi_get_uv_event_loop(callDataUsageCallback_.env, &loop);
2160 #endif
2161 if (loop == nullptr) {
2162 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2163 }
2164 CallDataUsageWorker *callDataUsageWorker = std::make_unique<CallDataUsageWorker>().release();
2165 if (callDataUsageWorker == nullptr) {
2166 TELEPHONY_LOGE("callDataUsageWorker is nullptr!");
2167 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2168 }
2169 callDataUsageWorker->callDataUsage = dataUsage;
2170 callDataUsageWorker->callback = callDataUsageCallback_;
2171 uv_work_t *work = std::make_unique<uv_work_t>().release();
2172 if (work == nullptr) {
2173 delete callDataUsageWorker;
2174 callDataUsageWorker = nullptr;
2175 TELEPHONY_LOGE("work is nullptr");
2176 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2177 }
2178 work->data = (void *)callDataUsageWorker;
2179 int32_t errCode = uv_queue_work_with_qos(
2180 loop, work, [](uv_work_t *work) {
2181 TELEPHONY_LOGD("CallDataUsageChange uv_queue_work_with_qos");
2182 }, ReportCallDataUsageWork, uv_qos_default);
2183 if (errCode != 0) {
2184 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
2185 delete callDataUsageWorker;
2186 callDataUsageWorker = nullptr;
2187 delete work;
2188 work = nullptr;
2189 return TELEPHONY_ERROR;
2190 }
2191 return TELEPHONY_SUCCESS;
2192 }
2193
ReportCallDataUsageWork(uv_work_t * work,int32_t status)2194 void NapiCallAbilityCallback::ReportCallDataUsageWork(uv_work_t *work, int32_t status)
2195 {
2196 CallDataUsageWorker *dataWorkerData = (CallDataUsageWorker *)work->data;
2197 if (dataWorkerData == nullptr) {
2198 TELEPHONY_LOGE("dataWorkerData is nullptr!");
2199 return;
2200 }
2201 int32_t ret = ReportCallDataUsage(dataWorkerData->callDataUsage, dataWorkerData->callback);
2202 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
2203 delete dataWorkerData;
2204 dataWorkerData = nullptr;
2205 delete work;
2206 work = nullptr;
2207 }
2208
ReportCallDataUsage(int64_t dataUsage,EventCallback eventCallback)2209 int32_t NapiCallAbilityCallback::ReportCallDataUsage(int64_t dataUsage, EventCallback eventCallback)
2210 {
2211 napi_env env = eventCallback.env;
2212 napi_handle_scope CallDataUsageScope = nullptr;
2213 napi_open_handle_scope(env, &CallDataUsageScope);
2214 if (CallDataUsageScope == nullptr) {
2215 TELEPHONY_LOGE("CallMediaModeInfoScope is nullptr");
2216 napi_close_handle_scope(env, CallDataUsageScope);
2217 return TELEPHONY_ERROR;
2218 }
2219 napi_value callbackFunc = nullptr;
2220 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
2221 napi_create_int64(env, dataUsage, &callbackValues[ARRAY_INDEX_FIRST]);
2222
2223 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
2224 if (callbackFunc == nullptr) {
2225 TELEPHONY_LOGE("callbackFunc is null!");
2226 napi_close_handle_scope(env, CallDataUsageScope);
2227 return CALL_ERR_CALLBACK_NOT_EXIST;
2228 }
2229 napi_value thisVar = nullptr;
2230 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
2231 napi_value callbackResult = nullptr;
2232 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
2233 napi_close_handle_scope(env, CallDataUsageScope);
2234 return TELEPHONY_SUCCESS;
2235 }
2236
UpdateCameraCapabilities(const CameraCapabilities & cameraCapabilities)2237 int32_t NapiCallAbilityCallback::UpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities)
2238 {
2239 if (cameraCapabilitiesCallback_.thisVar == nullptr) {
2240 TELEPHONY_LOGE("thisVar is nullptr!");
2241 return CALL_ERR_CALLBACK_NOT_EXIST;
2242 }
2243 uv_loop_s *loop = nullptr;
2244 #if defined(NAPI_VERSION) && NAPI_VERSION >= 2
2245 napi_get_uv_event_loop(cameraCapabilitiesCallback_.env, &loop);
2246 #endif
2247 if (loop == nullptr) {
2248 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2249 }
2250 CameraCapbilitiesWorker *cameraCapbilitiesWorker = std::make_unique<CameraCapbilitiesWorker>().release();
2251 if (cameraCapbilitiesWorker == nullptr) {
2252 TELEPHONY_LOGE("cameraCapbilitiesWorker is nullptr!");
2253 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2254 }
2255 cameraCapbilitiesWorker->cameraCapabilities = cameraCapabilities;
2256 cameraCapbilitiesWorker->callback = cameraCapabilitiesCallback_;
2257 uv_work_t *work = std::make_unique<uv_work_t>().release();
2258 if (work == nullptr) {
2259 delete cameraCapbilitiesWorker;
2260 cameraCapbilitiesWorker = nullptr;
2261 TELEPHONY_LOGE("work is nullptr");
2262 return TELEPHONY_ERR_LOCAL_PTR_NULL;
2263 }
2264 work->data = (void *)cameraCapbilitiesWorker;
2265 int32_t errCode = uv_queue_work_with_qos(
2266 loop, work, [](uv_work_t *work) {
2267 TELEPHONY_LOGD("UpdateCameraCapabilities uv_queue_work_with_qos");
2268 }, ReportCameraCapabilitiesInfoWork, uv_qos_default);
2269 if (errCode != 0) {
2270 TELEPHONY_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
2271 delete cameraCapbilitiesWorker;
2272 cameraCapbilitiesWorker = nullptr;
2273 delete work;
2274 work = nullptr;
2275 return TELEPHONY_ERROR;
2276 }
2277 return TELEPHONY_SUCCESS;
2278 }
2279
ReportCameraCapabilitiesInfoWork(uv_work_t * work,int32_t status)2280 void NapiCallAbilityCallback::ReportCameraCapabilitiesInfoWork(uv_work_t *work, int32_t status)
2281 {
2282 CameraCapbilitiesWorker *dataWorkerData = (CameraCapbilitiesWorker *)work->data;
2283 if (dataWorkerData == nullptr) {
2284 TELEPHONY_LOGE("dataWorkerData is nullptr!");
2285 return;
2286 }
2287 int32_t ret = ReportCameraCapabilitiesInfo(dataWorkerData->cameraCapabilities, dataWorkerData->callback);
2288 TELEPHONY_LOGI("ReportPostDialDelay result = %{public}d", ret);
2289 delete dataWorkerData;
2290 dataWorkerData = nullptr;
2291 delete work;
2292 work = nullptr;
2293 }
2294
ReportCameraCapabilitiesInfo(CameraCapabilities & cameraCapabilities,EventCallback eventCallback)2295 int32_t NapiCallAbilityCallback::ReportCameraCapabilitiesInfo(
2296 CameraCapabilities &cameraCapabilities, EventCallback eventCallback)
2297 {
2298 napi_env env = eventCallback.env;
2299 napi_handle_scope cameraCapabilitiesScope = nullptr;
2300 napi_open_handle_scope(env, &cameraCapabilitiesScope);
2301 if (cameraCapabilitiesScope == nullptr) {
2302 TELEPHONY_LOGE("CallMediaModeInfoScope is nullptr");
2303 napi_close_handle_scope(env, cameraCapabilitiesScope);
2304 return TELEPHONY_ERROR;
2305 }
2306 napi_value callbackFunc = nullptr;
2307 napi_value callbackValues[ARRAY_INDEX_SECOND] = { 0 };
2308
2309 napi_create_object(env, &callbackValues[ARRAY_INDEX_FIRST]);
2310 NapiCallManagerUtils::SetPropertyInt32(
2311 env, callbackValues[ARRAY_INDEX_FIRST], "callId", cameraCapabilities.callId);
2312 NapiCallManagerUtils::SetPropertyInt32(
2313 env, callbackValues[ARRAY_INDEX_FIRST], "width", cameraCapabilities.width);
2314 NapiCallManagerUtils::SetPropertyInt32(
2315 env, callbackValues[ARRAY_INDEX_FIRST], "height", cameraCapabilities.height);
2316
2317 napi_get_reference_value(env, eventCallback.callbackRef, &callbackFunc);
2318 if (callbackFunc == nullptr) {
2319 TELEPHONY_LOGE("callbackFunc is null!");
2320 napi_close_handle_scope(env, cameraCapabilitiesScope);
2321 return CALL_ERR_CALLBACK_NOT_EXIST;
2322 }
2323 napi_value thisVar = nullptr;
2324 napi_get_reference_value(env, eventCallback.thisVar, &thisVar);
2325 napi_value callbackResult = nullptr;
2326 napi_call_function(env, thisVar, callbackFunc, DATA_LENGTH_ONE, callbackValues, &callbackResult);
2327 napi_close_handle_scope(env, cameraCapabilitiesScope);
2328 return TELEPHONY_SUCCESS;
2329 }
2330 } // namespace Telephony
2331 } // namespace OHOS
2332