blob: 536af8e3669c1f5937413ae5f32765ef68176441 [file] [log] [blame]
Eric Erfanianccca3152017-02-22 16:32:36 -08001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.incallui;
18
19import android.app.Activity;
20import android.content.Context;
21import android.graphics.Point;
22import android.os.Handler;
wangqida410d32018-03-06 16:51:38 -080023import android.support.annotation.NonNull;
Eric Erfanianccca3152017-02-22 16:32:36 -080024import android.support.annotation.Nullable;
Eric Erfanianccca3152017-02-22 16:32:36 -080025import android.telecom.InCallService.VideoCall;
26import android.telecom.VideoProfile;
27import android.telecom.VideoProfile.CameraCapabilities;
28import android.view.Surface;
Eric Erfanian90508232017-03-24 09:31:16 -070029import android.view.SurfaceView;
Eric Erfanianccca3152017-02-22 16:32:36 -080030import com.android.dialer.common.Assert;
Eric Erfanianccca3152017-02-22 16:32:36 -080031import com.android.dialer.common.LogUtil;
zachh190343a2018-05-31 17:30:46 -070032import com.android.dialer.configprovider.ConfigProviderComponent;
Eric Erfanian2ca43182017-08-31 06:57:16 -070033import com.android.dialer.util.PermissionsUtil;
Eric Erfanianccca3152017-02-22 16:32:36 -080034import com.android.incallui.InCallPresenter.InCallDetailsListener;
35import com.android.incallui.InCallPresenter.InCallOrientationListener;
36import com.android.incallui.InCallPresenter.InCallStateListener;
37import com.android.incallui.InCallPresenter.IncomingCallListener;
38import com.android.incallui.call.CallList;
39import com.android.incallui.call.DialerCall;
Eric Erfaniand5e47f62017-03-15 14:41:07 -070040import com.android.incallui.call.DialerCall.CameraDirection;
Eric Erfanianccca3152017-02-22 16:32:36 -080041import com.android.incallui.call.InCallVideoCallCallbackNotifier;
42import com.android.incallui.call.InCallVideoCallCallbackNotifier.SurfaceChangeListener;
wangqibb94ca62018-04-27 14:34:04 -070043import com.android.incallui.call.state.DialerCallState;
Eric Erfanianccca3152017-02-22 16:32:36 -080044import com.android.incallui.util.AccessibilityUtil;
45import com.android.incallui.video.protocol.VideoCallScreen;
46import com.android.incallui.video.protocol.VideoCallScreenDelegate;
47import com.android.incallui.videosurface.protocol.VideoSurfaceDelegate;
48import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
Eric Erfanian90508232017-03-24 09:31:16 -070049import com.android.incallui.videotech.utils.SessionModificationState;
50import com.android.incallui.videotech.utils.VideoUtils;
Eric Erfanianccca3152017-02-22 16:32:36 -080051import java.util.Objects;
52
53/**
54 * Logic related to the {@link VideoCallScreen} and for managing changes to the video calling
55 * surfaces based on other user interface events and incoming events from the {@class
56 * VideoCallListener}.
57 *
58 * <p>When a call's video state changes to bi-directional video, the {@link
59 * com.android.incallui.VideoCallPresenter} performs the following negotiation with the telephony
60 * layer:
61 *
62 * <ul>
wangqi385a5a12017-09-28 10:44:54 -070063 * <li>{@code VideoCallPresenter} creates and informs telephony of the display surface.
64 * <li>{@code VideoCallPresenter} creates the preview surface.
65 * <li>{@code VideoCallPresenter} informs telephony of the currently selected camera.
66 * <li>Telephony layer sends {@link CameraCapabilities}, including the dimensions of the video for
67 * the current camera.
68 * <li>{@code VideoCallPresenter} adjusts size of the preview surface to match the aspect ratio of
69 * the camera.
70 * <li>{@code VideoCallPresenter} informs telephony of the new preview surface.
Eric Erfanianccca3152017-02-22 16:32:36 -080071 * </ul>
72 *
73 * <p>When downgrading to an audio-only video state, the {@code VideoCallPresenter} nulls both
74 * surfaces.
75 */
76public class VideoCallPresenter
77 implements IncomingCallListener,
78 InCallOrientationListener,
79 InCallStateListener,
80 InCallDetailsListener,
81 SurfaceChangeListener,
Eric Erfanianccca3152017-02-22 16:32:36 -080082 InCallPresenter.InCallEventListener,
wangqida410d32018-03-06 16:51:38 -080083 VideoCallScreenDelegate,
84 CallList.Listener {
Eric Erfanianccca3152017-02-22 16:32:36 -080085
linyuh183cb712017-12-27 17:02:37 -080086 private static boolean isVideoMode = false;
Eric Erfanianccca3152017-02-22 16:32:36 -080087
linyuh183cb712017-12-27 17:02:37 -080088 private final Handler handler = new Handler();
89 private VideoCallScreen videoCallScreen;
Eric Erfanianccca3152017-02-22 16:32:36 -080090
91 /** The current context. */
linyuh183cb712017-12-27 17:02:37 -080092 private Context context;
Eric Erfanianccca3152017-02-22 16:32:36 -080093
Eric Erfanianccca3152017-02-22 16:32:36 -080094 /** The call the video surfaces are currently related to */
linyuh183cb712017-12-27 17:02:37 -080095 private DialerCall primaryCall;
Eric Erfanianccca3152017-02-22 16:32:36 -080096 /**
97 * The {@link VideoCall} used to inform the video telephony layer of changes to the video
98 * surfaces.
99 */
linyuh183cb712017-12-27 17:02:37 -0800100 private VideoCall videoCall;
Eric Erfanianccca3152017-02-22 16:32:36 -0800101 /** Determines if the current UI state represents a video call. */
linyuh183cb712017-12-27 17:02:37 -0800102 private int currentVideoState;
Eric Erfanianccca3152017-02-22 16:32:36 -0800103 /** DialerCall's current state */
wangqibb94ca62018-04-27 14:34:04 -0700104 private int currentCallState = DialerCallState.INVALID;
Eric Erfanianccca3152017-02-22 16:32:36 -0800105 /** Determines the device orientation (portrait/lanscape). */
linyuh183cb712017-12-27 17:02:37 -0800106 private int deviceOrientation = InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN;
Eric Erfanianccca3152017-02-22 16:32:36 -0800107 /** Tracks the state of the preview surface negotiation with the telephony layer. */
linyuh183cb712017-12-27 17:02:37 -0800108 private int previewSurfaceState = PreviewSurfaceState.NONE;
Eric Erfanianccca3152017-02-22 16:32:36 -0800109 /**
110 * Determines whether video calls should automatically enter full screen mode after {@link
linyuh183cb712017-12-27 17:02:37 -0800111 * #autoFullscreenTimeoutMillis} milliseconds.
Eric Erfanianccca3152017-02-22 16:32:36 -0800112 */
linyuh183cb712017-12-27 17:02:37 -0800113 private boolean isAutoFullscreenEnabled = false;
Eric Erfanianccca3152017-02-22 16:32:36 -0800114 /**
115 * Determines the number of milliseconds after which a video call will automatically enter
linyuh183cb712017-12-27 17:02:37 -0800116 * fullscreen mode. Requires {@link #isAutoFullscreenEnabled} to be {@code true}.
Eric Erfanianccca3152017-02-22 16:32:36 -0800117 */
linyuh183cb712017-12-27 17:02:37 -0800118 private int autoFullscreenTimeoutMillis = 0;
Eric Erfanianccca3152017-02-22 16:32:36 -0800119 /**
120 * Determines if the countdown is currently running to automatically enter full screen video mode.
121 */
linyuh183cb712017-12-27 17:02:37 -0800122 private boolean autoFullScreenPending = false;
Eric Erfanianccca3152017-02-22 16:32:36 -0800123 /** Whether if the call is remotely held. */
linyuh183cb712017-12-27 17:02:37 -0800124 private boolean isRemotelyHeld = false;
Eric Erfanianccca3152017-02-22 16:32:36 -0800125 /**
126 * Runnable which is posted to schedule automatically entering fullscreen mode. Will not auto
127 * enter fullscreen mode if the dialpad is visible (doing so would make it impossible to exit the
128 * dialpad).
129 */
linyuh183cb712017-12-27 17:02:37 -0800130 private Runnable autoFullscreenRunnable =
Eric Erfanianccca3152017-02-22 16:32:36 -0800131 new Runnable() {
132 @Override
133 public void run() {
linyuh183cb712017-12-27 17:02:37 -0800134 if (autoFullScreenPending
Eric Erfanianccca3152017-02-22 16:32:36 -0800135 && !InCallPresenter.getInstance().isDialpadVisible()
linyuh183cb712017-12-27 17:02:37 -0800136 && isVideoMode) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800137
138 LogUtil.v("VideoCallPresenter.mAutoFullScreenRunnable", "entering fullscreen mode");
139 InCallPresenter.getInstance().setFullScreen(true);
linyuh183cb712017-12-27 17:02:37 -0800140 autoFullScreenPending = false;
Eric Erfanianccca3152017-02-22 16:32:36 -0800141 } else {
142 LogUtil.v(
143 "VideoCallPresenter.mAutoFullScreenRunnable",
144 "skipping scheduled fullscreen mode.");
145 }
146 }
147 };
148
149 private boolean isVideoCallScreenUiReady;
150
151 private static boolean isCameraRequired(int videoState, int sessionModificationState) {
152 return VideoProfile.isBidirectional(videoState)
153 || VideoProfile.isTransmissionEnabled(videoState)
154 || isVideoUpgrade(sessionModificationState);
155 }
156
157 /**
158 * Determines if the incoming video surface should be shown based on the current videoState and
Eric Erfaniand8046e52017-04-06 09:41:50 -0700159 * callState. The video surface is shown when incoming video is not paused, the call is active or
160 * dialing and video reception is enabled.
Eric Erfanianccca3152017-02-22 16:32:36 -0800161 *
162 * @param videoState The current video state.
163 * @param callState The current call state.
164 * @return {@code true} if the incoming video surface should be shown, {@code false} otherwise.
165 */
linyuh122fb0b2018-03-26 13:35:32 -0700166 static boolean showIncomingVideo(int videoState, int callState) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800167
168 boolean isPaused = VideoProfile.isPaused(videoState);
wangqibb94ca62018-04-27 14:34:04 -0700169 boolean isCallActive = callState == DialerCallState.ACTIVE;
wangqi385a5a12017-09-28 10:44:54 -0700170 // Show incoming Video for dialing calls to support early media
Eric Erfaniand8046e52017-04-06 09:41:50 -0700171 boolean isCallOutgoingPending =
wangqibb94ca62018-04-27 14:34:04 -0700172 DialerCallState.isDialing(callState) || callState == DialerCallState.CONNECTING;
Eric Erfanianccca3152017-02-22 16:32:36 -0800173
Eric Erfaniand8046e52017-04-06 09:41:50 -0700174 return !isPaused
175 && (isCallActive || isCallOutgoingPending)
176 && VideoProfile.isReceptionEnabled(videoState);
Eric Erfanianccca3152017-02-22 16:32:36 -0800177 }
178
179 /**
180 * Determines if the outgoing video surface should be shown based on the current videoState. The
181 * video surface is shown if video transmission is enabled.
182 *
183 * @return {@code true} if the the outgoing video surface should be shown, {@code false}
184 * otherwise.
185 */
linyuh122fb0b2018-03-26 13:35:32 -0700186 private static boolean showOutgoingVideo(
Eric Erfanianccca3152017-02-22 16:32:36 -0800187 Context context, int videoState, int sessionModificationState) {
Eric Erfanian2ca43182017-08-31 06:57:16 -0700188 if (!VideoUtils.hasCameraPermissionAndShownPrivacyToast(context)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800189 LogUtil.i("VideoCallPresenter.showOutgoingVideo", "Camera permission is disabled by user.");
190 return false;
191 }
192
Eric Erfanianccca3152017-02-22 16:32:36 -0800193 return VideoProfile.isTransmissionEnabled(videoState)
194 || isVideoUpgrade(sessionModificationState);
195 }
196
197 private static void updateCameraSelection(DialerCall call) {
198 LogUtil.v("VideoCallPresenter.updateCameraSelection", "call=" + call);
199 LogUtil.v("VideoCallPresenter.updateCameraSelection", "call=" + toSimpleString(call));
200
201 final DialerCall activeCall = CallList.getInstance().getActiveCall();
202 int cameraDir;
203
204 // this function should never be called with null call object, however if it happens we
205 // should handle it gracefully.
206 if (call == null) {
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700207 cameraDir = CameraDirection.CAMERA_DIRECTION_UNKNOWN;
Eric Erfanianccca3152017-02-22 16:32:36 -0800208 LogUtil.e(
209 "VideoCallPresenter.updateCameraSelection",
210 "call is null. Setting camera direction to default value (CAMERA_DIRECTION_UNKNOWN)");
211 }
212
213 // Clear camera direction if this is not a video call.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700214 else if (isAudioCall(call) && !isVideoUpgrade(call)) {
215 cameraDir = CameraDirection.CAMERA_DIRECTION_UNKNOWN;
216 call.setCameraDir(cameraDir);
Eric Erfanianccca3152017-02-22 16:32:36 -0800217 }
218
219 // If this is a waiting video call, default to active call's camera,
220 // since we don't want to change the current camera for waiting call
221 // without user's permission.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700222 else if (isVideoCall(activeCall) && isIncomingVideoCall(call)) {
223 cameraDir = activeCall.getCameraDir();
Eric Erfanianccca3152017-02-22 16:32:36 -0800224 }
225
226 // Infer the camera direction from the video state and store it,
227 // if this is an outgoing video call.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700228 else if (isOutgoingVideoCall(call) && !isCameraDirectionSet(call)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800229 cameraDir = toCameraDirection(call.getVideoState());
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700230 call.setCameraDir(cameraDir);
Eric Erfanianccca3152017-02-22 16:32:36 -0800231 }
232
233 // Use the stored camera dir if this is an outgoing video call for which camera direction
234 // is set.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700235 else if (isOutgoingVideoCall(call)) {
236 cameraDir = call.getCameraDir();
Eric Erfanianccca3152017-02-22 16:32:36 -0800237 }
238
239 // Infer the camera direction from the video state and store it,
240 // if this is an active video call and camera direction is not set.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700241 else if (isActiveVideoCall(call) && !isCameraDirectionSet(call)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800242 cameraDir = toCameraDirection(call.getVideoState());
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700243 call.setCameraDir(cameraDir);
Eric Erfanianccca3152017-02-22 16:32:36 -0800244 }
245
246 // Use the stored camera dir if this is an active video call for which camera direction
247 // is set.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700248 else if (isActiveVideoCall(call)) {
249 cameraDir = call.getCameraDir();
Eric Erfanianccca3152017-02-22 16:32:36 -0800250 }
251
252 // For all other cases infer the camera direction but don't store it in the call object.
253 else {
254 cameraDir = toCameraDirection(call.getVideoState());
255 }
256
257 LogUtil.i(
258 "VideoCallPresenter.updateCameraSelection",
259 "setting camera direction to %d, call: %s",
260 cameraDir,
261 call);
262 final InCallCameraManager cameraManager =
263 InCallPresenter.getInstance().getInCallCameraManager();
264 cameraManager.setUseFrontFacingCamera(
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700265 cameraDir == CameraDirection.CAMERA_DIRECTION_FRONT_FACING);
Eric Erfanianccca3152017-02-22 16:32:36 -0800266 }
267
268 private static int toCameraDirection(int videoState) {
269 return VideoProfile.isTransmissionEnabled(videoState)
270 && !VideoProfile.isBidirectional(videoState)
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700271 ? CameraDirection.CAMERA_DIRECTION_BACK_FACING
272 : CameraDirection.CAMERA_DIRECTION_FRONT_FACING;
Eric Erfanianccca3152017-02-22 16:32:36 -0800273 }
274
275 private static boolean isCameraDirectionSet(DialerCall call) {
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700276 return isVideoCall(call) && call.getCameraDir() != CameraDirection.CAMERA_DIRECTION_UNKNOWN;
Eric Erfanianccca3152017-02-22 16:32:36 -0800277 }
278
279 private static String toSimpleString(DialerCall call) {
280 return call == null ? null : call.toSimpleString();
281 }
282
283 /**
284 * Initializes the presenter.
285 *
286 * @param context The current context.
287 */
288 @Override
289 public void initVideoCallScreenDelegate(Context context, VideoCallScreen videoCallScreen) {
linyuh183cb712017-12-27 17:02:37 -0800290 this.context = context;
291 this.videoCallScreen = videoCallScreen;
292 isAutoFullscreenEnabled =
293 this.context.getResources().getBoolean(R.bool.video_call_auto_fullscreen);
294 autoFullscreenTimeoutMillis =
295 this.context.getResources().getInteger(R.integer.video_call_auto_fullscreen_timeout);
Eric Erfanianccca3152017-02-22 16:32:36 -0800296 }
297
298 /** Called when the user interface is ready to be used. */
299 @Override
300 public void onVideoCallScreenUiReady() {
301 LogUtil.v("VideoCallPresenter.onVideoCallScreenUiReady", "");
302 Assert.checkState(!isVideoCallScreenUiReady);
303
linyuh183cb712017-12-27 17:02:37 -0800304 deviceOrientation = InCallOrientationEventListener.getCurrentOrientation();
Eric Erfanianccca3152017-02-22 16:32:36 -0800305
306 // Register for call state changes last
307 InCallPresenter.getInstance().addListener(this);
308 InCallPresenter.getInstance().addDetailsListener(this);
309 InCallPresenter.getInstance().addIncomingCallListener(this);
310 InCallPresenter.getInstance().addOrientationListener(this);
311 // To get updates of video call details changes
312 InCallPresenter.getInstance().addInCallEventListener(this);
313 InCallPresenter.getInstance().getLocalVideoSurfaceTexture().setDelegate(new LocalDelegate());
314 InCallPresenter.getInstance().getRemoteVideoSurfaceTexture().setDelegate(new RemoteDelegate());
315
wangqida410d32018-03-06 16:51:38 -0800316 CallList.getInstance().addListener(this);
317
Eric Erfanianccca3152017-02-22 16:32:36 -0800318 // Register for surface and video events from {@link InCallVideoCallListener}s.
319 InCallVideoCallCallbackNotifier.getInstance().addSurfaceChangeListener(this);
linyuh183cb712017-12-27 17:02:37 -0800320 currentVideoState = VideoProfile.STATE_AUDIO_ONLY;
wangqibb94ca62018-04-27 14:34:04 -0700321 currentCallState = DialerCallState.INVALID;
Eric Erfanianccca3152017-02-22 16:32:36 -0800322
323 InCallPresenter.InCallState inCallState = InCallPresenter.getInstance().getInCallState();
324 onStateChange(inCallState, inCallState, CallList.getInstance());
325 isVideoCallScreenUiReady = true;
326 }
327
328 /** Called when the user interface is no longer ready to be used. */
329 @Override
330 public void onVideoCallScreenUiUnready() {
331 LogUtil.v("VideoCallPresenter.onVideoCallScreenUiUnready", "");
332 Assert.checkState(isVideoCallScreenUiReady);
333
Eric Erfanianccca3152017-02-22 16:32:36 -0800334 cancelAutoFullScreen();
335
336 InCallPresenter.getInstance().removeListener(this);
337 InCallPresenter.getInstance().removeDetailsListener(this);
338 InCallPresenter.getInstance().removeIncomingCallListener(this);
339 InCallPresenter.getInstance().removeOrientationListener(this);
340 InCallPresenter.getInstance().removeInCallEventListener(this);
341 InCallPresenter.getInstance().getLocalVideoSurfaceTexture().setDelegate(null);
342
wangqida410d32018-03-06 16:51:38 -0800343 CallList.getInstance().removeListener(this);
344
Eric Erfanianccca3152017-02-22 16:32:36 -0800345 InCallVideoCallCallbackNotifier.getInstance().removeSurfaceChangeListener(this);
Eric Erfanianccca3152017-02-22 16:32:36 -0800346
347 // Ensure that the call's camera direction is updated (most likely to UNKNOWN). Normally this
348 // happens after any call state changes but we're unregistering from InCallPresenter above so
Eric Erfanian938468d2017-10-24 14:05:52 -0700349 // we won't get any more call state changes. See a bug.
linyuh183cb712017-12-27 17:02:37 -0800350 if (primaryCall != null) {
351 updateCameraSelection(primaryCall);
Eric Erfanianccca3152017-02-22 16:32:36 -0800352 }
353
354 isVideoCallScreenUiReady = false;
355 }
356
357 /**
358 * Handles clicks on the video surfaces. If not currently in fullscreen mode, will set fullscreen.
359 */
360 private void onSurfaceClick() {
361 LogUtil.i("VideoCallPresenter.onSurfaceClick", "");
362 cancelAutoFullScreen();
363 if (!InCallPresenter.getInstance().isFullscreen()) {
364 InCallPresenter.getInstance().setFullScreen(true);
365 } else {
366 InCallPresenter.getInstance().setFullScreen(false);
linyuh183cb712017-12-27 17:02:37 -0800367 maybeAutoEnterFullscreen(primaryCall);
Eric Erfanianccca3152017-02-22 16:32:36 -0800368 // If Activity is not multiwindow, fullscreen will be driven by SystemUI visibility changes
369 // instead. See #onSystemUiVisibilityChange(boolean)
370
371 // TODO (keyboardr): onSystemUiVisibilityChange isn't being called the first time
372 // visibility changes after orientation change, so this is currently always done as a backup.
373 }
374 }
375
376 @Override
377 public void onSystemUiVisibilityChange(boolean visible) {
378 // If the SystemUI has changed to be visible, take us out of fullscreen mode
379 LogUtil.i("VideoCallPresenter.onSystemUiVisibilityChange", "visible: " + visible);
380 if (visible) {
381 InCallPresenter.getInstance().setFullScreen(false);
linyuh183cb712017-12-27 17:02:37 -0800382 maybeAutoEnterFullscreen(primaryCall);
Eric Erfanianccca3152017-02-22 16:32:36 -0800383 }
384 }
385
386 @Override
387 public VideoSurfaceTexture getLocalVideoSurfaceTexture() {
388 return InCallPresenter.getInstance().getLocalVideoSurfaceTexture();
389 }
390
391 @Override
392 public VideoSurfaceTexture getRemoteVideoSurfaceTexture() {
393 return InCallPresenter.getInstance().getRemoteVideoSurfaceTexture();
394 }
395
396 @Override
Eric Erfanian90508232017-03-24 09:31:16 -0700397 public void setSurfaceViews(SurfaceView preview, SurfaceView remote) {
398 throw Assert.createUnsupportedOperationFailException();
399 }
400
401 @Override
Eric Erfanianccca3152017-02-22 16:32:36 -0800402 public int getDeviceOrientation() {
linyuh183cb712017-12-27 17:02:37 -0800403 return deviceOrientation;
Eric Erfanianccca3152017-02-22 16:32:36 -0800404 }
405
406 /**
407 * This should only be called when user approved the camera permission, which is local action and
408 * does NOT change any call states.
409 */
410 @Override
411 public void onCameraPermissionGranted() {
412 LogUtil.i("VideoCallPresenter.onCameraPermissionGranted", "");
linyuh183cb712017-12-27 17:02:37 -0800413 PermissionsUtil.setCameraPrivacyToastShown(context);
414 enableCamera(primaryCall, isCameraRequired());
Eric Erfanianccca3152017-02-22 16:32:36 -0800415 showVideoUi(
linyuh183cb712017-12-27 17:02:37 -0800416 primaryCall.getVideoState(),
417 primaryCall.getState(),
418 primaryCall.getVideoTech().getSessionModificationState(),
419 primaryCall.isRemotelyHeld());
Eric Erfanianccca3152017-02-22 16:32:36 -0800420 InCallPresenter.getInstance().getInCallCameraManager().onCameraPermissionGranted();
421 }
422
Hideki Ishiie39b9262017-07-25 21:29:43 +0900423 @Override
424 public boolean isFullscreen() {
425 return InCallPresenter.getInstance().isFullscreen();
426 }
427
Eric Erfanianccca3152017-02-22 16:32:36 -0800428 /**
429 * Called when the user interacts with the UI. If a fullscreen timer is pending then we start the
430 * timer from scratch to avoid having the UI disappear while the user is interacting with it.
431 */
432 @Override
433 public void resetAutoFullscreenTimer() {
linyuh183cb712017-12-27 17:02:37 -0800434 if (autoFullScreenPending) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800435 LogUtil.i("VideoCallPresenter.resetAutoFullscreenTimer", "resetting");
linyuh183cb712017-12-27 17:02:37 -0800436 handler.removeCallbacks(autoFullscreenRunnable);
437 handler.postDelayed(autoFullscreenRunnable, autoFullscreenTimeoutMillis);
Eric Erfanianccca3152017-02-22 16:32:36 -0800438 }
439 }
440
441 /**
442 * Handles incoming calls.
443 *
444 * @param oldState The old in call state.
445 * @param newState The new in call state.
446 * @param call The call.
447 */
448 @Override
449 public void onIncomingCall(
450 InCallPresenter.InCallState oldState, InCallPresenter.InCallState newState, DialerCall call) {
wangqi385a5a12017-09-28 10:44:54 -0700451 // If video call screen ui is already destroyed, this shouldn't be called. But the UI may be
452 // updated synchronized by {@link CallCardPresenter#onIncomingCall} before this is called, this
453 // could still be called. Thus just do nothing in this case.
454 if (!isVideoCallScreenUiReady) {
455 LogUtil.i("VideoCallPresenter.onIncomingCall", "UI is not ready");
456 return;
457 }
Eric Erfanianccca3152017-02-22 16:32:36 -0800458 // same logic should happen as with onStateChange()
459 onStateChange(oldState, newState, CallList.getInstance());
460 }
461
462 /**
463 * Handles state changes (including incoming calls)
464 *
465 * @param newState The in call state.
466 * @param callList The call list.
467 */
468 @Override
469 public void onStateChange(
470 InCallPresenter.InCallState oldState,
471 InCallPresenter.InCallState newState,
472 CallList callList) {
473 LogUtil.v(
474 "VideoCallPresenter.onStateChange",
475 "oldState: %s, newState: %s, isVideoMode: %b",
476 oldState,
477 newState,
478 isVideoMode());
479
480 if (newState == InCallPresenter.InCallState.NO_CALLS) {
481 if (isVideoMode()) {
482 exitVideoMode();
483 }
484
485 InCallPresenter.getInstance().cleanupSurfaces();
486 }
487
488 // Determine the primary active call).
489 DialerCall primary = null;
490
491 // Determine the call which is the focus of the user's attention. In the case of an
492 // incoming call waiting call, the primary call is still the active video call, however
493 // the determination of whether we should be in fullscreen mode is based on the type of the
494 // incoming call, not the active video call.
495 DialerCall currentCall = null;
496
497 if (newState == InCallPresenter.InCallState.INCOMING) {
498 // We don't want to replace active video call (primary call)
499 // with a waiting call, since user may choose to ignore/decline the waiting call and
500 // this should have no impact on current active video call, that is, we should not
501 // change the camera or UI unless the waiting VT call becomes active.
502 primary = callList.getActiveCall();
503 currentCall = callList.getIncomingCall();
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700504 if (!isActiveVideoCall(primary)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800505 primary = callList.getIncomingCall();
506 }
507 } else if (newState == InCallPresenter.InCallState.OUTGOING) {
508 currentCall = primary = callList.getOutgoingCall();
509 } else if (newState == InCallPresenter.InCallState.PENDING_OUTGOING) {
510 currentCall = primary = callList.getPendingOutgoingCall();
511 } else if (newState == InCallPresenter.InCallState.INCALL) {
512 currentCall = primary = callList.getActiveCall();
513 }
514
linyuh183cb712017-12-27 17:02:37 -0800515 final boolean primaryChanged = !Objects.equals(primaryCall, primary);
Eric Erfanianccca3152017-02-22 16:32:36 -0800516 LogUtil.i(
517 "VideoCallPresenter.onStateChange",
518 "primaryChanged: %b, primary: %s, mPrimaryCall: %s",
519 primaryChanged,
520 primary,
linyuh183cb712017-12-27 17:02:37 -0800521 primaryCall);
Eric Erfanianccca3152017-02-22 16:32:36 -0800522 if (primaryChanged) {
523 onPrimaryCallChanged(primary);
linyuh183cb712017-12-27 17:02:37 -0800524 } else if (primaryCall != null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800525 updateVideoCall(primary);
526 }
527 updateCallCache(primary);
528
529 // If the call context changed, potentially exit fullscreen or schedule auto enter of
530 // fullscreen mode.
531 // If the current call context is no longer a video call, exit fullscreen mode.
532 maybeExitFullscreen(currentCall);
533 // Schedule auto-enter of fullscreen mode if the current call context is a video call
534 maybeAutoEnterFullscreen(currentCall);
535 }
536
537 /**
538 * Handles a change to the fullscreen mode of the app.
539 *
540 * @param isFullscreenMode {@code true} if the app is now fullscreen, {@code false} otherwise.
541 */
542 @Override
543 public void onFullscreenModeChanged(boolean isFullscreenMode) {
544 cancelAutoFullScreen();
linyuh183cb712017-12-27 17:02:37 -0800545 if (primaryCall != null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800546 updateFullscreenAndGreenScreenMode(
linyuh183cb712017-12-27 17:02:37 -0800547 primaryCall.getState(), primaryCall.getVideoTech().getSessionModificationState());
Eric Erfanianccca3152017-02-22 16:32:36 -0800548 } else {
wangqibb94ca62018-04-27 14:34:04 -0700549 updateFullscreenAndGreenScreenMode(
550 DialerCallState.INVALID, SessionModificationState.NO_REQUEST);
Eric Erfanianccca3152017-02-22 16:32:36 -0800551 }
552 }
553
554 private void checkForVideoStateChange(DialerCall call) {
555 final boolean shouldShowVideoUi = shouldShowVideoUiForCall(call);
linyuh183cb712017-12-27 17:02:37 -0800556 final boolean hasVideoStateChanged = currentVideoState != call.getVideoState();
Eric Erfanianccca3152017-02-22 16:32:36 -0800557
558 LogUtil.v(
559 "VideoCallPresenter.checkForVideoStateChange",
560 "shouldShowVideoUi: %b, hasVideoStateChanged: %b, isVideoMode: %b, previousVideoState: %s,"
561 + " newVideoState: %s",
562 shouldShowVideoUi,
563 hasVideoStateChanged,
564 isVideoMode(),
linyuh183cb712017-12-27 17:02:37 -0800565 VideoProfile.videoStateToString(currentVideoState),
Eric Erfanianccca3152017-02-22 16:32:36 -0800566 VideoProfile.videoStateToString(call.getVideoState()));
567 if (!hasVideoStateChanged) {
568 return;
569 }
570
571 updateCameraSelection(call);
572
573 if (shouldShowVideoUi) {
574 adjustVideoMode(call);
575 } else if (isVideoMode()) {
576 exitVideoMode();
577 }
578 }
579
580 private void checkForCallStateChange(DialerCall call) {
581 final boolean shouldShowVideoUi = shouldShowVideoUiForCall(call);
582 final boolean hasCallStateChanged =
linyuh183cb712017-12-27 17:02:37 -0800583 currentCallState != call.getState() || isRemotelyHeld != call.isRemotelyHeld();
584 isRemotelyHeld = call.isRemotelyHeld();
Eric Erfanianccca3152017-02-22 16:32:36 -0800585
586 LogUtil.v(
587 "VideoCallPresenter.checkForCallStateChange",
588 "shouldShowVideoUi: %b, hasCallStateChanged: %b, isVideoMode: %b",
589 shouldShowVideoUi,
590 hasCallStateChanged,
591 isVideoMode());
592
593 if (!hasCallStateChanged) {
594 return;
595 }
596
597 if (shouldShowVideoUi) {
598 final InCallCameraManager cameraManager =
599 InCallPresenter.getInstance().getInCallCameraManager();
600
601 String prevCameraId = cameraManager.getActiveCameraId();
602 updateCameraSelection(call);
603 String newCameraId = cameraManager.getActiveCameraId();
604
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700605 if (!Objects.equals(prevCameraId, newCameraId) && isActiveVideoCall(call)) {
roldenburgca475472017-10-25 13:00:42 -0700606 enableCamera(call, true);
Eric Erfanianccca3152017-02-22 16:32:36 -0800607 }
608 }
609
610 // Make sure we hide or show the video UI if needed.
611 showVideoUi(
612 call.getVideoState(),
613 call.getState(),
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700614 call.getVideoTech().getSessionModificationState(),
Eric Erfanianccca3152017-02-22 16:32:36 -0800615 call.isRemotelyHeld());
616 }
617
618 private void onPrimaryCallChanged(DialerCall newPrimaryCall) {
619 final boolean shouldShowVideoUi = shouldShowVideoUiForCall(newPrimaryCall);
620 final boolean isVideoMode = isVideoMode();
621
622 LogUtil.v(
623 "VideoCallPresenter.onPrimaryCallChanged",
624 "shouldShowVideoUi: %b, isVideoMode: %b",
625 shouldShowVideoUi,
626 isVideoMode);
627
628 if (!shouldShowVideoUi && isVideoMode) {
629 // Terminate video mode if new primary call is not a video call
630 // and we are currently in video mode.
631 LogUtil.i("VideoCallPresenter.onPrimaryCallChanged", "exiting video mode...");
632 exitVideoMode();
633 } else if (shouldShowVideoUi) {
634 LogUtil.i("VideoCallPresenter.onPrimaryCallChanged", "entering video mode...");
635
636 updateCameraSelection(newPrimaryCall);
637 adjustVideoMode(newPrimaryCall);
638 }
639 checkForOrientationAllowedChange(newPrimaryCall);
640 }
641
642 private boolean isVideoMode() {
linyuh183cb712017-12-27 17:02:37 -0800643 return isVideoMode;
Eric Erfanianccca3152017-02-22 16:32:36 -0800644 }
645
646 private void updateCallCache(DialerCall call) {
647 if (call == null) {
linyuh183cb712017-12-27 17:02:37 -0800648 currentVideoState = VideoProfile.STATE_AUDIO_ONLY;
wangqibb94ca62018-04-27 14:34:04 -0700649 currentCallState = DialerCallState.INVALID;
linyuh183cb712017-12-27 17:02:37 -0800650 videoCall = null;
651 primaryCall = null;
Eric Erfanianccca3152017-02-22 16:32:36 -0800652 } else {
linyuh183cb712017-12-27 17:02:37 -0800653 currentVideoState = call.getVideoState();
654 videoCall = call.getVideoCall();
655 currentCallState = call.getState();
656 primaryCall = call;
Eric Erfanianccca3152017-02-22 16:32:36 -0800657 }
658 }
659
660 /**
661 * Handles changes to the details of the call. The {@link VideoCallPresenter} is interested in
662 * changes to the video state.
663 *
664 * @param call The call for which the details changed.
665 * @param details The new call details.
666 */
667 @Override
668 public void onDetailsChanged(DialerCall call, android.telecom.Call.Details details) {
669 LogUtil.v(
670 "VideoCallPresenter.onDetailsChanged",
671 "call: %s, details: %s, mPrimaryCall: %s",
672 call,
673 details,
linyuh183cb712017-12-27 17:02:37 -0800674 primaryCall);
Eric Erfanianccca3152017-02-22 16:32:36 -0800675 if (call == null) {
676 return;
677 }
678 // If the details change is not for the currently active call no update is required.
linyuh183cb712017-12-27 17:02:37 -0800679 if (!call.equals(primaryCall)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800680 LogUtil.v("VideoCallPresenter.onDetailsChanged", "details not for current active call");
681 return;
682 }
683
684 updateVideoCall(call);
685
686 updateCallCache(call);
687 }
688
689 private void updateVideoCall(DialerCall call) {
690 checkForVideoCallChange(call);
691 checkForVideoStateChange(call);
692 checkForCallStateChange(call);
693 checkForOrientationAllowedChange(call);
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700694 updateFullscreenAndGreenScreenMode(
695 call.getState(), call.getVideoTech().getSessionModificationState());
Eric Erfanianccca3152017-02-22 16:32:36 -0800696 }
697
698 private void checkForOrientationAllowedChange(@Nullable DialerCall call) {
wangqi4a22adb2018-06-18 13:18:06 -0700699 // Call could be null when video call ended. This check could prevent unwanted orientation
700 // change before incall UI gets destroyed.
701 if (call != null) {
702 InCallPresenter.getInstance()
703 .setInCallAllowsOrientationChange(isVideoCall(call) || isVideoUpgrade(call));
704 }
Eric Erfanianccca3152017-02-22 16:32:36 -0800705 }
706
707 private void updateFullscreenAndGreenScreenMode(
708 int callState, @SessionModificationState int sessionModificationState) {
linyuh183cb712017-12-27 17:02:37 -0800709 if (videoCallScreen != null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800710 boolean shouldShowFullscreen = InCallPresenter.getInstance().isFullscreen();
711 boolean shouldShowGreenScreen =
wangqibb94ca62018-04-27 14:34:04 -0700712 callState == DialerCallState.DIALING
713 || callState == DialerCallState.CONNECTING
714 || callState == DialerCallState.INCOMING
Eric Erfanianccca3152017-02-22 16:32:36 -0800715 || isVideoUpgrade(sessionModificationState);
linyuh183cb712017-12-27 17:02:37 -0800716 videoCallScreen.updateFullscreenAndGreenScreenMode(
Eric Erfanianccca3152017-02-22 16:32:36 -0800717 shouldShowFullscreen, shouldShowGreenScreen);
718 }
719 }
720
721 /** Checks for a change to the video call and changes it if required. */
722 private void checkForVideoCallChange(DialerCall call) {
723 final VideoCall videoCall = call.getVideoCall();
724 LogUtil.v(
725 "VideoCallPresenter.checkForVideoCallChange",
726 "videoCall: %s, mVideoCall: %s",
727 videoCall,
linyuh183cb712017-12-27 17:02:37 -0800728 this.videoCall);
729 if (!Objects.equals(videoCall, this.videoCall)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800730 changeVideoCall(call);
731 }
732 }
733
734 /**
735 * Handles a change to the video call. Sets the surfaces on the previous call to null and sets the
736 * surfaces on the new video call accordingly.
737 *
738 * @param call The new video call.
739 */
740 private void changeVideoCall(DialerCall call) {
741 final VideoCall videoCall = call == null ? null : call.getVideoCall();
742 LogUtil.i(
743 "VideoCallPresenter.changeVideoCall",
744 "videoCall: %s, mVideoCall: %s",
745 videoCall,
linyuh183cb712017-12-27 17:02:37 -0800746 this.videoCall);
747 final boolean hasChanged = this.videoCall == null && videoCall != null;
Eric Erfanianccca3152017-02-22 16:32:36 -0800748
linyuh183cb712017-12-27 17:02:37 -0800749 this.videoCall = videoCall;
750 if (this.videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800751 LogUtil.v("VideoCallPresenter.changeVideoCall", "video call or primary call is null. Return");
752 return;
753 }
754
755 if (shouldShowVideoUiForCall(call) && hasChanged) {
756 adjustVideoMode(call);
757 }
758 }
759
760 private boolean isCameraRequired() {
linyuh183cb712017-12-27 17:02:37 -0800761 return primaryCall != null
Eric Erfanianccca3152017-02-22 16:32:36 -0800762 && isCameraRequired(
linyuh183cb712017-12-27 17:02:37 -0800763 primaryCall.getVideoState(), primaryCall.getVideoTech().getSessionModificationState());
Eric Erfanianccca3152017-02-22 16:32:36 -0800764 }
765
766 /**
767 * Adjusts the current video mode by setting up the preview and display surfaces as necessary.
768 * Expected to be called whenever the video state associated with a call changes (e.g. a user
Eric Erfanian2ca43182017-08-31 06:57:16 -0700769 * turns their camera on or off) to ensure the correct surfaces are shown/hidden. TODO(vt): Need
Eric Erfanianccca3152017-02-22 16:32:36 -0800770 * to adjust size and orientation of preview surface here.
771 */
772 private void adjustVideoMode(DialerCall call) {
773 VideoCall videoCall = call.getVideoCall();
774 int newVideoState = call.getVideoState();
775
776 LogUtil.i(
777 "VideoCallPresenter.adjustVideoMode",
778 "videoCall: %s, videoState: %d",
779 videoCall,
780 newVideoState);
linyuh183cb712017-12-27 17:02:37 -0800781 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800782 LogUtil.e("VideoCallPresenter.adjustVideoMode", "error VideoCallScreen is null so returning");
783 return;
784 }
785
786 showVideoUi(
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700787 newVideoState,
788 call.getState(),
789 call.getVideoTech().getSessionModificationState(),
790 call.isRemotelyHeld());
Eric Erfanianccca3152017-02-22 16:32:36 -0800791
792 // Communicate the current camera to telephony and make a request for the camera
793 // capabilities.
794 if (videoCall != null) {
795 Surface surface = getRemoteVideoSurfaceTexture().getSavedSurface();
796 if (surface != null) {
797 LogUtil.v(
798 "VideoCallPresenter.adjustVideoMode", "calling setDisplaySurface with: " + surface);
799 videoCall.setDisplaySurface(surface);
800 }
801
802 Assert.checkState(
linyuh183cb712017-12-27 17:02:37 -0800803 deviceOrientation != InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN);
804 videoCall.setDeviceOrientation(deviceOrientation);
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700805 enableCamera(
roldenburgca475472017-10-25 13:00:42 -0700806 call, isCameraRequired(newVideoState, call.getVideoTech().getSessionModificationState()));
Eric Erfanianccca3152017-02-22 16:32:36 -0800807 }
linyuh183cb712017-12-27 17:02:37 -0800808 int previousVideoState = currentVideoState;
809 currentVideoState = newVideoState;
810 isVideoMode = true;
Eric Erfanianccca3152017-02-22 16:32:36 -0800811
812 // adjustVideoMode may be called if we are already in a 1-way video state. In this case
813 // we do not want to trigger auto-fullscreen mode.
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700814 if (!isVideoCall(previousVideoState) && isVideoCall(newVideoState)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800815 maybeAutoEnterFullscreen(call);
816 }
817 }
818
819 private static boolean shouldShowVideoUiForCall(@Nullable DialerCall call) {
820 if (call == null) {
821 return false;
822 }
823
Eric Erfaniand5e47f62017-03-15 14:41:07 -0700824 if (isVideoCall(call)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800825 return true;
826 }
827
828 if (isVideoUpgrade(call)) {
829 return true;
830 }
831
832 return false;
833 }
834
roldenburgca475472017-10-25 13:00:42 -0700835 private void enableCamera(DialerCall call, boolean isCameraRequired) {
836 LogUtil.v("VideoCallPresenter.enableCamera", "call: %s, enabling: %b", call, isCameraRequired);
837 if (call == null) {
838 LogUtil.i("VideoCallPresenter.enableCamera", "call is null");
Eric Erfanianccca3152017-02-22 16:32:36 -0800839 return;
840 }
841
linyuh183cb712017-12-27 17:02:37 -0800842 boolean hasCameraPermission = VideoUtils.hasCameraPermissionAndShownPrivacyToast(context);
Eric Erfanianccca3152017-02-22 16:32:36 -0800843 if (!hasCameraPermission) {
roldenburgca475472017-10-25 13:00:42 -0700844 call.getVideoTech().setCamera(null);
linyuh183cb712017-12-27 17:02:37 -0800845 previewSurfaceState = PreviewSurfaceState.NONE;
Eric Erfanian938468d2017-10-24 14:05:52 -0700846 // TODO(wangqi): Inform remote party that the video is off. This is similar to a bug.
Eric Erfanianccca3152017-02-22 16:32:36 -0800847 } else if (isCameraRequired) {
848 InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager();
roldenburgca475472017-10-25 13:00:42 -0700849 call.getVideoTech().setCamera(cameraManager.getActiveCameraId());
linyuh183cb712017-12-27 17:02:37 -0800850 previewSurfaceState = PreviewSurfaceState.CAMERA_SET;
Eric Erfanianccca3152017-02-22 16:32:36 -0800851 } else {
linyuh183cb712017-12-27 17:02:37 -0800852 previewSurfaceState = PreviewSurfaceState.NONE;
roldenburgca475472017-10-25 13:00:42 -0700853 call.getVideoTech().setCamera(null);
Eric Erfanianccca3152017-02-22 16:32:36 -0800854 }
855 }
856
857 /** Exits video mode by hiding the video surfaces and making other adjustments (eg. audio). */
858 private void exitVideoMode() {
859 LogUtil.i("VideoCallPresenter.exitVideoMode", "");
860
861 showVideoUi(
862 VideoProfile.STATE_AUDIO_ONLY,
wangqibb94ca62018-04-27 14:34:04 -0700863 DialerCallState.ACTIVE,
Eric Erfanian90508232017-03-24 09:31:16 -0700864 SessionModificationState.NO_REQUEST,
Eric Erfanianccca3152017-02-22 16:32:36 -0800865 false /* isRemotelyHeld */);
linyuh183cb712017-12-27 17:02:37 -0800866 enableCamera(primaryCall, false);
Eric Erfanianccca3152017-02-22 16:32:36 -0800867 InCallPresenter.getInstance().setFullScreen(false);
Eric Erfanian2ca43182017-08-31 06:57:16 -0700868 InCallPresenter.getInstance().enableScreenTimeout(false);
linyuh183cb712017-12-27 17:02:37 -0800869 isVideoMode = false;
Eric Erfanianccca3152017-02-22 16:32:36 -0800870 }
871
872 /**
873 * Based on the current video state and call state, show or hide the incoming and outgoing video
874 * surfaces. The outgoing video surface is shown any time video is transmitting. The incoming
875 * video surface is shown whenever the video is un-paused and active.
876 *
877 * @param videoState The video state.
878 * @param callState The call state.
879 */
880 private void showVideoUi(
881 int videoState,
882 int callState,
883 @SessionModificationState int sessionModificationState,
884 boolean isRemotelyHeld) {
linyuh183cb712017-12-27 17:02:37 -0800885 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800886 LogUtil.e("VideoCallPresenter.showVideoUi", "videoCallScreen is null returning");
887 return;
888 }
889 boolean showIncomingVideo = showIncomingVideo(videoState, callState);
linyuh183cb712017-12-27 17:02:37 -0800890 boolean showOutgoingVideo = showOutgoingVideo(context, videoState, sessionModificationState);
Eric Erfanianccca3152017-02-22 16:32:36 -0800891 LogUtil.i(
892 "VideoCallPresenter.showVideoUi",
893 "showIncoming: %b, showOutgoing: %b, isRemotelyHeld: %b",
894 showIncomingVideo,
895 showOutgoingVideo,
896 isRemotelyHeld);
897 updateRemoteVideoSurfaceDimensions();
linyuh183cb712017-12-27 17:02:37 -0800898 videoCallScreen.showVideoViews(showOutgoingVideo, showIncomingVideo, isRemotelyHeld);
Eric Erfanianccca3152017-02-22 16:32:36 -0800899
900 InCallPresenter.getInstance().enableScreenTimeout(VideoProfile.isAudioOnly(videoState));
901 updateFullscreenAndGreenScreenMode(callState, sessionModificationState);
902 }
903
904 /**
Eric Erfanianccca3152017-02-22 16:32:36 -0800905 * Handles peer video dimension changes.
906 *
907 * @param call The call which experienced a peer video dimension change.
908 * @param width The new peer video width .
909 * @param height The new peer video height.
910 */
911 @Override
912 public void onUpdatePeerDimensions(DialerCall call, int width, int height) {
913 LogUtil.i("VideoCallPresenter.onUpdatePeerDimensions", "width: %d, height: %d", width, height);
linyuh183cb712017-12-27 17:02:37 -0800914 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800915 LogUtil.e("VideoCallPresenter.onUpdatePeerDimensions", "videoCallScreen is null");
916 return;
917 }
linyuh183cb712017-12-27 17:02:37 -0800918 if (!call.equals(primaryCall)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800919 LogUtil.e(
920 "VideoCallPresenter.onUpdatePeerDimensions", "current call is not equal to primary");
921 return;
922 }
923
924 // Change size of display surface to match the peer aspect ratio
linyuh183cb712017-12-27 17:02:37 -0800925 if (width > 0 && height > 0 && videoCallScreen != null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800926 getRemoteVideoSurfaceTexture().setSourceVideoDimensions(new Point(width, height));
linyuh183cb712017-12-27 17:02:37 -0800927 videoCallScreen.onRemoteVideoDimensionsChanged();
Eric Erfanianccca3152017-02-22 16:32:36 -0800928 }
929 }
930
931 /**
Eric Erfanianccca3152017-02-22 16:32:36 -0800932 * Handles a change to the dimensions of the local camera. Receiving the camera capabilities
933 * triggers the creation of the video
934 *
935 * @param call The call which experienced the camera dimension change.
936 * @param width The new camera video width.
937 * @param height The new camera video height.
938 */
939 @Override
940 public void onCameraDimensionsChange(DialerCall call, int width, int height) {
941 LogUtil.i(
942 "VideoCallPresenter.onCameraDimensionsChange",
943 "call: %s, width: %d, height: %d",
944 call,
945 width,
946 height);
linyuh183cb712017-12-27 17:02:37 -0800947 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800948 LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "ui is null");
949 return;
950 }
951
linyuh183cb712017-12-27 17:02:37 -0800952 if (!call.equals(primaryCall)) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800953 LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "not the primary call");
954 return;
955 }
956
linyuh183cb712017-12-27 17:02:37 -0800957 previewSurfaceState = PreviewSurfaceState.CAPABILITIES_RECEIVED;
Eric Erfanianccca3152017-02-22 16:32:36 -0800958 changePreviewDimensions(width, height);
959
960 // Check if the preview surface is ready yet; if it is, set it on the {@code VideoCall}.
961 // If it not yet ready, it will be set when when creation completes.
962 Surface surface = getLocalVideoSurfaceTexture().getSavedSurface();
963 if (surface != null) {
linyuh183cb712017-12-27 17:02:37 -0800964 previewSurfaceState = PreviewSurfaceState.SURFACE_SET;
965 videoCall.setPreviewSurface(surface);
Eric Erfanianccca3152017-02-22 16:32:36 -0800966 }
967 }
968
969 /**
970 * Changes the dimensions of the preview surface.
971 *
972 * @param width The new width.
973 * @param height The new height.
974 */
975 private void changePreviewDimensions(int width, int height) {
linyuh183cb712017-12-27 17:02:37 -0800976 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -0800977 return;
978 }
979
980 // Resize the surface used to display the preview video
981 getLocalVideoSurfaceTexture().setSurfaceDimensions(new Point(width, height));
linyuh183cb712017-12-27 17:02:37 -0800982 videoCallScreen.onLocalVideoDimensionsChanged();
Eric Erfanianccca3152017-02-22 16:32:36 -0800983 }
984
985 /**
Eric Erfanianccca3152017-02-22 16:32:36 -0800986 * Handles changes to the device orientation.
987 *
988 * @param orientation The screen orientation of the device (one of: {@link
989 * InCallOrientationEventListener#SCREEN_ORIENTATION_0}, {@link
990 * InCallOrientationEventListener#SCREEN_ORIENTATION_90}, {@link
991 * InCallOrientationEventListener#SCREEN_ORIENTATION_180}, {@link
992 * InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
993 */
994 @Override
995 public void onDeviceOrientationChanged(int orientation) {
996 LogUtil.i(
997 "VideoCallPresenter.onDeviceOrientationChanged",
998 "orientation: %d -> %d",
linyuh183cb712017-12-27 17:02:37 -0800999 deviceOrientation,
Eric Erfanianccca3152017-02-22 16:32:36 -08001000 orientation);
linyuh183cb712017-12-27 17:02:37 -08001001 deviceOrientation = orientation;
Eric Erfanianccca3152017-02-22 16:32:36 -08001002
linyuh183cb712017-12-27 17:02:37 -08001003 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001004 LogUtil.e("VideoCallPresenter.onDeviceOrientationChanged", "videoCallScreen is null");
1005 return;
1006 }
1007
1008 Point previewDimensions = getLocalVideoSurfaceTexture().getSurfaceDimensions();
1009 if (previewDimensions == null) {
1010 return;
1011 }
1012 LogUtil.v(
1013 "VideoCallPresenter.onDeviceOrientationChanged",
1014 "orientation: %d, size: %s",
1015 orientation,
1016 previewDimensions);
1017 changePreviewDimensions(previewDimensions.x, previewDimensions.y);
1018
linyuh183cb712017-12-27 17:02:37 -08001019 videoCallScreen.onLocalVideoOrientationChanged();
Eric Erfanianccca3152017-02-22 16:32:36 -08001020 }
1021
1022 /**
1023 * Exits fullscreen mode if the current call context has changed to a non-video call.
1024 *
1025 * @param call The call.
1026 */
1027 protected void maybeExitFullscreen(DialerCall call) {
1028 if (call == null) {
1029 return;
1030 }
1031
wangqibb94ca62018-04-27 14:34:04 -07001032 if (!isVideoCall(call) || call.getState() == DialerCallState.INCOMING) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001033 LogUtil.i("VideoCallPresenter.maybeExitFullscreen", "exiting fullscreen");
1034 InCallPresenter.getInstance().setFullScreen(false);
1035 }
1036 }
1037
1038 /**
1039 * Schedules auto-entering of fullscreen mode. Will not enter full screen mode if any of the
1040 * following conditions are met: 1. No call 2. DialerCall is not active 3. The current video state
1041 * is not bi-directional. 4. Already in fullscreen mode 5. In accessibility mode
1042 *
1043 * @param call The current call.
1044 */
1045 protected void maybeAutoEnterFullscreen(DialerCall call) {
linyuh183cb712017-12-27 17:02:37 -08001046 if (!isAutoFullscreenEnabled) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001047 return;
1048 }
1049
1050 if (call == null
wangqibb94ca62018-04-27 14:34:04 -07001051 || call.getState() != DialerCallState.ACTIVE
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001052 || !isBidirectionalVideoCall(call)
Eric Erfanianccca3152017-02-22 16:32:36 -08001053 || InCallPresenter.getInstance().isFullscreen()
linyuh183cb712017-12-27 17:02:37 -08001054 || (context != null && AccessibilityUtil.isTouchExplorationEnabled(context))) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001055 // Ensure any previously scheduled attempt to enter fullscreen is cancelled.
1056 cancelAutoFullScreen();
1057 return;
1058 }
1059
linyuh183cb712017-12-27 17:02:37 -08001060 if (autoFullScreenPending) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001061 LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "already pending.");
1062 return;
1063 }
1064 LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "scheduled");
linyuh183cb712017-12-27 17:02:37 -08001065 autoFullScreenPending = true;
1066 handler.removeCallbacks(autoFullscreenRunnable);
1067 handler.postDelayed(autoFullscreenRunnable, autoFullscreenTimeoutMillis);
Eric Erfanianccca3152017-02-22 16:32:36 -08001068 }
1069
1070 /** Cancels pending auto fullscreen mode. */
1071 @Override
1072 public void cancelAutoFullScreen() {
linyuh183cb712017-12-27 17:02:37 -08001073 if (!autoFullScreenPending) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001074 LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "none pending.");
1075 return;
1076 }
1077 LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "cancelling pending");
linyuh183cb712017-12-27 17:02:37 -08001078 autoFullScreenPending = false;
1079 handler.removeCallbacks(autoFullscreenRunnable);
Eric Erfanianccca3152017-02-22 16:32:36 -08001080 }
1081
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001082 @Override
Eric Erfanian2ca43182017-08-31 06:57:16 -07001083 public boolean shouldShowCameraPermissionToast() {
linyuh183cb712017-12-27 17:02:37 -08001084 if (primaryCall == null) {
Eric Erfanian2ca43182017-08-31 06:57:16 -07001085 LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionToast", "null call");
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001086 return false;
1087 }
linyuh183cb712017-12-27 17:02:37 -08001088 if (primaryCall.didShowCameraPermission()) {
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001089 LogUtil.i(
Eric Erfanian2ca43182017-08-31 06:57:16 -07001090 "VideoCallPresenter.shouldShowCameraPermissionToast", "already shown for this call");
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001091 return false;
1092 }
zachh190343a2018-05-31 17:30:46 -07001093 if (!ConfigProviderComponent.get(context)
1094 .getConfigProvider()
1095 .getBoolean("camera_permission_dialog_allowed", true)) {
Eric Erfanian2ca43182017-08-31 06:57:16 -07001096 LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionToast", "disabled by config");
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001097 return false;
1098 }
linyuh183cb712017-12-27 17:02:37 -08001099 return !VideoUtils.hasCameraPermission(context)
1100 || !PermissionsUtil.hasCameraPrivacyToastShown(context);
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001101 }
1102
1103 @Override
1104 public void onCameraPermissionDialogShown() {
linyuh183cb712017-12-27 17:02:37 -08001105 if (primaryCall != null) {
1106 primaryCall.setDidShowCameraPermission(true);
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001107 }
1108 }
1109
Eric Erfanianccca3152017-02-22 16:32:36 -08001110 private void updateRemoteVideoSurfaceDimensions() {
linyuh183cb712017-12-27 17:02:37 -08001111 Activity activity = videoCallScreen.getVideoCallScreenFragment().getActivity();
Eric Erfanianccca3152017-02-22 16:32:36 -08001112 if (activity != null) {
1113 Point screenSize = new Point();
1114 activity.getWindowManager().getDefaultDisplay().getSize(screenSize);
1115 getRemoteVideoSurfaceTexture().setSurfaceDimensions(screenSize);
1116 }
1117 }
1118
1119 private static boolean isVideoUpgrade(DialerCall call) {
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001120 return call != null
1121 && (call.hasSentVideoUpgradeRequest() || call.hasReceivedVideoUpgradeRequest());
Eric Erfanianccca3152017-02-22 16:32:36 -08001122 }
1123
1124 private static boolean isVideoUpgrade(@SessionModificationState int state) {
1125 return VideoUtils.hasSentVideoUpgradeRequest(state)
1126 || VideoUtils.hasReceivedVideoUpgradeRequest(state);
1127 }
1128
wangqida410d32018-03-06 16:51:38 -08001129 @Override
1130 public void onIncomingCall(DialerCall call) {}
1131
1132 @Override
1133 public void onUpgradeToVideo(DialerCall call) {}
1134
1135 @Override
1136 public void onSessionModificationStateChange(DialerCall call) {}
1137
1138 @Override
1139 public void onCallListChange(CallList callList) {}
1140
1141 @Override
1142 public void onDisconnect(DialerCall call) {}
1143
1144 @Override
1145 public void onWiFiToLteHandover(DialerCall call) {
1146 if (call.isVideoCall() || call.hasSentVideoUpgradeRequest()) {
1147 videoCallScreen.onHandoverFromWiFiToLte();
1148 }
1149 }
1150
1151 @Override
1152 public void onHandoverToWifiFailed(DialerCall call) {}
1153
1154 @Override
1155 public void onInternationalCallOnWifi(@NonNull DialerCall call) {}
1156
Eric Erfanianccca3152017-02-22 16:32:36 -08001157 private class LocalDelegate implements VideoSurfaceDelegate {
1158 @Override
1159 public void onSurfaceCreated(VideoSurfaceTexture videoCallSurface) {
linyuh183cb712017-12-27 17:02:37 -08001160 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001161 LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceCreated", "no UI");
1162 return;
1163 }
linyuh183cb712017-12-27 17:02:37 -08001164 if (videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001165 LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceCreated", "no video call");
1166 return;
1167 }
1168
1169 // If the preview surface has just been created and we have already received camera
1170 // capabilities, but not yet set the surface, we will set the surface now.
linyuh183cb712017-12-27 17:02:37 -08001171 if (previewSurfaceState == PreviewSurfaceState.CAPABILITIES_RECEIVED) {
1172 previewSurfaceState = PreviewSurfaceState.SURFACE_SET;
1173 videoCall.setPreviewSurface(videoCallSurface.getSavedSurface());
1174 } else if (previewSurfaceState == PreviewSurfaceState.NONE && isCameraRequired()) {
1175 enableCamera(primaryCall, true);
Eric Erfanianccca3152017-02-22 16:32:36 -08001176 }
1177 }
1178
1179 @Override
1180 public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) {
linyuh183cb712017-12-27 17:02:37 -08001181 if (videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001182 LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceReleased", "no video call");
1183 return;
1184 }
1185
linyuh183cb712017-12-27 17:02:37 -08001186 videoCall.setPreviewSurface(null);
1187 enableCamera(primaryCall, false);
Eric Erfanianccca3152017-02-22 16:32:36 -08001188 }
1189
1190 @Override
1191 public void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface) {
linyuh183cb712017-12-27 17:02:37 -08001192 if (videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001193 LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceDestroyed", "no video call");
1194 return;
1195 }
1196
1197 boolean isChangingConfigurations = InCallPresenter.getInstance().isChangingConfigurations();
1198 if (!isChangingConfigurations) {
linyuh183cb712017-12-27 17:02:37 -08001199 enableCamera(primaryCall, false);
Eric Erfanianccca3152017-02-22 16:32:36 -08001200 } else {
1201 LogUtil.i(
1202 "VideoCallPresenter.LocalDelegate.onSurfaceDestroyed",
1203 "activity is being destroyed due to configuration changes. Not closing the camera.");
1204 }
1205 }
1206
1207 @Override
1208 public void onSurfaceClick(VideoSurfaceTexture videoCallSurface) {
1209 VideoCallPresenter.this.onSurfaceClick();
1210 }
1211 }
1212
1213 private class RemoteDelegate implements VideoSurfaceDelegate {
1214 @Override
1215 public void onSurfaceCreated(VideoSurfaceTexture videoCallSurface) {
linyuh183cb712017-12-27 17:02:37 -08001216 if (videoCallScreen == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001217 LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no UI");
1218 return;
1219 }
linyuh183cb712017-12-27 17:02:37 -08001220 if (videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001221 LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no video call");
1222 return;
1223 }
linyuh183cb712017-12-27 17:02:37 -08001224 videoCall.setDisplaySurface(videoCallSurface.getSavedSurface());
Eric Erfanianccca3152017-02-22 16:32:36 -08001225 }
1226
1227 @Override
1228 public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) {
linyuh183cb712017-12-27 17:02:37 -08001229 if (videoCall == null) {
Eric Erfanianccca3152017-02-22 16:32:36 -08001230 LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceReleased", "no video call");
1231 return;
1232 }
linyuh183cb712017-12-27 17:02:37 -08001233 videoCall.setDisplaySurface(null);
Eric Erfanianccca3152017-02-22 16:32:36 -08001234 }
1235
1236 @Override
1237 public void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface) {}
1238
1239 @Override
1240 public void onSurfaceClick(VideoSurfaceTexture videoCallSurface) {
1241 VideoCallPresenter.this.onSurfaceClick();
1242 }
1243 }
1244
1245 /** Defines the state of the preview surface negotiation with the telephony layer. */
1246 private static class PreviewSurfaceState {
1247
1248 /**
1249 * The camera has not yet been set on the {@link VideoCall}; negotiation has not yet started.
1250 */
1251 private static final int NONE = 0;
1252
1253 /**
1254 * The camera has been set on the {@link VideoCall}, but camera capabilities have not yet been
1255 * received.
1256 */
1257 private static final int CAMERA_SET = 1;
1258
1259 /**
1260 * The camera capabilties have been received from telephony, but the surface has not yet been
1261 * set on the {@link VideoCall}.
1262 */
1263 private static final int CAPABILITIES_RECEIVED = 2;
1264
1265 /** The surface has been set on the {@link VideoCall}. */
1266 private static final int SURFACE_SET = 3;
1267 }
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001268
1269 private static boolean isBidirectionalVideoCall(DialerCall call) {
linyuh122fb0b2018-03-26 13:35:32 -07001270 return VideoProfile.isBidirectional(call.getVideoState());
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001271 }
1272
1273 private static boolean isIncomingVideoCall(DialerCall call) {
1274 if (!isVideoCall(call)) {
1275 return false;
1276 }
1277 final int state = call.getState();
wangqibb94ca62018-04-27 14:34:04 -07001278 return (state == DialerCallState.INCOMING) || (state == DialerCallState.CALL_WAITING);
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001279 }
1280
1281 private static boolean isActiveVideoCall(DialerCall call) {
wangqibb94ca62018-04-27 14:34:04 -07001282 return isVideoCall(call) && call.getState() == DialerCallState.ACTIVE;
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001283 }
1284
1285 private static boolean isOutgoingVideoCall(DialerCall call) {
1286 if (!isVideoCall(call)) {
1287 return false;
1288 }
1289 final int state = call.getState();
wangqibb94ca62018-04-27 14:34:04 -07001290 return DialerCallState.isDialing(state)
1291 || state == DialerCallState.CONNECTING
1292 || state == DialerCallState.SELECT_PHONE_ACCOUNT;
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001293 }
1294
1295 private static boolean isAudioCall(DialerCall call) {
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001296 return call != null && VideoProfile.isAudioOnly(call.getVideoState());
1297 }
1298
1299 private static boolean isVideoCall(@Nullable DialerCall call) {
1300 return call != null && call.isVideoCall();
1301 }
1302
1303 private static boolean isVideoCall(int videoState) {
linyuh122fb0b2018-03-26 13:35:32 -07001304 return VideoProfile.isTransmissionEnabled(videoState)
1305 || VideoProfile.isReceptionEnabled(videoState);
Eric Erfaniand5e47f62017-03-15 14:41:07 -07001306 }
Eric Erfanianccca3152017-02-22 16:32:36 -08001307}