/* * Copyright (C) 2013 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.content.Context; import android.os.Bundle; import android.os.Trace; import android.support.v4.app.Fragment; import android.support.v4.os.UserManagerCompat; import android.telecom.CallAudioState; import android.telecom.PhoneAccountHandle; import com.android.contacts.common.compat.CallCompat; import com.android.dialer.common.Assert; import com.android.dialer.common.LogUtil; import com.android.dialer.common.concurrent.DialerExecutorComponent; import com.android.dialer.logging.DialerImpression; import com.android.dialer.logging.DialerImpression.Type; import com.android.dialer.logging.Logger; import com.android.dialer.telecom.TelecomUtil; import com.android.incallui.InCallCameraManager.Listener; import com.android.incallui.InCallPresenter.CanAddCallListener; import com.android.incallui.InCallPresenter.InCallDetailsListener; import com.android.incallui.InCallPresenter.InCallState; import com.android.incallui.InCallPresenter.InCallStateListener; import com.android.incallui.InCallPresenter.IncomingCallListener; import com.android.incallui.audiomode.AudioModeProvider; import com.android.incallui.audiomode.AudioModeProvider.AudioModeListener; import com.android.incallui.call.CallList; import com.android.incallui.call.DialerCall; import com.android.incallui.call.DialerCall.CameraDirection; import com.android.incallui.call.DialerCallListener; import com.android.incallui.call.TelecomAdapter; import com.android.incallui.call.state.DialerCallState; import com.android.incallui.incall.protocol.InCallButtonIds; import com.android.incallui.incall.protocol.InCallButtonUi; import com.android.incallui.incall.protocol.InCallButtonUiDelegate; import com.android.incallui.multisim.SwapSimWorker; import com.android.incallui.videotech.utils.VideoUtils; /** Logic for call buttons. */ public class CallButtonPresenter implements InCallStateListener, AudioModeListener, IncomingCallListener, InCallDetailsListener, CanAddCallListener, Listener, InCallButtonUiDelegate, DialerCallListener { private final Context context; private InCallButtonUi inCallButtonUi; private DialerCall call; private boolean isInCallButtonUiReady; private PhoneAccountHandle otherAccount; public CallButtonPresenter(Context context) { this.context = context.getApplicationContext(); } @Override public void onInCallButtonUiReady(InCallButtonUi ui) { Assert.checkState(!isInCallButtonUiReady); inCallButtonUi = ui; AudioModeProvider.getInstance().addListener(this); // register for call state changes last final InCallPresenter inCallPresenter = InCallPresenter.getInstance(); inCallPresenter.addListener(this); inCallPresenter.addIncomingCallListener(this); inCallPresenter.addDetailsListener(this); inCallPresenter.addCanAddCallListener(this); inCallPresenter.getInCallCameraManager().addCameraSelectionListener(this); // Update the buttons state immediately for the current call onStateChange(InCallState.NO_CALLS, inCallPresenter.getInCallState(), CallList.getInstance()); isInCallButtonUiReady = true; } @Override public void onInCallButtonUiUnready() { Assert.checkState(isInCallButtonUiReady); inCallButtonUi = null; InCallPresenter.getInstance().removeListener(this); AudioModeProvider.getInstance().removeListener(this); InCallPresenter.getInstance().removeIncomingCallListener(this); InCallPresenter.getInstance().removeDetailsListener(this); InCallPresenter.getInstance().getInCallCameraManager().removeCameraSelectionListener(this); InCallPresenter.getInstance().removeCanAddCallListener(this); isInCallButtonUiReady = false; if (call != null) { call.removeListener(this); } } @Override public void onStateChange(InCallState oldState, InCallState newState, CallList callList) { Trace.beginSection("CallButtonPresenter.onStateChange"); if (call != null) { call.removeListener(this); } if (newState == InCallState.OUTGOING) { call = callList.getOutgoingCall(); } else if (newState == InCallState.INCALL) { call = callList.getActiveOrBackgroundCall(); // When connected to voice mail, automatically shows the dialpad. // (On previous releases we showed it when in-call shows up, before waiting for // OUTGOING. We may want to do that once we start showing "Voice mail" label on // the dialpad too.) if (oldState == InCallState.OUTGOING && call != null) { if (call.isVoiceMailNumber() && getActivity() != null) { getActivity().showDialpadFragment(true /* show */, true /* animate */); } } } else if (newState == InCallState.INCOMING) { if (getActivity() != null) { getActivity().showDialpadFragment(false /* show */, true /* animate */); } call = callList.getIncomingCall(); } else { call = null; } if (call != null) { call.addListener(this); } updateUi(newState, call); Trace.endSection(); } /** * Updates the user interface in response to a change in the details of a call. Currently handles * changes to the call buttons in response to a change in the details for a call. This is * important to ensure changes to the active call are reflected in the available buttons. * * @param call The active call. * @param details The call details. */ @Override public void onDetailsChanged(DialerCall call, android.telecom.Call.Details details) { // Only update if the changes are for the currently active call if (inCallButtonUi != null && call != null && call.equals(this.call)) { updateButtonsState(call); } } @Override public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) { onStateChange(oldState, newState, CallList.getInstance()); } @Override public void onCanAddCallChanged(boolean canAddCall) { if (inCallButtonUi != null && call != null) { updateButtonsState(call); } } @Override public void onAudioStateChanged(CallAudioState audioState) { if (inCallButtonUi != null) { inCallButtonUi.setAudioState(audioState); } } @Override public CallAudioState getCurrentAudioState() { return AudioModeProvider.getInstance().getAudioState(); } @Override public void setAudioRoute(int route) { LogUtil.i( "CallButtonPresenter.setAudioRoute", "sending new audio route: " + CallAudioState.audioRouteToString(route)); TelecomAdapter.getInstance().setAudioRoute(route); } /** Function assumes that bluetooth is not supported. */ @Override public void toggleSpeakerphone() { // This function should not be called if bluetooth is available. CallAudioState audioState = getCurrentAudioState(); if (0 != (CallAudioState.ROUTE_BLUETOOTH & audioState.getSupportedRouteMask())) { // It's clear the UI is wrong, so update the supported mode once again. LogUtil.e( "CallButtonPresenter", "toggling speakerphone not allowed when bluetooth supported."); inCallButtonUi.setAudioState(audioState); return; } int newRoute; if (audioState.getRoute() == CallAudioState.ROUTE_SPEAKER) { newRoute = CallAudioState.ROUTE_WIRED_OR_EARPIECE; if (call != null) { Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_WIRED_OR_EARPIECE, call.getUniqueCallId(), call.getTimeAddedMs()); } } else { newRoute = CallAudioState.ROUTE_SPEAKER; if (call != null) { Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_SPEAKERPHONE, call.getUniqueCallId(), call.getTimeAddedMs()); } } setAudioRoute(newRoute); } @Override public void muteClicked(boolean checked, boolean clickedByUser) { LogUtil.i( "CallButtonPresenter", "turning on mute: %s, clicked by user: %s", checked, clickedByUser); if (clickedByUser) { Logger.get(context) .logCallImpression( checked ? DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_MUTE : DialerImpression.Type.IN_CALL_SCREEN_TURN_OFF_MUTE, call.getUniqueCallId(), call.getTimeAddedMs()); } TelecomAdapter.getInstance().mute(checked); } @Override public void holdClicked(boolean checked) { if (call == null) { return; } if (checked) { LogUtil.i("CallButtonPresenter", "putting the call on hold: " + call); call.hold(); } else { LogUtil.i("CallButtonPresenter", "removing the call from hold: " + call); call.unhold(); } } @Override public void swapClicked() { if (call == null) { return; } LogUtil.i("CallButtonPresenter", "swapping the call: " + call); TelecomAdapter.getInstance().swap(call.getId()); } @Override public void mergeClicked() { Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_MERGE_BUTTON_PRESSED, call.getUniqueCallId(), call.getTimeAddedMs()); TelecomAdapter.getInstance().merge(call.getId()); } @Override public void addCallClicked() { Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_ADD_CALL_BUTTON_PRESSED, call.getUniqueCallId(), call.getTimeAddedMs()); InCallPresenter.getInstance().addCallClicked(); } @Override public void showDialpadClicked(boolean checked) { Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_SHOW_DIALPAD_BUTTON_PRESSED, call.getUniqueCallId(), call.getTimeAddedMs()); LogUtil.v("CallButtonPresenter", "show dialpad " + String.valueOf(checked)); getActivity().showDialpadFragment(checked /* show */, true /* animate */); } @Override public void changeToVideoClicked() { LogUtil.enterBlock("CallButtonPresenter.changeToVideoClicked"); Logger.get(context) .logCallImpression( DialerImpression.Type.VIDEO_CALL_UPGRADE_REQUESTED, call.getUniqueCallId(), call.getTimeAddedMs()); call.getVideoTech().upgradeToVideo(context); } @Override public void changeToRttClicked() { LogUtil.enterBlock("CallButtonPresenter.changeToRttClicked"); call.sendRttUpgradeRequest(); } @Override public void onEndCallClicked() { LogUtil.i("CallButtonPresenter.onEndCallClicked", "call: " + call); if (call != null) { call.disconnect(); } } @Override public void showAudioRouteSelector() { inCallButtonUi.showAudioRouteSelector(); } @Override public void swapSimClicked() { LogUtil.enterBlock("CallButtonPresenter.swapSimClicked"); Logger.get(getContext()).logImpression(Type.DUAL_SIM_CHANGE_SIM_PRESSED); SwapSimWorker worker = new SwapSimWorker( getContext(), call, InCallPresenter.getInstance().getCallList(), otherAccount, InCallPresenter.getInstance().acquireInCallUiLock("swapSim")); DialerExecutorComponent.get(getContext()) .dialerExecutorFactory() .createNonUiTaskBuilder(worker) .build() .executeParallel(null); } /** * Switches the camera between the front-facing and back-facing camera. * * @param useFrontFacingCamera True if we should switch to using the front-facing camera, or false * if we should switch to using the back-facing camera. */ @Override public void switchCameraClicked(boolean useFrontFacingCamera) { updateCamera(useFrontFacingCamera); } @Override public void toggleCameraClicked() { LogUtil.i("CallButtonPresenter.toggleCameraClicked", ""); if (call == null) { return; } Logger.get(context) .logCallImpression( DialerImpression.Type.IN_CALL_SCREEN_SWAP_CAMERA, call.getUniqueCallId(), call.getTimeAddedMs()); switchCameraClicked( !InCallPresenter.getInstance().getInCallCameraManager().isUsingFrontFacingCamera()); } /** * Stop or start client's video transmission. * * @param pause True if pausing the local user's video, or false if starting the local user's * video. */ @Override public void pauseVideoClicked(boolean pause) { LogUtil.i("CallButtonPresenter.pauseVideoClicked", "%s", pause ? "pause" : "unpause"); Logger.get(context) .logCallImpression( pause ? DialerImpression.Type.IN_CALL_SCREEN_TURN_OFF_VIDEO : DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_VIDEO, call.getUniqueCallId(), call.getTimeAddedMs()); if (pause) { call.getVideoTech().stopTransmission(); } else { updateCamera( InCallPresenter.getInstance().getInCallCameraManager().isUsingFrontFacingCamera()); call.getVideoTech().resumeTransmission(context); } inCallButtonUi.setVideoPaused(pause); inCallButtonUi.enableButton(InCallButtonIds.BUTTON_PAUSE_VIDEO, false); } private void updateCamera(boolean useFrontFacingCamera) { InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager(); cameraManager.setUseFrontFacingCamera(useFrontFacingCamera); String cameraId = cameraManager.getActiveCameraId(); if (cameraId != null) { final int cameraDir = cameraManager.isUsingFrontFacingCamera() ? CameraDirection.CAMERA_DIRECTION_FRONT_FACING : CameraDirection.CAMERA_DIRECTION_BACK_FACING; call.setCameraDir(cameraDir); call.getVideoTech().setCamera(cameraId); } } private void updateUi(InCallState state, DialerCall call) { LogUtil.v("CallButtonPresenter", "updating call UI for call: %s", call); if (inCallButtonUi == null) { return; } if (call != null) { inCallButtonUi.updateInCallButtonUiColors( InCallPresenter.getInstance().getThemeColorManager().getSecondaryColor()); } final boolean isEnabled = state.isConnectingOrConnected() && !state.isIncoming() && call != null; inCallButtonUi.setEnabled(isEnabled); if (call == null) { return; } updateButtonsState(call); } /** * Updates the buttons applicable for the UI. * * @param call The active call. */ @SuppressWarnings(value = {"MissingPermission"}) private void updateButtonsState(DialerCall call) { LogUtil.v("CallButtonPresenter.updateButtonsState", ""); final boolean isVideo = call.isVideoCall(); // Common functionality (audio, hold, etc). // Show either HOLD or SWAP, but not both. If neither HOLD or SWAP is available: // (1) If the device normally can hold, show HOLD in a disabled state. // (2) If the device doesn't have the concept of hold/swap, remove the button. final boolean showSwap = call.can(android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE); final boolean showHold = !showSwap && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORT_HOLD) && call.can(android.telecom.Call.Details.CAPABILITY_HOLD); final boolean isCallOnHold = call.getState() == DialerCallState.ONHOLD; final boolean showAddCall = TelecomAdapter.getInstance().canAddCall() && UserManagerCompat.isUserUnlocked(context); // There can only be two calls so don't show the ability to merge when one of them // is a speak easy call. final boolean showMerge = InCallPresenter.getInstance() .getCallList() .getAllCalls() .stream() .noneMatch(c -> c != null && c.isSpeakEasyCall()) && call.can(android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE); final boolean showUpgradeToVideo = !isVideo && (hasVideoCallCapabilities(call)); final boolean showDowngradeToAudio = isVideo && isDowngradeToAudioSupported(call); final boolean showMute = call.can(android.telecom.Call.Details.CAPABILITY_MUTE); final boolean hasCameraPermission = isVideo && VideoUtils.hasCameraPermissionAndShownPrivacyToast(context); // Disabling local video doesn't seem to work when dialing. See a bug. final boolean showPauseVideo = isVideo && call.getState() != DialerCallState.DIALING && call.getState() != DialerCallState.CONNECTING; otherAccount = TelecomUtil.getOtherAccount(getContext(), call.getAccountHandle()); boolean showSwapSim = !call.isEmergencyCall() && otherAccount != null && !call.isVoiceMailNumber() && DialerCallState.isDialing(call.getState()) // Most devices cannot make calls on 2 SIMs at the same time. && InCallPresenter.getInstance().getCallList().getAllCalls().size() == 1; boolean showUpgradeToRtt = call.canUpgradeToRttCall(); boolean enableUpgradeToRtt = showUpgradeToRtt && call.getState() == DialerCallState.ACTIVE; inCallButtonUi.showButton(InCallButtonIds.BUTTON_AUDIO, true); inCallButtonUi.showButton(InCallButtonIds.BUTTON_SWAP, showSwap); inCallButtonUi.showButton(InCallButtonIds.BUTTON_HOLD, showHold); inCallButtonUi.setHold(isCallOnHold); inCallButtonUi.showButton(InCallButtonIds.BUTTON_MUTE, showMute); inCallButtonUi.showButton(InCallButtonIds.BUTTON_SWAP_SIM, showSwapSim); inCallButtonUi.showButton(InCallButtonIds.BUTTON_ADD_CALL, true); inCallButtonUi.enableButton(InCallButtonIds.BUTTON_ADD_CALL, showAddCall); inCallButtonUi.showButton(InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO, showUpgradeToVideo); inCallButtonUi.showButton(InCallButtonIds.BUTTON_UPGRADE_TO_RTT, showUpgradeToRtt); inCallButtonUi.enableButton(InCallButtonIds.BUTTON_UPGRADE_TO_RTT, enableUpgradeToRtt); inCallButtonUi.showButton(InCallButtonIds.BUTTON_DOWNGRADE_TO_AUDIO, showDowngradeToAudio); inCallButtonUi.showButton( InCallButtonIds.BUTTON_SWITCH_CAMERA, isVideo && hasCameraPermission && call.getVideoTech().isTransmitting()); inCallButtonUi.showButton(InCallButtonIds.BUTTON_PAUSE_VIDEO, showPauseVideo); if (isVideo) { inCallButtonUi.setVideoPaused(!call.getVideoTech().isTransmitting() || !hasCameraPermission); } inCallButtonUi.showButton(InCallButtonIds.BUTTON_DIALPAD, true); inCallButtonUi.showButton(InCallButtonIds.BUTTON_MERGE, showMerge); inCallButtonUi.updateButtonStates(); } private boolean hasVideoCallCapabilities(DialerCall call) { return call.getVideoTech().isAvailable(context, call.getAccountHandle()); } /** * Determines if downgrading from a video call to an audio-only call is supported. In order to * support downgrade to audio, the SDK version must be >= N and the call should NOT have the * {@link android.telecom.Call.Details#CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO}. * * @param call The call. * @return {@code true} if downgrading to an audio-only call from a video call is supported. */ private boolean isDowngradeToAudioSupported(DialerCall call) { // TODO(a bug): If there is an RCS video share session, return true here return !call.can(CallCompat.Details.CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO); } @Override public void onSaveInstanceState(Bundle outState) {} @Override public void onRestoreInstanceState(Bundle savedInstanceState) {} @Override public void onCameraPermissionGranted() { if (call != null) { updateButtonsState(call); } } @Override public void onActiveCameraSelectionChanged(boolean isUsingFrontFacingCamera) { if (inCallButtonUi == null) { return; } inCallButtonUi.setCameraSwitched(!isUsingFrontFacingCamera); } @Override public void onDialerCallSessionModificationStateChange() { if (inCallButtonUi != null && call != null) { inCallButtonUi.enableButton(InCallButtonIds.BUTTON_PAUSE_VIDEO, true); updateButtonsState(call); } } @Override public void onDialerCallDisconnect() {} @Override public void onDialerCallUpdate() {} @Override public void onDialerCallChildNumberChange() {} @Override public void onDialerCallLastForwardedNumberChange() {} @Override public void onDialerCallUpgradeToVideo() {} @Override public void onWiFiToLteHandover() {} @Override public void onHandoverToWifiFailure() {} @Override public void onInternationalCallOnWifi() {} @Override public void onEnrichedCallSessionUpdate() {} @Override public Context getContext() { return context; } private InCallActivity getActivity() { if (inCallButtonUi != null) { Fragment fragment = inCallButtonUi.getInCallButtonUiFragment(); if (fragment != null) { return (InCallActivity) fragment.getActivity(); } } return null; } }