1 /*
2 * Copyright (C) 2021 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 "video_call_state.h"
17
18 #include "telephony_errors.h"
19 #include "telephony_log_wrapper.h"
20 #include "call_manager_errors.h"
21 #include "ims_call.h"
22
23 namespace OHOS {
24 namespace Telephony {
VideoCallState(sptr<NetCallBase> callPtr)25 VideoCallState::VideoCallState(sptr<NetCallBase> callPtr)
26 : call_(callPtr), updateStatus_(VideoUpdateStatus::STATUS_NONE)
27 {}
28
IsCallSupportVideoCall()29 bool VideoCallState::IsCallSupportVideoCall()
30 {
31 if (call_ == nullptr) {
32 TELEPHONY_LOGE("unexpected null pointer.");
33 return false;
34 }
35 sptr<IMSCall> netCall = static_cast<IMSCall *>(call_.GetRefPtr());
36 return netCall->IsSupportVideoCall();
37 }
38
SetVideoUpdateStatus(VideoUpdateStatus status)39 void VideoCallState::SetVideoUpdateStatus(VideoUpdateStatus status)
40 {
41 updateStatus_ = status;
42 }
43
GetVideoUpdateStatus()44 VideoUpdateStatus VideoCallState::GetVideoUpdateStatus()
45 {
46 return updateStatus_;
47 }
48
SwitchCallVideoState(ImsCallMode mode)49 int32_t VideoCallState::SwitchCallVideoState(ImsCallMode mode)
50 {
51 if (call_ == nullptr) {
52 TELEPHONY_LOGE("unexpected null pointer.");
53 return TELEPHONY_ERR_LOCAL_PTR_NULL;
54 }
55 sptr<IMSCall> netCall = static_cast<IMSCall *>(call_.GetRefPtr());
56 netCall->SwitchVideoState(mode);
57 return TELEPHONY_SUCCESS;
58 }
59
DispatchUpdateVideoRequest(ImsCallMode mode)60 int32_t VideoCallState::DispatchUpdateVideoRequest(ImsCallMode mode)
61 {
62 if (call_ == nullptr) {
63 TELEPHONY_LOGE("unexpected null pointer.");
64 return TELEPHONY_ERR_LOCAL_PTR_NULL;
65 }
66 return call_->DispatchUpdateVideoRequest(mode);
67 }
68
DispatchUpdateVideoResponse(ImsCallMode mode)69 int32_t VideoCallState::DispatchUpdateVideoResponse(ImsCallMode mode)
70 {
71 if (call_ == nullptr) {
72 TELEPHONY_LOGE("unexpected null pointer.");
73 return TELEPHONY_ERR_LOCAL_PTR_NULL;
74 }
75 return call_->DispatchUpdateVideoResponse(mode);
76 }
77
GetCallVideoState(ImsCallMode mode)78 sptr<VideoCallState> VideoCallState::GetCallVideoState(ImsCallMode mode)
79 {
80 if (call_ == nullptr) {
81 TELEPHONY_LOGE("unexpected null pointer.");
82 return nullptr;
83 }
84 sptr<IMSCall> netCall = static_cast<IMSCall *>(call_.GetRefPtr());
85 return netCall->GetCallVideoState(mode);
86 }
87
AudioOnlyState(sptr<NetCallBase> callPtr)88 AudioOnlyState::AudioOnlyState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
89
SendUpdateCallMediaModeRequest(ImsCallMode mode)90 int32_t AudioOnlyState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
91 {
92 TELEPHONY_LOGI("AudioOnlyState send update video request. mode:%{public}d", mode);
93 int ret = TELEPHONY_SUCCESS;
94 VideoUpdateStatus status = GetVideoUpdateStatus();
95 switch (mode) {
96 case ImsCallMode::CALL_MODE_SEND_ONLY:
97 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
98 ret = DispatchUpdateVideoRequest(mode);
99 if (ret != TELEPHONY_SUCCESS) {
100 TELEPHONY_LOGE("error occur when send updateRequest to call");
101 return ret;
102 }
103 break;
104 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
105 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
106 TELEPHONY_LOGE("illegal media type.");
107 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
108 break;
109 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
110 if (!IsCallSupportVideoCall()) {
111 TELEPHONY_LOGE("call not support video, end.");
112 return CALL_ERR_VIDEO_NOT_SUPPORTED;
113 }
114 if (status != VideoUpdateStatus::STATUS_NONE) {
115 TELEPHONY_LOGE("update is in progress. no need");
116 return CALL_ERR_VIDEO_IN_PROGRESS;
117 }
118 ret = DispatchUpdateVideoRequest(mode);
119 if (ret != TELEPHONY_SUCCESS) {
120 TELEPHONY_LOGE("error occur when send updateRequest to call");
121 return ret;
122 }
123 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_SEND_REQUEST);
124 break;
125 default:
126 TELEPHONY_LOGE("unknown call media type.");
127 return CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
128 }
129 return ret;
130 }
131
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)132 int32_t AudioOnlyState::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
133 {
134 TELEPHONY_LOGI("AudioOnlyState receive update video request. mode:%{public}d", mode);
135 int32_t ret = TELEPHONY_SUCCESS;
136 VideoUpdateStatus status = GetVideoUpdateStatus();
137 switch (mode) {
138 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
139 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
140 TELEPHONY_LOGI("invalid media state request.");
141 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
142 break;
143 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
144 case ImsCallMode::CALL_MODE_SEND_ONLY:
145 TELEPHONY_LOGI("receive request.");
146 break;
147 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
148 if (!IsCallSupportVideoCall()) {
149 TELEPHONY_LOGE("not support video, refuse");
150 (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
151 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
152 }
153 if (status != VideoUpdateStatus::STATUS_NONE) {
154 TELEPHONY_LOGE("video update in progress");
155 return CALL_ERR_VIDEO_IN_PROGRESS;
156 }
157 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
158 if (call_) {
159 // notify app to accept or refuse, assume always accept here
160 sptr<IMSCall> netCall = static_cast<IMSCall *>(call_.GetRefPtr());
161 if (netCall == nullptr) {
162 TELEPHONY_LOGE("unexpected null pointer.");
163 return TELEPHONY_ERR_LOCAL_PTR_NULL;
164 }
165 (void)netCall->AcceptVideoCall();
166 } else {
167 TELEPHONY_LOGE("unexpected null pointer.");
168 ret = TELEPHONY_ERR_LOCAL_PTR_NULL;
169 }
170 break;
171 default:
172 TELEPHONY_LOGE("unknown call media type.");
173 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
174 break;
175 }
176 return ret;
177 }
178
SendUpdateCallMediaModeResponse(ImsCallMode mode)179 int32_t AudioOnlyState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
180 {
181 TELEPHONY_LOGI("AudioOnlyState send response ignored, mode %{public}d", mode);
182 return TELEPHONY_SUCCESS;
183 }
184
ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)185 int32_t AudioOnlyState::ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)
186 {
187 TELEPHONY_LOGI("AudioOnlyState receive response, mode %{public}d", mode);
188 int32_t ret = TELEPHONY_SUCCESS;
189 VideoUpdateStatus status = GetVideoUpdateStatus();
190 switch (mode) {
191 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
192 if (status == VideoUpdateStatus::STATUS_SEND_REQUEST) {
193 (void)SwitchCallVideoState(ImsCallMode::CALL_MODE_SEND_RECEIVE);
194 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
195 }
196 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
197 break;
198 default:
199 TELEPHONY_LOGI("other media type, ignored");
200 break;
201 }
202 return ret;
203 }
204
VideoSendState(sptr<NetCallBase> callPtr)205 VideoSendState::VideoSendState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
206
SendUpdateCallMediaModeRequest(ImsCallMode mode)207 int32_t VideoSendState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
208 {
209 TELEPHONY_LOGI("VideoSendState send update video request. mode:%{public}d", mode);
210 int32_t ret = TELEPHONY_SUCCESS;
211 switch (mode) {
212 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
213 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
214 ret = DispatchUpdateVideoRequest(mode);
215 if (ret != TELEPHONY_SUCCESS) {
216 TELEPHONY_LOGE("error occurs when dispatch request");
217 return ret;
218 }
219 ret = SwitchCallVideoState(mode); // switch call video state
220 if (ret != TELEPHONY_SUCCESS) {
221 TELEPHONY_LOGE("error occurs when switch call state");
222 return ret;
223 }
224 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
225 break;
226 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
227 case ImsCallMode::CALL_MODE_SEND_ONLY:
228 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
229 TELEPHONY_LOGE("already in progress.");
230 ret = CALL_ERR_VIDEO_IN_PROGRESS;
231 break;
232 default:
233 TELEPHONY_LOGE("unknown media type.");
234 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
235 break;
236 }
237 return ret;
238 }
239
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)240 int32_t VideoSendState::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
241 {
242 TELEPHONY_LOGI("VideoSendState receive update video request. mode:%{public}d", mode);
243 int32_t ret = TELEPHONY_SUCCESS;
244 VideoUpdateStatus status = GetVideoUpdateStatus();
245 switch (mode) {
246 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
247 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
248 ret = SwitchCallVideoState(mode);
249 if (ret != TELEPHONY_SUCCESS) {
250 TELEPHONY_LOGE("error occurs when switch call state.");
251 return ret;
252 }
253 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
254 break;
255 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
256 TELEPHONY_LOGE("invalid media state request.");
257 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
258 break;
259 case ImsCallMode::CALL_MODE_SEND_ONLY:
260 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
261 if (status != VideoUpdateStatus::STATUS_NONE) {
262 TELEPHONY_LOGE("already in progress.");
263 ret = CALL_ERR_VIDEO_IN_PROGRESS;
264 }
265 break;
266 default:
267 TELEPHONY_LOGE("unknown media type.");
268 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
269 break;
270 }
271 return ret;
272 }
273
SendUpdateCallMediaModeResponse(ImsCallMode mode)274 int32_t VideoSendState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
275 {
276 TELEPHONY_LOGI("VideoSendState send response ignored. mode %{public}d", mode);
277 return TELEPHONY_SUCCESS;
278 }
279
ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)280 int32_t VideoSendState::ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)
281 {
282 TELEPHONY_LOGI("VideoSendState receive update video response. mode:%{public}d", mode);
283 int32_t ret = TELEPHONY_SUCCESS;
284 VideoUpdateStatus status = GetVideoUpdateStatus();
285 switch (mode) {
286 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
287 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
288 ret = SwitchCallVideoState(mode);
289 if (ret != TELEPHONY_SUCCESS) {
290 TELEPHONY_LOGE("error occurs when switch call state");
291 return ret;
292 }
293 // set previous state none
294 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
295 break;
296 case ImsCallMode::CALL_MODE_SEND_ONLY:
297 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
298 if (status != TELEPHONY_SUCCESS) {
299 TELEPHONY_LOGE("already in progress.");
300 ret = CALL_ERR_VIDEO_IN_PROGRESS;
301 }
302 break;
303 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
304 ret = DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
305 if (ret != TELEPHONY_SUCCESS) {
306 return ret;
307 }
308 ret = SwitchCallVideoState(mode);
309 if (ret != TELEPHONY_SUCCESS) {
310 TELEPHONY_LOGE("error occurs when switch call");
311 return ret;
312 }
313 GetCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY)->SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
314 break;
315 default:
316 TELEPHONY_LOGE("unknown media type.");
317 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
318 break;
319 }
320 return ret;
321 }
322
VideoReceiveState(sptr<NetCallBase> callPtr)323 VideoReceiveState::VideoReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
324
SendUpdateCallMediaModeRequest(ImsCallMode mode)325 int32_t VideoReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
326 {
327 TELEPHONY_LOGI("VideoReceiveState send update video response. mode:%{public}d", mode);
328 int32_t ret = TELEPHONY_SUCCESS;
329 VideoUpdateStatus status = GetVideoUpdateStatus();
330 switch (mode) {
331 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
332 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
333 ret = DispatchUpdateVideoRequest(mode);
334 if (ret != TELEPHONY_SUCCESS) {
335 TELEPHONY_LOGE("error occurs when dispatch request");
336 return ret;
337 }
338 ret = SwitchCallVideoState(mode);
339 if (ret) {
340 TELEPHONY_LOGE("error occur when switch call state");
341 return ret;
342 }
343 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
344 break;
345 case ImsCallMode::CALL_MODE_SEND_ONLY:
346 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
347 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
348 if (status != VideoUpdateStatus::STATUS_NONE) {
349 TELEPHONY_LOGE("already in progress.");
350 ret = CALL_ERR_VIDEO_IN_PROGRESS;
351 }
352 break;
353 default:
354 TELEPHONY_LOGE("unknown media type.");
355 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
356 break;
357 }
358 return ret;
359 }
360
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)361 int32_t VideoReceiveState::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
362 {
363 TELEPHONY_LOGI("VideoReceiveState send update video response. mode:%{public}d", mode);
364 int32_t ret = TELEPHONY_SUCCESS;
365 VideoUpdateStatus status = GetVideoUpdateStatus();
366 switch (mode) {
367 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
368 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
369 ret = SwitchCallVideoState(mode);
370 if (ret != TELEPHONY_SUCCESS) {
371 return ret;
372 }
373 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
374 break;
375 case ImsCallMode::CALL_MODE_SEND_ONLY:
376 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
377 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
378 if (status != VideoUpdateStatus::STATUS_NONE) {
379 TELEPHONY_LOGE("already in progress.");
380 ret = CALL_ERR_VIDEO_IN_PROGRESS;
381 }
382 break;
383 default:
384 TELEPHONY_LOGE("unknown media type.");
385 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
386 break;
387 }
388 return ret;
389 }
390
SendUpdateCallMediaModeResponse(ImsCallMode mode)391 int32_t VideoReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
392 {
393 TELEPHONY_LOGI("VideoReceiveState send update video response. mode:%{public}d", mode);
394 int32_t ret = TELEPHONY_SUCCESS;
395 VideoUpdateStatus status = GetVideoUpdateStatus();
396 switch (mode) {
397 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
398 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
399 ret = SwitchCallVideoState(mode);
400 if (ret == TELEPHONY_SUCCESS) {
401 TELEPHONY_LOGE("error occur when switch call state");
402 return ret;
403 }
404 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
405 break;
406 case ImsCallMode::CALL_MODE_SEND_ONLY:
407 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
408 if (status != VideoUpdateStatus::STATUS_NONE) {
409 TELEPHONY_LOGW("already in progress.");
410 ret = CALL_ERR_VIDEO_IN_PROGRESS;
411 }
412 break;
413 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
414 ret = DispatchUpdateVideoResponse(mode);
415 break;
416 default:
417 TELEPHONY_LOGE("unknown media type.");
418 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
419 break;
420 }
421 return ret;
422 }
423
ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)424 int32_t VideoReceiveState::ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)
425 {
426 TELEPHONY_LOGI("VideoReceiveState receive update video response. mode:%{public}d", mode);
427 int32_t ret = TELEPHONY_SUCCESS;
428 switch (mode) {
429 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
430 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
431 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
432 ret = SwitchCallVideoState(mode);
433 if (ret != TELEPHONY_SUCCESS) {
434 TELEPHONY_LOGE("error occur when switch call state");
435 return ret;
436 }
437 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
438 break;
439 case ImsCallMode::CALL_MODE_SEND_ONLY:
440 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
441 TELEPHONY_LOGE("already in progress.");
442 ret = CALL_ERR_VIDEO_IN_PROGRESS;
443 break;
444 default:
445 TELEPHONY_LOGE("unknown media type.");
446 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
447 break;
448 }
449 return ret;
450 }
451
VideoSendReceiveState(sptr<NetCallBase> callPtr)452 VideoSendReceiveState::VideoSendReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
453
SendUpdateCallMediaModeRequest(ImsCallMode mode)454 int32_t VideoSendReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
455 {
456 TELEPHONY_LOGI("VideoSendReceiveState send update video request. mode:%{public}d", mode);
457 int32_t ret = TELEPHONY_SUCCESS;
458 switch (mode) {
459 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
460 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
461 ret = DispatchUpdateVideoRequest(mode);
462 if (ret != TELEPHONY_SUCCESS) {
463 TELEPHONY_LOGE("error occur when send updateRequest to call");
464 return ret;
465 }
466 ret = SwitchCallVideoState(mode);
467 if (ret != TELEPHONY_SUCCESS) {
468 TELEPHONY_LOGE("error occur when switch call state");
469 return ret;
470 }
471 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
472 break;
473 case ImsCallMode::CALL_MODE_SEND_ONLY:
474 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
475 ret = DispatchUpdateVideoRequest(mode);
476 if (ret != TELEPHONY_SUCCESS) {
477 TELEPHONY_LOGE("error occur when send updateRequest to call");
478 return ret;
479 }
480 break;
481 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
482 TELEPHONY_LOGE("illegal media type.");
483 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
484 default:
485 TELEPHONY_LOGE("unknown media type.");
486 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
487 break;
488 }
489 return ret;
490 }
491
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)492 int32_t VideoSendReceiveState::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
493 {
494 TELEPHONY_LOGI("VideoSendReceiveState receive update video response. mode:%{public}d", mode);
495 int32_t ret = TELEPHONY_SUCCESS;
496 switch (mode) {
497 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
498 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
499 ret = SwitchCallVideoState(mode); // support send downgrade & pause video request
500 if (ret != TELEPHONY_SUCCESS) {
501 TELEPHONY_LOGE("error occurs when switch call state");
502 return ret;
503 }
504 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
505 break;
506 case ImsCallMode::CALL_MODE_SEND_ONLY:
507 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
508 TELEPHONY_LOGI("receive update video request");
509 break;
510 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
511 TELEPHONY_LOGE("illegal media type.");
512 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
513 break;
514 default:
515 TELEPHONY_LOGE("unknown media type.");
516 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
517 break;
518 }
519 return ret;
520 }
521
SendUpdateCallMediaModeResponse(ImsCallMode mode)522 int32_t VideoSendReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
523 {
524 TELEPHONY_LOGI("VideoSendReceiveState ignore response");
525 return TELEPHONY_SUCCESS;
526 }
527
ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)528 int32_t VideoSendReceiveState::ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)
529 {
530 TELEPHONY_LOGI("VideoSendReceiveState ignore response");
531 return TELEPHONY_SUCCESS;
532 }
533
VideoPauseState(sptr<NetCallBase> callPtr)534 VideoPauseState::VideoPauseState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
535
SendUpdateCallMediaModeRequest(ImsCallMode mode)536 int32_t VideoPauseState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
537 {
538 TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", mode);
539 int32_t ret = TELEPHONY_SUCCESS;
540 switch (mode) {
541 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
542 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
543 ret = DispatchUpdateVideoRequest(mode);
544 if (ret != TELEPHONY_SUCCESS) {
545 TELEPHONY_LOGE("error occur when send updateRequest to call");
546 return ret;
547 }
548 ret = SwitchCallVideoState(mode);
549 if (ret == TELEPHONY_SUCCESS) {
550 TELEPHONY_LOGE("error occur when switch call state");
551 return ret;
552 }
553 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
554 break;
555 case ImsCallMode::CALL_MODE_SEND_ONLY:
556 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
557 TELEPHONY_LOGI("send update video state");
558 ret = DispatchUpdateVideoRequest(mode);
559 break;
560 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
561 TELEPHONY_LOGE("illegal media type.");
562 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
563 break;
564 default:
565 TELEPHONY_LOGE("unknown media type.");
566 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
567 break;
568 }
569 return ret;
570 }
571
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)572 int32_t VideoPauseState::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
573 {
574 TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", mode);
575 int32_t ret = TELEPHONY_SUCCESS;
576 switch (mode) {
577 case ImsCallMode::CALL_MODE_AUDIO_ONLY:
578 case ImsCallMode::CALL_MODE_SEND_RECEIVE:
579 ret = SwitchCallVideoState(mode);
580 if (ret == TELEPHONY_SUCCESS) {
581 TELEPHONY_LOGE("error occur when switch call state");
582 return ret;
583 }
584 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
585 break;
586 case ImsCallMode::CALL_MODE_SEND_ONLY:
587 case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
588 TELEPHONY_LOGI("receive update call media request");
589 break;
590 case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
591 TELEPHONY_LOGE("illegal media type.");
592 ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
593 break;
594 default:
595 TELEPHONY_LOGE("unknown media type.");
596 ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
597 break;
598 }
599 return ret;
600 }
601
SendUpdateCallMediaModeResponse(ImsCallMode mode)602 int32_t VideoPauseState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
603 {
604 TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", mode);
605 return TELEPHONY_SUCCESS;
606 }
607
ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)608 int32_t VideoPauseState::ReceiveUpdateCallMediaModeResponse(ImsCallMode mode)
609 {
610 TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", mode);
611 return TELEPHONY_SUCCESS;
612 }
613 } // namespace Telephony
614 } // namespace OHOS
615