Home | History | Annotate | Download | only in incallui 
      1 /*
      2  * Copyright (C) 2016 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.ActivityManager;
     20 import android.app.ActivityManager.AppTask;
     21 import android.app.ActivityManager.TaskDescription;
     22 import android.app.AlertDialog;
     23 import android.app.Dialog;
     24 import android.content.Context;
     25 import android.content.DialogInterface;
     26 import android.content.DialogInterface.OnCancelListener;
     27 import android.content.DialogInterface.OnDismissListener;
     28 import android.content.Intent;
     29 import android.content.res.Configuration;
     30 import android.content.res.Resources;
     31 import android.os.Bundle;
     32 import android.support.annotation.IntDef;
     33 import android.support.annotation.NonNull;
     34 import android.support.annotation.Nullable;
     35 import android.support.v4.app.Fragment;
     36 import android.support.v4.app.FragmentManager;
     37 import android.support.v4.app.FragmentTransaction;
     38 import android.support.v4.content.res.ResourcesCompat;
     39 import android.telecom.DisconnectCause;
     40 import android.telecom.PhoneAccountHandle;
     41 import android.text.TextUtils;
     42 import android.util.Pair;
     43 import android.view.KeyEvent;
     44 import android.view.View;
     45 import android.view.Window;
     46 import android.view.WindowManager;
     47 import android.view.animation.Animation;
     48 import android.view.animation.AnimationUtils;
     49 import android.widget.CheckBox;
     50 import android.widget.Toast;
     51 import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment;
     52 import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment.SelectPhoneAccountListener;
     53 import com.android.dialer.animation.AnimUtils;
     54 import com.android.dialer.animation.AnimationListenerAdapter;
     55 import com.android.dialer.common.LogUtil;
     56 import com.android.dialer.compat.CompatUtils;
     57 import com.android.dialer.logging.Logger;
     58 import com.android.dialer.logging.ScreenEvent;
     59 import com.android.dialer.util.ViewUtil;
     60 import com.android.incallui.audiomode.AudioModeProvider;
     61 import com.android.incallui.call.CallList;
     62 import com.android.incallui.call.DialerCall;
     63 import com.android.incallui.call.DialerCall.State;
     64 import com.android.incallui.call.TelecomAdapter;
     65 import com.android.incallui.telecomeventui.InternationalCallOnWifiDialogFragment;
     66 import com.android.incallui.telecomeventui.InternationalCallOnWifiDialogFragment.Callback;
     67 import com.android.incallui.wifi.EnableWifiCallingPrompt;
     68 import java.lang.annotation.Retention;
     69 import java.lang.annotation.RetentionPolicy;
     70 import java.util.ArrayList;
     71 import java.util.List;
     72 
     73 /** Shared functionality between the new and old in call activity. */
     74 public class InCallActivityCommon {
     75 
     76   private static final String INTENT_EXTRA_SHOW_DIALPAD = "InCallActivity.show_dialpad";
     77   private static final String INTENT_EXTRA_NEW_OUTGOING_CALL = "InCallActivity.new_outgoing_call";
     78   private static final String INTENT_EXTRA_FOR_FULL_SCREEN =
     79       "InCallActivity.for_full_screen_intent";
     80 
     81   private static final String DIALPAD_TEXT_KEY = "InCallActivity.dialpad_text";
     82 
     83   private static final String TAG_SELECT_ACCOUNT_FRAGMENT = "tag_select_account_fragment";
     84   private static final String TAG_DIALPAD_FRAGMENT = "tag_dialpad_fragment";
     85   private static final String TAG_INTERNATIONAL_CALL_ON_WIFI = "tag_international_call_on_wifi";
     86 
     87   @Retention(RetentionPolicy.SOURCE)
     88   @IntDef({
     89     DIALPAD_REQUEST_NONE,
     90     DIALPAD_REQUEST_SHOW,
     91     DIALPAD_REQUEST_HIDE,
     92   })
     93   @interface DialpadRequestType {}
     94 
     95   private static final int DIALPAD_REQUEST_NONE = 1;
     96   private static final int DIALPAD_REQUEST_SHOW = 2;
     97   private static final int DIALPAD_REQUEST_HIDE = 3;
     98 
     99   private final InCallActivity inCallActivity;
    100   private boolean dismissKeyguard;
    101   private boolean showPostCharWaitDialogOnResume;
    102   private String showPostCharWaitDialogCallId;
    103   private String showPostCharWaitDialogChars;
    104   private Dialog dialog;
    105   private SelectPhoneAccountDialogFragment selectPhoneAccountDialogFragment;
    106   private InCallOrientationEventListener inCallOrientationEventListener;
    107   private Animation dialpadSlideInAnimation;
    108   private Animation dialpadSlideOutAnimation;
    109   private boolean animateDialpadOnShow;
    110   private String dtmfTextToPreopulate;
    111   @DialpadRequestType private int showDialpadRequest = DIALPAD_REQUEST_NONE;
    112 
    113   private final SelectPhoneAccountListener selectAccountListener =
    114       new SelectPhoneAccountListener() {
    115         @Override
    116         public void onPhoneAccountSelected(
    117             PhoneAccountHandle selectedAccountHandle, boolean setDefault, String callId) {
    118           DialerCall call = CallList.getInstance().getCallById(callId);
    119           LogUtil.i(
    120               "InCallActivityCommon.SelectPhoneAccountListener.onPhoneAccountSelected",
    121               "call: " + call);
    122           if (call != null) {
    123             call.phoneAccountSelected(selectedAccountHandle, setDefault);
    124           }
    125         }
    126 
    127         @Override
    128         public void onDialogDismissed(String callId) {
    129           DialerCall call = CallList.getInstance().getCallById(callId);
    130           LogUtil.i(
    131               "InCallActivityCommon.SelectPhoneAccountListener.onDialogDismissed",
    132               "disconnecting call: " + call);
    133           if (call != null) {
    134             call.disconnect();
    135           }
    136         }
    137       };
    138 
    139   private InternationalCallOnWifiDialogFragment.Callback internationalCallOnWifiCallback =
    140       new Callback() {
    141         @Override
    142         public void continueCall(@NonNull String callId) {
    143           LogUtil.i("InCallActivityCommon.continueCall", "continuing call with id: %s", callId);
    144         }
    145 
    146         @Override
    147         public void cancelCall(@NonNull String callId) {
    148           DialerCall call = CallList.getInstance().getCallById(callId);
    149           if (call == null) {
    150             LogUtil.i("InCallActivityCommon.cancelCall", "call destroyed before dialog closed");
    151             return;
    152           }
    153           LogUtil.i("InCallActivityCommon.cancelCall", "disconnecting international call on wifi");
    154           call.disconnect();
    155         }
    156       };
    157 
    158   public static void setIntentExtras(
    159       Intent intent, boolean showDialpad, boolean newOutgoingCall, boolean isForFullScreen) {
    160     if (showDialpad) {
    161       intent.putExtra(INTENT_EXTRA_SHOW_DIALPAD, true);
    162     }
    163     intent.putExtra(INTENT_EXTRA_NEW_OUTGOING_CALL, newOutgoingCall);
    164     intent.putExtra(INTENT_EXTRA_FOR_FULL_SCREEN, isForFullScreen);
    165   }
    166 
    167   public InCallActivityCommon(InCallActivity inCallActivity) {
    168     this.inCallActivity = inCallActivity;
    169   }
    170 
    171   public void onCreate(Bundle icicle) {
    172     // set this flag so this activity will stay in front of the keyguard
    173     // Have the WindowManager filter out touch events that are "too fat".
    174     int flags =
    175         WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
    176             | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
    177             | WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;
    178 
    179     inCallActivity.getWindow().addFlags(flags);
    180 
    181     inCallActivity.setContentView(R.layout.incall_screen);
    182 
    183     internalResolveIntent(inCallActivity.getIntent());
    184 
    185     boolean isLandscape =
    186         inCallActivity.getResources().getConfiguration().orientation
    187             == Configuration.ORIENTATION_LANDSCAPE;
    188     boolean isRtl = ViewUtil.isRtl();
    189 
    190     if (isLandscape) {
    191       dialpadSlideInAnimation =
    192           AnimationUtils.loadAnimation(
    193               inCallActivity, isRtl ? R.anim.dialpad_slide_in_left : R.anim.dialpad_slide_in_right);
    194       dialpadSlideOutAnimation =
    195           AnimationUtils.loadAnimation(
    196               inCallActivity,
    197               isRtl ? R.anim.dialpad_slide_out_left : R.anim.dialpad_slide_out_right);
    198     } else {
    199       dialpadSlideInAnimation =
    200           AnimationUtils.loadAnimation(inCallActivity, R.anim.dialpad_slide_in_bottom);
    201       dialpadSlideOutAnimation =
    202           AnimationUtils.loadAnimation(inCallActivity, R.anim.dialpad_slide_out_bottom);
    203     }
    204 
    205     dialpadSlideInAnimation.setInterpolator(AnimUtils.EASE_IN);
    206     dialpadSlideOutAnimation.setInterpolator(AnimUtils.EASE_OUT);
    207 
    208     dialpadSlideOutAnimation.setAnimationListener(
    209         new AnimationListenerAdapter() {
    210           @Override
    211           public void onAnimationEnd(Animation animation) {
    212             performHideDialpadFragment();
    213           }
    214         });
    215 
    216     if (icicle != null) {
    217       // If the dialpad was shown before, set variables indicating it should be shown and
    218       // populated with the previous DTMF text.  The dialpad is actually shown and populated
    219       // in onResume() to ensure the hosting fragment has been inflated and is ready to receive it.
    220       if (icicle.containsKey(INTENT_EXTRA_SHOW_DIALPAD)) {
    221         boolean showDialpad = icicle.getBoolean(INTENT_EXTRA_SHOW_DIALPAD);
    222         showDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_HIDE;
    223         animateDialpadOnShow = false;
    224       }
    225       dtmfTextToPreopulate = icicle.getString(DIALPAD_TEXT_KEY);
    226 
    227       SelectPhoneAccountDialogFragment dialogFragment =
    228           (SelectPhoneAccountDialogFragment)
    229               inCallActivity.getFragmentManager().findFragmentByTag(TAG_SELECT_ACCOUNT_FRAGMENT);
    230       if (dialogFragment != null) {
    231         dialogFragment.setListener(selectAccountListener);
    232       }
    233     }
    234 
    235     InternationalCallOnWifiDialogFragment existingInternationalFragment =
    236         (InternationalCallOnWifiDialogFragment)
    237             inCallActivity
    238                 .getSupportFragmentManager()
    239                 .findFragmentByTag(TAG_INTERNATIONAL_CALL_ON_WIFI);
    240     if (existingInternationalFragment != null) {
    241       LogUtil.i(
    242           "InCallActivityCommon.onCreate", "international fragment exists attaching callback");
    243       existingInternationalFragment.setCallback(internationalCallOnWifiCallback);
    244     }
    245 
    246     inCallOrientationEventListener = new InCallOrientationEventListener(inCallActivity);
    247   }
    248 
    249   public void onSaveInstanceState(Bundle out) {
    250     // TODO: The dialpad fragment should handle this as part of its own state
    251     out.putBoolean(INTENT_EXTRA_SHOW_DIALPAD, isDialpadVisible());
    252     DialpadFragment dialpadFragment = getDialpadFragment();
    253     if (dialpadFragment != null) {
    254       out.putString(DIALPAD_TEXT_KEY, dialpadFragment.getDtmfText());
    255     }
    256   }
    257 
    258   public void onStart() {
    259     // setting activity should be last thing in setup process
    260     InCallPresenter.getInstance().setActivity(inCallActivity);
    261     enableInCallOrientationEventListener(
    262         inCallActivity.getRequestedOrientation()
    263             == InCallOrientationEventListener.ACTIVITY_PREFERENCE_ALLOW_ROTATION);
    264 
    265     InCallPresenter.getInstance().onActivityStarted();
    266   }
    267 
    268   public void onResume() {
    269     if (InCallPresenter.getInstance().isReadyForTearDown()) {
    270       LogUtil.i(
    271           "InCallActivityCommon.onResume",
    272           "InCallPresenter is ready for tear down, not sending updates");
    273     } else {
    274       updateTaskDescription();
    275       InCallPresenter.getInstance().onUiShowing(true);
    276     }
    277 
    278     // If there is a pending request to show or hide the dialpad, handle that now.
    279     if (showDialpadRequest != DIALPAD_REQUEST_NONE) {
    280       if (showDialpadRequest == DIALPAD_REQUEST_SHOW) {
    281         // Exit fullscreen so that the user has access to the dialpad hide/show button and
    282         // can hide the dialpad.  Important when showing the dialpad from within dialer.
    283         InCallPresenter.getInstance().setFullScreen(false, true /* force */);
    284 
    285         inCallActivity.showDialpadFragment(true /* show */, animateDialpadOnShow /* animate */);
    286         animateDialpadOnShow = false;
    287 
    288         DialpadFragment dialpadFragment = getDialpadFragment();
    289         if (dialpadFragment != null) {
    290           dialpadFragment.setDtmfText(dtmfTextToPreopulate);
    291           dtmfTextToPreopulate = null;
    292         }
    293       } else {
    294         LogUtil.i("InCallActivityCommon.onResume", "force hide dialpad");
    295         if (getDialpadFragment() != null) {
    296           inCallActivity.showDialpadFragment(false /* show */, false /* animate */);
    297         }
    298       }
    299       showDialpadRequest = DIALPAD_REQUEST_NONE;
    300     }
    301 
    302     if (showPostCharWaitDialogOnResume) {
    303       showPostCharWaitDialog(showPostCharWaitDialogCallId, showPostCharWaitDialogChars);
    304     }
    305 
    306     CallList.getInstance()
    307         .onInCallUiShown(
    308             inCallActivity.getIntent().getBooleanExtra(INTENT_EXTRA_FOR_FULL_SCREEN, false));
    309   }
    310 
    311   // onPause is guaranteed to be called when the InCallActivity goes
    312   // in the background.
    313   public void onPause() {
    314     DialpadFragment dialpadFragment = getDialpadFragment();
    315     if (dialpadFragment != null) {
    316       dialpadFragment.onDialerKeyUp(null);
    317     }
    318 
    319     InCallPresenter.getInstance().onUiShowing(false);
    320     if (inCallActivity.isFinishing()) {
    321       InCallPresenter.getInstance().unsetActivity(inCallActivity);
    322     }
    323   }
    324 
    325   public void onStop() {
    326     enableInCallOrientationEventListener(false);
    327     InCallPresenter.getInstance().updateIsChangingConfigurations();
    328     InCallPresenter.getInstance().onActivityStopped();
    329   }
    330 
    331   public void onDestroy() {
    332     InCallPresenter.getInstance().unsetActivity(inCallActivity);
    333     InCallPresenter.getInstance().updateIsChangingConfigurations();
    334   }
    335 
    336   void onNewIntent(Intent intent, boolean isRecreating) {
    337     LogUtil.i("InCallActivityCommon.onNewIntent", "");
    338 
    339     // We're being re-launched with a new Intent.  Since it's possible for a
    340     // single InCallActivity instance to persist indefinitely (even if we
    341     // finish() ourselves), this sequence can potentially happen any time
    342     // the InCallActivity needs to be displayed.
    343 
    344     // Stash away the new intent so that we can get it in the future
    345     // by calling getIntent().  (Otherwise getIntent() will return the
    346     // original Intent from when we first got created!)
    347     inCallActivity.setIntent(intent);
    348 
    349     // Activities are always paused before receiving a new intent, so
    350     // we can count on our onResume() method being called next.
    351 
    352     // Just like in onCreate(), handle the intent.
    353     // Skip if InCallActivity is going to recreate since this will be called in onCreate().
    354     if (!isRecreating) {
    355       internalResolveIntent(intent);
    356     }
    357   }
    358 
    359   public boolean onBackPressed(boolean isInCallScreenVisible) {
    360     LogUtil.i("InCallActivityCommon.onBackPressed", "");
    361 
    362     // BACK is also used to exit out of any "special modes" of the
    363     // in-call UI:
    364     if (!inCallActivity.isVisible()) {
    365       return true;
    366     }
    367 
    368     if (!isInCallScreenVisible) {
    369       return true;
    370     }
    371 
    372     DialpadFragment dialpadFragment = getDialpadFragment();
    373     if (dialpadFragment != null && dialpadFragment.isVisible()) {
    374       inCallActivity.showDialpadFragment(false /* show */, true /* animate */);
    375       return true;
    376     }
    377 
    378     // Always disable the Back key while an incoming call is ringing
    379     DialerCall call = CallList.getInstance().getIncomingCall();
    380     if (call != null) {
    381       LogUtil.i("InCallActivityCommon.onBackPressed", "consume Back press for an incoming call");
    382       return true;
    383     }
    384 
    385     // Nothing special to do. Fall back to the default behavior.
    386     return false;
    387   }
    388 
    389   public boolean onKeyUp(int keyCode, KeyEvent event) {
    390     DialpadFragment dialpadFragment = getDialpadFragment();
    391     // push input to the dialer.
    392     if (dialpadFragment != null
    393         && (dialpadFragment.isVisible())
    394         && (dialpadFragment.onDialerKeyUp(event))) {
    395       return true;
    396     } else if (keyCode == KeyEvent.KEYCODE_CALL) {
    397       // Always consume CALL to be sure the PhoneWindow won't do anything with it
    398       return true;
    399     }
    400     return false;
    401   }
    402 
    403   public boolean onKeyDown(int keyCode, KeyEvent event) {
    404     switch (keyCode) {
    405       case KeyEvent.KEYCODE_CALL:
    406         boolean handled = InCallPresenter.getInstance().handleCallKey();
    407         if (!handled) {
    408           LogUtil.e(
    409               "InCallActivityCommon.onKeyDown",
    410               "InCallPresenter should always handle KEYCODE_CALL in onKeyDown");
    411         }
    412         // Always consume CALL to be sure the PhoneWindow won't do anything with it
    413         return true;
    414 
    415         // Note there's no KeyEvent.KEYCODE_ENDCALL case here.
    416         // The standard system-wide handling of the ENDCALL key
    417         // (see PhoneWindowManager's handling of KEYCODE_ENDCALL)
    418         // already implements exactly what the UI spec wants,
    419         // namely (1) "hang up" if there's a current active call,
    420         // or (2) "don't answer" if there's a current ringing call.
    421 
    422       case KeyEvent.KEYCODE_CAMERA:
    423         // Disable the CAMERA button while in-call since it's too
    424         // easy to press accidentally.
    425         return true;
    426 
    427       case KeyEvent.KEYCODE_VOLUME_UP:
    428       case KeyEvent.KEYCODE_VOLUME_DOWN:
    429       case KeyEvent.KEYCODE_VOLUME_MUTE:
    430         // Ringer silencing handled by PhoneWindowManager.
    431         break;
    432 
    433       case KeyEvent.KEYCODE_MUTE:
    434         TelecomAdapter.getInstance()
    435             .mute(!AudioModeProvider.getInstance().getAudioState().isMuted());
    436         return true;
    437 
    438         // Various testing/debugging features, enabled ONLY when VERBOSE == true.
    439       case KeyEvent.KEYCODE_SLASH:
    440         if (LogUtil.isVerboseEnabled()) {
    441           LogUtil.v(
    442               "InCallActivityCommon.onKeyDown",
    443               "----------- InCallActivity View dump --------------");
    444           // Dump starting from the top-level view of the entire activity:
    445           Window w = inCallActivity.getWindow();
    446           View decorView = w.getDecorView();
    447           LogUtil.v("InCallActivityCommon.onKeyDown", "View dump:" + decorView);
    448           return true;
    449         }
    450         break;
    451       case KeyEvent.KEYCODE_EQUALS:
    452         break;
    453       default: // fall out
    454     }
    455 
    456     return event.getRepeatCount() == 0 && handleDialerKeyDown(keyCode, event);
    457   }
    458 
    459   private boolean handleDialerKeyDown(int keyCode, KeyEvent event) {
    460     LogUtil.v("InCallActivityCommon.handleDialerKeyDown", "keyCode %d, event: %s", keyCode, event);
    461 
    462     // As soon as the user starts typing valid dialable keys on the
    463     // keyboard (presumably to type DTMF tones) we start passing the
    464     // key events to the DTMFDialer's onDialerKeyDown.
    465     DialpadFragment dialpadFragment = getDialpadFragment();
    466     if (dialpadFragment != null && dialpadFragment.isVisible()) {
    467       return dialpadFragment.onDialerKeyDown(event);
    468     }
    469 
    470     return false;
    471   }
    472 
    473   public void dismissKeyguard(boolean dismiss) {
    474     if (dismissKeyguard == dismiss) {
    475       return;
    476     }
    477     dismissKeyguard = dismiss;
    478     if (dismiss) {
    479       inCallActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
    480     } else {
    481       inCallActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
    482     }
    483   }
    484 
    485   public void showPostCharWaitDialog(String callId, String chars) {
    486     if (inCallActivity.isVisible()) {
    487       PostCharDialogFragment fragment = new PostCharDialogFragment(callId, chars);
    488       fragment.show(inCallActivity.getSupportFragmentManager(), "postCharWait");
    489 
    490       showPostCharWaitDialogOnResume = false;
    491       showPostCharWaitDialogCallId = null;
    492       showPostCharWaitDialogChars = null;
    493     } else {
    494       showPostCharWaitDialogOnResume = true;
    495       showPostCharWaitDialogCallId = callId;
    496       showPostCharWaitDialogChars = chars;
    497     }
    498   }
    499 
    500   public void maybeShowErrorDialogOnDisconnect(DisconnectCause cause) {
    501     LogUtil.i(
    502         "InCallActivityCommon.maybeShowErrorDialogOnDisconnect", "disconnect cause: %s", cause);
    503 
    504     if (!inCallActivity.isFinishing()) {
    505       if (EnableWifiCallingPrompt.shouldShowPrompt(cause)) {
    506         Pair<Dialog, CharSequence> pair =
    507             EnableWifiCallingPrompt.createDialog(inCallActivity, cause);
    508         showErrorDialog(pair.first, pair.second);
    509       } else if (shouldShowDisconnectErrorDialog(cause)) {
    510         Pair<Dialog, CharSequence> pair = getDisconnectErrorDialog(inCallActivity, cause);
    511         showErrorDialog(pair.first, pair.second);
    512       }
    513     }
    514   }
    515 
    516   /**
    517    * When relaunching from the dialer app, {@code showDialpad} indicates whether the dialpad should
    518    * be shown on launch.
    519    *
    520    * @param showDialpad {@code true} to indicate the dialpad should be shown on launch, and {@code
    521    *     false} to indicate no change should be made to the dialpad visibility.
    522    */
    523   private void relaunchedFromDialer(boolean showDialpad) {
    524     showDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_NONE;
    525     animateDialpadOnShow = true;
    526 
    527     if (showDialpadRequest == DIALPAD_REQUEST_SHOW) {
    528       // If there's only one line in use, AND it's on hold, then we're sure the user
    529       // wants to use the dialpad toward the exact line, so un-hold the holding line.
    530       DialerCall call = CallList.getInstance().getActiveOrBackgroundCall();
    531       if (call != null && call.getState() == State.ONHOLD) {
    532         call.unhold();
    533       }
    534     }
    535   }
    536 
    537   void dismissPendingDialogs() {
    538     if (dialog != null) {
    539       dialog.dismiss();
    540       dialog = null;
    541     }
    542     if (selectPhoneAccountDialogFragment != null) {
    543       selectPhoneAccountDialogFragment.dismiss();
    544       selectPhoneAccountDialogFragment = null;
    545     }
    546 
    547     InternationalCallOnWifiDialogFragment internationalCallOnWifiFragment =
    548         (InternationalCallOnWifiDialogFragment)
    549             inCallActivity
    550                 .getSupportFragmentManager()
    551                 .findFragmentByTag(TAG_INTERNATIONAL_CALL_ON_WIFI);
    552     if (internationalCallOnWifiFragment != null) {
    553       LogUtil.i(
    554           "InCallActivityCommon.dismissPendingDialogs",
    555           "dismissing InternationalCallOnWifiDialogFragment");
    556       internationalCallOnWifiFragment.dismiss();
    557     }
    558   }
    559 
    560   private static boolean shouldShowDisconnectErrorDialog(@NonNull DisconnectCause cause) {
    561     return !TextUtils.isEmpty(cause.getDescription())
    562         && (cause.getCode() == DisconnectCause.ERROR
    563             || cause.getCode() == DisconnectCause.RESTRICTED);
    564   }
    565 
    566   private static Pair<Dialog, CharSequence> getDisconnectErrorDialog(
    567       @NonNull Context context, @NonNull DisconnectCause cause) {
    568     CharSequence message = cause.getDescription();
    569     Dialog dialog =
    570         new AlertDialog.Builder(context)
    571             .setMessage(message)
    572             .setPositiveButton(android.R.string.ok, null)
    573             .create();
    574     return new Pair<>(dialog, message);
    575   }
    576 
    577   private void showErrorDialog(Dialog dialog, CharSequence message) {
    578     LogUtil.i("InCallActivityCommon.showErrorDialog", "message: %s", message);
    579     inCallActivity.dismissPendingDialogs();
    580 
    581     // Show toast if apps is in background when dialog won't be visible.
    582     if (!inCallActivity.isVisible()) {
    583       Toast.makeText(inCallActivity.getApplicationContext(), message, Toast.LENGTH_LONG).show();
    584       return;
    585     }
    586 
    587     this.dialog = dialog;
    588     dialog.setOnDismissListener(
    589         new OnDismissListener() {
    590           @Override
    591           public void onDismiss(DialogInterface dialog) {
    592             LogUtil.i("InCallActivityCommon.showErrorDialog", "dialog dismissed");
    593             onDialogDismissed();
    594           }
    595         });
    596     dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
    597     dialog.show();
    598   }
    599 
    600   private void onDialogDismissed() {
    601     dialog = null;
    602     CallList.getInstance().onErrorDialogDismissed();
    603     InCallPresenter.getInstance().onDismissDialog();
    604   }
    605 
    606   public void enableInCallOrientationEventListener(boolean enable) {
    607     if (enable) {
    608       inCallOrientationEventListener.enable(true);
    609     } else {
    610       inCallOrientationEventListener.disable();
    611     }
    612   }
    613 
    614   public void setExcludeFromRecents(boolean exclude) {
    615     List<AppTask> tasks = inCallActivity.getSystemService(ActivityManager.class).getAppTasks();
    616     int taskId = inCallActivity.getTaskId();
    617     for (int i = 0; i < tasks.size(); i++) {
    618       ActivityManager.AppTask task = tasks.get(i);
    619       try {
    620         if (task.getTaskInfo().id == taskId) {
    621           task.setExcludeFromRecents(exclude);
    622         }
    623       } catch (RuntimeException e) {
    624         LogUtil.e(
    625             "InCallActivityCommon.setExcludeFromRecents",
    626             "RuntimeException when excluding task from recents.",
    627             e);
    628       }
    629     }
    630   }
    631 
    632   void showInternationalCallOnWifiDialog(@NonNull DialerCall call) {
    633     LogUtil.enterBlock("InCallActivityCommon.showInternationalCallOnWifiDialog");
    634     if (!InternationalCallOnWifiDialogFragment.shouldShow(inCallActivity)) {
    635       LogUtil.i(
    636           "InCallActivityCommon.showInternationalCallOnWifiDialog",
    637           "InternationalCallOnWifiDialogFragment.shouldShow returned false");
    638       return;
    639     }
    640 
    641     InternationalCallOnWifiDialogFragment fragment =
    642         InternationalCallOnWifiDialogFragment.newInstance(
    643             call.getId(), internationalCallOnWifiCallback);
    644     fragment.show(inCallActivity.getSupportFragmentManager(), TAG_INTERNATIONAL_CALL_ON_WIFI);
    645   }
    646 
    647   public void showWifiToLteHandoverToast(DialerCall call) {
    648     if (call.hasShownWiFiToLteHandoverToast()) {
    649       return;
    650     }
    651     Toast.makeText(
    652             inCallActivity, R.string.video_call_wifi_to_lte_handover_toast, Toast.LENGTH_LONG)
    653         .show();
    654     call.setHasShownWiFiToLteHandoverToast();
    655   }
    656 
    657   public void showWifiFailedDialog(final DialerCall call) {
    658     if (call.showWifiHandoverAlertAsToast()) {
    659       LogUtil.i("InCallActivityCommon.showWifiFailedDialog", "as toast");
    660       Toast.makeText(
    661               inCallActivity, R.string.video_call_lte_to_wifi_failed_message, Toast.LENGTH_SHORT)
    662           .show();
    663       return;
    664     }
    665 
    666     dismissPendingDialogs();
    667 
    668     AlertDialog.Builder builder =
    669         new AlertDialog.Builder(inCallActivity)
    670             .setTitle(R.string.video_call_lte_to_wifi_failed_title);
    671 
    672     // This allows us to use the theme of the dialog instead of the activity
    673     View dialogCheckBoxView =
    674         View.inflate(builder.getContext(), R.layout.video_call_lte_to_wifi_failed, null);
    675     final CheckBox wifiHandoverFailureCheckbox =
    676         (CheckBox) dialogCheckBoxView.findViewById(R.id.video_call_lte_to_wifi_failed_checkbox);
    677     wifiHandoverFailureCheckbox.setChecked(false);
    678 
    679     dialog =
    680         builder
    681             .setView(dialogCheckBoxView)
    682             .setMessage(R.string.video_call_lte_to_wifi_failed_message)
    683             .setOnCancelListener(
    684                 new OnCancelListener() {
    685                   @Override
    686                   public void onCancel(DialogInterface dialog) {
    687                     onDialogDismissed();
    688                   }
    689                 })
    690             .setPositiveButton(
    691                 android.R.string.ok,
    692                 new DialogInterface.OnClickListener() {
    693                   @Override
    694                   public void onClick(DialogInterface dialog, int id) {
    695                     call.setDoNotShowDialogForHandoffToWifiFailure(
    696                         wifiHandoverFailureCheckbox.isChecked());
    697                     dialog.cancel();
    698                     onDialogDismissed();
    699                   }
    700                 })
    701             .create();
    702 
    703     LogUtil.i("InCallActivityCommon.showWifiFailedDialog", "as dialog");
    704     dialog.show();
    705   }
    706 
    707   public boolean showDialpadFragment(boolean show, boolean animate) {
    708     // If the dialpad is already visible, don't animate in. If it's gone, don't animate out.
    709     boolean isDialpadVisible = isDialpadVisible();
    710     LogUtil.i(
    711         "InCallActivityCommon.showDialpadFragment",
    712         "show: %b, animate: %b, " + "isDialpadVisible: %b",
    713         show,
    714         animate,
    715         isDialpadVisible);
    716     if (show == isDialpadVisible) {
    717       return false;
    718     }
    719 
    720     FragmentManager dialpadFragmentManager = inCallActivity.getDialpadFragmentManager();
    721     if (dialpadFragmentManager == null) {
    722       LogUtil.i(
    723           "InCallActivityCommon.showDialpadFragment", "unable to show or hide dialpad fragment");
    724       return false;
    725     }
    726 
    727     // We don't do a FragmentTransaction on the hide case because it will be dealt with when
    728     // the listener is fired after an animation finishes.
    729     if (!animate) {
    730       if (show) {
    731         performShowDialpadFragment(dialpadFragmentManager);
    732       } else {
    733         performHideDialpadFragment();
    734       }
    735     } else {
    736       if (show) {
    737         performShowDialpadFragment(dialpadFragmentManager);
    738         getDialpadFragment().animateShowDialpad();
    739       }
    740       getDialpadFragment()
    741           .getView()
    742           .startAnimation(show ? dialpadSlideInAnimation : dialpadSlideOutAnimation);
    743     }
    744 
    745     ProximitySensor sensor = InCallPresenter.getInstance().getProximitySensor();
    746     if (sensor != null) {
    747       sensor.onDialpadVisible(show);
    748     }
    749     showDialpadRequest = DIALPAD_REQUEST_NONE;
    750     return true;
    751   }
    752 
    753   private void performShowDialpadFragment(@NonNull FragmentManager dialpadFragmentManager) {
    754     FragmentTransaction transaction = dialpadFragmentManager.beginTransaction();
    755     DialpadFragment dialpadFragment = getDialpadFragment();
    756     if (dialpadFragment == null) {
    757       transaction.add(
    758           inCallActivity.getDialpadContainerId(), new DialpadFragment(), TAG_DIALPAD_FRAGMENT);
    759     } else {
    760       transaction.show(dialpadFragment);
    761     }
    762 
    763     transaction.commitAllowingStateLoss();
    764     dialpadFragmentManager.executePendingTransactions();
    765 
    766     Logger.get(inCallActivity).logScreenView(ScreenEvent.Type.INCALL_DIALPAD, inCallActivity);
    767   }
    768 
    769   private void performHideDialpadFragment() {
    770     FragmentManager fragmentManager = inCallActivity.getDialpadFragmentManager();
    771     if (fragmentManager == null) {
    772       LogUtil.e(
    773           "InCallActivityCommon.performHideDialpadFragment", "child fragment manager is null");
    774       return;
    775     }
    776 
    777     Fragment fragment = fragmentManager.findFragmentByTag(TAG_DIALPAD_FRAGMENT);
    778     if (fragment != null) {
    779       FragmentTransaction transaction = fragmentManager.beginTransaction();
    780       transaction.hide(fragment);
    781       transaction.commitAllowingStateLoss();
    782       fragmentManager.executePendingTransactions();
    783     }
    784   }
    785 
    786   public boolean isDialpadVisible() {
    787     DialpadFragment dialpadFragment = getDialpadFragment();
    788     return dialpadFragment != null && dialpadFragment.isVisible();
    789   }
    790 
    791   /** Returns the {@link DialpadFragment} that's shown by this activity, or {@code null} */
    792   @Nullable
    793   private DialpadFragment getDialpadFragment() {
    794     FragmentManager fragmentManager = inCallActivity.getDialpadFragmentManager();
    795     if (fragmentManager == null) {
    796       return null;
    797     }
    798     return (DialpadFragment) fragmentManager.findFragmentByTag(TAG_DIALPAD_FRAGMENT);
    799   }
    800 
    801   public void updateTaskDescription() {
    802     Resources resources = inCallActivity.getResources();
    803     int color;
    804     if (resources.getBoolean(R.bool.is_layout_landscape)) {
    805       color =
    806           ResourcesCompat.getColor(
    807               resources, R.color.statusbar_background_color, inCallActivity.getTheme());
    808     } else {
    809       color = InCallPresenter.getInstance().getThemeColorManager().getSecondaryColor();
    810     }
    811 
    812     TaskDescription td =
    813         new TaskDescription(resources.getString(R.string.notification_ongoing_call), null, color);
    814     inCallActivity.setTaskDescription(td);
    815   }
    816 
    817   public boolean hasPendingDialogs() {
    818     return dialog != null;
    819   }
    820 
    821   private void internalResolveIntent(Intent intent) {
    822     if (!intent.getAction().equals(Intent.ACTION_MAIN)) {
    823       return;
    824     }
    825 
    826     if (intent.hasExtra(INTENT_EXTRA_SHOW_DIALPAD)) {
    827       // SHOW_DIALPAD_EXTRA can be used here to specify whether the DTMF
    828       // dialpad should be initially visible.  If the extra isn't
    829       // present at all, we just leave the dialpad in its previous state.
    830       boolean showDialpad = intent.getBooleanExtra(INTENT_EXTRA_SHOW_DIALPAD, false);
    831       LogUtil.i("InCallActivityCommon.internalResolveIntent", "SHOW_DIALPAD_EXTRA: " + showDialpad);
    832 
    833       relaunchedFromDialer(showDialpad);
    834     }
    835 
    836     DialerCall outgoingCall = CallList.getInstance().getOutgoingCall();
    837     if (outgoingCall == null) {
    838       outgoingCall = CallList.getInstance().getPendingOutgoingCall();
    839     }
    840 
    841     if (intent.getBooleanExtra(INTENT_EXTRA_NEW_OUTGOING_CALL, false)) {
    842       intent.removeExtra(INTENT_EXTRA_NEW_OUTGOING_CALL);
    843 
    844       // InCallActivity is responsible for disconnecting a new outgoing call if there
    845       // is no way of making it (i.e. no valid call capable accounts).
    846       // If the version is not MSIM compatible, then ignore this code.
    847       if (CompatUtils.isMSIMCompatible()
    848           && InCallPresenter.isCallWithNoValidAccounts(outgoingCall)) {
    849         LogUtil.i(
    850             "InCallActivityCommon.internalResolveIntent",
    851             "call with no valid accounts, disconnecting");
    852         outgoingCall.disconnect();
    853       }
    854 
    855       dismissKeyguard(true);
    856     }
    857 
    858     boolean didShowAccountSelectionDialog = maybeShowAccountSelectionDialog();
    859     if (didShowAccountSelectionDialog) {
    860       inCallActivity.hideMainInCallFragment();
    861     }
    862   }
    863 
    864   private boolean maybeShowAccountSelectionDialog() {
    865     DialerCall waitingForAccountCall = CallList.getInstance().getWaitingForAccountCall();
    866     if (waitingForAccountCall == null) {
    867       return false;
    868     }
    869 
    870     Bundle extras = waitingForAccountCall.getIntentExtras();
    871     List<PhoneAccountHandle> phoneAccountHandles;
    872     if (extras != null) {
    873       phoneAccountHandles =
    874           extras.getParcelableArrayList(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
    875     } else {
    876       phoneAccountHandles = new ArrayList<>();
    877     }
    878 
    879     selectPhoneAccountDialogFragment =
    880         SelectPhoneAccountDialogFragment.newInstance(
    881             R.string.select_phone_account_for_calls,
    882             true,
    883             phoneAccountHandles,
    884             selectAccountListener,
    885             waitingForAccountCall.getId());
    886     selectPhoneAccountDialogFragment.show(
    887         inCallActivity.getFragmentManager(), TAG_SELECT_ACCOUNT_FRAGMENT);
    888     return true;
    889   }
    890 }
    891