Update dialer sources.

Test: Built package and system image.

This change clobbers the old source, and is an export
from an internal Google repository.

The internal repository was forked form Android in March,
and this change includes modifications since then, to
near the v8 release.

Since the fork, we've moved code from monolithic to independent modules. In addition,
we've switched to Blaze/Bazel as the build sysetm. This export, however, still uses make.

New dependencies have been added:
- Dagger
- Auto-Value
- Glide
- Libshortcutbadger

Going forward, development will still be in Google3, and the Gerrit release
will become an automated export, with the next drop happening in ~ two weeks.

Android.mk includes local modifications from ToT.

Abridged changelog:

Bug fixes
● Not able to mute, add a call when using Phone app in multiwindow mode
● Double tap on keypad triggering multiple key and tones
● Reported spam numbers not showing as spam in the call log
● Crash when user tries to block number while Phone app is not set as default
● Crash when user picks a number from search auto-complete list

Visual Voicemail (VVM) improvements
● Share Voicemail audio via standard exporting mechanisms that support file attachment
(email, MMS, etc.)
● Make phone number, email and web sites in VVM transcript clickable
● Set PIN before declining VVM Terms of Service {Carrier}
● Set client type for outbound visual voicemail SMS {Carrier}

New incoming call and incall UI on older devices
(Android M)
● Updated Phone app icon
● New incall UI (large buttons, button labels)
● New and animated Answer/Reject gestures

Accessibility
● Add custom answer/decline call buttons on answer screen for touch exploration
accessibility services
● Increase size of touch target
● Add verbal feedback when a Voicemail fails to load
● Fix pressing of Phone buttons while in a phone call using Switch Access
● Fix selecting and opening contacts in talkback mode
● Split focus for ‘Learn More’ link in caller id & spam to help distinguish similar text

Other
● Backup & Restore for App Preferences
● Prompt user to enable Wi-Fi calling if the call ends due to out of service and Wi-Fi is
connected
● Rename “Dialpad” to “Keypad”
● Show "Private number" for restricted calls
● Delete unused items (vcard, add contact, call history) from Phone menu

Change-Id: I2a7e53532a24c21bf308bf0a6d178d7ddbca4958

1 files changed, 1110 insertions, 0 deletions

diff --git a/java/com/android/incallui/CallCardPresenter.java b/java/com/android/incallui/CallCardPresenter.java
new file mode 100644
index 000000000..930775772
--- /dev/null
+++ b/java/com/android/incallui/CallCardPresenter.java
@@ -0,0 +1,1110 @@
+/*
+ * 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 static com.android.contacts.common.compat.CallCompat.Details.PROPERTY_ENTERPRISE_CALL;
+
+import android.Manifest;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.Drawable;
+import android.hardware.display.DisplayManager;
+import android.os.BatteryManager;
+import android.os.Handler;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v4.content.ContextCompat;
+import android.telecom.Call.Details;
+import android.telecom.StatusHints;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.view.Display;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityManager;
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.enrichedcall.EnrichedCallManager;
+import com.android.dialer.enrichedcall.Session;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallEventListener;
+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.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCallListener;
+import com.android.incallui.incall.protocol.ContactPhotoType;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import java.lang.ref.WeakReference;
+
+/**
+ * Controller for the Call Card Fragment. This class listens for changes to InCallState and passes
+ * it along to the fragment.
+ */
+public class CallCardPresenter
+    implements InCallStateListener,
+        IncomingCallListener,
+        InCallDetailsListener,
+        InCallEventListener,
+        InCallScreenDelegate,
+        DialerCallListener,
+        EnrichedCallManager.StateChangedListener {
+
+  /**
+   * Amount of time to wait before sending an announcement via the accessibility manager. When the
+   * call state changes to an outgoing or incoming state for the first time, the UI can often be
+   * changing due to call updates or contact lookup. This allows the UI to settle to a stable state
+   * to ensure that the correct information is announced.
+   */
+  private static final long ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS = 500;
+
+  /** Flag to allow the user's current location to be shown during emergency calls. */
+  private static final String CONFIG_ENABLE_EMERGENCY_LOCATION = "config_enable_emergency_location";
+
+  private static final boolean CONFIG_ENABLE_EMERGENCY_LOCATION_DEFAULT = true;
+
+  /**
+   * Make it possible to not get location during an emergency call if the battery is too low, since
+   * doing so could trigger gps and thus potentially cause the phone to die in the middle of the
+   * call.
+   */
+  private static final String CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION =
+      "min_battery_percent_for_emergency_location";
+
+  private static final long CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT = 10;
+
+  private final Context mContext;
+  private final Handler handler = new Handler();
+
+  private DialerCall mPrimary;
+  private DialerCall mSecondary;
+  private ContactCacheEntry mPrimaryContactInfo;
+  private ContactCacheEntry mSecondaryContactInfo;
+  @Nullable private ContactsPreferences mContactsPreferences;
+  private boolean mIsFullscreen = false;
+  private InCallScreen mInCallScreen;
+  private boolean isInCallScreenReady;
+  private boolean shouldSendAccessibilityEvent;
+  private final String locationModule = null;
+  private final Runnable sendAccessibilityEventRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          shouldSendAccessibilityEvent = !sendAccessibilityEvent(mContext, getUi());
+          LogUtil.i(
+              "CallCardPresenter.sendAccessibilityEventRunnable",
+              "still should send: %b",
+              shouldSendAccessibilityEvent);
+          if (!shouldSendAccessibilityEvent) {
+            handler.removeCallbacks(this);
+          }
+        }
+      };
+
+  public CallCardPresenter(Context context) {
+    LogUtil.i("CallCardController.constructor", null);
+    mContext = Assert.isNotNull(context).getApplicationContext();
+  }
+
+  private static boolean hasCallSubject(DialerCall call) {
+    return !TextUtils.isEmpty(call.getCallSubject());
+  }
+
+  @Override
+  public void onInCallScreenDelegateInit(InCallScreen inCallScreen) {
+    Assert.isNotNull(inCallScreen);
+    mInCallScreen = inCallScreen;
+    mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+
+    // Call may be null if disconnect happened already.
+    DialerCall call = CallList.getInstance().getFirstCall();
+    if (call != null) {
+      mPrimary = call;
+      if (shouldShowNoteSentToast(mPrimary)) {
+        mInCallScreen.showNoteSentToast();
+      }
+      call.addListener(this);
+
+      // start processing lookups right away.
+      if (!call.isConferenceCall()) {
+        startContactInfoSearch(call, true, call.getState() == DialerCall.State.INCOMING);
+      } else {
+        updateContactEntry(null, true);
+      }
+    }
+
+    onStateChange(null, InCallPresenter.getInstance().getInCallState(), CallList.getInstance());
+  }
+
+  @Override
+  public void onInCallScreenReady() {
+    LogUtil.i("CallCardController.onInCallScreenReady", null);
+    Assert.checkState(!isInCallScreenReady);
+    if (mContactsPreferences != null) {
+      mContactsPreferences.refreshValue(ContactsPreferences.DISPLAY_ORDER_KEY);
+    }
+
+    EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+        .registerStateChangedListener(this);
+
+    // Contact search may have completed before ui is ready.
+    if (mPrimaryContactInfo != null) {
+      updatePrimaryDisplayInfo();
+    }
+
+    // Register for call state changes last
+    InCallPresenter.getInstance().addListener(this);
+    InCallPresenter.getInstance().addIncomingCallListener(this);
+    InCallPresenter.getInstance().addDetailsListener(this);
+    InCallPresenter.getInstance().addInCallEventListener(this);
+    isInCallScreenReady = true;
+  }
+
+  @Override
+  public void onInCallScreenUnready() {
+    LogUtil.i("CallCardController.onInCallScreenUnready", null);
+    Assert.checkState(isInCallScreenReady);
+
+    EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+        .unregisterStateChangedListener(this);
+    // stop getting call state changes
+    InCallPresenter.getInstance().removeListener(this);
+    InCallPresenter.getInstance().removeIncomingCallListener(this);
+    InCallPresenter.getInstance().removeDetailsListener(this);
+    InCallPresenter.getInstance().removeInCallEventListener(this);
+    if (mPrimary != null) {
+      mPrimary.removeListener(this);
+    }
+
+    mPrimary = null;
+    mPrimaryContactInfo = null;
+    mSecondaryContactInfo = null;
+    isInCallScreenReady = false;
+  }
+
+  @Override
+  public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) {
+    // same logic should happen as with onStateChange()
+    onStateChange(oldState, newState, CallList.getInstance());
+  }
+
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    LogUtil.v("CallCardPresenter.onStateChange", "" + newState);
+    if (mInCallScreen == null) {
+      return;
+    }
+
+    DialerCall primary = null;
+    DialerCall secondary = null;
+
+    if (newState == InCallState.INCOMING) {
+      primary = callList.getIncomingCall();
+    } else if (newState == InCallState.PENDING_OUTGOING || newState == InCallState.OUTGOING) {
+      primary = callList.getOutgoingCall();
+      if (primary == null) {
+        primary = callList.getPendingOutgoingCall();
+      }
+
+      // getCallToDisplay doesn't go through outgoing or incoming calls. It will return the
+      // highest priority call to display as the secondary call.
+      secondary = getCallToDisplay(callList, null, true);
+    } else if (newState == InCallState.INCALL) {
+      primary = getCallToDisplay(callList, null, false);
+      secondary = getCallToDisplay(callList, primary, true);
+    }
+
+    LogUtil.v("CallCardPresenter.onStateChange", "primary call: " + primary);
+    LogUtil.v("CallCardPresenter.onStateChange", "secondary call: " + secondary);
+
+    final boolean primaryChanged =
+        !(DialerCall.areSame(mPrimary, primary) && DialerCall.areSameNumber(mPrimary, primary));
+    final boolean secondaryChanged =
+        !(DialerCall.areSame(mSecondary, secondary)
+            && DialerCall.areSameNumber(mSecondary, secondary));
+
+    mSecondary = secondary;
+    DialerCall previousPrimary = mPrimary;
+    mPrimary = primary;
+
+    if (mPrimary != null) {
+      InCallPresenter.getInstance().onForegroundCallChanged(mPrimary);
+      mInCallScreen.updateInCallScreenColors();
+    }
+
+    if (primaryChanged && shouldShowNoteSentToast(primary)) {
+      mInCallScreen.showNoteSentToast();
+    }
+
+    // Refresh primary call information if either:
+    // 1. Primary call changed.
+    // 2. The call's ability to manage conference has changed.
+    if (shouldRefreshPrimaryInfo(primaryChanged)) {
+      // primary call has changed
+      if (previousPrimary != null) {
+        previousPrimary.removeListener(this);
+      }
+      mPrimary.addListener(this);
+
+      mPrimaryContactInfo =
+          ContactInfoCache.buildCacheEntryFromCall(
+              mContext, mPrimary, mPrimary.getState() == DialerCall.State.INCOMING);
+      updatePrimaryDisplayInfo();
+      maybeStartSearch(mPrimary, true);
+      maybeClearSessionModificationState(mPrimary);
+    }
+
+    if (previousPrimary != null && mPrimary == null) {
+      previousPrimary.removeListener(this);
+    }
+
+    if (mSecondary == null) {
+      // Secondary call may have ended.  Update the ui.
+      mSecondaryContactInfo = null;
+      updateSecondaryDisplayInfo();
+    } else if (secondaryChanged) {
+      // secondary call has changed
+      mSecondaryContactInfo =
+          ContactInfoCache.buildCacheEntryFromCall(
+              mContext, mSecondary, mSecondary.getState() == DialerCall.State.INCOMING);
+      updateSecondaryDisplayInfo();
+      maybeStartSearch(mSecondary, false);
+      maybeClearSessionModificationState(mSecondary);
+    }
+
+    // Set the call state
+    int callState = DialerCall.State.IDLE;
+    if (mPrimary != null) {
+      callState = mPrimary.getState();
+      updatePrimaryCallState();
+    } else {
+      getUi().setCallState(PrimaryCallState.createEmptyPrimaryCallState());
+    }
+
+    maybeShowManageConferenceCallButton();
+
+    // Hide the end call button instantly if we're receiving an incoming call.
+    getUi()
+        .setEndCallButtonEnabled(
+            shouldShowEndCallButton(mPrimary, callState),
+            callState != DialerCall.State.INCOMING /* animate */);
+
+    maybeSendAccessibilityEvent(oldState, newState, primaryChanged);
+  }
+
+  @Override
+  public void onDetailsChanged(DialerCall call, Details details) {
+    updatePrimaryCallState();
+
+    if (call.can(Details.CAPABILITY_MANAGE_CONFERENCE)
+        != details.can(Details.CAPABILITY_MANAGE_CONFERENCE)) {
+      maybeShowManageConferenceCallButton();
+    }
+  }
+
+  @Override
+  public void onDialerCallDisconnect() {}
+
+  @Override
+  public void onDialerCallUpdate() {
+    // No-op; specific call updates handled elsewhere.
+  }
+
+  @Override
+  public void onWiFiToLteHandover() {}
+
+  @Override
+  public void onHandoverToWifiFailure() {}
+
+  /** Handles a change to the child number by refreshing the primary call info. */
+  @Override
+  public void onDialerCallChildNumberChange() {
+    LogUtil.v("CallCardPresenter.onDialerCallChildNumberChange", "");
+
+    if (mPrimary == null) {
+      return;
+    }
+    updatePrimaryDisplayInfo();
+  }
+
+  /** Handles a change to the last forwarding number by refreshing the primary call info. */
+  @Override
+  public void onDialerCallLastForwardedNumberChange() {
+    LogUtil.v("CallCardPresenter.onDialerCallLastForwardedNumberChange", "");
+
+    if (mPrimary == null) {
+      return;
+    }
+    updatePrimaryDisplayInfo();
+    updatePrimaryCallState();
+  }
+
+  @Override
+  public void onDialerCallUpgradeToVideo() {}
+
+  /**
+   * Handles a change to the session modification state for a call.
+   *
+   * @param sessionModificationState The new session modification state.
+   */
+  @Override
+  public void onDialerCallSessionModificationStateChange(
+      @SessionModificationState int sessionModificationState) {
+    LogUtil.v(
+        "CallCardPresenter.onDialerCallSessionModificationStateChange",
+        "state: " + sessionModificationState);
+
+    if (mPrimary == null) {
+      return;
+    }
+    getUi()
+        .setEndCallButtonEnabled(
+            sessionModificationState
+                != DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST,
+            true /* shouldAnimate */);
+    updatePrimaryCallState();
+  }
+
+  @Override
+  public void onEnrichedCallStateChanged() {
+    LogUtil.enterBlock("CallCardPresenter.onEnrichedCallStateChanged");
+    updatePrimaryDisplayInfo();
+  }
+
+  private boolean shouldRefreshPrimaryInfo(boolean primaryChanged) {
+    if (mPrimary == null) {
+      return false;
+    }
+    return primaryChanged
+        || mInCallScreen.isManageConferenceVisible() != shouldShowManageConference();
+  }
+
+  private void updatePrimaryCallState() {
+    if (getUi() != null && mPrimary != null) {
+      boolean isWorkCall =
+          mPrimary.hasProperty(PROPERTY_ENTERPRISE_CALL)
+              || (mPrimaryContactInfo != null
+                  && mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+      boolean isHdAudioCall =
+          isPrimaryCallActive() && mPrimary.hasProperty(Details.PROPERTY_HIGH_DEF_AUDIO);
+      // Check for video state change and update the visibility of the contact photo.  The contact
+      // photo is hidden when the incoming video surface is shown.
+      // The contact photo visibility can also change in setPrimary().
+      boolean shouldShowContactPhoto =
+          !VideoCallPresenter.showIncomingVideo(mPrimary.getVideoState(), mPrimary.getState());
+      getUi()
+          .setCallState(
+              new PrimaryCallState(
+                  mPrimary.getState(),
+                  mPrimary.getVideoState(),
+                  mPrimary.getSessionModificationState(),
+                  mPrimary.getDisconnectCause(),
+                  getConnectionLabel(),
+                  getCallStateIcon(),
+                  getGatewayNumber(),
+                  shouldShowCallSubject(mPrimary) ? mPrimary.getCallSubject() : null,
+                  mPrimary.getCallbackNumber(),
+                  mPrimary.hasProperty(Details.PROPERTY_WIFI),
+                  mPrimary.isConferenceCall(),
+                  isWorkCall,
+                  isHdAudioCall,
+                  !TextUtils.isEmpty(mPrimary.getLastForwardedNumber()),
+                  shouldShowContactPhoto,
+                  mPrimary.getConnectTimeMillis(),
+                  CallerInfoUtils.isVoiceMailNumber(mContext, mPrimary),
+                  mPrimary.isRemotelyHeld()));
+
+      InCallActivity activity =
+          (InCallActivity) (mInCallScreen.getInCallScreenFragment().getActivity());
+      if (activity != null) {
+        activity.onPrimaryCallStateChanged();
+      }
+    }
+  }
+
+  /** Only show the conference call button if we can manage the conference. */
+  private void maybeShowManageConferenceCallButton() {
+    getUi().showManageConferenceCallButton(shouldShowManageConference());
+  }
+
+  /**
+   * Determines if the manage conference button should be visible, based on the current primary
+   * call.
+   *
+   * @return {@code True} if the manage conference button should be visible.
+   */
+  private boolean shouldShowManageConference() {
+    if (mPrimary == null) {
+      return false;
+    }
+
+    return mPrimary.can(android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE)
+        && !mIsFullscreen;
+  }
+
+  @Override
+  public void onCallStateButtonClicked() {
+    Intent broadcastIntent = Bindings.get(mContext).getCallStateButtonBroadcastIntent(mContext);
+    if (broadcastIntent != null) {
+      LogUtil.v(
+          "CallCardPresenter.onCallStateButtonClicked",
+          "sending call state button broadcast: " + broadcastIntent);
+      mContext.sendBroadcast(broadcastIntent, Manifest.permission.READ_PHONE_STATE);
+    }
+  }
+
+  @Override
+  public void onManageConferenceClicked() {
+    InCallActivity activity =
+        (InCallActivity) (mInCallScreen.getInCallScreenFragment().getActivity());
+    activity.showConferenceFragment(true);
+  }
+
+  @Override
+  public void onShrinkAnimationComplete() {
+    InCallPresenter.getInstance().onShrinkAnimationComplete();
+  }
+
+  @Override
+  public Drawable getDefaultContactPhotoDrawable() {
+    return ContactInfoCache.getInstance(mContext).getDefaultContactPhotoDrawable();
+  }
+
+  private void maybeStartSearch(DialerCall call, boolean isPrimary) {
+    // no need to start search for conference calls which show generic info.
+    if (call != null && !call.isConferenceCall()) {
+      startContactInfoSearch(call, isPrimary, call.getState() == DialerCall.State.INCOMING);
+    }
+  }
+
+  private void maybeClearSessionModificationState(DialerCall call) {
+    @SessionModificationState int state = call.getSessionModificationState();
+    if (state != DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST
+        && state != DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      LogUtil.i("CallCardPresenter.maybeClearSessionModificationState", "clearing state");
+      call.setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    }
+  }
+
+  /** Starts a query for more contact data for the save primary and secondary calls. */
+  private void startContactInfoSearch(
+      final DialerCall call, final boolean isPrimary, boolean isIncoming) {
+    final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
+
+    cache.findInfo(call, isIncoming, new ContactLookupCallback(this, isPrimary));
+  }
+
+  private void onContactInfoComplete(String callId, ContactCacheEntry entry, boolean isPrimary) {
+    final boolean entryMatchesExistingCall =
+        (isPrimary && mPrimary != null && TextUtils.equals(callId, mPrimary.getId()))
+            || (!isPrimary && mSecondary != null && TextUtils.equals(callId, mSecondary.getId()));
+    if (entryMatchesExistingCall) {
+      updateContactEntry(entry, isPrimary);
+    } else {
+      LogUtil.e(
+          "CallCardPresenter.onContactInfoComplete",
+          "dropping stale contact lookup info for " + callId);
+    }
+
+    final DialerCall call = CallList.getInstance().getCallById(callId);
+    if (call != null) {
+      call.getLogState().contactLookupResult = entry.contactLookupResult;
+    }
+    if (entry.contactUri != null) {
+      CallerInfoUtils.sendViewNotification(mContext, entry.contactUri);
+    }
+  }
+
+  private void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+    if (getUi() == null) {
+      return;
+    }
+
+    if (entry.photo != null) {
+      if (mPrimary != null && callId.equals(mPrimary.getId())) {
+        updateContactEntry(entry, true /* isPrimary */);
+      } else if (mSecondary != null && callId.equals(mSecondary.getId())) {
+        updateContactEntry(entry, false /* isPrimary */);
+      }
+    }
+  }
+
+  private void updateContactEntry(ContactCacheEntry entry, boolean isPrimary) {
+    if (isPrimary) {
+      mPrimaryContactInfo = entry;
+      updatePrimaryDisplayInfo();
+    } else {
+      mSecondaryContactInfo = entry;
+      updateSecondaryDisplayInfo();
+    }
+  }
+
+  /**
+   * Get the highest priority call to display. Goes through the calls and chooses which to return
+   * based on priority of which type of call to display to the user. Callers can use the "ignore"
+   * feature to get the second best call by passing a previously found primary call as ignore.
+   *
+   * @param ignore A call to ignore if found.
+   */
+  private DialerCall getCallToDisplay(
+      CallList callList, DialerCall ignore, boolean skipDisconnected) {
+    // Active calls come second.  An active call always gets precedent.
+    DialerCall retval = callList.getActiveCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Sometimes there is intemediate state that two calls are in active even one is about
+    // to be on hold.
+    retval = callList.getSecondActiveCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Disconnected calls get primary position if there are no active calls
+    // to let user know quickly what call has disconnected. Disconnected
+    // calls are very short lived.
+    if (!skipDisconnected) {
+      retval = callList.getDisconnectingCall();
+      if (retval != null && retval != ignore) {
+        return retval;
+      }
+      retval = callList.getDisconnectedCall();
+      if (retval != null && retval != ignore) {
+        return retval;
+      }
+    }
+
+    // Then we go to background call (calls on hold)
+    retval = callList.getBackgroundCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Lastly, we go to a second background call.
+    retval = callList.getSecondBackgroundCall();
+
+    return retval;
+  }
+
+  private void updatePrimaryDisplayInfo() {
+    if (mInCallScreen == null) {
+      // TODO: May also occur if search result comes back after ui is destroyed. Look into
+      // removing that case completely.
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "updatePrimaryDisplayInfo called but ui is null!");
+      return;
+    }
+
+    if (mPrimary == null) {
+      // Clear the primary display info.
+      mInCallScreen.setPrimary(PrimaryInfo.createEmptyPrimaryInfo());
+      return;
+    }
+
+    // Hide the contact photo if we are in a video call and the incoming video surface is
+    // showing.
+    boolean showContactPhoto =
+        !VideoCallPresenter.showIncomingVideo(mPrimary.getVideoState(), mPrimary.getState());
+
+    // DialerCall placed through a work phone account.
+    boolean hasWorkCallProperty = mPrimary.hasProperty(PROPERTY_ENTERPRISE_CALL);
+
+    Session enrichedCallSession =
+        mPrimary.getNumber() == null
+            ? null
+            : EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+                .getSession(mPrimary.getNumber());
+    MultimediaData enrichedCallMultimediaData =
+        enrichedCallSession == null ? null : enrichedCallSession.getMultimediaData();
+
+    if (mPrimary.isConferenceCall()) {
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "update primary display info for conference call.");
+
+      mInCallScreen.setPrimary(
+          new PrimaryInfo(
+              null /* number */,
+              getConferenceString(mPrimary),
+              false /* nameIsNumber */,
+              null /* location */,
+              null /* label */,
+              getConferencePhoto(mPrimary),
+              ContactPhotoType.DEFAULT_PLACEHOLDER,
+              false /* isSipCall */,
+              showContactPhoto,
+              hasWorkCallProperty,
+              false /* isSpam */,
+              false /* answeringDisconnectsOngoingCall */,
+              shouldShowLocation(),
+              null /* contactInfoLookupKey */,
+              null /* enrichedCallMultimediaData */));
+    } else if (mPrimaryContactInfo != null) {
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "update primary display info for " + mPrimaryContactInfo);
+
+      String name = getNameForCall(mPrimaryContactInfo);
+      String number;
+
+      boolean isChildNumberShown = !TextUtils.isEmpty(mPrimary.getChildNumber());
+      boolean isForwardedNumberShown = !TextUtils.isEmpty(mPrimary.getLastForwardedNumber());
+      boolean isCallSubjectShown = shouldShowCallSubject(mPrimary);
+
+      if (isCallSubjectShown) {
+        number = null;
+      } else if (isChildNumberShown) {
+        number = mContext.getString(R.string.child_number, mPrimary.getChildNumber());
+      } else if (isForwardedNumberShown) {
+        // Use last forwarded number instead of second line, if present.
+        number = mPrimary.getLastForwardedNumber();
+      } else {
+        number = mPrimaryContactInfo.number;
+      }
+
+      boolean nameIsNumber = name != null && name.equals(mPrimaryContactInfo.number);
+      // DialerCall with caller that is a work contact.
+      boolean isWorkContact = (mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+      mInCallScreen.setPrimary(
+          new PrimaryInfo(
+              number,
+              name,
+              nameIsNumber,
+              mPrimaryContactInfo.location,
+              isChildNumberShown || isCallSubjectShown ? null : mPrimaryContactInfo.label,
+              mPrimaryContactInfo.photo,
+              mPrimaryContactInfo.photoType,
+              mPrimaryContactInfo.isSipCall,
+              showContactPhoto,
+              hasWorkCallProperty || isWorkContact,
+              mPrimary.isSpam(),
+              mPrimary.answeringDisconnectsForegroundVideoCall(),
+              shouldShowLocation(),
+              mPrimaryContactInfo.lookupKey,
+              enrichedCallMultimediaData));
+    } else {
+      // Clear the primary display info.
+      mInCallScreen.setPrimary(PrimaryInfo.createEmptyPrimaryInfo());
+    }
+
+    mInCallScreen.showLocationUi(null);
+  }
+
+  private boolean shouldShowLocation() {
+    if (isOutgoingEmergencyCall(mPrimary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "new emergency call");
+      return true;
+    } else if (isIncomingEmergencyCall(mPrimary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "potential emergency callback");
+      return true;
+    } else if (isIncomingEmergencyCall(mSecondary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "has potential emergency callback");
+      return true;
+    }
+    return false;
+  }
+
+  private static boolean isOutgoingEmergencyCall(@Nullable DialerCall call) {
+    return call != null && !call.isIncoming() && call.isEmergencyCall();
+  }
+
+  private static boolean isIncomingEmergencyCall(@Nullable DialerCall call) {
+    return call != null && call.isIncoming() && call.isPotentialEmergencyCallback();
+  }
+
+  private boolean hasLocationPermission() {
+    return ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION)
+        == PackageManager.PERMISSION_GRANTED;
+  }
+
+  private boolean isBatteryTooLowForEmergencyLocation() {
+    Intent batteryStatus =
+        mContext.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+    int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
+    if (status == BatteryManager.BATTERY_STATUS_CHARGING
+        || status == BatteryManager.BATTERY_STATUS_FULL) {
+      // Plugged in or full battery
+      return false;
+    }
+    int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
+    int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
+    float batteryPercent = (100f * level) / scale;
+    long threshold =
+        ConfigProviderBindings.get(mContext)
+            .getLong(
+                CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION,
+                CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT);
+    LogUtil.i(
+        "CallCardPresenter.isBatteryTooLowForEmergencyLocation",
+        "percent charged: " + batteryPercent + ", min required charge: " + threshold);
+    return batteryPercent < threshold;
+  }
+
+  private void updateSecondaryDisplayInfo() {
+    if (mInCallScreen == null) {
+      return;
+    }
+
+    if (mSecondary == null) {
+      // Clear the secondary display info.
+      mInCallScreen.setSecondary(SecondaryInfo.createEmptySecondaryInfo(mIsFullscreen));
+      return;
+    }
+
+    if (mSecondary.isConferenceCall()) {
+      mInCallScreen.setSecondary(
+          new SecondaryInfo(
+              true /* show */,
+              getConferenceString(mSecondary),
+              false /* nameIsNumber */,
+              null /* label */,
+              mSecondary.getCallProviderLabel(),
+              true /* isConference */,
+              mSecondary.isVideoCall(),
+              mIsFullscreen));
+    } else if (mSecondaryContactInfo != null) {
+      LogUtil.v("CallCardPresenter.updateSecondaryDisplayInfo", "" + mSecondaryContactInfo);
+      String name = getNameForCall(mSecondaryContactInfo);
+      boolean nameIsNumber = name != null && name.equals(mSecondaryContactInfo.number);
+      mInCallScreen.setSecondary(
+          new SecondaryInfo(
+              true /* show */,
+              name,
+              nameIsNumber,
+              mSecondaryContactInfo.label,
+              mSecondary.getCallProviderLabel(),
+              false /* isConference */,
+              mSecondary.isVideoCall(),
+              mIsFullscreen));
+    } else {
+      // Clear the secondary display info.
+      mInCallScreen.setSecondary(SecondaryInfo.createEmptySecondaryInfo(mIsFullscreen));
+    }
+  }
+
+  /** Returns the gateway number for any existing outgoing call. */
+  private String getGatewayNumber() {
+    if (hasOutgoingGatewayCall()) {
+      return DialerCall.getNumberFromHandle(mPrimary.getGatewayInfo().getGatewayAddress());
+    }
+    return null;
+  }
+
+  /**
+   * Returns the label (line of text above the number/name) for any given call. For example,
+   * "calling via [Account/Google Voice]" for outgoing calls.
+   */
+  private String getConnectionLabel() {
+    if (ContextCompat.checkSelfPermission(mContext, Manifest.permission.READ_PHONE_STATE)
+        != PackageManager.PERMISSION_GRANTED) {
+      return null;
+    }
+    StatusHints statusHints = mPrimary.getStatusHints();
+    if (statusHints != null && !TextUtils.isEmpty(statusHints.getLabel())) {
+      return statusHints.getLabel().toString();
+    }
+
+    if (hasOutgoingGatewayCall() && getUi() != null) {
+      // Return the label for the gateway app on outgoing calls.
+      final PackageManager pm = mContext.getPackageManager();
+      try {
+        ApplicationInfo info =
+            pm.getApplicationInfo(mPrimary.getGatewayInfo().getGatewayProviderPackageName(), 0);
+        return pm.getApplicationLabel(info).toString();
+      } catch (PackageManager.NameNotFoundException e) {
+        LogUtil.e("CallCardPresenter.getConnectionLabel", "gateway Application Not Found.", e);
+        return null;
+      }
+    }
+    return mPrimary.getCallProviderLabel();
+  }
+
+  private Drawable getCallStateIcon() {
+    // Return connection icon if one exists.
+    StatusHints statusHints = mPrimary.getStatusHints();
+    if (statusHints != null && statusHints.getIcon() != null) {
+      Drawable icon = statusHints.getIcon().loadDrawable(mContext);
+      if (icon != null) {
+        return icon;
+      }
+    }
+
+    return null;
+  }
+
+  private boolean hasOutgoingGatewayCall() {
+    // We only display the gateway information while STATE_DIALING so return false for any other
+    // call state.
+    // TODO: mPrimary can be null because this is called from updatePrimaryDisplayInfo which
+    // is also called after a contact search completes (call is not present yet).  Split the
+    // UI update so it can receive independent updates.
+    if (mPrimary == null) {
+      return false;
+    }
+    return DialerCall.State.isDialing(mPrimary.getState())
+        && mPrimary.getGatewayInfo() != null
+        && !mPrimary.getGatewayInfo().isEmpty();
+  }
+
+  /** Gets the name to display for the call. */
+  String getNameForCall(ContactCacheEntry contactInfo) {
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, mContactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return contactInfo.number;
+    }
+    return preferredName;
+  }
+
+  /** Gets the number to display for a call. */
+  String getNumberForCall(ContactCacheEntry contactInfo) {
+    // If the name is empty, we use the number for the name...so don't show a second
+    // number in the number field
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, mContactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return contactInfo.location;
+    }
+    return contactInfo.number;
+  }
+
+  @Override
+  public void onSecondaryInfoClicked() {
+    if (mSecondary == null) {
+      LogUtil.e(
+          "CallCardPresenter.onSecondaryInfoClicked",
+          "secondary info clicked but no secondary call.");
+      return;
+    }
+
+    LogUtil.i(
+        "CallCardPresenter.onSecondaryInfoClicked", "swapping call to foreground: " + mSecondary);
+    mSecondary.unhold();
+  }
+
+  @Override
+  public void onEndCallClicked() {
+    LogUtil.i("CallCardPresenter.onEndCallClicked", "disconnecting call: " + mPrimary);
+    if (mPrimary != null) {
+      mPrimary.disconnect();
+    }
+  }
+
+  /**
+   * Handles a change to the fullscreen mode of the in-call UI.
+   *
+   * @param isFullscreenMode {@code True} if the in-call UI is entering full screen mode.
+   */
+  @Override
+  public void onFullscreenModeChanged(boolean isFullscreenMode) {
+    mIsFullscreen = isFullscreenMode;
+    if (mInCallScreen == null) {
+      return;
+    }
+    maybeShowManageConferenceCallButton();
+  }
+
+  private boolean isPrimaryCallActive() {
+    return mPrimary != null && mPrimary.getState() == DialerCall.State.ACTIVE;
+  }
+
+  private String getConferenceString(DialerCall call) {
+    boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+    LogUtil.v("CallCardPresenter.getConferenceString", "" + isGenericConference);
+
+    final int resId =
+        isGenericConference ? R.string.generic_conference_call_name : R.string.conference_call_name;
+    return mContext.getResources().getString(resId);
+  }
+
+  private Drawable getConferencePhoto(DialerCall call) {
+    boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+    LogUtil.v("CallCardPresenter.getConferencePhoto", "" + isGenericConference);
+
+    final int resId = isGenericConference ? R.drawable.img_phone : R.drawable.img_conference;
+    Drawable photo = mContext.getResources().getDrawable(resId);
+    photo.setAutoMirrored(true);
+    return photo;
+  }
+
+  private boolean shouldShowEndCallButton(DialerCall primary, int callState) {
+    if (primary == null) {
+      return false;
+    }
+    if ((!DialerCall.State.isConnectingOrConnected(callState)
+            && callState != DialerCall.State.DISCONNECTING
+            && callState != DialerCall.State.DISCONNECTED)
+        || callState == DialerCall.State.INCOMING) {
+      return false;
+    }
+    if (mPrimary.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  public void onInCallScreenResumed() {
+    if (shouldSendAccessibilityEvent) {
+      handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS);
+    }
+  }
+
+  static boolean sendAccessibilityEvent(Context context, InCallScreen inCallScreen) {
+    AccessibilityManager am =
+        (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    if (!am.isEnabled()) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "accessibility is off");
+      return false;
+    }
+    if (inCallScreen == null) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "incallscreen is null");
+      return false;
+    }
+    Fragment fragment = inCallScreen.getInCallScreenFragment();
+    if (fragment == null || fragment.getView() == null || fragment.getView().getParent() == null) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "fragment/view/parent is null");
+      return false;
+    }
+
+    DisplayManager displayManager =
+        (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
+    Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY);
+    boolean screenIsOn = display.getState() == Display.STATE_ON;
+    LogUtil.d("CallCardPresenter.sendAccessibilityEvent", "screen is on: %b", screenIsOn);
+    if (!screenIsOn) {
+      return false;
+    }
+
+    AccessibilityEvent event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_ANNOUNCEMENT);
+    inCallScreen.dispatchPopulateAccessibilityEvent(event);
+    View view = inCallScreen.getInCallScreenFragment().getView();
+    view.getParent().requestSendAccessibilityEvent(view, event);
+    return true;
+  }
+
+  private void maybeSendAccessibilityEvent(
+      InCallState oldState, final InCallState newState, boolean primaryChanged) {
+    shouldSendAccessibilityEvent = false;
+    if (mContext == null) {
+      return;
+    }
+    final AccessibilityManager am =
+        (AccessibilityManager) mContext.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    if (!am.isEnabled()) {
+      return;
+    }
+    // Announce the current call if it's new incoming/outgoing call or primary call is changed
+    // due to switching calls between two ongoing calls (one is on hold).
+    if ((oldState != InCallState.OUTGOING && newState == InCallState.OUTGOING)
+        || (oldState != InCallState.INCOMING && newState == InCallState.INCOMING)
+        || primaryChanged) {
+      LogUtil.i(
+          "CallCardPresenter.maybeSendAccessibilityEvent", "schedule accessibility announcement");
+      shouldSendAccessibilityEvent = true;
+      handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS);
+    }
+  }
+
+  /**
+   * Determines whether the call subject should be visible on the UI. For the call subject to be
+   * visible, the call has to be in an incoming or waiting state, and the subject must not be empty.
+   *
+   * @param call The call.
+   * @return {@code true} if the subject should be shown, {@code false} otherwise.
+   */
+  private boolean shouldShowCallSubject(DialerCall call) {
+    if (call == null) {
+      return false;
+    }
+
+    boolean isIncomingOrWaiting =
+        mPrimary.getState() == DialerCall.State.INCOMING
+            || mPrimary.getState() == DialerCall.State.CALL_WAITING;
+    return isIncomingOrWaiting
+        && !TextUtils.isEmpty(call.getCallSubject())
+        && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED
+        && call.isCallSubjectSupported();
+  }
+
+  /**
+   * Determines whether the "note sent" toast should be shown. It should be shown for a new outgoing
+   * call with a subject.
+   *
+   * @param call The call
+   * @return {@code true} if the toast should be shown, {@code false} otherwise.
+   */
+  private boolean shouldShowNoteSentToast(DialerCall call) {
+    return call != null
+        && hasCallSubject(call)
+        && (call.getState() == DialerCall.State.DIALING
+            || call.getState() == DialerCall.State.CONNECTING);
+  }
+
+  private InCallScreen getUi() {
+    return mInCallScreen;
+  }
+
+  public static class ContactLookupCallback implements ContactInfoCacheCallback {
+
+    private final WeakReference<CallCardPresenter> mCallCardPresenter;
+    private final boolean mIsPrimary;
+
+    public ContactLookupCallback(CallCardPresenter callCardPresenter, boolean isPrimary) {
+      mCallCardPresenter = new WeakReference<CallCardPresenter>(callCardPresenter);
+      mIsPrimary = isPrimary;
+    }
+
+    @Override
+    public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+      CallCardPresenter presenter = mCallCardPresenter.get();
+      if (presenter != null) {
+        presenter.onContactInfoComplete(callId, entry, mIsPrimary);
+      }
+    }
+
+    @Override
+    public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+      CallCardPresenter presenter = mCallCardPresenter.get();
+      if (presenter != null) {
+        presenter.onImageLoadComplete(callId, entry);
+      }
+    }
+  }
+}