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_->SendUpdateCallMediaModeRequest(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_->SendUpdateCallMediaModeResponse(mode);
76 }
77 
DispatchReportVideoCallInfo(CallMediaModeInfo & imsCallModeInfo)78 int32_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 
GetCallVideoState(ImsCallMode mode)87 sptr<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 
AudioOnlyState(sptr<NetCallBase> callPtr)97 AudioOnlyState::AudioOnlyState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
98 
SendUpdateCallMediaModeRequest(ImsCallMode mode)99 int32_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 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo & imsCallModeInfo)136 int32_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 
SendUpdateCallMediaModeResponse(ImsCallMode mode)182 int32_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 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo & imsCallModeInfo)233 int32_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 
VideoSendState(sptr<NetCallBase> callPtr)270 VideoSendState::VideoSendState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
271 
SendUpdateCallMediaModeRequest(ImsCallMode mode)272 int32_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 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo & imsCallModeInfo)305 int32_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 
SendUpdateCallMediaModeResponse(ImsCallMode mode)340 int32_t VideoSendState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
341 {
342     TELEPHONY_LOGI("VideoSendState send response ignored. mode %{public}d", mode);
343     return TELEPHONY_SUCCESS;
344 }
345 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo & imsCallModeInfo)346 int32_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             GetCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY)->SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
381             break;
382         default:
383             TELEPHONY_LOGE("unknown media type.");
384             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
385             break;
386     }
387     return ret;
388 }
389 
VideoReceiveState(sptr<NetCallBase> callPtr)390 VideoReceiveState::VideoReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
391 
SendUpdateCallMediaModeRequest(ImsCallMode mode)392 int32_t VideoReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
393 {
394     int32_t ret = TELEPHONY_SUCCESS;
395     VideoUpdateStatus status = GetVideoUpdateStatus();
396     TELEPHONY_LOGI("VideoReceiveState send update video request. mode:%{public}d, status:%{public}d", mode, status);
397     switch (mode) {
398         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
399         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
400             ret = DispatchUpdateVideoRequest(mode);
401             if (ret != TELEPHONY_SUCCESS) {
402                 TELEPHONY_LOGE("error occurs when dispatch request");
403                 return ret;
404             }
405             ret = SwitchCallVideoState(mode);
406             if (ret) {
407                 TELEPHONY_LOGE("error occur when switch call state");
408                 return ret;
409             }
410             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
411             break;
412         case ImsCallMode::CALL_MODE_SEND_ONLY:
413         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
414         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
415             if (status != VideoUpdateStatus::STATUS_NONE) {
416                 TELEPHONY_LOGE("already in progress.");
417                 ret = CALL_ERR_VIDEO_IN_PROGRESS;
418             }
419             break;
420         default:
421             TELEPHONY_LOGE("unknown media type.");
422             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
423             break;
424     }
425     return ret;
426 }
427 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo & imsCallModeInfo)428 int32_t VideoReceiveState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
429 {
430     int32_t ret = TELEPHONY_SUCCESS;
431     VideoUpdateStatus status = GetVideoUpdateStatus();
432     TELEPHONY_LOGI("VideoReceiveState receive update video request. mode:%{public}d, status:%{public}d",
433         imsCallModeInfo.callMode, status);
434     switch (imsCallModeInfo.callMode) {
435         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
436         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
437             ret = SwitchCallVideoState(imsCallModeInfo.callMode);
438             if (ret != TELEPHONY_SUCCESS) {
439                 return ret;
440             }
441             DispatchReportVideoCallInfo(imsCallModeInfo);
442             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
443             break;
444         case ImsCallMode::CALL_MODE_SEND_ONLY:
445             break;
446         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
447         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
448             if (status != VideoUpdateStatus::STATUS_NONE) {
449                 TELEPHONY_LOGE("already in progress.");
450                 ret = CALL_ERR_VIDEO_IN_PROGRESS;
451             }
452             DispatchReportVideoCallInfo(imsCallModeInfo);
453             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
454             break;
455         default:
456             TELEPHONY_LOGE("unknown media type.");
457             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
458             break;
459     }
460     return ret;
461 }
462 
SendUpdateCallMediaModeResponse(ImsCallMode mode)463 int32_t VideoReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
464 {
465     int32_t ret = TELEPHONY_SUCCESS;
466     VideoUpdateStatus status = GetVideoUpdateStatus();
467     TELEPHONY_LOGI("VideoReceiveState send update video response. mode:%{public}d, status:%{public}d", mode, status);
468     switch (mode) {
469         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
470         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
471             ret = SwitchCallVideoState(mode);
472             if (ret == TELEPHONY_SUCCESS) {
473                 TELEPHONY_LOGE("error occur when switch call state");
474                 return ret;
475             }
476             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
477             break;
478         case ImsCallMode::CALL_MODE_SEND_ONLY:
479             break;
480         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
481             if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
482                 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
483             }
484             DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY);
485             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
486             break;
487         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
488             if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
489                 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
490             }
491             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
492             DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
493             ret = SwitchCallVideoState(mode);
494             if (ret) {
495                 TELEPHONY_LOGE("error occur when switch call state");
496                 return ret;
497             }
498             break;
499         default:
500             TELEPHONY_LOGE("unknown media type.");
501             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
502             break;
503     }
504     return ret;
505 }
506 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo & imsCallModeInfo)507 int32_t VideoReceiveState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
508 {
509     TELEPHONY_LOGI("VideoReceiveState receive update video response. mode:%{public}d", imsCallModeInfo.callMode);
510     int32_t ret = TELEPHONY_SUCCESS;
511     switch (imsCallModeInfo.callMode) {
512         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
513         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
514         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
515             ret = SwitchCallVideoState(imsCallModeInfo.callMode);
516             if (ret != TELEPHONY_SUCCESS) {
517                 TELEPHONY_LOGE("error occur when switch call state");
518                 return ret;
519             }
520             DispatchReportVideoCallInfo(imsCallModeInfo);
521             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
522             break;
523         case ImsCallMode::CALL_MODE_SEND_ONLY:
524             break;
525         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
526             DispatchReportVideoCallInfo(imsCallModeInfo);
527             if (GetVideoUpdateStatus() != VideoUpdateStatus::STATUS_NONE) {
528                 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
529             }
530             break;
531         default:
532             TELEPHONY_LOGE("unknown media type.");
533             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
534             break;
535     }
536     return ret;
537 }
538 
VideoSendReceiveState(sptr<NetCallBase> callPtr)539 VideoSendReceiveState::VideoSendReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
540 
SendUpdateCallMediaModeRequest(ImsCallMode mode)541 int32_t VideoSendReceiveState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
542 {
543     TELEPHONY_LOGI("VideoSendReceiveState send update video request. mode:%{public}d", mode);
544     int32_t ret = TELEPHONY_SUCCESS;
545     switch (mode) {
546         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
547         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
548             ret = DispatchUpdateVideoRequest(mode);
549             if (ret != TELEPHONY_SUCCESS) {
550                 TELEPHONY_LOGE("error occur when send updateRequest to call");
551                 return ret;
552             }
553             ret = SwitchCallVideoState(mode);
554             if (ret != TELEPHONY_SUCCESS) {
555                 TELEPHONY_LOGE("error occur when switch call state");
556                 return ret;
557             }
558             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
559             break;
560         case ImsCallMode::CALL_MODE_SEND_ONLY:
561         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
562             ret = DispatchUpdateVideoRequest(mode);
563             if (ret != TELEPHONY_SUCCESS) {
564                 TELEPHONY_LOGE("error occur when send updateRequest to call");
565                 return ret;
566             }
567             break;
568         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
569             TELEPHONY_LOGE("illegal media type.");
570             return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
571         default:
572             TELEPHONY_LOGE("unknown media type.");
573             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
574             break;
575     }
576     return ret;
577 }
578 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo & imsCallModeInfo)579 int32_t VideoSendReceiveState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
580 {
581     int32_t ret = TELEPHONY_SUCCESS;
582     VideoUpdateStatus status = GetVideoUpdateStatus();
583     TELEPHONY_LOGI("VideoSendReceiveState receive update video request. mode:%{public}d, status:%{public}d",
584         imsCallModeInfo.callMode, status);
585     switch (imsCallModeInfo.callMode) {
586         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
587             ret = SwitchCallVideoState(imsCallModeInfo.callMode); // support send downgrade & pause video request
588             if (ret != TELEPHONY_SUCCESS) {
589                 TELEPHONY_LOGE("error occurs when switch call state");
590                 return ret;
591             }
592             (void)DispatchReportVideoCallInfo(imsCallModeInfo);
593             if (status != VideoUpdateStatus::STATUS_NONE) {
594                 SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
595             }
596             break;
597         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
598         case ImsCallMode::CALL_MODE_SEND_ONLY:
599             TELEPHONY_LOGI("receive update video request");
600             break;
601         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
602             TELEPHONY_LOGI("receive update video request");
603             if (status != VideoUpdateStatus::STATUS_NONE) {
604                 TELEPHONY_LOGI("already in progress.");
605                 return CALL_ERR_VIDEO_IN_PROGRESS;
606             }
607             (void)DispatchReportVideoCallInfo(imsCallModeInfo);
608             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
609             break;
610         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
611             (void)DispatchReportVideoCallInfo(imsCallModeInfo);
612             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_RECV_REQUEST);
613             break;
614         default:
615             TELEPHONY_LOGE("unknown media type.");
616             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
617             break;
618     }
619     return ret;
620 }
621 
SendUpdateCallMediaModeResponse(ImsCallMode mode)622 int32_t VideoSendReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
623 {
624     TELEPHONY_LOGI("VideoSendReceiveState ignore response");
625     return TELEPHONY_SUCCESS;
626 }
627 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo & imsCallModeInfo)628 int32_t VideoSendReceiveState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
629 {
630     int32_t ret = TELEPHONY_SUCCESS;
631     VideoUpdateStatus status = GetVideoUpdateStatus();
632     TELEPHONY_LOGI("VideoSendReceiveState receive update video response. mode:%{public}d, status:%{public}d",
633         imsCallModeInfo.callMode, status);
634     switch (imsCallModeInfo.callMode) {
635         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
636             TELEPHONY_LOGI("receive update video response");
637             if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
638                 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
639             }
640             DispatchReportVideoCallInfo(imsCallModeInfo);
641             ret = SwitchCallVideoState(imsCallModeInfo.callMode); // support send downgrade & pause video request
642             if (ret != TELEPHONY_SUCCESS) {
643                 TELEPHONY_LOGE("error occurs when switch call state");
644                 return ret;
645             }
646             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
647             break;
648         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
649             if (status != VideoUpdateStatus::STATUS_RECV_REQUEST) {
650                 return CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
651             }
652             ret = DispatchReportVideoCallInfo(imsCallModeInfo);
653             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
654             break;
655         default:
656             TELEPHONY_LOGE("unknown media type.");
657             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
658             break;
659     }
660     return ret;
661 }
662 
VideoPauseState(sptr<NetCallBase> callPtr)663 VideoPauseState::VideoPauseState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
664 
SendUpdateCallMediaModeRequest(ImsCallMode mode)665 int32_t VideoPauseState::SendUpdateCallMediaModeRequest(ImsCallMode mode)
666 {
667     TELEPHONY_LOGI("VideoPauseState send update video request. mode:%{public}d", mode);
668     int32_t ret = TELEPHONY_SUCCESS;
669     switch (mode) {
670         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
671         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
672             ret = DispatchUpdateVideoRequest(mode);
673             if (ret != TELEPHONY_SUCCESS) {
674                 TELEPHONY_LOGE("error occur when send updateRequest to call");
675                 return ret;
676             }
677             ret = SwitchCallVideoState(mode);
678             if (ret == TELEPHONY_SUCCESS) {
679                 TELEPHONY_LOGE("error occur when switch call state");
680                 return ret;
681             }
682             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
683             break;
684         case ImsCallMode::CALL_MODE_SEND_ONLY:
685         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
686             TELEPHONY_LOGI("send update video state");
687             ret = DispatchUpdateVideoRequest(mode);
688             break;
689         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
690             TELEPHONY_LOGE("illegal media type.");
691             ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
692             break;
693         default:
694             TELEPHONY_LOGE("unknown media type.");
695             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
696             break;
697     }
698     return ret;
699 }
700 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo & imsCallModeInfo)701 int32_t VideoPauseState::RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)
702 {
703     TELEPHONY_LOGI("VideoPauseState receive update video request. mode:%{public}d", imsCallModeInfo.callMode);
704     int32_t ret = TELEPHONY_SUCCESS;
705     switch (imsCallModeInfo.callMode) {
706         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
707         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
708             ret = SwitchCallVideoState(imsCallModeInfo.callMode);
709             if (ret == TELEPHONY_SUCCESS) {
710                 TELEPHONY_LOGE("error occur when switch call state");
711                 return ret;
712             }
713             SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
714             break;
715         case ImsCallMode::CALL_MODE_SEND_ONLY:
716         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
717             TELEPHONY_LOGI("receive update call media request");
718             break;
719         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
720             TELEPHONY_LOGE("illegal media type.");
721             ret = CALL_ERR_VIDEO_ILLEAGAL_SCENARIO;
722             break;
723         default:
724             TELEPHONY_LOGE("unknown media type.");
725             ret = CALL_ERR_VIDEO_ILLEGAL_MEDIA_TYPE;
726             break;
727     }
728     return ret;
729 }
730 
SendUpdateCallMediaModeResponse(ImsCallMode mode)731 int32_t VideoPauseState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
732 {
733     TELEPHONY_LOGI("VideoPauseState send update video response. mode:%{public}d", mode);
734     return TELEPHONY_SUCCESS;
735 }
736 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo & imsCallModeInfo)737 int32_t VideoPauseState::ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)
738 {
739     TELEPHONY_LOGI("VideoPauseState receive update video response. mode:%{public}d", imsCallModeInfo.callMode);
740     return TELEPHONY_SUCCESS;
741 }
742 } // namespace Telephony
743 } // namespace OHOS
744