| /* |
| * 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.car.dialer; |
| |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.graphics.Color; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.support.v4.app.Fragment; |
| import android.telecom.Call; |
| import android.telecom.CallAudioState; |
| import android.text.TextUtils; |
| import android.text.format.DateUtils; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.animation.AccelerateDecelerateInterpolator; |
| import android.view.animation.AccelerateInterpolator; |
| import android.view.animation.Animation; |
| import android.view.animation.Interpolator; |
| import android.view.animation.Transformation; |
| import android.widget.ImageButton; |
| import android.widget.ImageView; |
| import android.widget.LinearLayout; |
| import android.widget.TextView; |
| import com.android.car.apps.common.CircleBitmapDrawable; |
| import com.android.car.apps.common.FabDrawable; |
| import com.android.car.dialer.telecom.TelecomUtils; |
| import com.android.car.dialer.telecom.UiCall; |
| import com.android.car.dialer.telecom.UiCallManager; |
| import com.android.car.dialer.telecom.UiCallManager.CallListener; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| |
| public class OngoingCallFragment extends Fragment { |
| private static final String TAG = "Em.OngoingCall"; |
| private static final HashMap<Integer, Character> mDialpadButtonMap = new HashMap<>(); |
| |
| static { |
| mDialpadButtonMap.put(R.id.one, '1'); |
| mDialpadButtonMap.put(R.id.two, '2'); |
| mDialpadButtonMap.put(R.id.three, '3'); |
| mDialpadButtonMap.put(R.id.four, '4'); |
| mDialpadButtonMap.put(R.id.five, '5'); |
| mDialpadButtonMap.put(R.id.six, '6'); |
| mDialpadButtonMap.put(R.id.seven, '7'); |
| mDialpadButtonMap.put(R.id.eight, '8'); |
| mDialpadButtonMap.put(R.id.nine, '9'); |
| mDialpadButtonMap.put(R.id.zero, '0'); |
| mDialpadButtonMap.put(R.id.star, '*'); |
| mDialpadButtonMap.put(R.id.pound, '#'); |
| } |
| |
| private UiCall mPrimaryCall; |
| private UiCall mSecondaryCall; |
| private UiCall mLastRemovedCall; |
| private UiCallManager mUiCallManager; |
| private Handler mHandler; |
| private View mRingingCallControls; |
| private View mActiveCallControls; |
| private ImageButton mEndCallButton; |
| private ImageButton mUnholdCallButton; |
| private ImageButton mMuteButton; |
| private ImageButton mToggleDialpadButton; |
| private ImageButton mSwapButton; |
| private ImageButton mMergeButton; |
| private ImageButton mAnswerCallButton; |
| private ImageButton mRejectCallButton; |
| private TextView mNameTextView; |
| private TextView mSecondaryNameTextView; |
| private TextView mStateTextView; |
| private TextView mSecondaryStateTextView; |
| private ImageView mLargeContactPhotoView; |
| private ImageView mSmallContactPhotoView; |
| private View mDialpadContainer; |
| private View mSecondaryCallContainer; |
| private View mSecondaryCallControls; |
| private LinearLayout mRotaryDialpad; |
| private List<View> mDialpadViews; |
| private String mLoadedNumber; |
| private CharSequence mCallInfoLabel; |
| private UiBluetoothMonitor mUiBluetoothMonitor; |
| |
| private final Interpolator |
| mAccelerateDecelerateInterpolator = new AccelerateDecelerateInterpolator(); |
| private final Interpolator mAccelerateInterpolator = new AccelerateInterpolator(10); |
| |
| public static OngoingCallFragment newInstance( |
| UiCallManager callManager, UiBluetoothMonitor btMonitor) { |
| OngoingCallFragment fragment = new OngoingCallFragment(); |
| fragment.mUiCallManager = callManager; |
| fragment.mUiBluetoothMonitor = btMonitor; |
| return fragment; |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| mHandler = new Handler(); |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| mHandler.removeCallbacks(mUpdateDurationRunnable); |
| mHandler.removeCallbacks(mStopDtmfToneRunnable); |
| mHandler = null; |
| mLoadedNumber = null; |
| } |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| Bundle savedInstanceState) { |
| View view = inflater.inflate(R.layout.ongoing_call, container, false); |
| mRingingCallControls = view.findViewById(R.id.ringing_call_controls); |
| mActiveCallControls = view.findViewById(R.id.active_call_controls); |
| mEndCallButton = (ImageButton) view.findViewById(R.id.end_call); |
| mUnholdCallButton = (ImageButton) view.findViewById(R.id.unhold_call); |
| mMuteButton = (ImageButton) view.findViewById(R.id.mute); |
| mToggleDialpadButton = (ImageButton) view.findViewById(R.id.toggle_dialpad); |
| mDialpadContainer = view.findViewById(R.id.dialpad_container); |
| mNameTextView = (TextView) view.findViewById(R.id.name); |
| mSecondaryNameTextView = (TextView) view.findViewById(R.id.name_secondary); |
| mStateTextView = (TextView) view.findViewById(R.id.info); |
| mSecondaryStateTextView = (TextView) view.findViewById(R.id.info_secondary); |
| mLargeContactPhotoView = (ImageView) view.findViewById(R.id.large_contact_photo); |
| mSmallContactPhotoView = (ImageView) view.findViewById(R.id.small_contact_photo); |
| mSecondaryCallContainer = view.findViewById(R.id.secondary_call_container); |
| mSecondaryCallControls = view.findViewById(R.id.secondary_call_controls); |
| mRotaryDialpad = (LinearLayout) view.findViewById(R.id.rotary_dialpad); |
| mSwapButton = (ImageButton) view.findViewById(R.id.swap); |
| mMergeButton = (ImageButton) view.findViewById(R.id.merge); |
| mAnswerCallButton = (ImageButton) view.findViewById(R.id.answer_call_button); |
| mRejectCallButton = (ImageButton) view.findViewById(R.id.reject_call_button); |
| |
| boolean hasTouch = getResources().getBoolean(R.bool.has_touch); |
| View dialPadContainer = hasTouch ? mDialpadContainer : mRotaryDialpad; |
| mDialpadViews = Arrays.asList( |
| dialPadContainer.findViewById(R.id.one), |
| dialPadContainer.findViewById(R.id.two), |
| dialPadContainer.findViewById(R.id.three), |
| dialPadContainer.findViewById(R.id.four), |
| dialPadContainer.findViewById(R.id.five), |
| dialPadContainer.findViewById(R.id.six), |
| dialPadContainer.findViewById(R.id.seven), |
| dialPadContainer.findViewById(R.id.eight), |
| dialPadContainer.findViewById(R.id.nine), |
| dialPadContainer.findViewById(R.id.zero), |
| dialPadContainer.findViewById(R.id.pound), |
| dialPadContainer.findViewById(R.id.star) |
| ); |
| if (hasTouch) { |
| // In touch screen, we need to adjust the InCall card for the narrow screen to show the |
| // full dial pad. |
| for (View dialpadView : mDialpadViews) { |
| dialpadView.setOnTouchListener(mDialpadTouchListener); |
| dialpadView.setOnKeyListener(mDialpadKeyListener); |
| } |
| } else { |
| for (View dialpadView : mDialpadViews) { |
| dialpadView.setOnKeyListener(mDialpadKeyListener); |
| } |
| mToggleDialpadButton.setImageResource(R.drawable.ic_rotary_dialpad); |
| } |
| setDialPadFocusability(!hasTouch); |
| setInCallControllerFocusability(!hasTouch); |
| |
| mAnswerCallButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getCallWithState(Call.STATE_RINGING); |
| if (call == null) { |
| Log.w(TAG, "There is no incoming call to answer."); |
| return; |
| } |
| mUiCallManager.answerCall(call); |
| }); |
| Context context = getContext(); |
| FabDrawable answerCallDrawable = new FabDrawable(context); |
| answerCallDrawable.setFabAndStrokeColor(getResources().getColor(R.color.phone_call)); |
| mAnswerCallButton.setBackground(answerCallDrawable); |
| |
| mRejectCallButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getCallWithState(Call.STATE_RINGING); |
| if (call == null) { |
| Log.w(TAG, "There is no incoming call to reject."); |
| return; |
| } |
| mUiCallManager.rejectCall(call, false, null); |
| }); |
| |
| mEndCallButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getPrimaryCall(); |
| if (call == null) { |
| Log.w(TAG, "There is no active call to end."); |
| return; |
| } |
| mUiCallManager.disconnectCall(call); |
| }); |
| FabDrawable endCallDrawable = new FabDrawable(context); |
| endCallDrawable.setFabAndStrokeColor(getResources().getColor(R.color.phone_end_call)); |
| mEndCallButton.setBackground(endCallDrawable); |
| |
| mUnholdCallButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getPrimaryCall(); |
| if (call == null) { |
| Log.w(TAG, "There is no active call to unhold."); |
| return; |
| } |
| mUiCallManager.unholdCall(call); |
| }); |
| FabDrawable unholdCallDrawable = new FabDrawable(context); |
| unholdCallDrawable.setFabAndStrokeColor(getResources().getColor(R.color.phone_call)); |
| mUnholdCallButton.setBackground(unholdCallDrawable); |
| |
| mMuteButton.setOnClickListener((unusedView) -> { |
| if (mUiCallManager.getMuted()) { |
| mUiCallManager.setMuted(false); |
| } else { |
| mUiCallManager.setMuted(true); |
| } |
| }); |
| |
| mSwapButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getPrimaryCall(); |
| if (call == null) { |
| Log.w(TAG, "There is no active call to hold."); |
| return; |
| } |
| if (call.getState() == Call.STATE_HOLDING) { |
| mUiCallManager.unholdCall(call); |
| } else { |
| mUiCallManager.holdCall(call); |
| } |
| }); |
| |
| mMergeButton.setOnClickListener((unusedView) -> { |
| UiCall call = mUiCallManager.getPrimaryCall(); |
| UiCall secondarycall = mUiCallManager.getSecondaryCall(); |
| if (call == null || mSecondaryCall == null) { |
| Log.w(TAG, "There aren't two call to merge."); |
| return; |
| } |
| |
| mUiCallManager.conference(call, secondarycall); |
| }); |
| |
| mToggleDialpadButton.setOnClickListener((unusedView) -> { |
| if (mToggleDialpadButton.isActivated()) { |
| closeDialpad(); |
| } else { |
| openDialpad(true /*animate*/); |
| } |
| }); |
| |
| mUiCallManager.addListener(mCallListener); |
| |
| updateCalls(); |
| updateRotaryFocus(); |
| |
| return view; |
| } |
| |
| @Override |
| public void onDestroyView() { |
| super.onDestroyView(); |
| mUiCallManager.removeListener(mCallListener); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| trySpeakerAudioRouteIfNecessary(); |
| } |
| |
| private void rebindViews() { |
| mHandler.removeCallbacks(mUpdateDurationRunnable); |
| |
| // Toggle the visibility between the active call controls, ringing call controls, |
| // and no controls. |
| CharSequence disconnectCauseLabel = mLastRemovedCall == null ? |
| null : mLastRemovedCall.getDisconnectCause(); |
| if (mPrimaryCall == null && !TextUtils.isEmpty(disconnectCauseLabel)) { |
| closeDialpad(); |
| setStateText(disconnectCauseLabel); |
| return; |
| } else if (mPrimaryCall == null || mPrimaryCall.getState() == Call.STATE_DISCONNECTED) { |
| closeDialpad(); |
| setStateText(getString(R.string.call_state_call_ended)); |
| mRingingCallControls.setVisibility(View.GONE); |
| mActiveCallControls.setVisibility(View.GONE); |
| return; |
| } else if (mPrimaryCall.getState() == Call.STATE_RINGING) { |
| mRingingCallControls.setVisibility(View.VISIBLE); |
| mActiveCallControls.setVisibility(View.GONE); |
| } else { |
| mRingingCallControls.setVisibility(View.GONE); |
| mActiveCallControls.setVisibility(View.VISIBLE); |
| } |
| |
| // Show the primary contact photo in the large ImageView on the right if there is no |
| // secondary call. Otherwise, show it in the small ImageView that is inside the card. |
| Context context = getContext(); |
| final ContentResolver cr = context.getContentResolver(); |
| final String primaryNumber = mPrimaryCall.getNumber(); |
| // Don't reload the image if the number is the same. |
| if ((primaryNumber != null && !primaryNumber.equals(mLoadedNumber)) |
| || (primaryNumber == null && mLoadedNumber != null)) { |
| BitmapWorkerTask.BitmapRunnable runnable = new BitmapWorkerTask.BitmapRunnable() { |
| @Override |
| public void run() { |
| if (mBitmap != null) { |
| Resources r = mSmallContactPhotoView.getResources(); |
| mSmallContactPhotoView.setImageDrawable( |
| new CircleBitmapDrawable(r, mBitmap)); |
| mLargeContactPhotoView.setImageBitmap(mBitmap); |
| mLargeContactPhotoView.clearColorFilter(); |
| } else { |
| mSmallContactPhotoView.setImageResource(R.drawable.logo_avatar); |
| mLargeContactPhotoView.setImageResource(R.drawable.ic_avatar_bg); |
| } |
| |
| if (mSecondaryCall != null) { |
| BitmapWorkerTask.BitmapRunnable secondCallContactPhotoHandler = |
| new BitmapWorkerTask.BitmapRunnable() { |
| @Override |
| public void run() { |
| if (mBitmap != null) { |
| mLargeContactPhotoView.setImageBitmap(mBitmap); |
| } else { |
| mLargeContactPhotoView.setImageResource( |
| R.drawable.logo_avatar); |
| } |
| } |
| }; |
| |
| BitmapWorkerTask.loadBitmap( |
| cr, mLargeContactPhotoView, mSecondaryCall.getNumber(), |
| secondCallContactPhotoHandler); |
| |
| int scrimColor = getResources().getColor( |
| R.color.phone_secondary_call_scrim); |
| mLargeContactPhotoView.setColorFilter(scrimColor); |
| } |
| mLoadedNumber = primaryNumber; |
| } |
| }; |
| BitmapWorkerTask.loadBitmap(cr, mLargeContactPhotoView, primaryNumber, runnable); |
| } |
| |
| if (mSecondaryCall != null) { |
| mSecondaryCallContainer.setVisibility(View.VISIBLE); |
| if (mPrimaryCall.getState() == Call.STATE_ACTIVE |
| && mSecondaryCall.getState() == Call.STATE_HOLDING) { |
| mSecondaryCallControls.setVisibility(View.VISIBLE); |
| } else { |
| mSecondaryCallControls.setVisibility(View.GONE); |
| } |
| } else { |
| mSecondaryCallContainer.setVisibility(View.GONE); |
| mSecondaryCallControls.setVisibility(View.GONE); |
| } |
| |
| String displayName = TelecomUtils.getDisplayName(context, mPrimaryCall); |
| mNameTextView.setText(displayName); |
| mNameTextView.setVisibility(TextUtils.isEmpty(displayName) ? View.GONE : View.VISIBLE); |
| |
| if (mSecondaryCall != null) { |
| mSecondaryNameTextView.setText( |
| TelecomUtils.getDisplayName(context, mSecondaryCall)); |
| } |
| |
| switch (mPrimaryCall.getState()) { |
| case Call.STATE_NEW: |
| // Since the content resolver call is only cached when a contact is found, |
| // this should only be called once on a new call to avoid jank. |
| // TODO: consider moving TelecomUtils.getTypeFromNumber into a CursorLoader |
| String number = mPrimaryCall.getNumber(); |
| mCallInfoLabel = TelecomUtils.getTypeFromNumber(context, number); |
| case Call.STATE_CONNECTING: |
| case Call.STATE_DIALING: |
| case Call.STATE_SELECT_PHONE_ACCOUNT: |
| case Call.STATE_HOLDING: |
| case Call.STATE_DISCONNECTED: |
| mHandler.removeCallbacks(mUpdateDurationRunnable); |
| String callInfoText = TelecomUtils.getCallInfoText(context, |
| mPrimaryCall, mCallInfoLabel); |
| setStateText(callInfoText); |
| break; |
| case Call.STATE_ACTIVE: |
| if (mUiBluetoothMonitor.isHfpConnected()) { |
| mHandler.post(mUpdateDurationRunnable); |
| } |
| break; |
| case Call.STATE_RINGING: |
| Log.w(TAG, "There should not be a ringing call in the ongoing call fragment."); |
| break; |
| default: |
| Log.w(TAG, "Unhandled call state: " + mPrimaryCall.getState()); |
| } |
| |
| if (mSecondaryCall != null) { |
| mSecondaryStateTextView.setText( |
| TelecomUtils.callStateToUiString(context, mSecondaryCall.getState())); |
| } |
| |
| // If it is a voicemail call, open the dialpad (with no animation). |
| if (primaryNumber != null && primaryNumber.equals( |
| TelecomUtils.getVoicemailNumber(context))) { |
| if (getResources().getBoolean(R.bool.has_touch)) { |
| openDialpad(false /*animate*/); |
| mToggleDialpadButton.setVisibility(View.GONE); |
| } else { |
| mToggleDialpadButton.setVisibility(View.VISIBLE); |
| mToggleDialpadButton.requestFocus(); |
| } |
| } else { |
| mToggleDialpadButton.setVisibility(View.VISIBLE); |
| } |
| |
| // Handle the holding case. |
| if (mPrimaryCall.getState() == Call.STATE_HOLDING) { |
| mEndCallButton.setVisibility(View.GONE); |
| mUnholdCallButton.setVisibility(View.VISIBLE); |
| mMuteButton.setVisibility(View.INVISIBLE); |
| mToggleDialpadButton.setVisibility(View.INVISIBLE); |
| } else { |
| mEndCallButton.setVisibility(View.VISIBLE); |
| mUnholdCallButton.setVisibility(View.GONE); |
| mMuteButton.setVisibility(View.VISIBLE); |
| mToggleDialpadButton.setVisibility(View.VISIBLE); |
| } |
| } |
| |
| private void setStateText(CharSequence stateText) { |
| mStateTextView.setText(stateText); |
| mStateTextView.setVisibility(TextUtils.isEmpty(stateText) ? View.GONE : View.VISIBLE); |
| } |
| |
| private void updateCalls() { |
| mPrimaryCall = mUiCallManager.getPrimaryCall(); |
| if (mPrimaryCall != null && mPrimaryCall.getState() == Call.STATE_RINGING) { |
| // TODO: update when notifications will work |
| } |
| mSecondaryCall = mUiCallManager.getSecondaryCall(); |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Primary call: " + mPrimaryCall + "\tSecondary call:" + mSecondaryCall); |
| } |
| rebindViews(); |
| } |
| |
| /** |
| * If the phone is using bluetooth: |
| * * Do nothing |
| * If the phone is not using bluetooth: |
| * * If the phone supports bluetooth, use it. |
| * * If the phone doesn't support bluetooth and support speaker, use speaker |
| * * Otherwise, do nothing. Hopefully no phones won't have bt or speaker. |
| */ |
| private void trySpeakerAudioRouteIfNecessary() { |
| if (mUiCallManager == null) { |
| return; |
| } |
| |
| int supportedAudioRouteMask = mUiCallManager.getSupportedAudioRouteMask(); |
| boolean supportsBluetooth = (supportedAudioRouteMask & CallAudioState.ROUTE_BLUETOOTH) != 0; |
| boolean supportsSpeaker = (supportedAudioRouteMask & CallAudioState.ROUTE_SPEAKER) != 0; |
| boolean isUsingBluetooth = |
| mUiCallManager.getAudioRoute() == CallAudioState.ROUTE_BLUETOOTH; |
| |
| if (supportsBluetooth && !isUsingBluetooth) { |
| mUiCallManager.setAudioRoute(CallAudioState.ROUTE_BLUETOOTH); |
| } else if (!supportsBluetooth && supportsSpeaker) { |
| mUiCallManager.setAudioRoute(CallAudioState.ROUTE_SPEAKER); |
| } |
| } |
| |
| private void openDialpad(boolean animate) { |
| if (mToggleDialpadButton.isActivated()) { |
| return; |
| } |
| mToggleDialpadButton.setActivated(true); |
| if (getResources().getBoolean(R.bool.has_touch)) { |
| // This array of of size 2 because getLocationOnScreen returns (x,y) coordinates. |
| int[] location = new int[2]; |
| mToggleDialpadButton.getLocationOnScreen(location); |
| |
| // The dialpad should be aligned with the right edge of mToggleDialpadButton. |
| int startingMargin = location[1] + mToggleDialpadButton.getWidth(); |
| |
| ViewGroup.MarginLayoutParams layoutParams = |
| (ViewGroup.MarginLayoutParams) mDialpadContainer.getLayoutParams(); |
| |
| if (layoutParams.getMarginStart() != startingMargin) { |
| layoutParams.setMarginStart(startingMargin); |
| mDialpadContainer.setLayoutParams(layoutParams); |
| } |
| |
| Animation anim = new DialpadAnimation(getContext(), false /* reverse */, animate); |
| mDialpadContainer.startAnimation(anim); |
| } else { |
| final int toggleButtonImageOffset = getResources().getDimensionPixelSize( |
| R.dimen.in_call_toggle_button_image_offset); |
| final int muteButtonLeftMargin = |
| ((LinearLayout.LayoutParams) mMuteButton.getLayoutParams()).leftMargin; |
| |
| mEndCallButton.animate() |
| .alpha(0) |
| .setStartDelay(0) |
| .setDuration(384) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .withEndAction(() -> { |
| mEndCallButton.setVisibility(View.INVISIBLE); |
| mEndCallButton.setFocusable(false); |
| }).start(); |
| mMuteButton.animate() |
| .alpha(0) |
| .setStartDelay(0) |
| .setDuration(240) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .withEndAction(() -> { |
| mMuteButton.setVisibility(View.INVISIBLE); |
| mMuteButton.setFocusable(false); |
| }).start(); |
| mToggleDialpadButton.animate() |
| .setStartDelay(0) |
| .translationX(-(mEndCallButton.getWidth() + muteButtonLeftMargin |
| + mMuteButton.getWidth() + toggleButtonImageOffset)) |
| .setDuration(480) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .start(); |
| |
| mRotaryDialpad.setTranslationX( |
| -(mEndCallButton.getWidth() + muteButtonLeftMargin + toggleButtonImageOffset)); |
| mRotaryDialpad.animate() |
| .translationX(-(mEndCallButton.getWidth() + muteButtonLeftMargin |
| + mMuteButton.getWidth() + toggleButtonImageOffset)) |
| .setDuration(320) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .setStartDelay(240) |
| .withStartAction(() -> { |
| mRotaryDialpad.setVisibility(View.VISIBLE); |
| int delay = 0; |
| for (View dialpadView : mDialpadViews) { |
| dialpadView.setAlpha(0); |
| dialpadView.animate() |
| .alpha(1) |
| .setDuration(160) |
| .setStartDelay(delay) |
| .setInterpolator(mAccelerateInterpolator) |
| .start(); |
| delay += 10; |
| } |
| }).start(); |
| } |
| } |
| |
| private void closeDialpad() { |
| if (!mToggleDialpadButton.isActivated()) { |
| return; |
| } |
| mToggleDialpadButton.setActivated(false); |
| if (getResources().getBoolean(R.bool.has_touch)) { |
| Animation anim = new DialpadAnimation(getContext(), true /* reverse */); |
| mDialpadContainer.startAnimation(anim); |
| } else { |
| final int toggleButtonImageOffset = getResources().getDimensionPixelSize( |
| R.dimen.in_call_toggle_button_image_offset); |
| final int muteButtonLeftMargin = |
| ((LinearLayout.LayoutParams) mMuteButton.getLayoutParams()).leftMargin; |
| |
| mRotaryDialpad.animate() |
| .setStartDelay(0) |
| .translationX(-(mEndCallButton.getWidth() |
| + muteButtonLeftMargin + toggleButtonImageOffset)) |
| .setDuration(320) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .withStartAction(() -> { |
| int delay = 0; |
| for (int i = mDialpadViews.size() - 1; i >= 0; i--) { |
| View dialpadView = mDialpadViews.get(i); |
| dialpadView.animate() |
| .alpha(0) |
| .setDuration(160) |
| .setStartDelay(delay) |
| .setInterpolator(mAccelerateInterpolator) |
| .start(); |
| delay += 10; |
| } |
| }).withEndAction(() -> { |
| mRotaryDialpad.setVisibility(View.GONE); |
| mRotaryDialpad.setTranslationX(0); |
| }).start(); |
| mToggleDialpadButton.animate() |
| .translationX(0) |
| .setDuration(480) |
| .setStartDelay(80) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .start(); |
| mMuteButton.animate() |
| .alpha(1) |
| .setDuration(176) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .setStartDelay(384) |
| .withStartAction(() -> { |
| mMuteButton.setVisibility(View.VISIBLE); |
| mMuteButton.setFocusable(true); |
| }).start(); |
| mEndCallButton.animate() |
| .alpha(1) |
| .setDuration(320) |
| .setInterpolator(mAccelerateDecelerateInterpolator) |
| .setStartDelay(240) |
| .withStartAction(() -> { |
| mEndCallButton.setVisibility(View.VISIBLE); |
| mEndCallButton.setFocusable(true); |
| }).start(); |
| } |
| } |
| |
| private void updateRotaryFocus() { |
| boolean hasTouch = getResources().getBoolean(R.bool.has_touch); |
| if (mPrimaryCall != null && !hasTouch) { |
| if (mPrimaryCall.getState() == Call.STATE_RINGING) { |
| mRingingCallControls.requestFocus(); |
| } else { |
| mActiveCallControls.requestFocus(); |
| } |
| } |
| } |
| |
| private void setInCallControllerFocusability(boolean focusable) { |
| mSwapButton.setFocusable(focusable); |
| mMergeButton.setFocusable(focusable); |
| |
| mAnswerCallButton.setFocusable(focusable); |
| mRejectCallButton.setFocusable(focusable); |
| |
| mEndCallButton.setFocusable(focusable); |
| mUnholdCallButton.setFocusable(focusable); |
| mMuteButton.setFocusable(focusable); |
| mToggleDialpadButton.setFocusable(focusable); |
| } |
| |
| private void setDialPadFocusability(boolean focusable) { |
| for (View dialPadView : mDialpadViews) { |
| dialPadView.setFocusable(focusable); |
| } |
| } |
| |
| private final View.OnTouchListener mDialpadTouchListener = new View.OnTouchListener() { |
| |
| @Override |
| public boolean onTouch(View v, MotionEvent event) { |
| Character digit = mDialpadButtonMap.get(v.getId()); |
| if (digit == null) { |
| Log.w(TAG, "Unknown dialpad button pressed."); |
| return false; |
| } |
| if (event.getAction() == MotionEvent.ACTION_DOWN) { |
| v.setPressed(true); |
| mUiCallManager.playDtmfTone(mPrimaryCall, digit); |
| return true; |
| } else if (event.getAction() == MotionEvent.ACTION_UP) { |
| v.setPressed(false); |
| v.performClick(); |
| mUiCallManager.stopDtmfTone(mPrimaryCall); |
| return true; |
| } |
| |
| return false; |
| } |
| }; |
| |
| private final View.OnKeyListener mDialpadKeyListener = new View.OnKeyListener() { |
| @Override |
| public boolean onKey(View v, int keyCode, KeyEvent event) { |
| Character digit = mDialpadButtonMap.get(v.getId()); |
| if (digit == null) { |
| Log.w(TAG, "Unknown dialpad button pressed."); |
| return false; |
| } |
| |
| if (event.getKeyCode() != KeyEvent.KEYCODE_DPAD_CENTER) { |
| return false; |
| } |
| |
| if (event.getAction() == KeyEvent.ACTION_DOWN) { |
| v.setPressed(true); |
| mUiCallManager.playDtmfTone(mPrimaryCall, digit); |
| return true; |
| } else if (event.getAction() == KeyEvent.ACTION_UP) { |
| v.setPressed(false); |
| mUiCallManager.stopDtmfTone(mPrimaryCall); |
| return true; |
| } |
| |
| return false; |
| } |
| }; |
| |
| private final Runnable mUpdateDurationRunnable = new Runnable() { |
| @Override |
| public void run() { |
| if (mPrimaryCall.getState() != Call.STATE_ACTIVE) { |
| return; |
| } |
| String callInfoText = TelecomUtils.getCallInfoText(getContext(), |
| mPrimaryCall, mCallInfoLabel); |
| setStateText(callInfoText); |
| mHandler.postDelayed(this /* runnable */, DateUtils.SECOND_IN_MILLIS); |
| } |
| }; |
| |
| private final Runnable mStopDtmfToneRunnable = new Runnable() { |
| @Override |
| public void run() { |
| mUiCallManager.stopDtmfTone(mPrimaryCall); |
| } |
| }; |
| |
| private final class DialpadAnimation extends Animation { |
| private static final int DURATION = 300; |
| private static final float MAX_SCRIM_ALPHA = 0.6f; |
| |
| private final int mStartingTranslation; |
| private final int mScrimColor; |
| private final boolean mReverse; |
| |
| public DialpadAnimation(Context context, boolean reverse) { |
| this(context, reverse, true); |
| } |
| |
| public DialpadAnimation(Context context, boolean reverse, boolean animate) { |
| setDuration(animate ? DURATION : 0); |
| setInterpolator(new AccelerateDecelerateInterpolator()); |
| Resources res = context.getResources(); |
| mStartingTranslation = |
| res.getDimensionPixelOffset(R.dimen.in_call_card_dialpad_translation_x); |
| mScrimColor = res.getColor(R.color.phone_theme); |
| mReverse = reverse; |
| } |
| |
| @Override |
| protected void applyTransformation(float interpolatedTime, Transformation t) { |
| if (mReverse) { |
| interpolatedTime = 1f - interpolatedTime; |
| } |
| int translationX = (int) (mStartingTranslation * (1f - interpolatedTime)); |
| mDialpadContainer.setTranslationX(translationX); |
| mDialpadContainer.setAlpha(interpolatedTime); |
| if (interpolatedTime == 0f) { |
| mDialpadContainer.setVisibility(View.GONE); |
| } else { |
| mDialpadContainer.setVisibility(View.VISIBLE); |
| } |
| float alpha = 255f * interpolatedTime * MAX_SCRIM_ALPHA; |
| mLargeContactPhotoView.setColorFilter(Color.argb((int) alpha, Color.red(mScrimColor), |
| Color.green(mScrimColor), Color.blue(mScrimColor))); |
| |
| mSecondaryNameTextView.setAlpha(1f - interpolatedTime); |
| mSecondaryStateTextView.setAlpha(1f - interpolatedTime); |
| } |
| } |
| |
| private final CallListener mCallListener = new CallListener() { |
| |
| @Override |
| public void onCallAdded(UiCall call) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "on call added"); |
| } |
| updateCalls(); |
| trySpeakerAudioRouteIfNecessary(); |
| } |
| |
| @Override |
| public void onCallRemoved(UiCall call) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "on call removed"); |
| } |
| mLastRemovedCall = call; |
| updateCalls(); |
| } |
| |
| @Override |
| public void onAudioStateChanged(boolean isMuted, int audioRoute, |
| int supportedAudioRouteMask) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "on audio state changed"); |
| } |
| mMuteButton.setActivated(isMuted); |
| trySpeakerAudioRouteIfNecessary(); |
| } |
| |
| @Override |
| public void onStateChanged(UiCall call, int state) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onStateChanged"); |
| } |
| updateCalls(); |
| // this will reset the focus if any state of any call changes on pure rotary devices. |
| updateRotaryFocus(); |
| } |
| |
| @Override |
| public void onCallUpdated(UiCall call) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onCallUpdated"); |
| } |
| updateCalls(); |
| } |
| }; |
| } |
