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             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 
VideoReceiveState(sptr<NetCallBase> callPtr)397 VideoReceiveState::VideoReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
398 
SendUpdateCallMediaModeRequest(ImsCallMode mode)399 int32_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 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)435 int32_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 
SendUpdateCallMediaModeResponse(ImsCallMode mode)470 int32_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 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)514 int32_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 
VideoSendReceiveState(sptr<NetCallBase> callPtr)546 VideoSendReceiveState::VideoSendReceiveState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
547 
SendUpdateCallMediaModeRequest(ImsCallMode mode)548 int32_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 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)586 int32_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 
SendUpdateCallMediaModeResponse(ImsCallMode mode)629 int32_t VideoSendReceiveState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
630 {
631     TELEPHONY_LOGI("VideoSendReceiveState ignore response");
632     return TELEPHONY_SUCCESS;
633 }
634 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)635 int32_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 
VideoPauseState(sptr<NetCallBase> callPtr)670 VideoPauseState::VideoPauseState(sptr<NetCallBase> callPtr) : VideoCallState(callPtr) {}
671 
SendUpdateCallMediaModeRequest(ImsCallMode mode)672 int32_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 
RecieveUpdateCallMediaModeRequest(CallMediaModeInfo &imsCallModeInfo)708 int32_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 
SendUpdateCallMediaModeResponse(ImsCallMode mode)738 int32_t VideoPauseState::SendUpdateCallMediaModeResponse(ImsCallMode mode)
739 {
740     TELEPHONY_LOGI("VideoPauseState send update video response. mode:%{public}d", mode);
741     return TELEPHONY_SUCCESS;
742 }
743 
ReceiveUpdateCallMediaModeResponse(CallMediaModeInfo &imsCallModeInfo)744 int32_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