/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License */ package com.android.incallui; import android.support.annotation.NonNull; import com.android.dialer.common.Assert; import com.android.dialer.common.LogUtil; import com.android.incallui.InCallPresenter.InCallState; import com.android.incallui.InCallPresenter.InCallStateListener; import com.android.incallui.InCallPresenter.IncomingCallListener; import com.android.incallui.call.CallList; import com.android.incallui.call.DialerCall; import com.android.incallui.call.state.DialerCallState; import java.util.Objects; /** * This class is responsible for generating video pause/resume requests when the InCall UI is sent * to the background and subsequently brought back to the foreground. */ class VideoPauseController implements InCallStateListener, IncomingCallListener { private static VideoPauseController videoPauseController; private InCallPresenter inCallPresenter; /** The current call, if applicable. */ private DialerCall primaryCall = null; /** * The cached state of primary call, updated after onStateChange has processed. * *
These values are stored to detect specific changes in state between onStateChange calls. */ private int prevCallState = DialerCallState.INVALID; private boolean wasVideoCall = false; /** * Tracks whether the application is in the background. {@code True} if the application is in the * background, {@code false} otherwise. */ private boolean isInBackground = false; /** * Singleton accessor for the {@link VideoPauseController}. * * @return Singleton instance of the {@link VideoPauseController}. */ /*package*/ static synchronized VideoPauseController getInstance() { if (videoPauseController == null) { videoPauseController = new VideoPauseController(); } return videoPauseController; } /** * Determines if a call is in incoming/waiting state. * * @param call The call. * @return {@code true} if the call is in incoming or waiting state, {@code false} otherwise. */ private static boolean isIncomingCall(DialerCall call) { return call != null && (call.getState() == DialerCallState.CALL_WAITING || call.getState() == DialerCallState.INCOMING); } /** * Determines if a call is dialing. * * @return {@code true} if the call is dialing, {@code false} otherwise. */ private boolean wasDialing() { return DialerCallState.isDialing(prevCallState); } /** * Configures the {@link VideoPauseController} to listen to call events. Configured via the {@link * com.android.incallui.InCallPresenter}. * * @param inCallPresenter The {@link com.android.incallui.InCallPresenter}. */ public void setUp(@NonNull InCallPresenter inCallPresenter) { LogUtil.enterBlock("VideoPauseController.setUp"); this.inCallPresenter = Assert.isNotNull(inCallPresenter); this.inCallPresenter.addListener(this); this.inCallPresenter.addIncomingCallListener(this); } /** * Cleans up the {@link VideoPauseController} by removing all listeners and clearing its internal * state. Called from {@link com.android.incallui.InCallPresenter}. */ public void tearDown() { LogUtil.enterBlock("VideoPauseController.tearDown"); inCallPresenter.removeListener(this); inCallPresenter.removeIncomingCallListener(this); clear(); } /** Clears the internal state for the {@link VideoPauseController}. */ private void clear() { inCallPresenter = null; primaryCall = null; prevCallState = DialerCallState.INVALID; wasVideoCall = false; isInBackground = false; } /** * Handles changes in the {@link InCallState}. Triggers pause and resumption of video for the * current foreground call. * * @param oldState The previous {@link InCallState}. * @param newState The current {@link InCallState}. * @param callList List of current call. */ @Override public void onStateChange(InCallState oldState, InCallState newState, CallList callList) { DialerCall call; if (newState == InCallState.INCOMING) { call = callList.getIncomingCall(); } else if (newState == InCallState.WAITING_FOR_ACCOUNT) { call = callList.getWaitingForAccountCall(); } else if (newState == InCallState.PENDING_OUTGOING) { call = callList.getPendingOutgoingCall(); } else if (newState == InCallState.OUTGOING) { call = callList.getOutgoingCall(); } else { call = callList.getActiveCall(); } boolean hasPrimaryCallChanged = !Objects.equals(call, primaryCall); boolean canVideoPause = videoCanPause(call); LogUtil.i( "VideoPauseController.onStateChange", "hasPrimaryCallChanged: %b, videoCanPause: %b, isInBackground: %b", hasPrimaryCallChanged, canVideoPause, isInBackground); if (hasPrimaryCallChanged) { onPrimaryCallChanged(call); return; } if (wasDialing() && canVideoPause && isInBackground) { // Bring UI to foreground if outgoing request becomes active while UI is in // background. bringToForeground(); } else if (!wasVideoCall && canVideoPause && isInBackground) { // Bring UI to foreground if VoLTE call becomes active while UI is in // background. bringToForeground(); } updatePrimaryCallContext(call); } /** * Handles a change to the primary call. * *
Reject incoming or hangup dialing call: Where the previous call was an incoming call or a * call in dialing state, resume the new primary call. DialerCall swap: Where the new primary call * is incoming, pause video on the previous primary call. * * @param call The new primary call. */ private void onPrimaryCallChanged(DialerCall call) { LogUtil.i( "VideoPauseController.onPrimaryCallChanged", "new call: %s, old call: %s, mIsInBackground: %b", call, primaryCall, isInBackground); if (Objects.equals(call, primaryCall)) { throw new IllegalStateException(); } final boolean canVideoPause = videoCanPause(call); if (canVideoPause && !isInBackground) { // Send resume request for the active call, if user rejects incoming call, ends dialing // call, or the call was previously in a paused state and UI is in the foreground. sendRequest(call, true); } else if (isIncomingCall(call) && videoCanPause(primaryCall)) { // Send pause request if there is an active video call, and we just received a new // incoming call. sendRequest(primaryCall, false); } updatePrimaryCallContext(call); } /** * Handles new incoming calls by triggering a change in the primary call. * * @param oldState the old {@link InCallState}. * @param newState the new {@link InCallState}. * @param call the incoming call. */ @Override public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) { LogUtil.i( "VideoPauseController.onIncomingCall", "oldState: %s, newState: %s, call: %s", oldState, newState, call); if (Objects.equals(call, primaryCall)) { return; } onPrimaryCallChanged(call); } /** * Caches a reference to the primary call and stores its previous state. * * @param call The new primary call. */ private void updatePrimaryCallContext(DialerCall call) { if (call == null) { primaryCall = null; prevCallState = DialerCallState.INVALID; wasVideoCall = false; } else { primaryCall = call; prevCallState = call.getState(); wasVideoCall = call.isVideoCall(); } } /** * Called when UI goes in/out of the foreground. * * @param showing true if UI is in the foreground, false otherwise. */ public void onUiShowing(boolean showing) { if (inCallPresenter == null) { return; } final boolean isInCall = inCallPresenter.getInCallState() == InCallState.INCALL; if (showing) { onResume(isInCall); } else { onPause(isInCall); } } /** * Called when UI is brought to the foreground. Sends a session modification request to resume the * outgoing video. * * @param isInCall {@code true} if we are in an active call. A resume request is only sent to the * video provider if we are in a call. */ private void onResume(boolean isInCall) { isInBackground = false; if (isInCall) { sendRequest(primaryCall, true); } } /** * Called when UI is sent to the background. Sends a session modification request to pause the * outgoing video. * * @param isInCall {@code true} if we are in an active call. A pause request is only sent to the * video provider if we are in a call. */ private void onPause(boolean isInCall) { isInBackground = true; if (isInCall) { sendRequest(primaryCall, false); } } private void bringToForeground() { LogUtil.enterBlock("VideoPauseController.bringToForeground"); if (inCallPresenter != null) { inCallPresenter.bringToForeground(false); } else { LogUtil.e( "VideoPauseController.bringToForeground", "InCallPresenter is null. Cannot bring UI to foreground"); } } /** * Sends Pause/Resume request. * * @param call DialerCall to be paused/resumed. * @param resume If true resume request will be sent, otherwise pause request. */ private void sendRequest(DialerCall call, boolean resume) { if (call == null) { return; } if (resume) { call.getVideoTech().unpause(); } else { call.getVideoTech().pause(); } } private static boolean videoCanPause(DialerCall call) { return call != null && call.isVideoCall() && call.getState() == DialerCallState.ACTIVE; } }