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
23namespace OHOS {
24namespace Telephony {
25VideoCallState::VideoCallState(sptr<NetCallBase> callPtr)
26    : call_(callPtr), updateStatus_(VideoUpdateStatus::STATUS_NONE)
27{}
28
29bool 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
39void VideoCallState::SetVideoUpdateStatus(VideoUpdateStatus status)
40{
41    updateStatus_ = status;
42}
43
44VideoUpdateStatus VideoCallState::GetVideoUpdateStatus()
45{
46    return updateStatus_;
47}
48
49int32_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
60int32_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_->SendUpdateCallMediaModeRequest(mode);
67}
68
69int32_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_->SendUpdateCallMediaModeResponse(mode);
76}
77
78int32_t VideoCallState::DispatchReportVideoCallInfo(CallMediaModeInfo &imsCallModeInfo)
79{
80    if (call_ == nullptr) {
81        TELEPHONY_LOGE("unexpected null pointer.");
82        return TELEPHONY_ERR_LOCAL_PTR_NULL;
83    }
84    return call_->ReportImsCallModeInfo(imsCallModeInfo);
85}
86
87sptr<VideoCallState> VideoCallState::GetCallVideoState(ImsCallMode mode)
88{
89    if (call_ == nullptr) {
90        TELEPHONY_LOGE("unexpected null pointer.");
91        return nullptr;
92    }
93    sptr<IMSCall> netCall = static_cast<IMSCall *>(call_.GetRefPtr());
94    return netCall->GetCallVideoState(mode);
95}
96
97AudioOnlyState::AudioOnlyState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
98
99int32_t AudioOnlyState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
100{
101    int ret = TELEPHONY_SUCCESS;
102    VideoUpdateStatus status = GetVideoUpdateStatus();
103    TELEPHONY_LOGI("AudioOnlyState send update video request. mode:%{public}d, status %{public}d", mode, status);
104    switch (mode) {
105        case ImsCallMode::CALL_MODE_SEND_ONLY:
106        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
107            break;
108        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
109        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
110            TELEPHONY_LOGE("illegal media type.");
111            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
112            break;
113        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
114            if (!IsCallSupportVideoCall()) {
115                TELEPHONY_LOGE("call not support video, end.");
116                return CALL_ERR_VIDEO_NOT_SUPPORTED;
117            }
118            if (status != VideoUpdateStatus::STATUS_NONE) {
119                TELEPHONY_LOGE("update is in progress. no need");
120                return CALL_ERR_VIDEO_IN_PROGRESS;
121            }
122            ret = DispatchUpdateVideoRequest(mode);
123            if (ret != TELEPHONY_SUCCESS) {
124                TELEPHONY_LOGE("error occur when send updateRequest to call");
125                return ret;
126            }
127            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_SEND_REQUEST);
128            break;
129        default:
130            TELEPHONY_LOGE("unknown call media type.");
131            return CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
132    }
133    return ret;
134}
135
136int32_t AudioOnlyState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
137{
138    int32_t ret = TELEPHONY_SUCCESS;
139    VideoUpdateStatus status = GetVideoUpdateStatus();
140    TELEPHONY_LOGI("AudioOnlyState receive update video request. mode:%{public}d, status %{public}d",
141        imsCallModeInfo.callMode, status);
142    switch (imsCallModeInfo.callMode) {
143        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
144        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
145            TELEPHONY_LOGI("invalid media state request.");
146            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
147            break;
148        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
149            if (status != VideoUpdateStatus::STATUS_NONE) {
150                TELEPHONY_LOGE("video update in progress");
151                return CALL_ERR_VIDEO_IN_PROGRESS;
152            }
153            // notify app to accept or refuse, assume always accept here
154            (void)DispatchReportVideoCallInfo(imsCallModeInfo);
155            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
156            break;
157        case ImsCallMode::CALL_MODE_SEND_ONLY:
158            TELEPHONY_LOGI("receive request.");
159            break;
160        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
161            if (!IsCallSupportVideoCall()) {
162                TELEPHONY_LOGE("not support video, refuse");
163                (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
164                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
165            }
166            if (status != VideoUpdateStatus::STATUS_NONE) {
167                TELEPHONY_LOGE("video update in progress");
168                return CALL_ERR_VIDEO_IN_PROGRESS;
169            }
170            // notify app to accept or refuse, assume always accept here
171            (void)DispatchReportVideoCallInfo(imsCallModeInfo);
172            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
173            break;
174        default:
175            TELEPHONY_LOGE("unknown call media type.");
176            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
177            break;
178    }
179    return ret;
180}
181
182int32_t AudioOnlyState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
183{
184    int32_t ret = TELEPHONY_SUCCESS;
185    VideoUpdateStatus status = GetVideoUpdateStatus();
186    TELEPHONY_LOGI("AudioOnlyState send update video response. mode:%{public}d, status %{public}d", mode, status);
187    switch (mode) {
188        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
189            if (!IsCallSupportVideoCall()) {
190                TELEPHONY_LOGE("not support video, refuse");
191                (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
192                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
193            }
194            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
195                TELEPHONY_LOGE("video update in progress");
196                return CALL_ERR_VIDEO_IN_PROGRESS;
197            }
198            // notify app to accept or refuse, assume always accept here
199            (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
200            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
201            break;
202        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
203            TELEPHONY_LOGI("invalid media state request.");
204            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
205            break;
206        case ImsCallMode::CALL_MODE_SEND_ONLY:
207            TELEPHONY_LOGI("receive request.");
208            break;
209        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
210        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
211            if (!IsCallSupportVideoCall()) {
212                TELEPHONY_LOGE("not support video, refuse");
213                (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
214                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
215            }
216            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
217                TELEPHONY_LOGE("video update in progress");
218                return CALL_ERR_VIDEO_IN_PROGRESS;
219            }
220            // notify app to accept or refuse, assume always accept here
221            (void)DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
222            (void)SwitchCallVideoState(ImsCallMode::CALL_MODE_SEND_RECEIVE);
223            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
224            break;
225        default:
226            TELEPHONY_LOGE("unknown call media type.");
227            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
228            break;
229    }
230    return ret;
231}
232
233int32_t AudioOnlyState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
234{
235    int32_t ret = TELEPHONY_SUCCESS;
236    VideoUpdateStatus status = GetVideoUpdateStatus();
237    TELEPHONY_LOGI(
238        "AudioOnlyState receive response, mode %{public}d, status %{public}d", imsCallModeInfo.callMode, status);
239    switch (imsCallModeInfo.callMode) {
240        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
241            if (status != VideoUpdateStatus::STATUS_SEND_REQUEST) {
242                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
243            }
244            (void)SwitchCallVideoState(ImsCallMode::CALL_MODE_SEND_RECEIVE);
245            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
246            // notify app to accept or refuse, assume always accept here
247            DispatchReportVideoCallInfo(imsCallModeInfo);
248            break;
249        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
250            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
251            // notify app to accept or refuse, assume always accept here
252            DispatchReportVideoCallInfo(imsCallModeInfo);
253            break;
254        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
255            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
256                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
257            }
258            (void)SwitchCallVideoState(ImsCallMode::CALL_MODE_RECEIVE_ONLY);
259            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
260            // notify app to accept or refuse, assume always accept here
261            DispatchReportVideoCallInfo(imsCallModeInfo);
262            break;
263        default:
264            TELEPHONY_LOGI("other media type, ignored");
265            break;
266    }
267    return ret;
268}
269
270VideoSendState::VideoSendState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
271
272int32_t VideoSendState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
273{
274    TELEPHONY_LOGI("VideoSendState send update video request. mode:%{public}d", mode);
275    int32_t ret = TELEPHONY_SUCCESS;
276    switch (mode) {
277        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
278        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
279            ret = DispatchUpdateVideoRequest(mode);
280            if (ret != TELEPHONY_SUCCESS) {
281                TELEPHONY_LOGE("error occurs when dispatch request");
282                return ret;
283            }
284            ret = SwitchCallVideoState(mode); // switch call video state
285            if (ret != TELEPHONY_SUCCESS) {
286                TELEPHONY_LOGE("error occurs when switch call state");
287                return ret;
288            }
289            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
290            break;
291        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
292        case ImsCallMode::CALL_MODE_SEND_ONLY:
293        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
294            TELEPHONY_LOGE("already in progress.");
295            ret = CALL_ERR_VIDEO_IN_PROGRESS;
296            break;
297        default:
298            TELEPHONY_LOGE("unknown media type.");
299            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
300            break;
301    }
302    return ret;
303}
304
305int32_t VideoSendState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
306{
307    int32_t ret = TELEPHONY_SUCCESS;
308    VideoUpdateStatus status = GetVideoUpdateStatus();
309    TELEPHONY_LOGI("VideoSendState receive update video request. mode:%{public}d, status:%{public}d",
310        imsCallModeInfo.callMode, status);
311    switch (imsCallModeInfo.callMode) {
312        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
313        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
314            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
315            if (ret != TELEPHONY_SUCCESS) {
316                TELEPHONY_LOGE("error occurs when switch call state.");
317                return ret;
318            }
319            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
320            break;
321        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
322            TELEPHONY_LOGE("invalid media state request.");
323            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
324            break;
325        case ImsCallMode::CALL_MODE_SEND_ONLY:
326        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
327            if (status != VideoUpdateStatus::STATUS_NONE) {
328                TELEPHONY_LOGE("already in progress.");
329                ret = CALL_ERR_VIDEO_IN_PROGRESS;
330            }
331            break;
332        default:
333            TELEPHONY_LOGE("unknown media type.");
334            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
335            break;
336    }
337    return ret;
338}
339
340int32_t VideoSendState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
341{
342    TELEPHONY_LOGI("VideoSendState send response ignored. mode %{public}d", mode);
343    return TELEPHONY_SUCCESS;
344}
345
346int32_t VideoSendState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
347{
348    int32_t ret = TELEPHONY_SUCCESS;
349    VideoUpdateStatus status = GetVideoUpdateStatus();
350    TELEPHONY_LOGI("VideoSendState receive update video response. mode:%{public}d, status:%{public}d",
351        imsCallModeInfo.callMode, status);
352    switch (imsCallModeInfo.callMode) {
353        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
354        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
355            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
356            if (ret != TELEPHONY_SUCCESS) {
357                TELEPHONY_LOGE("error occurs when switch call state");
358                return ret;
359            }
360            // set previous state none
361            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
362            break;
363        case ImsCallMode::CALL_MODE_SEND_ONLY:
364        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
365            if (status != TELEPHONY_SUCCESS) {
366                TELEPHONY_LOGE("already in progress.");
367                ret = CALL_ERR_VIDEO_IN_PROGRESS;
368            }
369            break;
370        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
371            ret = DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
372            if (ret != TELEPHONY_SUCCESS) {
373                return ret;
374            }
375            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
376            if (ret != TELEPHONY_SUCCESS) {
377                TELEPHONY_LOGE("error occurs when switch call");
378                return ret;
379            }
380            if (GetCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY) != nullptr) {
381                GetCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY)->
382                    SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
383                break;
384            } else {
385                TELEPHONY_LOGE("CALL_MODE_AUDIO_ONLY is nullptr");
386                ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
387                break;
388            }
389        default:
390            TELEPHONY_LOGE("unknown media type.");
391            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
392            break;
393    }
394    return ret;
395}
396
397VideoReceiveState::VideoReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
398
399int32_t VideoReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
400{
401    int32_t ret = TELEPHONY_SUCCESS;
402    VideoUpdateStatus status = GetVideoUpdateStatus();
403    TELEPHONY_LOGI("VideoReceiveState send update video request. mode:%{public}d, status:%{public}d", mode, status);
404    switch (mode) {
405        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
406        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
407            ret = DispatchUpdateVideoRequest(mode);
408            if (ret != TELEPHONY_SUCCESS) {
409                TELEPHONY_LOGE("error occurs when dispatch request");
410                return ret;
411            }
412            ret = SwitchCallVideoState(mode);
413            if (ret) {
414                TELEPHONY_LOGE("error occur when switch call state");
415                return ret;
416            }
417            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
418            break;
419        case ImsCallMode::CALL_MODE_SEND_ONLY:
420        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
421        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
422            if (status != VideoUpdateStatus::STATUS_NONE) {
423                TELEPHONY_LOGE("already in progress.");
424                ret = CALL_ERR_VIDEO_IN_PROGRESS;
425            }
426            break;
427        default:
428            TELEPHONY_LOGE("unknown media type.");
429            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
430            break;
431    }
432    return ret;
433}
434
435int32_t VideoReceiveState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
436{
437    int32_t ret = TELEPHONY_SUCCESS;
438    VideoUpdateStatus status = GetVideoUpdateStatus();
439    TELEPHONY_LOGI("VideoReceiveState receive update video request. mode:%{public}d, status:%{public}d",
440        imsCallModeInfo.callMode, status);
441    switch (imsCallModeInfo.callMode) {
442        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
443        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
444            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
445            if (ret != TELEPHONY_SUCCESS) {
446                return ret;
447            }
448            DispatchReportVideoCallInfo(imsCallModeInfo);
449            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
450            break;
451        case ImsCallMode::CALL_MODE_SEND_ONLY:
452            break;
453        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
454        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
455            if (status != VideoUpdateStatus::STATUS_NONE) {
456                TELEPHONY_LOGE("already in progress.");
457                ret = CALL_ERR_VIDEO_IN_PROGRESS;
458            }
459            DispatchReportVideoCallInfo(imsCallModeInfo);
460            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
461            break;
462        default:
463            TELEPHONY_LOGE("unknown media type.");
464            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
465            break;
466    }
467    return ret;
468}
469
470int32_t VideoReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
471{
472    int32_t ret = TELEPHONY_SUCCESS;
473    VideoUpdateStatus status = GetVideoUpdateStatus();
474    TELEPHONY_LOGI("VideoReceiveState send update video response. mode:%{public}d, status:%{public}d", mode, status);
475    switch (mode) {
476        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
477        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
478            ret = SwitchCallVideoState(mode);
479            if (ret == TELEPHONY_SUCCESS) {
480                TELEPHONY_LOGE("error occur when switch call state");
481                return ret;
482            }
483            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
484            break;
485        case ImsCallMode::CALL_MODE_SEND_ONLY:
486            break;
487        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
488            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
489                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
490            }
491            DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY);
492            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
493            break;
494        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
495            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
496                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
497            }
498            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
499            DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
500            ret = SwitchCallVideoState(mode);
501            if (ret) {
502                TELEPHONY_LOGE("error occur when switch call state");
503                return ret;
504            }
505            break;
506        default:
507            TELEPHONY_LOGE("unknown media type.");
508            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
509            break;
510    }
511    return ret;
512}
513
514int32_t VideoReceiveState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
515{
516    TELEPHONY_LOGI("VideoReceiveState receive update video response. mode:%{public}d", imsCallModeInfo.callMode);
517    int32_t ret = TELEPHONY_SUCCESS;
518    switch (imsCallModeInfo.callMode) {
519        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
520        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
521        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
522            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
523            if (ret != TELEPHONY_SUCCESS) {
524                TELEPHONY_LOGE("error occur when switch call state");
525                return ret;
526            }
527            DispatchReportVideoCallInfo(imsCallModeInfo);
528            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
529            break;
530        case ImsCallMode::CALL_MODE_SEND_ONLY:
531            break;
532        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
533            DispatchReportVideoCallInfo(imsCallModeInfo);
534            if (GetVideoUpdateStatus() != VideoUpdateStatus::STATUS_NONE) {
535                SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
536            }
537            break;
538        default:
539            TELEPHONY_LOGE("unknown media type.");
540            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
541            break;
542    }
543    return ret;
544}
545
546VideoSendReceiveState::VideoSendReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
547
548int32_t VideoSendReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
549{
550    TELEPHONY_LOGI("VideoSendReceiveState send update video request. mode:%{public}d", mode);
551    int32_t ret = TELEPHONY_SUCCESS;
552    switch (mode) {
553        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
554        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
555            ret = DispatchUpdateVideoRequest(mode);
556            if (ret != TELEPHONY_SUCCESS) {
557                TELEPHONY_LOGE("error occur when send updateRequest to call");
558                return ret;
559            }
560            ret = SwitchCallVideoState(mode);
561            if (ret != TELEPHONY_SUCCESS) {
562                TELEPHONY_LOGE("error occur when switch call state");
563                return ret;
564            }
565            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
566            break;
567        case ImsCallMode::CALL_MODE_SEND_ONLY:
568        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
569            ret = DispatchUpdateVideoRequest(mode);
570            if (ret != TELEPHONY_SUCCESS) {
571                TELEPHONY_LOGE("error occur when send updateRequest to call");
572                return ret;
573            }
574            break;
575        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
576            TELEPHONY_LOGE("illegal media type.");
577            return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
578        default:
579            TELEPHONY_LOGE("unknown media type.");
580            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
581            break;
582    }
583    return ret;
584}
585
586int32_t VideoSendReceiveState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
587{
588    int32_t ret = TELEPHONY_SUCCESS;
589    VideoUpdateStatus status = GetVideoUpdateStatus();
590    TELEPHONY_LOGI("VideoSendReceiveState receive update video request. mode:%{public}d, status:%{public}d",
591        imsCallModeInfo.callMode, status);
592    switch (imsCallModeInfo.callMode) {
593        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
594            ret = SwitchCallVideoState(imsCallModeInfo.callMode); // support send downgrade & pause video request
595            if (ret != TELEPHONY_SUCCESS) {
596                TELEPHONY_LOGE("error occurs when switch call state");
597                return ret;
598            }
599            (void)DispatchReportVideoCallInfo(imsCallModeInfo);
600            if (status != VideoUpdateStatus::STATUS_NONE) {
601                SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
602            }
603            break;
604        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
605        case ImsCallMode::CALL_MODE_SEND_ONLY:
606            TELEPHONY_LOGI("receive update video request");
607            break;
608        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
609            TELEPHONY_LOGI("receive update video request");
610            if (status != VideoUpdateStatus::STATUS_NONE) {
611                TELEPHONY_LOGI("already in progress.");
612                return CALL_ERR_VIDEO_IN_PROGRESS;
613            }
614            (void)DispatchReportVideoCallInfo(imsCallModeInfo);
615            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
616            break;
617        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
618            (void)DispatchReportVideoCallInfo(imsCallModeInfo);
619            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
620            break;
621        default:
622            TELEPHONY_LOGE("unknown media type.");
623            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
624            break;
625    }
626    return ret;
627}
628
629int32_t VideoSendReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
630{
631    TELEPHONY_LOGI("VideoSendReceiveState ignore response");
632    return TELEPHONY_SUCCESS;
633}
634
635int32_t VideoSendReceiveState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
636{
637    int32_t ret = TELEPHONY_SUCCESS;
638    VideoUpdateStatus status = GetVideoUpdateStatus();
639    TELEPHONY_LOGI("VideoSendReceiveState receive update video response. mode:%{public}d, status:%{public}d",
640        imsCallModeInfo.callMode, status);
641    switch (imsCallModeInfo.callMode) {
642        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
643            TELEPHONY_LOGI("receive update video response");
644            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
645                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
646            }
647            DispatchReportVideoCallInfo(imsCallModeInfo);
648            ret = SwitchCallVideoState(imsCallModeInfo.callMode); // support send downgrade & pause video request
649            if (ret != TELEPHONY_SUCCESS) {
650                TELEPHONY_LOGE("error occurs when switch call state");
651                return ret;
652            }
653            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
654            break;
655        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
656            if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
657                return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
658            }
659            ret = DispatchReportVideoCallInfo(imsCallModeInfo);
660            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
661            break;
662        default:
663            TELEPHONY_LOGE("unknown media type.");
664            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
665            break;
666    }
667    return ret;
668}
669
670VideoPauseState::VideoPauseState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
671
672int32_t VideoPauseState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
673{
674    TELEPHONY_LOGI("VideoPauseState send update video request. mode:%{public}d", mode);
675    int32_t ret = TELEPHONY_SUCCESS;
676    switch (mode) {
677        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
678        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
679            ret = DispatchUpdateVideoRequest(mode);
680            if (ret != TELEPHONY_SUCCESS) {
681                TELEPHONY_LOGE("error occur when send updateRequest to call");
682                return ret;
683            }
684            ret = SwitchCallVideoState(mode);
685            if (ret == TELEPHONY_SUCCESS) {
686                TELEPHONY_LOGE("error occur when switch call state");
687                return ret;
688            }
689            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
690            break;
691        case ImsCallMode::CALL_MODE_SEND_ONLY:
692        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
693            TELEPHONY_LOGI("send update video state");
694            ret = DispatchUpdateVideoRequest(mode);
695            break;
696        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
697            TELEPHONY_LOGE("illegal media type.");
698            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
699            break;
700        default:
701            TELEPHONY_LOGE("unknown media type.");
702            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
703            break;
704    }
705    return ret;
706}
707
708int32_t VideoPauseState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
709{
710    TELEPHONY_LOGI("VideoPauseState receive update video request. mode:%{public}d", imsCallModeInfo.callMode);
711    int32_t ret = TELEPHONY_SUCCESS;
712    switch (imsCallModeInfo.callMode) {
713        case ImsCallMode::CALL_MODE_AUDIO_ONLY:
714        case ImsCallMode::CALL_MODE_SEND_RECEIVE:
715            ret = SwitchCallVideoState(imsCallModeInfo.callMode);
716            if (ret == TELEPHONY_SUCCESS) {
717                TELEPHONY_LOGE("error occur when switch call state");
718                return ret;
719            }
720            SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
721            break;
722        case ImsCallMode::CALL_MODE_SEND_ONLY:
723        case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
724            TELEPHONY_LOGI("receive update call media request");
725            break;
726        case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
727            TELEPHONY_LOGE("illegal media type.");
728            ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
729            break;
730        default:
731            TELEPHONY_LOGE("unknown media type.");
732            ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
733            break;
734    }
735    return ret;
736}
737
738int32_t VideoPauseState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
739{
740    TELEPHONY_LOGI("VideoPauseState send update video response. mode:%{public}d", mode);
741    return TELEPHONY_SUCCESS;
742}
743
744int32_t VideoPauseState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
745{
746    TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", imsCallModeInfo.callMode);
747    return TELEPHONY_SUCCESS;
748}
749} // namespace Telephony
750} // namespace OHOS
751