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