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