Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1 | /* |
| 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 | |
| 17 | package com.android.incallui; |
| 18 | |
| 19 | import android.app.Activity; |
| 20 | import android.content.Context; |
| 21 | import android.graphics.Point; |
| 22 | import android.os.Handler; |
wangqi | da410d3 | 2018-03-06 16:51:38 -0800 | [diff] [blame] | 23 | import android.support.annotation.NonNull; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 24 | import android.support.annotation.Nullable; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 25 | import android.telecom.InCallService.VideoCall; |
| 26 | import android.telecom.VideoProfile; |
| 27 | import android.telecom.VideoProfile.CameraCapabilities; |
| 28 | import android.view.Surface; |
Eric Erfanian | 9050823 | 2017-03-24 09:31:16 -0700 | [diff] [blame] | 29 | import android.view.SurfaceView; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 30 | import com.android.dialer.common.Assert; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 31 | import com.android.dialer.common.LogUtil; |
zachh | 190343a | 2018-05-31 17:30:46 -0700 | [diff] [blame] | 32 | import com.android.dialer.configprovider.ConfigProviderComponent; |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 33 | import com.android.dialer.util.PermissionsUtil; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 34 | import com.android.incallui.InCallPresenter.InCallDetailsListener; |
| 35 | import com.android.incallui.InCallPresenter.InCallOrientationListener; |
| 36 | import com.android.incallui.InCallPresenter.InCallStateListener; |
| 37 | import com.android.incallui.InCallPresenter.IncomingCallListener; |
| 38 | import com.android.incallui.call.CallList; |
| 39 | import com.android.incallui.call.DialerCall; |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 40 | import com.android.incallui.call.DialerCall.CameraDirection; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 41 | import com.android.incallui.call.InCallVideoCallCallbackNotifier; |
| 42 | import com.android.incallui.call.InCallVideoCallCallbackNotifier.SurfaceChangeListener; |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 43 | import com.android.incallui.call.state.DialerCallState; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 44 | import com.android.incallui.util.AccessibilityUtil; |
| 45 | import com.android.incallui.video.protocol.VideoCallScreen; |
| 46 | import com.android.incallui.video.protocol.VideoCallScreenDelegate; |
| 47 | import com.android.incallui.videosurface.protocol.VideoSurfaceDelegate; |
| 48 | import com.android.incallui.videosurface.protocol.VideoSurfaceTexture; |
Eric Erfanian | 9050823 | 2017-03-24 09:31:16 -0700 | [diff] [blame] | 49 | import com.android.incallui.videotech.utils.SessionModificationState; |
| 50 | import com.android.incallui.videotech.utils.VideoUtils; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 51 | import 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> |
wangqi | 385a5a1 | 2017-09-28 10:44:54 -0700 | [diff] [blame] | 63 | * <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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 71 | * </ul> |
| 72 | * |
| 73 | * <p>When downgrading to an audio-only video state, the {@code VideoCallPresenter} nulls both |
| 74 | * surfaces. |
| 75 | */ |
| 76 | public class VideoCallPresenter |
| 77 | implements IncomingCallListener, |
| 78 | InCallOrientationListener, |
| 79 | InCallStateListener, |
| 80 | InCallDetailsListener, |
| 81 | SurfaceChangeListener, |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 82 | InCallPresenter.InCallEventListener, |
wangqi | da410d3 | 2018-03-06 16:51:38 -0800 | [diff] [blame] | 83 | VideoCallScreenDelegate, |
| 84 | CallList.Listener { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 85 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 86 | private static boolean isVideoMode = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 87 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 88 | private final Handler handler = new Handler(); |
| 89 | private VideoCallScreen videoCallScreen; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 90 | |
| 91 | /** The current context. */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 92 | private Context context; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 93 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 94 | /** The call the video surfaces are currently related to */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 95 | private DialerCall primaryCall; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 96 | /** |
| 97 | * The {@link VideoCall} used to inform the video telephony layer of changes to the video |
| 98 | * surfaces. |
| 99 | */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 100 | private VideoCall videoCall; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 101 | /** Determines if the current UI state represents a video call. */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 102 | private int currentVideoState; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 103 | /** DialerCall's current state */ |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 104 | private int currentCallState = DialerCallState.INVALID; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 105 | /** Determines the device orientation (portrait/lanscape). */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 106 | private int deviceOrientation = InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 107 | /** Tracks the state of the preview surface negotiation with the telephony layer. */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 108 | private int previewSurfaceState = PreviewSurfaceState.NONE; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 109 | /** |
| 110 | * Determines whether video calls should automatically enter full screen mode after {@link |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 111 | * #autoFullscreenTimeoutMillis} milliseconds. |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 112 | */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 113 | private boolean isAutoFullscreenEnabled = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 114 | /** |
| 115 | * Determines the number of milliseconds after which a video call will automatically enter |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 116 | * fullscreen mode. Requires {@link #isAutoFullscreenEnabled} to be {@code true}. |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 117 | */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 118 | private int autoFullscreenTimeoutMillis = 0; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 119 | /** |
| 120 | * Determines if the countdown is currently running to automatically enter full screen video mode. |
| 121 | */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 122 | private boolean autoFullScreenPending = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 123 | /** Whether if the call is remotely held. */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 124 | private boolean isRemotelyHeld = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 125 | /** |
| 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 | */ |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 130 | private Runnable autoFullscreenRunnable = |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 131 | new Runnable() { |
| 132 | @Override |
| 133 | public void run() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 134 | if (autoFullScreenPending |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 135 | && !InCallPresenter.getInstance().isDialpadVisible() |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 136 | && isVideoMode) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 137 | |
| 138 | LogUtil.v("VideoCallPresenter.mAutoFullScreenRunnable", "entering fullscreen mode"); |
| 139 | InCallPresenter.getInstance().setFullScreen(true); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 140 | autoFullScreenPending = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 141 | } 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 Erfanian | d8046e5 | 2017-04-06 09:41:50 -0700 | [diff] [blame] | 159 | * 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 161 | * |
| 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 | */ |
linyuh | 122fb0b | 2018-03-26 13:35:32 -0700 | [diff] [blame] | 166 | static boolean showIncomingVideo(int videoState, int callState) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 167 | |
| 168 | boolean isPaused = VideoProfile.isPaused(videoState); |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 169 | boolean isCallActive = callState == DialerCallState.ACTIVE; |
wangqi | 385a5a1 | 2017-09-28 10:44:54 -0700 | [diff] [blame] | 170 | // Show incoming Video for dialing calls to support early media |
Eric Erfanian | d8046e5 | 2017-04-06 09:41:50 -0700 | [diff] [blame] | 171 | boolean isCallOutgoingPending = |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 172 | DialerCallState.isDialing(callState) || callState == DialerCallState.CONNECTING; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 173 | |
Eric Erfanian | d8046e5 | 2017-04-06 09:41:50 -0700 | [diff] [blame] | 174 | return !isPaused |
| 175 | && (isCallActive || isCallOutgoingPending) |
| 176 | && VideoProfile.isReceptionEnabled(videoState); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 177 | } |
| 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 | */ |
linyuh | 122fb0b | 2018-03-26 13:35:32 -0700 | [diff] [blame] | 186 | private static boolean showOutgoingVideo( |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 187 | Context context, int videoState, int sessionModificationState) { |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 188 | if (!VideoUtils.hasCameraPermissionAndShownPrivacyToast(context)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 189 | LogUtil.i("VideoCallPresenter.showOutgoingVideo", "Camera permission is disabled by user."); |
| 190 | return false; |
| 191 | } |
| 192 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 193 | 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 207 | cameraDir = CameraDirection.CAMERA_DIRECTION_UNKNOWN; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 208 | 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 214 | else if (isAudioCall(call) && !isVideoUpgrade(call)) { |
| 215 | cameraDir = CameraDirection.CAMERA_DIRECTION_UNKNOWN; |
| 216 | call.setCameraDir(cameraDir); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 217 | } |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 222 | else if (isVideoCall(activeCall) && isIncomingVideoCall(call)) { |
| 223 | cameraDir = activeCall.getCameraDir(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 224 | } |
| 225 | |
| 226 | // Infer the camera direction from the video state and store it, |
| 227 | // if this is an outgoing video call. |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 228 | else if (isOutgoingVideoCall(call) && !isCameraDirectionSet(call)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 229 | cameraDir = toCameraDirection(call.getVideoState()); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 230 | call.setCameraDir(cameraDir); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 231 | } |
| 232 | |
| 233 | // Use the stored camera dir if this is an outgoing video call for which camera direction |
| 234 | // is set. |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 235 | else if (isOutgoingVideoCall(call)) { |
| 236 | cameraDir = call.getCameraDir(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 237 | } |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 241 | else if (isActiveVideoCall(call) && !isCameraDirectionSet(call)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 242 | cameraDir = toCameraDirection(call.getVideoState()); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 243 | call.setCameraDir(cameraDir); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | // Use the stored camera dir if this is an active video call for which camera direction |
| 247 | // is set. |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 248 | else if (isActiveVideoCall(call)) { |
| 249 | cameraDir = call.getCameraDir(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 250 | } |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 265 | cameraDir == CameraDirection.CAMERA_DIRECTION_FRONT_FACING); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 266 | } |
| 267 | |
| 268 | private static int toCameraDirection(int videoState) { |
| 269 | return VideoProfile.isTransmissionEnabled(videoState) |
| 270 | && !VideoProfile.isBidirectional(videoState) |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 271 | ? CameraDirection.CAMERA_DIRECTION_BACK_FACING |
| 272 | : CameraDirection.CAMERA_DIRECTION_FRONT_FACING; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | private static boolean isCameraDirectionSet(DialerCall call) { |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 276 | return isVideoCall(call) && call.getCameraDir() != CameraDirection.CAMERA_DIRECTION_UNKNOWN; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 277 | } |
| 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 290 | 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 296 | } |
| 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 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 304 | deviceOrientation = InCallOrientationEventListener.getCurrentOrientation(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 305 | |
| 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 | |
wangqi | da410d3 | 2018-03-06 16:51:38 -0800 | [diff] [blame] | 316 | CallList.getInstance().addListener(this); |
| 317 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 318 | // Register for surface and video events from {@link InCallVideoCallListener}s. |
| 319 | InCallVideoCallCallbackNotifier.getInstance().addSurfaceChangeListener(this); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 320 | currentVideoState = VideoProfile.STATE_AUDIO_ONLY; |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 321 | currentCallState = DialerCallState.INVALID; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 322 | |
| 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 334 | 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 | |
wangqi | da410d3 | 2018-03-06 16:51:38 -0800 | [diff] [blame] | 343 | CallList.getInstance().removeListener(this); |
| 344 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 345 | InCallVideoCallCallbackNotifier.getInstance().removeSurfaceChangeListener(this); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 346 | |
| 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 Erfanian | 938468d | 2017-10-24 14:05:52 -0700 | [diff] [blame] | 349 | // we won't get any more call state changes. See a bug. |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 350 | if (primaryCall != null) { |
| 351 | updateCameraSelection(primaryCall); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 352 | } |
| 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); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 367 | maybeAutoEnterFullscreen(primaryCall); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 368 | // 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); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 382 | maybeAutoEnterFullscreen(primaryCall); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 383 | } |
| 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 Erfanian | 9050823 | 2017-03-24 09:31:16 -0700 | [diff] [blame] | 397 | public void setSurfaceViews(SurfaceView preview, SurfaceView remote) { |
| 398 | throw Assert.createUnsupportedOperationFailException(); |
| 399 | } |
| 400 | |
| 401 | @Override |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 402 | public int getDeviceOrientation() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 403 | return deviceOrientation; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 404 | } |
| 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", ""); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 413 | PermissionsUtil.setCameraPrivacyToastShown(context); |
| 414 | enableCamera(primaryCall, isCameraRequired()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 415 | showVideoUi( |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 416 | primaryCall.getVideoState(), |
| 417 | primaryCall.getState(), |
| 418 | primaryCall.getVideoTech().getSessionModificationState(), |
| 419 | primaryCall.isRemotelyHeld()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 420 | InCallPresenter.getInstance().getInCallCameraManager().onCameraPermissionGranted(); |
| 421 | } |
| 422 | |
Hideki Ishii | e39b926 | 2017-07-25 21:29:43 +0900 | [diff] [blame^] | 423 | @Override |
| 424 | public boolean isFullscreen() { |
| 425 | return InCallPresenter.getInstance().isFullscreen(); |
| 426 | } |
| 427 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 428 | /** |
| 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() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 434 | if (autoFullScreenPending) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 435 | LogUtil.i("VideoCallPresenter.resetAutoFullscreenTimer", "resetting"); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 436 | handler.removeCallbacks(autoFullscreenRunnable); |
| 437 | handler.postDelayed(autoFullscreenRunnable, autoFullscreenTimeoutMillis); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 438 | } |
| 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) { |
wangqi | 385a5a1 | 2017-09-28 10:44:54 -0700 | [diff] [blame] | 451 | // 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 458 | // 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 504 | if (!isActiveVideoCall(primary)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 505 | 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 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 515 | final boolean primaryChanged = !Objects.equals(primaryCall, primary); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 516 | LogUtil.i( |
| 517 | "VideoCallPresenter.onStateChange", |
| 518 | "primaryChanged: %b, primary: %s, mPrimaryCall: %s", |
| 519 | primaryChanged, |
| 520 | primary, |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 521 | primaryCall); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 522 | if (primaryChanged) { |
| 523 | onPrimaryCallChanged(primary); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 524 | } else if (primaryCall != null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 525 | 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(); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 545 | if (primaryCall != null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 546 | updateFullscreenAndGreenScreenMode( |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 547 | primaryCall.getState(), primaryCall.getVideoTech().getSessionModificationState()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 548 | } else { |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 549 | updateFullscreenAndGreenScreenMode( |
| 550 | DialerCallState.INVALID, SessionModificationState.NO_REQUEST); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 551 | } |
| 552 | } |
| 553 | |
| 554 | private void checkForVideoStateChange(DialerCall call) { |
| 555 | final boolean shouldShowVideoUi = shouldShowVideoUiForCall(call); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 556 | final boolean hasVideoStateChanged = currentVideoState != call.getVideoState(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 557 | |
| 558 | LogUtil.v( |
| 559 | "VideoCallPresenter.checkForVideoStateChange", |
| 560 | "shouldShowVideoUi: %b, hasVideoStateChanged: %b, isVideoMode: %b, previousVideoState: %s," |
| 561 | + " newVideoState: %s", |
| 562 | shouldShowVideoUi, |
| 563 | hasVideoStateChanged, |
| 564 | isVideoMode(), |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 565 | VideoProfile.videoStateToString(currentVideoState), |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 566 | 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 = |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 583 | currentCallState != call.getState() || isRemotelyHeld != call.isRemotelyHeld(); |
| 584 | isRemotelyHeld = call.isRemotelyHeld(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 585 | |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 605 | if (!Objects.equals(prevCameraId, newCameraId) && isActiveVideoCall(call)) { |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 606 | enableCamera(call, true); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 607 | } |
| 608 | } |
| 609 | |
| 610 | // Make sure we hide or show the video UI if needed. |
| 611 | showVideoUi( |
| 612 | call.getVideoState(), |
| 613 | call.getState(), |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 614 | call.getVideoTech().getSessionModificationState(), |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 615 | 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() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 643 | return isVideoMode; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | private void updateCallCache(DialerCall call) { |
| 647 | if (call == null) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 648 | currentVideoState = VideoProfile.STATE_AUDIO_ONLY; |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 649 | currentCallState = DialerCallState.INVALID; |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 650 | videoCall = null; |
| 651 | primaryCall = null; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 652 | } else { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 653 | currentVideoState = call.getVideoState(); |
| 654 | videoCall = call.getVideoCall(); |
| 655 | currentCallState = call.getState(); |
| 656 | primaryCall = call; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 657 | } |
| 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, |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 674 | primaryCall); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 675 | if (call == null) { |
| 676 | return; |
| 677 | } |
| 678 | // If the details change is not for the currently active call no update is required. |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 679 | if (!call.equals(primaryCall)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 680 | 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 694 | updateFullscreenAndGreenScreenMode( |
| 695 | call.getState(), call.getVideoTech().getSessionModificationState()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | private void checkForOrientationAllowedChange(@Nullable DialerCall call) { |
wangqi | 4a22adb | 2018-06-18 13:18:06 -0700 | [diff] [blame] | 699 | // 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 705 | } |
| 706 | |
| 707 | private void updateFullscreenAndGreenScreenMode( |
| 708 | int callState, @SessionModificationState int sessionModificationState) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 709 | if (videoCallScreen != null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 710 | boolean shouldShowFullscreen = InCallPresenter.getInstance().isFullscreen(); |
| 711 | boolean shouldShowGreenScreen = |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 712 | callState == DialerCallState.DIALING |
| 713 | || callState == DialerCallState.CONNECTING |
| 714 | || callState == DialerCallState.INCOMING |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 715 | || isVideoUpgrade(sessionModificationState); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 716 | videoCallScreen.updateFullscreenAndGreenScreenMode( |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 717 | 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, |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 728 | this.videoCall); |
| 729 | if (!Objects.equals(videoCall, this.videoCall)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 730 | 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, |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 746 | this.videoCall); |
| 747 | final boolean hasChanged = this.videoCall == null && videoCall != null; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 748 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 749 | this.videoCall = videoCall; |
| 750 | if (this.videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 751 | 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() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 761 | return primaryCall != null |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 762 | && isCameraRequired( |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 763 | primaryCall.getVideoState(), primaryCall.getVideoTech().getSessionModificationState()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 764 | } |
| 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 Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 769 | * turns their camera on or off) to ensure the correct surfaces are shown/hidden. TODO(vt): Need |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 770 | * 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); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 781 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 782 | LogUtil.e("VideoCallPresenter.adjustVideoMode", "error VideoCallScreen is null so returning"); |
| 783 | return; |
| 784 | } |
| 785 | |
| 786 | showVideoUi( |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 787 | newVideoState, |
| 788 | call.getState(), |
| 789 | call.getVideoTech().getSessionModificationState(), |
| 790 | call.isRemotelyHeld()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 791 | |
| 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( |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 803 | deviceOrientation != InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN); |
| 804 | videoCall.setDeviceOrientation(deviceOrientation); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 805 | enableCamera( |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 806 | call, isCameraRequired(newVideoState, call.getVideoTech().getSessionModificationState())); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 807 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 808 | int previousVideoState = currentVideoState; |
| 809 | currentVideoState = newVideoState; |
| 810 | isVideoMode = true; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 811 | |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 814 | if (!isVideoCall(previousVideoState) && isVideoCall(newVideoState)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 815 | maybeAutoEnterFullscreen(call); |
| 816 | } |
| 817 | } |
| 818 | |
| 819 | private static boolean shouldShowVideoUiForCall(@Nullable DialerCall call) { |
| 820 | if (call == null) { |
| 821 | return false; |
| 822 | } |
| 823 | |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 824 | if (isVideoCall(call)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 825 | return true; |
| 826 | } |
| 827 | |
| 828 | if (isVideoUpgrade(call)) { |
| 829 | return true; |
| 830 | } |
| 831 | |
| 832 | return false; |
| 833 | } |
| 834 | |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 835 | 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 839 | return; |
| 840 | } |
| 841 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 842 | boolean hasCameraPermission = VideoUtils.hasCameraPermissionAndShownPrivacyToast(context); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 843 | if (!hasCameraPermission) { |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 844 | call.getVideoTech().setCamera(null); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 845 | previewSurfaceState = PreviewSurfaceState.NONE; |
Eric Erfanian | 938468d | 2017-10-24 14:05:52 -0700 | [diff] [blame] | 846 | // TODO(wangqi): Inform remote party that the video is off. This is similar to a bug. |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 847 | } else if (isCameraRequired) { |
| 848 | InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager(); |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 849 | call.getVideoTech().setCamera(cameraManager.getActiveCameraId()); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 850 | previewSurfaceState = PreviewSurfaceState.CAMERA_SET; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 851 | } else { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 852 | previewSurfaceState = PreviewSurfaceState.NONE; |
roldenburg | ca47547 | 2017-10-25 13:00:42 -0700 | [diff] [blame] | 853 | call.getVideoTech().setCamera(null); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 854 | } |
| 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, |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 863 | DialerCallState.ACTIVE, |
Eric Erfanian | 9050823 | 2017-03-24 09:31:16 -0700 | [diff] [blame] | 864 | SessionModificationState.NO_REQUEST, |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 865 | false /* isRemotelyHeld */); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 866 | enableCamera(primaryCall, false); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 867 | InCallPresenter.getInstance().setFullScreen(false); |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 868 | InCallPresenter.getInstance().enableScreenTimeout(false); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 869 | isVideoMode = false; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 870 | } |
| 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 885 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 886 | LogUtil.e("VideoCallPresenter.showVideoUi", "videoCallScreen is null returning"); |
| 887 | return; |
| 888 | } |
| 889 | boolean showIncomingVideo = showIncomingVideo(videoState, callState); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 890 | boolean showOutgoingVideo = showOutgoingVideo(context, videoState, sessionModificationState); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 891 | LogUtil.i( |
| 892 | "VideoCallPresenter.showVideoUi", |
| 893 | "showIncoming: %b, showOutgoing: %b, isRemotelyHeld: %b", |
| 894 | showIncomingVideo, |
| 895 | showOutgoingVideo, |
| 896 | isRemotelyHeld); |
| 897 | updateRemoteVideoSurfaceDimensions(); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 898 | videoCallScreen.showVideoViews(showOutgoingVideo, showIncomingVideo, isRemotelyHeld); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 899 | |
| 900 | InCallPresenter.getInstance().enableScreenTimeout(VideoProfile.isAudioOnly(videoState)); |
| 901 | updateFullscreenAndGreenScreenMode(callState, sessionModificationState); |
| 902 | } |
| 903 | |
| 904 | /** |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 905 | * 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); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 914 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 915 | LogUtil.e("VideoCallPresenter.onUpdatePeerDimensions", "videoCallScreen is null"); |
| 916 | return; |
| 917 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 918 | if (!call.equals(primaryCall)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 919 | 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 |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 925 | if (width > 0 && height > 0 && videoCallScreen != null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 926 | getRemoteVideoSurfaceTexture().setSourceVideoDimensions(new Point(width, height)); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 927 | videoCallScreen.onRemoteVideoDimensionsChanged(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 928 | } |
| 929 | } |
| 930 | |
| 931 | /** |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 932 | * 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); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 947 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 948 | LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "ui is null"); |
| 949 | return; |
| 950 | } |
| 951 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 952 | if (!call.equals(primaryCall)) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 953 | LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "not the primary call"); |
| 954 | return; |
| 955 | } |
| 956 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 957 | previewSurfaceState = PreviewSurfaceState.CAPABILITIES_RECEIVED; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 958 | 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 964 | previewSurfaceState = PreviewSurfaceState.SURFACE_SET; |
| 965 | videoCall.setPreviewSurface(surface); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 966 | } |
| 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 976 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 977 | return; |
| 978 | } |
| 979 | |
| 980 | // Resize the surface used to display the preview video |
| 981 | getLocalVideoSurfaceTexture().setSurfaceDimensions(new Point(width, height)); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 982 | videoCallScreen.onLocalVideoDimensionsChanged(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 983 | } |
| 984 | |
| 985 | /** |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 986 | * 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", |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 999 | deviceOrientation, |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1000 | orientation); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1001 | deviceOrientation = orientation; |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1002 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1003 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1004 | 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 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1019 | videoCallScreen.onLocalVideoOrientationChanged(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1020 | } |
| 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 | |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 1032 | if (!isVideoCall(call) || call.getState() == DialerCallState.INCOMING) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1033 | 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1046 | if (!isAutoFullscreenEnabled) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1047 | return; |
| 1048 | } |
| 1049 | |
| 1050 | if (call == null |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 1051 | || call.getState() != DialerCallState.ACTIVE |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1052 | || !isBidirectionalVideoCall(call) |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1053 | || InCallPresenter.getInstance().isFullscreen() |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1054 | || (context != null && AccessibilityUtil.isTouchExplorationEnabled(context))) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1055 | // Ensure any previously scheduled attempt to enter fullscreen is cancelled. |
| 1056 | cancelAutoFullScreen(); |
| 1057 | return; |
| 1058 | } |
| 1059 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1060 | if (autoFullScreenPending) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1061 | LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "already pending."); |
| 1062 | return; |
| 1063 | } |
| 1064 | LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "scheduled"); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1065 | autoFullScreenPending = true; |
| 1066 | handler.removeCallbacks(autoFullscreenRunnable); |
| 1067 | handler.postDelayed(autoFullscreenRunnable, autoFullscreenTimeoutMillis); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1068 | } |
| 1069 | |
| 1070 | /** Cancels pending auto fullscreen mode. */ |
| 1071 | @Override |
| 1072 | public void cancelAutoFullScreen() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1073 | if (!autoFullScreenPending) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1074 | LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "none pending."); |
| 1075 | return; |
| 1076 | } |
| 1077 | LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "cancelling pending"); |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1078 | autoFullScreenPending = false; |
| 1079 | handler.removeCallbacks(autoFullscreenRunnable); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1080 | } |
| 1081 | |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1082 | @Override |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 1083 | public boolean shouldShowCameraPermissionToast() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1084 | if (primaryCall == null) { |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 1085 | LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionToast", "null call"); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1086 | return false; |
| 1087 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1088 | if (primaryCall.didShowCameraPermission()) { |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1089 | LogUtil.i( |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 1090 | "VideoCallPresenter.shouldShowCameraPermissionToast", "already shown for this call"); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1091 | return false; |
| 1092 | } |
zachh | 190343a | 2018-05-31 17:30:46 -0700 | [diff] [blame] | 1093 | if (!ConfigProviderComponent.get(context) |
| 1094 | .getConfigProvider() |
| 1095 | .getBoolean("camera_permission_dialog_allowed", true)) { |
Eric Erfanian | 2ca4318 | 2017-08-31 06:57:16 -0700 | [diff] [blame] | 1096 | LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionToast", "disabled by config"); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1097 | return false; |
| 1098 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1099 | return !VideoUtils.hasCameraPermission(context) |
| 1100 | || !PermissionsUtil.hasCameraPrivacyToastShown(context); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1101 | } |
| 1102 | |
| 1103 | @Override |
| 1104 | public void onCameraPermissionDialogShown() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1105 | if (primaryCall != null) { |
| 1106 | primaryCall.setDidShowCameraPermission(true); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1107 | } |
| 1108 | } |
| 1109 | |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1110 | private void updateRemoteVideoSurfaceDimensions() { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1111 | Activity activity = videoCallScreen.getVideoCallScreenFragment().getActivity(); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1112 | 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1120 | return call != null |
| 1121 | && (call.hasSentVideoUpgradeRequest() || call.hasReceivedVideoUpgradeRequest()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1122 | } |
| 1123 | |
| 1124 | private static boolean isVideoUpgrade(@SessionModificationState int state) { |
| 1125 | return VideoUtils.hasSentVideoUpgradeRequest(state) |
| 1126 | || VideoUtils.hasReceivedVideoUpgradeRequest(state); |
| 1127 | } |
| 1128 | |
wangqi | da410d3 | 2018-03-06 16:51:38 -0800 | [diff] [blame] | 1129 | @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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1157 | private class LocalDelegate implements VideoSurfaceDelegate { |
| 1158 | @Override |
| 1159 | public void onSurfaceCreated(VideoSurfaceTexture videoCallSurface) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1160 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1161 | LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceCreated", "no UI"); |
| 1162 | return; |
| 1163 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1164 | if (videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1165 | 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. |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1171 | 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 Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1176 | } |
| 1177 | } |
| 1178 | |
| 1179 | @Override |
| 1180 | public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1181 | if (videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1182 | LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceReleased", "no video call"); |
| 1183 | return; |
| 1184 | } |
| 1185 | |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1186 | videoCall.setPreviewSurface(null); |
| 1187 | enableCamera(primaryCall, false); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1188 | } |
| 1189 | |
| 1190 | @Override |
| 1191 | public void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1192 | if (videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1193 | LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceDestroyed", "no video call"); |
| 1194 | return; |
| 1195 | } |
| 1196 | |
| 1197 | boolean isChangingConfigurations = InCallPresenter.getInstance().isChangingConfigurations(); |
| 1198 | if (!isChangingConfigurations) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1199 | enableCamera(primaryCall, false); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1200 | } 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) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1216 | if (videoCallScreen == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1217 | LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no UI"); |
| 1218 | return; |
| 1219 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1220 | if (videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1221 | LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no video call"); |
| 1222 | return; |
| 1223 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1224 | videoCall.setDisplaySurface(videoCallSurface.getSavedSurface()); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1225 | } |
| 1226 | |
| 1227 | @Override |
| 1228 | public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) { |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1229 | if (videoCall == null) { |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1230 | LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceReleased", "no video call"); |
| 1231 | return; |
| 1232 | } |
linyuh | 183cb71 | 2017-12-27 17:02:37 -0800 | [diff] [blame] | 1233 | videoCall.setDisplaySurface(null); |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1234 | } |
| 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 Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1268 | |
| 1269 | private static boolean isBidirectionalVideoCall(DialerCall call) { |
linyuh | 122fb0b | 2018-03-26 13:35:32 -0700 | [diff] [blame] | 1270 | return VideoProfile.isBidirectional(call.getVideoState()); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1271 | } |
| 1272 | |
| 1273 | private static boolean isIncomingVideoCall(DialerCall call) { |
| 1274 | if (!isVideoCall(call)) { |
| 1275 | return false; |
| 1276 | } |
| 1277 | final int state = call.getState(); |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 1278 | return (state == DialerCallState.INCOMING) || (state == DialerCallState.CALL_WAITING); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1279 | } |
| 1280 | |
| 1281 | private static boolean isActiveVideoCall(DialerCall call) { |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 1282 | return isVideoCall(call) && call.getState() == DialerCallState.ACTIVE; |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1283 | } |
| 1284 | |
| 1285 | private static boolean isOutgoingVideoCall(DialerCall call) { |
| 1286 | if (!isVideoCall(call)) { |
| 1287 | return false; |
| 1288 | } |
| 1289 | final int state = call.getState(); |
wangqi | bb94ca6 | 2018-04-27 14:34:04 -0700 | [diff] [blame] | 1290 | return DialerCallState.isDialing(state) |
| 1291 | || state == DialerCallState.CONNECTING |
| 1292 | || state == DialerCallState.SELECT_PHONE_ACCOUNT; |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1293 | } |
| 1294 | |
| 1295 | private static boolean isAudioCall(DialerCall call) { |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1296 | 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) { |
linyuh | 122fb0b | 2018-03-26 13:35:32 -0700 | [diff] [blame] | 1304 | return VideoProfile.isTransmissionEnabled(videoState) |
| 1305 | || VideoProfile.isReceptionEnabled(videoState); |
Eric Erfanian | d5e47f6 | 2017-03-15 14:41:07 -0700 | [diff] [blame] | 1306 | } |
Eric Erfanian | ccca315 | 2017-02-22 16:32:36 -0800 | [diff] [blame] | 1307 | } |