diff --git a/java/com/android/dialer/logging/dialer_impression.proto b/java/com/android/dialer/logging/dialer_impression.proto
index 7cd2207..55cef9a 100644
--- a/java/com/android/dialer/logging/dialer_impression.proto
+++ b/java/com/android/dialer/logging/dialer_impression.proto
@@ -12,7 +12,7 @@
   // Event enums to be used for Impression Logging in Dialer.
   // It's perfectly acceptable for this enum to be large
   // Values should be from 1000 to 100000.
-  // Next Tag: 1392
+  // Next Tag: 1397
   enum Type {
     UNKNOWN_AOSP_EVENT_TYPE = 1000;
 
@@ -770,5 +770,14 @@
     // Send button clicked in RTT call, this includes send button on keyboard.
     RTT_SEND_BUTTON_CLICKED = 1387;
     RTT_KEYBOARD_SEND_BUTTON_CLICKED = 1388;
+
+    // For background calling
+    START_CALL_IN_BUBBLE_MODE = 1392;
+
+    // Switch audio route
+    IN_CALL_SWITCH_AUDIO_ROUTE_SPEAKER = 1393;
+    IN_CALL_SWITCH_AUDIO_ROUTE_WIRED_HEADSET = 1394;
+    IN_CALL_SWITCH_AUDIO_ROUTE_EARPIECE = 1395;
+    IN_CALL_SWITCH_AUDIO_ROUTE_BLUETOOTH = 1396;
   }
 }
diff --git a/java/com/android/dialer/main/impl/OldMainActivityPeer.java b/java/com/android/dialer/main/impl/OldMainActivityPeer.java
index 9ac3510..e3d42fa 100644
--- a/java/com/android/dialer/main/impl/OldMainActivityPeer.java
+++ b/java/com/android/dialer/main/impl/OldMainActivityPeer.java
@@ -457,6 +457,7 @@
     return DialpadFragment.isAddCallMode(intent);
   }
 
+  @SuppressLint("MissingPermission")
   @Override
   public void onActivityResume() {
     callLogFragmentListener.onActivityResume();
@@ -492,11 +493,16 @@
     bottomNavTabListener.ensureCorrectCallLogShown();
     bottomNavTabListener.ensureCorrectVoicemailShown();
 
+    // Config the badge of missed calls for the new call log.
     if (bottomNavTabListener.newCallLogFragmentActive()) {
-      missedCallCountObserver.onChange(false); // Set the initial value for the badge
-      activity
-          .getContentResolver()
-          .registerContentObserver(Calls.CONTENT_URI, true, missedCallCountObserver);
+      if (PermissionsUtil.hasCallLogReadPermissions(activity)) {
+        missedCallCountObserver.onChange(false); // Set the initial value for the badge
+        activity
+            .getContentResolver()
+            .registerContentObserver(Calls.CONTENT_URI, true, missedCallCountObserver);
+      } else {
+        bottomNav.setNotificationCount(TabIndex.CALL_LOG, 0);
+      }
     }
 
     // add 1 sec delay to get memory snapshot so that dialer wont react slowly on resume.
diff --git a/java/com/android/dialer/main/impl/bottomnav/MissedCallCountObserver.java b/java/com/android/dialer/main/impl/bottomnav/MissedCallCountObserver.java
index ee7f6d0..a4995c1 100644
--- a/java/com/android/dialer/main/impl/bottomnav/MissedCallCountObserver.java
+++ b/java/com/android/dialer/main/impl/bottomnav/MissedCallCountObserver.java
@@ -16,15 +16,15 @@
 
 package com.android.dialer.main.impl.bottomnav;
 
-import android.annotation.SuppressLint;
+import android.Manifest;
 import android.content.Context;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.provider.CallLog.Calls;
+import android.support.annotation.RequiresPermission;
 import com.android.dialer.common.concurrent.DialerExecutorComponent;
 import com.android.dialer.common.concurrent.UiListener;
 import com.android.dialer.main.impl.bottomnav.BottomNavBar.TabIndex;
-import com.android.dialer.util.PermissionsUtil;
 import com.google.common.util.concurrent.ListenableFuture;
 
 /**
@@ -45,7 +45,7 @@
     this.uiListener = uiListener;
   }
 
-  @SuppressLint("MissingPermission")
+  @RequiresPermission(Manifest.permission.READ_CALL_LOG)
   @Override
   public void onChange(boolean selfChange) {
     ListenableFuture<Integer> countFuture =
@@ -53,9 +53,6 @@
             .backgroundExecutor()
             .submit(
                 () -> {
-                  if (!PermissionsUtil.hasCallLogReadPermissions(appContext)) {
-                    return 0;
-                  }
                   try (Cursor cursor =
                       appContext
                           .getContentResolver()
diff --git a/java/com/android/dialer/speeddial/ContextMenu.java b/java/com/android/dialer/speeddial/ContextMenu.java
index 126373c..09505ab 100644
--- a/java/com/android/dialer/speeddial/ContextMenu.java
+++ b/java/com/android/dialer/speeddial/ContextMenu.java
@@ -18,10 +18,12 @@
 
 import android.content.Context;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.util.AttributeSet;
 import android.view.View;
 import android.widget.LinearLayout;
 import android.widget.TextView;
+import com.android.dialer.common.Assert;
 import com.android.dialer.speeddial.database.SpeedDialEntry.Channel;
 import com.android.dialer.speeddial.loader.SpeedDialUiItem;
 
@@ -30,13 +32,13 @@
 
   private ContextMenuItemListener listener;
 
+  private TextView voiceView;
   private TextView videoView;
   private TextView smsView;
 
   private SpeedDialUiItem speedDialUiItem;
   private Channel voiceChannel;
   private Channel videoChannel;
-  private Channel smsChannel;
 
   public ContextMenu(Context context, @Nullable AttributeSet attrs) {
     super(context, attrs);
@@ -50,9 +52,11 @@
     videoView.setOnClickListener(v -> placeVideoCall());
 
     smsView = findViewById(R.id.send_message_container);
-    smsView.setOnClickListener(v -> listener.openSmsConversation(smsChannel.number()));
+    smsView.setOnClickListener(v -> listener.openSmsConversation(voiceChannel.number()));
 
-    findViewById(R.id.voice_call_container).setOnClickListener(v -> placeVoiceCall());
+    voiceView = findViewById(R.id.voice_call_container);
+    voiceView.setOnClickListener(v -> placeVoiceCall());
+
     findViewById(R.id.remove_container)
         .setOnClickListener(v -> listener.removeFavoriteContact(speedDialUiItem));
     findViewById(R.id.contact_info_container)
@@ -76,14 +80,11 @@
     setX((float) (childLocation[0] + .5 * childLayout.getWidth() - .5 * getWidth()));
     setY(childLocation[1] - parentLocation[1] + childLayout.getHeight());
 
-    voiceChannel = speedDialUiItem.getDeterministicVoiceChannel();
-    videoChannel = speedDialUiItem.getDeterministicVideoChannel();
-    videoView.setVisibility(
-        videoChannel == null && !speedDialUiItem.hasVideoChannels() ? View.GONE : View.VISIBLE);
-
-    // TODO(calderwoodra): disambig dialog for texts?
-    smsChannel = voiceChannel;
-    smsView.setVisibility(smsChannel == null ? View.GONE : View.VISIBLE);
+    voiceChannel = speedDialUiItem.getDefaultVoiceChannel();
+    videoChannel = speedDialUiItem.getDefaultVideoChannel();
+    voiceView.setVisibility(videoChannel == null ? View.GONE : View.VISIBLE);
+    videoView.setVisibility(videoChannel == null ? View.GONE : View.VISIBLE);
+    smsView.setVisibility(voiceChannel == null ? View.GONE : View.VISIBLE);
 
     // TODO(calderwoodra): a11y
     // TODO(calderwoodra): animate this similar to the bubble menu
@@ -102,19 +103,11 @@
   }
 
   private void placeVoiceCall() {
-    if (voiceChannel == null) {
-      listener.disambiguateCall(speedDialUiItem);
-    } else {
-      listener.placeCall(voiceChannel);
-    }
+    listener.placeCall(Assert.isNotNull(voiceChannel));
   }
 
   private void placeVideoCall() {
-    if (videoChannel == null) {
-      listener.disambiguateCall(speedDialUiItem);
-    } else {
-      listener.placeCall(videoChannel);
-    }
+    listener.placeCall(Assert.isNotNull(videoChannel));
   }
 
   public boolean isVisible() {
@@ -122,19 +115,12 @@
   }
 
   /** Listener to report user clicks on menu items. */
+  @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
   public interface ContextMenuItemListener {
 
     /** Called when the user selects "voice call" or "video call" option from the context menu. */
     void placeCall(Channel channel);
 
-    /**
-     * Called when the user selects "voice call" or "video call" option from the context menu, but
-     * it's not clear which channel they want to call.
-     *
-     * <p>TODO(calderwoodra): discuss with product how we want to handle these cases
-     */
-    void disambiguateCall(SpeedDialUiItem speedDialUiItem);
-
     /** Called when the user selects "send message" from the context menu. */
     void openSmsConversation(String number);
 
diff --git a/java/com/android/dialer/speeddial/SpeedDialFragment.java b/java/com/android/dialer/speeddial/SpeedDialFragment.java
index 018f978..97a5fac 100644
--- a/java/com/android/dialer/speeddial/SpeedDialFragment.java
+++ b/java/com/android/dialer/speeddial/SpeedDialFragment.java
@@ -105,6 +105,10 @@
     LogUtil.enterBlock("SpeedDialFragment.onCreateView");
     View rootLayout = inflater.inflate(R.layout.fragment_speed_dial, container, false);
 
+    speedDialLoaderListener =
+        DialerExecutorComponent.get(getContext())
+            .createUiListener(getChildFragmentManager(), "speed_dial_loader_listener");
+
     // Setup favorite contact context menu
     contextMenu = rootLayout.findViewById(R.id.favorite_contact_context_menu);
     contextMenuBackground = rootLayout.findViewById(R.id.context_menu_background);
@@ -124,7 +128,10 @@
             rootLayout,
             contextMenu,
             contextMenuBackground,
-            new SpeedDialContextMenuItemListener(getActivity(), getChildFragmentManager()),
+            new SpeedDialContextMenuItemListener(
+                getActivity(),
+                new UpdateSpeedDialAdapterListener(),
+                speedDialLoaderListener),
             layoutManager);
     adapter =
         new SpeedDialAdapter(getContext(), favoritesListener, suggestedListener, headerListener);
@@ -138,10 +145,6 @@
     ItemTouchHelper touchHelper = new ItemTouchHelper(callback);
     touchHelper.attachToRecyclerView(recyclerView);
     adapter.setItemTouchHelper(touchHelper);
-
-    speedDialLoaderListener =
-        DialerExecutorComponent.get(getContext())
-            .createUiListener(getChildFragmentManager(), "speed_dial_loader_listener");
     return rootLayout;
   }
 
@@ -317,19 +320,17 @@
       Channel defaultChannel = speedDialUiItem.defaultChannel();
 
       // Add voice call module
-      Channel voiceChannel = speedDialUiItem.getDeterministicVoiceChannel();
+      Channel voiceChannel = speedDialUiItem.getDefaultVoiceChannel();
       if (voiceChannel != null) {
         modules.add(
             IntentModule.newCallModule(
                 getContext(),
                 new CallIntentBuilder(voiceChannel.number(), CallInitiationType.Type.SPEED_DIAL)
                     .setAllowAssistedDial(true)));
-      } else {
-        modules.add(new DisambigDialogModule(speedDialUiItem, /* isVideo = */ false));
       }
 
       // Add video if we can determine the correct channel
-      Channel videoChannel = speedDialUiItem.getDeterministicVideoChannel();
+      Channel videoChannel = speedDialUiItem.getDefaultVideoChannel();
       if (videoChannel != null) {
         modules.add(
             IntentModule.newCallModule(
@@ -337,8 +338,6 @@
                 new CallIntentBuilder(videoChannel.number(), CallInitiationType.Type.SPEED_DIAL)
                     .setIsVideoCall(true)
                     .setAllowAssistedDial(true)));
-      } else if (speedDialUiItem.hasVideoChannels()) {
-        modules.add(new DisambigDialogModule(speedDialUiItem, /* isVideo = */ true));
       }
 
       // Add sms module
@@ -396,58 +395,21 @@
         return false;
       }
     }
-
-    private final class DisambigDialogModule implements HistoryItemActionModule {
-
-      private final SpeedDialUiItem speedDialUiItem;
-      private final boolean isVideo;
-
-      DisambigDialogModule(SpeedDialUiItem speedDialUiItem, boolean isVideo) {
-        this.speedDialUiItem = speedDialUiItem;
-        this.isVideo = isVideo;
-      }
-
-      @Override
-      public int getStringId() {
-        if (isVideo) {
-          return R.string.contact_menu_video_call;
-        } else {
-          return R.string.contact_menu_voice_call;
-        }
-      }
-
-      @Override
-      public int getDrawableId() {
-        if (isVideo) {
-          return R.drawable.quantum_ic_videocam_vd_theme_24;
-        } else {
-          return R.drawable.quantum_ic_phone_vd_theme_24;
-        }
-      }
-
-      @Override
-      public boolean onClick() {
-        DisambigDialog.show(speedDialUiItem, getChildFragmentManager());
-        return true;
-      }
-    }
   }
 
   private static final class SpeedDialContextMenuItemListener implements ContextMenuItemListener {
 
     private final FragmentActivity activity;
-    private final FragmentManager childFragmentManager;
+    private final SupportUiListener<ImmutableList<SpeedDialUiItem>> speedDialLoaderListener;
+    private final UpdateSpeedDialAdapterListener updateAdapterListener;
 
     SpeedDialContextMenuItemListener(
-        FragmentActivity activity, FragmentManager childFragmentManager) {
+        FragmentActivity activity,
+        UpdateSpeedDialAdapterListener updateAdapterListener,
+        SupportUiListener<ImmutableList<SpeedDialUiItem>> speedDialLoaderListener) {
       this.activity = activity;
-      this.childFragmentManager = childFragmentManager;
-    }
-
-    @Override
-    public void disambiguateCall(SpeedDialUiItem speedDialUiItem) {
-      // TODO(calderwoodra): show only video or voice channels in the disambig dialog
-      DisambigDialog.show(speedDialUiItem, childFragmentManager);
+      this.updateAdapterListener = updateAdapterListener;
+      this.speedDialLoaderListener = speedDialLoaderListener;
     }
 
     @Override
@@ -472,7 +434,15 @@
 
     @Override
     public void removeFavoriteContact(SpeedDialUiItem speedDialUiItem) {
-      // TODO(calderwoodra): implement remove
+      speedDialLoaderListener.listen(
+          activity,
+          UiItemLoaderComponent.get(activity)
+              .speedDialUiItemMutator()
+              .removeSpeedDialUiItem(speedDialUiItem),
+          updateAdapterListener::updateAdapter,
+          throwable -> {
+            throw new RuntimeException(throwable);
+          });
     }
 
     @Override
@@ -485,6 +455,14 @@
     }
   }
 
+  /** Listener for when a SpeedDialUiItem is updated. */
+  private class UpdateSpeedDialAdapterListener {
+
+    void updateAdapter(ImmutableList<SpeedDialUiItem> speedDialUiItems) {
+      onSpeedDialUiItemListLoaded(speedDialUiItems);
+    }
+  }
+
   /** Interface for {@link SpeedDialFragment} to communicate with its host/parent. */
   public interface HostInterface {
 
diff --git a/java/com/android/dialer/speeddial/loader/SpeedDialUiItem.java b/java/com/android/dialer/speeddial/loader/SpeedDialUiItem.java
index c5a3ea3..325af23 100644
--- a/java/com/android/dialer/speeddial/loader/SpeedDialUiItem.java
+++ b/java/com/android/dialer/speeddial/loader/SpeedDialUiItem.java
@@ -162,61 +162,77 @@
   }
 
   /**
-   * Returns a video channel if there is exactly one video channel or the default channel is a video
-   * channel.
+   * Returns one of the following:
+   *
+   * <ul>
+   *   <li>The default channel if it's a video channel.
+   *   <li>A video channel if it has the same attributes as the default channel, OR
+   *   <li>null. (This is a deliberate product decision, even if there is only a single video
+   *       reachable channel, we should still return null if it has different attributes from those
+   *       in the default channel).
+   * </ul>
    */
   @Nullable
-  public Channel getDeterministicVideoChannel() {
-    if (defaultChannel() != null && defaultChannel().isVideoTechnology()) {
+  public Channel getDefaultVideoChannel() {
+    if (defaultChannel() == null) {
+      return null;
+    }
+
+    if (defaultChannel().isVideoTechnology()) {
       return defaultChannel();
     }
 
-    Channel videoChannel = null;
-    for (Channel channel : channels()) {
-      if (channel.isVideoTechnology()) {
-        if (videoChannel != null) {
-          // We found two video channels, so we can't determine which one is correct..
-          return null;
-        }
-        videoChannel = channel;
-      }
+    if (channels().size() == 1) {
+      // If there is only a single channel, it can't be a video channel
+      return null;
     }
-    // Only found one channel, so return it
-    return videoChannel;
-  }
 
-  /** Returns true if any channels are video channels. */
-  public boolean hasVideoChannels() {
-    for (Channel channel : channels()) {
-      if (channel.isVideoTechnology()) {
-        return true;
+    // At this point, the default channel is a *voice* channel and there are more than
+    // one channel in total.
+    //
+    // Our defined assumptions about the channel list include that if a video channel
+    // follows a voice channel, it has the same attributes as that voice channel
+    // (see comments on method channels() for details).
+    //
+    // Therefore, if the default video channel exists, it must be the immediate successor
+    // of the default channel in the list.
+    //
+    // Note that we don't have to check if the last channel in the list is the default
+    // channel because even if it is, there will be no video channel under the assumption
+    // above.
+    for (int i = 0; i < channels().size() - 1; i++) {
+      // Find the default channel
+      if (Objects.equals(defaultChannel(), channels().get(i))) {
+        // Our defined assumptions about the list of channels is that if a video channel follows a
+        // voice channel, it has the same attributes as that voice channel.
+        Channel channel = channels().get(i + 1);
+        if (channel.isVideoTechnology()) {
+          return channel;
+        }
+        // Since the default voice channel isn't video reachable, we can't video call this number
+        return null;
       }
     }
-    return false;
+    throw Assert.createIllegalStateFailException("channels() doesn't contain defaultChannel().");
   }
 
   /**
-   * Returns a voice channel if there is exactly one voice channel or the default channel is a voice
+   * Returns a voice channel if there is exactly one channel or the default channel is a voice
    * channel.
    */
   @Nullable
-  public Channel getDeterministicVoiceChannel() {
+  public Channel getDefaultVoiceChannel() {
     if (defaultChannel() != null && !defaultChannel().isVideoTechnology()) {
       return defaultChannel();
     }
 
-    Channel voiceChannel = null;
-    for (Channel channel : channels()) {
-      if (!channel.isVideoTechnology()) {
-        if (voiceChannel != null) {
-          // We found two voice channels, so we can't determine which one is correct..
-          return null;
-        }
-        voiceChannel = channel;
-      }
+    if (channels().size() == 1) {
+      // If there is only a single channel, it must be a voice channel as per our defined
+      // assumptions (detailed in comments on method channels()).
+      return channels().get(0);
     }
-    // Only found one channel, so return it
-    return voiceChannel;
+
+    return null;
   }
 
   /**
@@ -254,6 +270,21 @@
    * enumerate each one here so that the user can choose the correct one. Each channel here
    * represents a row in the {@link com.android.dialer.speeddial.DisambigDialog}.
    *
+   * <p>These channels have a few very strictly enforced assumption that are used heavily throughout
+   * the codebase. Those assumption are that:
+   *
+   * <ol>
+   *   <li>Each of the contact's numbers are voice reachable. So if a channel has it's technology
+   *       set to anything other than {@link Channel#VOICE}, there is gaurenteed to be another
+   *       channel with the exact same attributes, but technology will be {@link Channel#VOICE}.
+   *   <li>For each of the contact's phone numbers, there will be a voice channel, then the next
+   *       channel will either be the same phone number but a video channel, or a new number.
+   * </ol>
+   *
+   * For example: Say a contact has two phone numbers (A & B) and A is duo reachable. Then you can
+   * assume the list of channels will be ordered as either {A_voice, A_duo, B_voice} or {B_voice,
+   * A_voice, A_duo}.
+   *
    * @see com.android.dialer.speeddial.database.SpeedDialEntry.Channel
    */
   public abstract ImmutableList<Channel> channels();
diff --git a/java/com/android/dialer/speeddial/loader/SpeedDialUiItemMutator.java b/java/com/android/dialer/speeddial/loader/SpeedDialUiItemMutator.java
index 5dae2ef..e8892c4 100644
--- a/java/com/android/dialer/speeddial/loader/SpeedDialUiItemMutator.java
+++ b/java/com/android/dialer/speeddial/loader/SpeedDialUiItemMutator.java
@@ -54,6 +54,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import javax.inject.Inject;
 import javax.inject.Singleton;
@@ -109,6 +110,85 @@
   }
 
   /**
+   * Delete the SpeedDialUiItem.
+   *
+   * <p>If the item is starred, it's entry will be removed from the SpeedDialEntry database.
+   * Additionally, if the contact only has one entry in the database, it will be unstarred.
+   *
+   * <p>If the item isn't starred, it's usage data will be deleted but the suggestion can come back
+   * if the user calls that contact again.
+   *
+   * @return the updated list of SpeedDialUiItems.
+   */
+  public ListenableFuture<ImmutableList<SpeedDialUiItem>> removeSpeedDialUiItem(
+      SpeedDialUiItem speedDialUiItem) {
+    return dialerFutureSerializer.submit(
+        () -> removeSpeedDialUiItemInternal(speedDialUiItem), backgroundExecutor);
+  }
+
+  @WorkerThread
+  private ImmutableList<SpeedDialUiItem> removeSpeedDialUiItemInternal(
+      SpeedDialUiItem speedDialUiItem) {
+    Assert.isWorkerThread();
+    if (speedDialUiItem.isStarred()) {
+      removeStarredSpeedDialUiItem(speedDialUiItem);
+    } else {
+      removeSuggestedSpeedDialUiItem(speedDialUiItem);
+    }
+    return loadSpeedDialUiItemsInternal();
+  }
+
+  /**
+   * Delete the SpeedDialEntry associated with the passed in SpeedDialUiItem. Additionally, if the
+   * entry being deleted is the only entry for that contact, unstar it in the cp2.
+   */
+  @WorkerThread
+  private void removeStarredSpeedDialUiItem(SpeedDialUiItem speedDialUiItem) {
+    Assert.isWorkerThread();
+    Assert.checkArgument(speedDialUiItem.isStarred());
+    SpeedDialEntryDao db = getSpeedDialEntryDao();
+    ImmutableList<SpeedDialEntry> entries = db.getAllEntries();
+
+    SpeedDialEntry entryToDelete = null;
+    int entriesForTheSameContact = 0;
+    for (SpeedDialEntry entry : entries) {
+      if (entry.contactId() == speedDialUiItem.contactId()) {
+        entriesForTheSameContact++;
+      }
+
+      if (Objects.equals(entry.id(), speedDialUiItem.speedDialEntryId())) {
+        Assert.checkArgument(entryToDelete == null);
+        entryToDelete = entry;
+      }
+    }
+    db.delete(ImmutableList.of(entryToDelete.id()));
+    if (entriesForTheSameContact == 1) {
+      unstarContact(speedDialUiItem);
+    }
+  }
+
+  @WorkerThread
+  private void unstarContact(SpeedDialUiItem speedDialUiItem) {
+    Assert.isWorkerThread();
+    ContentValues contentValues = new ContentValues();
+    contentValues.put(Phone.STARRED, 0);
+    appContext
+        .getContentResolver()
+        .update(
+            Phone.CONTENT_URI,
+            contentValues,
+            Phone.CONTACT_ID + " = ?",
+            new String[] {Long.toString(speedDialUiItem.contactId())});
+  }
+
+  @WorkerThread
+  @SuppressWarnings("unused")
+  private void removeSuggestedSpeedDialUiItem(SpeedDialUiItem speedDialUiItem) {
+    Assert.isWorkerThread();
+    // TODO(calderwoodra): remove strequent contact
+  }
+
+  /**
    * Takes a contact uri from {@link Phone#CONTENT_URI} and updates {@link Phone#STARRED} to be
    * true, if it isn't already or Inserts the contact into the {@link SpeedDialEntryDatabaseHelper}
    */
diff --git a/java/com/android/incallui/ActiveCallsCallListListener.java b/java/com/android/incallui/ActiveCallsCallListListener.java
index ce9f9a3..3e4cb93 100644
--- a/java/com/android/incallui/ActiveCallsCallListListener.java
+++ b/java/com/android/incallui/ActiveCallsCallListListener.java
@@ -22,7 +22,7 @@
 import com.android.dialer.activecalls.ActiveCallsComponent;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
 
@@ -49,7 +49,7 @@
   public void onCallListChange(CallList callList) {
     ImmutableList.Builder<ActiveCallInfo> activeCalls = ImmutableList.builder();
     for (DialerCall call : callList.getAllCalls()) {
-      if (call.getState() != State.DISCONNECTED) {
+      if (call.getState() != DialerCallState.DISCONNECTED) {
         activeCalls.add(
             ActiveCallInfo.builder()
                 .setPhoneAccountHandle(Optional.fromNullable(call.getAccountHandle()))
diff --git a/java/com/android/incallui/CallButtonPresenter.java b/java/com/android/incallui/CallButtonPresenter.java
index e30c70f..3fd3ee6 100644
--- a/java/com/android/incallui/CallButtonPresenter.java
+++ b/java/com/android/incallui/CallButtonPresenter.java
@@ -44,8 +44,8 @@
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.DialerCall.CameraDirection;
-import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.incall.protocol.InCallButtonIds;
 import com.android.incallui.incall.protocol.InCallButtonUi;
 import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
@@ -458,7 +458,7 @@
         !showSwap
             && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORT_HOLD)
             && call.can(android.telecom.Call.Details.CAPABILITY_HOLD);
-    final boolean isCallOnHold = call.getState() == DialerCall.State.ONHOLD;
+    final boolean isCallOnHold = call.getState() == DialerCallState.ONHOLD;
 
     final boolean showAddCall =
         TelecomAdapter.getInstance().canAddCall() && UserManagerCompat.isUserUnlocked(context);
@@ -480,20 +480,20 @@
     // Disabling local video doesn't seem to work when dialing. See a bug.
     final boolean showPauseVideo =
         isVideo
-            && call.getState() != DialerCall.State.DIALING
-            && call.getState() != DialerCall.State.CONNECTING;
+            && call.getState() != DialerCallState.DIALING
+            && call.getState() != DialerCallState.CONNECTING;
 
     otherAccount = TelecomUtil.getOtherAccount(getContext(), call.getAccountHandle());
     boolean showSwapSim =
         !call.isEmergencyCall()
             && otherAccount != null
             && !call.isVoiceMailNumber()
-            && DialerCall.State.isDialing(call.getState())
+            && DialerCallState.isDialing(call.getState())
             // Most devices cannot make calls on 2 SIMs at the same time.
             && InCallPresenter.getInstance().getCallList().getAllCalls().size() == 1;
 
     boolean showUpgradeToRtt = call.canUpgradeToRttCall();
-    boolean enableUpgradeToRtt = showUpgradeToRtt && call.getState() == State.ACTIVE;
+    boolean enableUpgradeToRtt = showUpgradeToRtt && call.getState() == DialerCallState.ACTIVE;
 
     inCallButtonUi.showButton(InCallButtonIds.BUTTON_AUDIO, true);
     inCallButtonUi.showButton(InCallButtonIds.BUTTON_SWAP, showSwap);
diff --git a/java/com/android/incallui/CallCardPresenter.java b/java/com/android/incallui/CallCardPresenter.java
index 1f7a0d3..83c1aff 100644
--- a/java/com/android/incallui/CallCardPresenter.java
+++ b/java/com/android/incallui/CallCardPresenter.java
@@ -65,8 +65,8 @@
 import com.android.incallui.InCallPresenter.IncomingCallListener;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.DialerCallListener;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.calllocation.CallLocation;
 import com.android.incallui.calllocation.CallLocationComponent;
 import com.android.incallui.incall.protocol.ContactPhotoType;
@@ -171,7 +171,7 @@
       call.addListener(this);
       // start processing lookups right away.
       if (!call.isConferenceCall()) {
-        startContactInfoSearch(call, true, call.getState() == DialerCall.State.INCOMING);
+        startContactInfoSearch(call, true, call.getState() == DialerCallState.INCOMING);
       } else {
         updateContactEntry(null, true);
       }
@@ -323,7 +323,7 @@
 
       primaryContactInfo =
           ContactInfoCache.buildCacheEntryFromCall(
-              context, this.primary, this.primary.getState() == DialerCall.State.INCOMING);
+              context, this.primary, this.primary.getState() == DialerCallState.INCOMING);
       updatePrimaryDisplayInfo();
       maybeStartSearch(this.primary, true);
     }
@@ -341,14 +341,14 @@
         // secondary call has changed
         secondaryContactInfo =
             ContactInfoCache.buildCacheEntryFromCall(
-                context, this.secondary, this.secondary.getState() == DialerCall.State.INCOMING);
+                context, this.secondary, this.secondary.getState() == DialerCallState.INCOMING);
         updateSecondaryDisplayInfo();
         maybeStartSearch(this.secondary, false);
       }
     }
 
     // Set the call state
-    int callState = DialerCall.State.IDLE;
+    int callState = DialerCallState.IDLE;
     if (this.primary != null) {
       callState = this.primary.getState();
       updatePrimaryCallState();
@@ -362,7 +362,7 @@
     getUi()
         .setEndCallButtonEnabled(
             shouldShowEndCallButton(this.primary, callState),
-            callState != DialerCall.State.INCOMING /* animate */);
+            callState != DialerCallState.INCOMING /* animate */);
 
     maybeSendAccessibilityEvent(oldState, newState, primaryChanged);
     Trace.endSection();
@@ -520,7 +520,7 @@
     if (secondary == null) {
       return ButtonState.NOT_SUPPORT;
     }
-    if (primary.getState() == State.ACTIVE) {
+    if (primary.getState() == DialerCallState.ACTIVE) {
       return ButtonState.ENABLED;
     }
     return ButtonState.DISABLED;
@@ -580,7 +580,7 @@
   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);
+      startContactInfoSearch(call, isPrimary, call.getState() == DialerCallState.INCOMING);
     }
   }
 
@@ -978,7 +978,7 @@
     if (primary == null) {
       return false;
     }
-    return DialerCall.State.isDialing(primary.getState())
+    return DialerCallState.isDialing(primary.getState())
         && primary.getGatewayInfo() != null
         && !primary.getGatewayInfo().isEmpty();
   }
@@ -1040,17 +1040,17 @@
   }
 
   private boolean isPrimaryCallActive() {
-    return primary != null && primary.getState() == DialerCall.State.ACTIVE;
+    return primary != null && primary.getState() == DialerCallState.ACTIVE;
   }
 
   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) {
+    if ((!DialerCallState.isConnectingOrConnected(callState)
+            && callState != DialerCallState.DISCONNECTING
+            && callState != DialerCallState.DISCONNECTED)
+        || callState == DialerCallState.INCOMING) {
       return false;
     }
     if (this.primary.getVideoTech().getSessionModificationState()
@@ -1141,8 +1141,8 @@
     }
 
     boolean isIncomingOrWaiting =
-        primary.getState() == DialerCall.State.INCOMING
-            || primary.getState() == DialerCall.State.CALL_WAITING;
+        primary.getState() == DialerCallState.INCOMING
+            || primary.getState() == DialerCallState.CALL_WAITING;
     return isIncomingOrWaiting
         && !TextUtils.isEmpty(call.getCallSubject())
         && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED
@@ -1159,8 +1159,8 @@
   private boolean shouldShowNoteSentToast(DialerCall call) {
     return call != null
         && hasCallSubject(call)
-        && (call.getState() == DialerCall.State.DIALING
-            || call.getState() == DialerCall.State.CONNECTING);
+        && (call.getState() == DialerCallState.DIALING
+            || call.getState() == DialerCallState.CONNECTING);
   }
 
   private InCallScreen getUi() {
diff --git a/java/com/android/incallui/ConferenceParticipantListAdapter.java b/java/com/android/incallui/ConferenceParticipantListAdapter.java
index dc793f7..597702b 100644
--- a/java/com/android/incallui/ConferenceParticipantListAdapter.java
+++ b/java/com/android/incallui/ConferenceParticipantListAdapter.java
@@ -41,6 +41,7 @@
 import com.android.incallui.ContactInfoCache.ContactCacheEntry;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.state.DialerCallState;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -223,7 +224,7 @@
     if (!participantInfo.isCacheLookupComplete()) {
       cache.findInfo(
           participantInfo.getCall(),
-          participantInfo.getCall().getState() == DialerCall.State.INCOMING,
+          participantInfo.getCall().getState() == DialerCallState.INCOMING,
           new ContactLookupCallback(this));
     }
 
@@ -299,7 +300,7 @@
     final View endButton = view.findViewById(R.id.conferenceCallerDisconnect);
     final View separateButton = view.findViewById(R.id.conferenceCallerSeparate);
 
-    if (callState == DialerCall.State.ONHOLD) {
+    if (callState == DialerCallState.ONHOLD) {
       setViewsOnHold(photoView, statusTextView, nameTextView, numberTextView);
     } else {
       setViewsNotOnHold(photoView, statusTextView, nameTextView, numberTextView);
@@ -401,7 +402,7 @@
       if (contactCache == null) {
         contactCache =
             ContactInfoCache.buildCacheEntryFromCall(
-                getContext(), call, call.getState() == DialerCall.State.INCOMING);
+                getContext(), call, call.getState() == DialerCallState.INCOMING);
       }
 
       if (participantsByCallId.containsKey(callId)) {
diff --git a/java/com/android/incallui/InCallActivity.java b/java/com/android/incallui/InCallActivity.java
index 02335b6..0f0e9d9 100644
--- a/java/com/android/incallui/InCallActivity.java
+++ b/java/com/android/incallui/InCallActivity.java
@@ -83,8 +83,8 @@
 import com.android.incallui.audiomode.AudioModeProvider;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.callpending.CallPendingActivity;
 import com.android.incallui.disconnectdialog.DisconnectMessage;
 import com.android.incallui.incall.bindings.InCallBindings;
@@ -348,7 +348,7 @@
       // If there's only one line in use, AND it's on hold, then we're sure the user
       // wants to use the dialpad toward the exact line, so un-hold the holding line.
       DialerCall call = CallList.getInstance().getActiveOrBackgroundCall();
-      if (call != null && call.getState() == State.ONHOLD) {
+      if (call != null && call.getState() == DialerCallState.ONHOLD) {
         call.unhold();
       }
     }
@@ -1449,7 +1449,7 @@
     if (call == null) {
       call = CallList.getInstance().getBackgroundCall();
     }
-    if (didShowAnswerScreen && (call == null || call.getState() == State.DISCONNECTED)) {
+    if (didShowAnswerScreen && (call == null || call.getState() == DialerCallState.DISCONNECTED)) {
       LogUtil.i("InCallActivity.getShouldShowAnswerUi", "found disconnecting incoming call");
       return new ShouldShowUiResult(true, call);
     }
diff --git a/java/com/android/incallui/InCallPresenter.java b/java/com/android/incallui/InCallPresenter.java
index 6e7daf5..8193c6e 100644
--- a/java/com/android/incallui/InCallPresenter.java
+++ b/java/com/android/incallui/InCallPresenter.java
@@ -52,6 +52,7 @@
 import com.android.dialer.common.concurrent.DialerExecutorComponent;
 import com.android.dialer.enrichedcall.EnrichedCallComponent;
 import com.android.dialer.location.GeoUtil;
+import com.android.dialer.logging.DialerImpression;
 import com.android.dialer.logging.InteractionEvent;
 import com.android.dialer.logging.Logger;
 import com.android.dialer.postcall.PostCall;
@@ -65,6 +66,7 @@
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.ExternalCallList;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.disconnectdialog.DisconnectMessage;
 import com.android.incallui.incalluilock.InCallUiLock;
 import com.android.incallui.latencyreport.LatencyReport;
@@ -271,8 +273,6 @@
 
   private SpeakEasyCallManager speakEasyCallManager;
 
-  private boolean audioRouteSetForBubbleMode;
-
   /** Inaccessible constructor. Must use getRunningInstance() to get this singleton. */
   @VisibleForTesting
   InCallPresenter() {}
@@ -429,7 +429,15 @@
     }
 
     Bundle extras = dialerCall.getIntentExtras();
-    return shouldStartInBubbleModeWithExtras(extras);
+    boolean result = shouldStartInBubbleModeWithExtras(extras);
+    if (result) {
+      Logger.get(context)
+          .logCallImpression(
+              DialerImpression.Type.START_CALL_IN_BUBBLE_MODE,
+              dialerCall.getUniqueCallId(),
+              dialerCall.getTimeAddedMs());
+    }
+    return result;
   }
 
   private boolean shouldStartInBubbleModeWithExtras(Bundle outgoingExtras) {
@@ -1347,7 +1355,7 @@
       LogUtil.v("InCallPresenter.handleCallKey", "heldCall: " + heldCall + ", canHold: " + canHold);
 
       // (4) unhold call
-      if (heldCall.getState() == DialerCall.State.ONHOLD && canHold) {
+      if (heldCall.getState() == DialerCallState.ONHOLD && canHold) {
         heldCall.unhold();
         return true;
       }
@@ -1419,7 +1427,7 @@
 
   /** Instruct the in-call activity to show an error dialog or toast for a disconnected call. */
   private void showDialogOrToastForDisconnectedCall(DialerCall call) {
-    if (call.getState() != DialerCall.State.DISCONNECTED) {
+    if (call.getState() != DialerCallState.DISCONNECTED) {
       return;
     }
 
@@ -1602,8 +1610,6 @@
 
       isChangingConfigurations = false;
 
-      audioRouteSetForBubbleMode = false;
-
       // blow away stale contact info so that we get fresh data on
       // the next set of calls
       if (contactInfoCache != null) {
@@ -1883,42 +1889,11 @@
 
   @Override
   public void onAudioStateChanged(CallAudioState audioState) {
-    // Set sensible audio route for bubble mode when we get real audio state for the first time
-    // During the first time this function is called, supportedRouteMask is set to
-    // SUPPORTED_AUDIO_ROUTE_ALL, but it's OK since shouldStartInBubbleMode() is false at that time
-    // (callList not updated yet).
-    if (!audioRouteSetForBubbleMode && shouldStartInBubbleMode()) {
-      setAudioRouteForBubbleMode(audioState);
-      audioRouteSetForBubbleMode = true;
-    }
-
     if (statusBarNotifier != null) {
       statusBarNotifier.updateNotification();
     }
   }
 
-  /**
-   * Set audio route to make audio sensible. According to availability, set audio route to Bluetooth
-   * or wired headset or speaker.
-   */
-  private void setAudioRouteForBubbleMode(CallAudioState audioState) {
-    if ((audioState.getSupportedRouteMask() & CallAudioState.ROUTE_BLUETOOTH)
-        == CallAudioState.ROUTE_BLUETOOTH) {
-      // Use Bluetooth if available
-      TelecomAdapter.getInstance().setAudioRoute(CallAudioState.ROUTE_BLUETOOTH);
-      LogUtil.i("InCallPrenter.setAudioRouteForBubbleMode", "bluetooth");
-    } else if ((audioState.getSupportedRouteMask() & CallAudioState.ROUTE_WIRED_HEADSET)
-        == CallAudioState.ROUTE_WIRED_HEADSET) {
-      // Use wired headset if available
-      TelecomAdapter.getInstance().setAudioRoute(CallAudioState.ROUTE_WIRED_HEADSET);
-      LogUtil.i("InCallPrenter.setAudioRouteForBubbleMode", "wired headset");
-    } else {
-      // Use speaker
-      TelecomAdapter.getInstance().setAudioRoute(CallAudioState.ROUTE_SPEAKER);
-      LogUtil.i("InCallPrenter.setAudioRouteForBubbleMode", "speaker");
-    }
-  }
-
   /** All the main states of InCallActivity. */
   public enum InCallState {
     // InCall Screen is off and there are no calls
diff --git a/java/com/android/incallui/StatusBarNotifier.java b/java/com/android/incallui/StatusBarNotifier.java
index 9a27532..32d2025 100644
--- a/java/com/android/incallui/StatusBarNotifier.java
+++ b/java/com/android/incallui/StatusBarNotifier.java
@@ -85,6 +85,7 @@
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.DialerCallListener;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.ringtone.DialerRingtoneManager;
 import com.android.incallui.ringtone.InCallTonePlayer;
 import com.android.incallui.ringtone.ToneGeneratorFactory;
@@ -117,7 +118,7 @@
   private final DialerRingtoneManager dialerRingtoneManager;
   @Nullable private ContactsPreferences contactsPreferences;
   private int currentNotification = NOTIFICATION_NONE;
-  private int callState = DialerCall.State.INVALID;
+  private int callState = DialerCallState.INVALID;
   private int videoState = VideoProfile.STATE_AUDIO_ONLY;
   private int savedIcon = 0;
   private String savedContent = null;
@@ -244,8 +245,8 @@
   private void showNotification(final DialerCall call) {
     Trace.beginSection("StatusBarNotifier.showNotification");
     final boolean isIncoming =
-        (call.getState() == DialerCall.State.INCOMING
-            || call.getState() == DialerCall.State.CALL_WAITING);
+        (call.getState() == DialerCallState.INCOMING
+            || call.getState() == DialerCallState.CALL_WAITING);
     setStatusBarCallListener(new StatusBarCallListener(call));
 
     // we make a call to the contact info cache to query for supplemental data to what the
@@ -287,8 +288,8 @@
         call.getVideoTech().getSessionModificationState()
             == SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
     final int notificationType;
-    if (callState == DialerCall.State.INCOMING
-        || callState == DialerCall.State.CALL_WAITING
+    if (callState == DialerCallState.INCOMING
+        || callState == DialerCallState.CALL_WAITING
         || isVideoUpgradeRequest) {
       if (ConfigProviderBindings.get(context)
           .getBoolean("quiet_incoming_call_if_ui_showing", true)) {
@@ -437,12 +438,12 @@
     setNotificationWhen(call, state, builder);
 
     // Add hang up option for any active calls (active | onhold), outgoing calls (dialing).
-    if (state == DialerCall.State.ACTIVE
-        || state == DialerCall.State.ONHOLD
-        || DialerCall.State.isDialing(state)) {
+    if (state == DialerCallState.ACTIVE
+        || state == DialerCallState.ONHOLD
+        || DialerCallState.isDialing(state)) {
       addHangupAction(builder);
       addSpeakerAction(builder, callAudioState);
-    } else if (state == DialerCall.State.INCOMING || state == DialerCall.State.CALL_WAITING) {
+    } else if (state == DialerCallState.INCOMING || state == DialerCallState.CALL_WAITING) {
       addDismissAction(builder);
       if (call.isVideoCall()) {
         addVideoCallAction(builder);
@@ -458,7 +459,7 @@
    * at which the notification was created.
    */
   private void setNotificationWhen(DialerCall call, int state, Notification.Builder builder) {
-    if (state == DialerCall.State.ACTIVE) {
+    if (state == DialerCallState.ACTIVE) {
       builder.setUsesChronometer(true);
       builder.setWhen(call.getConnectTimeMillis());
     } else {
@@ -642,7 +643,7 @@
     // different calls.  So if both lines are in use, display info
     // from the foreground call.  And if there's a ringing call,
     // display that regardless of the state of the other calls.
-    if (call.getState() == DialerCall.State.ONHOLD) {
+    if (call.getState() == DialerCallState.ONHOLD) {
       return R.drawable.quantum_ic_phone_paused_vd_theme_24;
     } else if (call.getVideoTech().getSessionModificationState()
             == SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST
@@ -668,8 +669,8 @@
   /** Returns the message to use with the notification. */
   private CharSequence getContentString(DialerCall call, @UserType long userType) {
     boolean isIncomingOrWaiting =
-        call.getState() == DialerCall.State.INCOMING
-            || call.getState() == DialerCall.State.CALL_WAITING;
+        call.getState() == DialerCallState.INCOMING
+            || call.getState() == DialerCallState.CALL_WAITING;
 
     if (isIncomingOrWaiting
         && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED) {
@@ -701,14 +702,14 @@
       } else {
         resId = R.string.notification_incoming_call;
       }
-    } else if (call.getState() == DialerCall.State.ONHOLD) {
+    } else if (call.getState() == DialerCallState.ONHOLD) {
       resId = R.string.notification_on_hold;
     } else if (call.isVideoCall()) {
       resId =
           call.getVideoTech().isPaused()
               ? R.string.notification_ongoing_paused_video_call
               : R.string.notification_ongoing_video_call;
-    } else if (DialerCall.State.isDialing(call.getState())) {
+    } else if (DialerCallState.isDialing(call.getState())) {
       resId = R.string.notification_dialing;
     } else if (call.getVideoTech().getSessionModificationState()
         == SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
diff --git a/java/com/android/incallui/VideoCallPresenter.java b/java/com/android/incallui/VideoCallPresenter.java
index 050ce98..41c3354 100644
--- a/java/com/android/incallui/VideoCallPresenter.java
+++ b/java/com/android/incallui/VideoCallPresenter.java
@@ -38,9 +38,9 @@
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.DialerCall.CameraDirection;
-import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.InCallVideoCallCallbackNotifier;
 import com.android.incallui.call.InCallVideoCallCallbackNotifier.SurfaceChangeListener;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.util.AccessibilityUtil;
 import com.android.incallui.video.protocol.VideoCallScreen;
 import com.android.incallui.video.protocol.VideoCallScreenDelegate;
@@ -101,7 +101,7 @@
   /** Determines if the current UI state represents a video call. */
   private int currentVideoState;
   /** DialerCall's current state */
-  private int currentCallState = DialerCall.State.INVALID;
+  private int currentCallState = DialerCallState.INVALID;
   /** Determines the device orientation (portrait/lanscape). */
   private int deviceOrientation = InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN;
   /** Tracks the state of the preview surface negotiation with the telephony layer. */
@@ -166,10 +166,10 @@
   static boolean showIncomingVideo(int videoState, int callState) {
 
     boolean isPaused = VideoProfile.isPaused(videoState);
-    boolean isCallActive = callState == DialerCall.State.ACTIVE;
+    boolean isCallActive = callState == DialerCallState.ACTIVE;
     // Show incoming Video for dialing calls to support early media
     boolean isCallOutgoingPending =
-        DialerCall.State.isDialing(callState) || callState == DialerCall.State.CONNECTING;
+        DialerCallState.isDialing(callState) || callState == DialerCallState.CONNECTING;
 
     return !isPaused
         && (isCallActive || isCallOutgoingPending)
@@ -318,7 +318,7 @@
     // Register for surface and video events from {@link InCallVideoCallListener}s.
     InCallVideoCallCallbackNotifier.getInstance().addSurfaceChangeListener(this);
     currentVideoState = VideoProfile.STATE_AUDIO_ONLY;
-    currentCallState = DialerCall.State.INVALID;
+    currentCallState = DialerCallState.INVALID;
 
     InCallPresenter.InCallState inCallState = InCallPresenter.getInstance().getInCallState();
     onStateChange(inCallState, inCallState, CallList.getInstance());
@@ -541,7 +541,8 @@
       updateFullscreenAndGreenScreenMode(
           primaryCall.getState(), primaryCall.getVideoTech().getSessionModificationState());
     } else {
-      updateFullscreenAndGreenScreenMode(State.INVALID, SessionModificationState.NO_REQUEST);
+      updateFullscreenAndGreenScreenMode(
+          DialerCallState.INVALID, SessionModificationState.NO_REQUEST);
     }
   }
 
@@ -640,7 +641,7 @@
   private void updateCallCache(DialerCall call) {
     if (call == null) {
       currentVideoState = VideoProfile.STATE_AUDIO_ONLY;
-      currentCallState = DialerCall.State.INVALID;
+      currentCallState = DialerCallState.INVALID;
       videoCall = null;
       primaryCall = null;
     } else {
@@ -699,9 +700,9 @@
     if (videoCallScreen != null) {
       boolean shouldShowFullscreen = InCallPresenter.getInstance().isFullscreen();
       boolean shouldShowGreenScreen =
-          callState == State.DIALING
-              || callState == State.CONNECTING
-              || callState == State.INCOMING
+          callState == DialerCallState.DIALING
+              || callState == DialerCallState.CONNECTING
+              || callState == DialerCallState.INCOMING
               || isVideoUpgrade(sessionModificationState);
       videoCallScreen.updateFullscreenAndGreenScreenMode(
           shouldShowFullscreen, shouldShowGreenScreen);
@@ -850,7 +851,7 @@
 
     showVideoUi(
         VideoProfile.STATE_AUDIO_ONLY,
-        DialerCall.State.ACTIVE,
+        DialerCallState.ACTIVE,
         SessionModificationState.NO_REQUEST,
         false /* isRemotelyHeld */);
     enableCamera(primaryCall, false);
@@ -1019,7 +1020,7 @@
       return;
     }
 
-    if (!isVideoCall(call) || call.getState() == DialerCall.State.INCOMING) {
+    if (!isVideoCall(call) || call.getState() == DialerCallState.INCOMING) {
       LogUtil.i("VideoCallPresenter.maybeExitFullscreen", "exiting fullscreen");
       InCallPresenter.getInstance().setFullScreen(false);
     }
@@ -1038,7 +1039,7 @@
     }
 
     if (call == null
-        || call.getState() != DialerCall.State.ACTIVE
+        || call.getState() != DialerCallState.ACTIVE
         || !isBidirectionalVideoCall(call)
         || InCallPresenter.getInstance().isFullscreen()
         || (context != null && AccessibilityUtil.isTouchExplorationEnabled(context))) {
@@ -1263,11 +1264,11 @@
       return false;
     }
     final int state = call.getState();
-    return (state == DialerCall.State.INCOMING) || (state == DialerCall.State.CALL_WAITING);
+    return (state == DialerCallState.INCOMING) || (state == DialerCallState.CALL_WAITING);
   }
 
   private static boolean isActiveVideoCall(DialerCall call) {
-    return isVideoCall(call) && call.getState() == DialerCall.State.ACTIVE;
+    return isVideoCall(call) && call.getState() == DialerCallState.ACTIVE;
   }
 
   private static boolean isOutgoingVideoCall(DialerCall call) {
@@ -1275,9 +1276,9 @@
       return false;
     }
     final int state = call.getState();
-    return DialerCall.State.isDialing(state)
-        || state == DialerCall.State.CONNECTING
-        || state == DialerCall.State.SELECT_PHONE_ACCOUNT;
+    return DialerCallState.isDialing(state)
+        || state == DialerCallState.CONNECTING
+        || state == DialerCallState.SELECT_PHONE_ACCOUNT;
   }
 
   private static boolean isAudioCall(DialerCall call) {
diff --git a/java/com/android/incallui/VideoPauseController.java b/java/com/android/incallui/VideoPauseController.java
index 1a65010..2bdbce3 100644
--- a/java/com/android/incallui/VideoPauseController.java
+++ b/java/com/android/incallui/VideoPauseController.java
@@ -24,7 +24,7 @@
 import com.android.incallui.InCallPresenter.IncomingCallListener;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import java.util.Objects;
 
 /**
@@ -43,7 +43,7 @@
    *
    * <p>These values are stored to detect specific changes in state between onStateChange calls.
    */
-  private int prevCallState = State.INVALID;
+  private int prevCallState = DialerCallState.INVALID;
 
   private boolean wasVideoCall = false;
 
@@ -74,8 +74,8 @@
    */
   private static boolean isIncomingCall(DialerCall call) {
     return call != null
-        && (call.getState() == DialerCall.State.CALL_WAITING
-            || call.getState() == DialerCall.State.INCOMING);
+        && (call.getState() == DialerCallState.CALL_WAITING
+            || call.getState() == DialerCallState.INCOMING);
   }
 
   /**
@@ -84,7 +84,7 @@
    * @return {@code true} if the call is dialing, {@code false} otherwise.
    */
   private boolean wasDialing() {
-    return DialerCall.State.isDialing(prevCallState);
+    return DialerCallState.isDialing(prevCallState);
   }
 
   /**
@@ -115,7 +115,7 @@
   private void clear() {
     inCallPresenter = null;
     primaryCall = null;
-    prevCallState = State.INVALID;
+    prevCallState = DialerCallState.INVALID;
     wasVideoCall = false;
     isInBackground = false;
   }
@@ -237,7 +237,7 @@
   private void updatePrimaryCallContext(DialerCall call) {
     if (call == null) {
       primaryCall = null;
-      prevCallState = State.INVALID;
+      prevCallState = DialerCallState.INVALID;
       wasVideoCall = false;
     } else {
       primaryCall = call;
@@ -322,6 +322,6 @@
   }
 
   private static boolean videoCanPause(DialerCall call) {
-    return call != null && call.isVideoCall() && call.getState() == DialerCall.State.ACTIVE;
+    return call != null && call.isVideoCall() && call.getState() == DialerCallState.ACTIVE;
   }
 }
diff --git a/java/com/android/incallui/answer/impl/AnswerFragment.java b/java/com/android/incallui/answer/impl/AnswerFragment.java
index 77352f9..fb1de05 100644
--- a/java/com/android/incallui/answer/impl/AnswerFragment.java
+++ b/java/com/android/incallui/answer/impl/AnswerFragment.java
@@ -69,7 +69,7 @@
 import com.android.incallui.answer.protocol.AnswerScreen;
 import com.android.incallui.answer.protocol.AnswerScreenDelegate;
 import com.android.incallui.answer.protocol.AnswerScreenDelegateFactory;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.contactgrid.ContactGridManager;
 import com.android.incallui.incall.protocol.ContactPhotoType;
 import com.android.incallui.incall.protocol.InCallScreen;
@@ -889,7 +889,7 @@
   public void onAnswerProgressUpdate(@FloatRange(from = -1f, to = 1f) float answerProgress) {
     // Don't fade the window background for call waiting or video upgrades. Fading the background
     // shows the system wallpaper which looks bad because on reject we switch to another call.
-    if (primaryCallState.state() == State.INCOMING && !isVideoCall()) {
+    if (primaryCallState.state() == DialerCallState.INCOMING && !isVideoCall()) {
       answerScreenDelegate.updateWindowBackgroundColor(answerProgress);
     }
 
@@ -1079,9 +1079,9 @@
 
   private boolean canRejectCallWithSms() {
     return primaryCallState != null
-        && !(primaryCallState.state() == State.DISCONNECTED
-            || primaryCallState.state() == State.DISCONNECTING
-            || primaryCallState.state() == State.IDLE);
+        && !(primaryCallState.state() == DialerCallState.DISCONNECTED
+            || primaryCallState.state() == DialerCallState.DISCONNECTING
+            || primaryCallState.state() == DialerCallState.IDLE);
   }
 
   private void createInCallScreenDelegate() {
diff --git a/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java b/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java
index 50f6ae6..939d120 100644
--- a/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java
+++ b/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java
@@ -24,8 +24,8 @@
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.configprovider.ConfigProviderBindings;
 import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.DialerCallListener;
+import com.android.incallui.call.state.DialerCallState;
 
 /**
  * This class prevents users from accidentally answering calls by keeping the screen off until the
@@ -47,7 +47,7 @@
     Trace.beginSection("AnswerProximitySensor.shouldUse");
     // Don't use the AnswerProximitySensor for call waiting and other states. Those states are
     // handled by the general ProximitySensor code.
-    if (call.getState() != State.INCOMING) {
+    if (call.getState() != DialerCallState.INCOMING) {
       LogUtil.i("AnswerProximitySensor.shouldUse", "call state is not incoming");
       Trace.endSection();
       return false;
@@ -129,7 +129,7 @@
 
   @Override
   public void onDialerCallUpdate() {
-    if (call.getState() != State.INCOMING) {
+    if (call.getState() != DialerCallState.INCOMING) {
       LogUtil.i("AnswerProximitySensor.onDialerCallUpdate", "no longer incoming, cleaning up");
       cleanup();
     }
diff --git a/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java b/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java
index 79cae09..cd17c25 100644
--- a/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java
+++ b/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java
@@ -16,6 +16,7 @@
 
 package com.android.incallui.audioroute;
 
+import android.annotation.SuppressLint;
 import android.app.Dialog;
 import android.bluetooth.BluetoothDevice;
 import android.content.Context;
@@ -34,7 +35,13 @@
 import android.widget.TextView;
 import com.android.dialer.common.FragmentUtils;
 import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.DialerImpression;
+import com.android.dialer.logging.Logger;
 import com.android.incallui.audiomode.BluetoothDeviceProviderComponent;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Set;
 
 /** Shows picker for audio routes */
@@ -98,15 +105,18 @@
     initItem(
         (TextView) view.findViewById(R.id.audioroute_speaker),
         CallAudioState.ROUTE_SPEAKER,
-        audioState);
+        audioState,
+        DialerImpression.Type.IN_CALL_SWITCH_AUDIO_ROUTE_SPEAKER);
     initItem(
         (TextView) view.findViewById(R.id.audioroute_headset),
         CallAudioState.ROUTE_WIRED_HEADSET,
-        audioState);
+        audioState,
+        DialerImpression.Type.IN_CALL_SWITCH_AUDIO_ROUTE_WIRED_HEADSET);
     initItem(
         (TextView) view.findViewById(R.id.audioroute_earpiece),
         CallAudioState.ROUTE_EARPIECE,
-        audioState);
+        audioState,
+        DialerImpression.Type.IN_CALL_SWITCH_AUDIO_ROUTE_EARPIECE);
 
     // TODO(a bug): set peak height correctly to fully expand it in landscape mode.
     return view;
@@ -120,7 +130,11 @@
         .onAudioRouteSelectorDismiss();
   }
 
-  private void initItem(TextView item, final int itemRoute, CallAudioState audioState) {
+  private void initItem(
+      TextView item,
+      final int itemRoute,
+      CallAudioState audioState,
+      DialerImpression.Type impressionType) {
     int selectedColor = getResources().getColor(R.color.dialer_theme_color);
     if ((audioState.getSupportedRouteMask() & itemRoute) == 0) {
       item.setVisibility(View.GONE);
@@ -131,10 +145,11 @@
     }
     item.setOnClickListener(
         (v) -> {
-          dismiss();
+          logCallAudioRouteImpression(impressionType);
           FragmentUtils.getParentUnsafe(
                   AudioRouteSelectorDialogFragment.this, AudioRouteSelectorPresenter.class)
               .onAudioRouteSelected(itemRoute);
+          dismiss();
         });
   }
 
@@ -142,7 +157,7 @@
     int selectedColor = getResources().getColor(R.color.dialer_theme_color);
     TextView textView =
         (TextView) getLayoutInflater().inflate(R.layout.audioroute_item, null, false);
-    textView.setText(bluetoothDevice.getName());
+    textView.setText(getAliasName(bluetoothDevice));
     if (selected) {
       textView.setTextColor(selectedColor);
       textView.setCompoundDrawableTintList(ColorStateList.valueOf(selectedColor));
@@ -150,7 +165,7 @@
     }
     textView.setOnClickListener(
         (v) -> {
-          dismiss();
+          logCallAudioRouteImpression(DialerImpression.Type.IN_CALL_SWITCH_AUDIO_ROUTE_BLUETOOTH);
           // Set Bluetooth audio route
           FragmentUtils.getParentUnsafe(
                   AudioRouteSelectorDialogFragment.this, AudioRouteSelectorPresenter.class)
@@ -159,8 +174,36 @@
           BluetoothDeviceProviderComponent.get(getContext())
               .bluetoothDeviceProvider()
               .setActiveBluetoothDevice(bluetoothDevice);
+          dismiss();
         });
 
     return textView;
   }
+
+  @SuppressLint("PrivateApi")
+  private String getAliasName(BluetoothDevice bluetoothDevice) {
+    try {
+      Method getActiveDeviceMethod = bluetoothDevice.getClass().getDeclaredMethod("getAliasName");
+      getActiveDeviceMethod.setAccessible(true);
+      return (String) getActiveDeviceMethod.invoke(bluetoothDevice);
+    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+      e.printStackTrace();
+      return bluetoothDevice.getName();
+    }
+  }
+
+  private void logCallAudioRouteImpression(DialerImpression.Type impressionType) {
+    DialerCall dialerCall = CallList.getInstance().getOutgoingCall();
+    if (dialerCall == null) {
+      dialerCall = CallList.getInstance().getActiveOrBackgroundCall();
+    }
+
+    if (dialerCall != null) {
+      Logger.get(getContext())
+          .logCallImpression(
+              impressionType, dialerCall.getUniqueCallId(), dialerCall.getTimeAddedMs());
+    } else {
+      Logger.get(getContext()).logImpression(impressionType);
+    }
+  }
 }
diff --git a/java/com/android/incallui/audioroute/res/layout/audioroute_item.xml b/java/com/android/incallui/audioroute/res/layout/audioroute_item.xml
index 66c83f6..dfd795f 100644
--- a/java/com/android/incallui/audioroute/res/layout/audioroute_item.xml
+++ b/java/com/android/incallui/audioroute/res/layout/audioroute_item.xml
@@ -18,4 +18,6 @@
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:drawableStart="@drawable/quantum_ic_bluetooth_audio_vd_theme_24"
-    android:drawableTint="@color/material_grey_600"/>
\ No newline at end of file
+    android:drawableTint="@color/material_grey_600"
+    android:gravity="start"
+    android:textAlignment="viewStart"/>
\ No newline at end of file
diff --git a/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml b/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml
index 145101d..b63f387 100644
--- a/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml
+++ b/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml
@@ -14,31 +14,34 @@
 ~ limitations under the License
 -->
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:tools="http://schemas.android.com/tools"
-  android:layout_width="match_parent"
-  android:layout_height="wrap_content"
-  android:orientation="vertical"
-  tools:layout_gravity="bottom">
-  <TextView
-    android:id="@+id/audioroute_speaker"
-    style="@style/AudioRouteItem"
+    xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:drawableStart="@drawable/quantum_ic_volume_up_grey600_24"
-    android:text="@string/audioroute_speaker"/>
+    android:orientation="vertical"
+    tools:layout_gravity="bottom">
   <TextView
-    android:id="@+id/audioroute_earpiece"
-    style="@style/AudioRouteItem"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:drawableStart="@drawable/ic_phone_audio_grey600_24dp"
-    android:text="@string/audioroute_phone"/>
+      android:id="@+id/audioroute_speaker"
+      style="@style/AudioRouteItem"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:drawableStart="@drawable/quantum_ic_volume_up_grey600_24"
+      android:text="@string/audioroute_speaker"
+      android:textAlignment="viewStart"/>
   <TextView
-    android:id="@+id/audioroute_headset"
-    style="@style/AudioRouteItem"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:drawableStart="@drawable/quantum_ic_headset_grey600_24"
-    android:text="@string/audioroute_headset"/>
+      android:id="@+id/audioroute_earpiece"
+      style="@style/AudioRouteItem"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:drawableStart="@drawable/ic_phone_audio_grey600_24dp"
+      android:text="@string/audioroute_phone"
+      android:textAlignment="viewStart"/>
+  <TextView
+      android:id="@+id/audioroute_headset"
+      style="@style/AudioRouteItem"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:drawableStart="@drawable/quantum_ic_headset_grey600_24"
+      android:text="@string/audioroute_headset"
+      android:textAlignment="viewStart"/>
 
 </LinearLayout>
diff --git a/java/com/android/incallui/call/CallList.java b/java/com/android/incallui/call/CallList.java
index 6b17962..5d9db32 100644
--- a/java/com/android/incallui/call/CallList.java
+++ b/java/com/android/incallui/call/CallList.java
@@ -42,7 +42,7 @@
 import com.android.dialer.spam.Spam;
 import com.android.dialer.spam.SpamComponent;
 import com.android.dialer.telecom.TelecomCallUtil;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.latencyreport.LatencyReport;
 import com.android.incallui.videotech.utils.SessionModificationState;
 import java.util.Collection;
@@ -155,8 +155,8 @@
                 @Override
                 public void onComplete(boolean isSpam) {
                   boolean isIncomingCall =
-                      call.getState() == DialerCall.State.INCOMING
-                          || call.getState() == DialerCall.State.CALL_WAITING;
+                      call.getState() == DialerCallState.INCOMING
+                          || call.getState() == DialerCallState.CALL_WAITING;
                   if (isSpam) {
                     if (!isIncomingCall) {
                       LogUtil.i(
@@ -211,8 +211,8 @@
         call.getCountryIso());
     Trace.endSection();
 
-    if (call.getState() == DialerCall.State.INCOMING
-        || call.getState() == DialerCall.State.CALL_WAITING) {
+    if (call.getState() == DialerCallState.INCOMING
+        || call.getState() == DialerCallState.CALL_WAITING) {
       if (call.isActiveRttCall()) {
         Logger.get(context)
             .logCallImpression(
@@ -233,7 +233,7 @@
       notifyGenericListeners();
     }
 
-    if (call.getState() != State.INCOMING) {
+    if (call.getState() != DialerCallState.INCOMING) {
       // Only report outgoing calls
       ShortcutUsageReporter.onOutgoingCallAdded(context, call.getNumber());
     }
@@ -444,46 +444,46 @@
 
   /** A call that is waiting for {@link PhoneAccount} selection */
   public DialerCall getWaitingForAccountCall() {
-    return getFirstCallWithState(DialerCall.State.SELECT_PHONE_ACCOUNT);
+    return getFirstCallWithState(DialerCallState.SELECT_PHONE_ACCOUNT);
   }
 
   public DialerCall getPendingOutgoingCall() {
-    return getFirstCallWithState(DialerCall.State.CONNECTING);
+    return getFirstCallWithState(DialerCallState.CONNECTING);
   }
 
   public DialerCall getOutgoingCall() {
-    DialerCall call = getFirstCallWithState(DialerCall.State.DIALING);
+    DialerCall call = getFirstCallWithState(DialerCallState.DIALING);
     if (call == null) {
-      call = getFirstCallWithState(DialerCall.State.REDIALING);
+      call = getFirstCallWithState(DialerCallState.REDIALING);
     }
     if (call == null) {
-      call = getFirstCallWithState(DialerCall.State.PULLING);
+      call = getFirstCallWithState(DialerCallState.PULLING);
     }
     return call;
   }
 
   public DialerCall getActiveCall() {
-    return getFirstCallWithState(DialerCall.State.ACTIVE);
+    return getFirstCallWithState(DialerCallState.ACTIVE);
   }
 
   public DialerCall getSecondActiveCall() {
-    return getCallWithState(DialerCall.State.ACTIVE, 1);
+    return getCallWithState(DialerCallState.ACTIVE, 1);
   }
 
   public DialerCall getBackgroundCall() {
-    return getFirstCallWithState(DialerCall.State.ONHOLD);
+    return getFirstCallWithState(DialerCallState.ONHOLD);
   }
 
   public DialerCall getDisconnectedCall() {
-    return getFirstCallWithState(DialerCall.State.DISCONNECTED);
+    return getFirstCallWithState(DialerCallState.DISCONNECTED);
   }
 
   public DialerCall getDisconnectingCall() {
-    return getFirstCallWithState(DialerCall.State.DISCONNECTING);
+    return getFirstCallWithState(DialerCallState.DISCONNECTING);
   }
 
   public DialerCall getSecondBackgroundCall() {
-    return getCallWithState(DialerCall.State.ONHOLD, 1);
+    return getCallWithState(DialerCallState.ONHOLD, 1);
   }
 
   public DialerCall getActiveOrBackgroundCall() {
@@ -495,9 +495,9 @@
   }
 
   public DialerCall getIncomingCall() {
-    DialerCall call = getFirstCallWithState(DialerCall.State.INCOMING);
+    DialerCall call = getFirstCallWithState(DialerCallState.INCOMING);
     if (call == null) {
-      call = getFirstCallWithState(DialerCall.State.CALL_WAITING);
+      call = getFirstCallWithState(DialerCallState.CALL_WAITING);
     }
 
     return call;
@@ -512,7 +512,7 @@
       result = getOutgoingCall();
     }
     if (result == null) {
-      result = getFirstCallWithState(DialerCall.State.ACTIVE);
+      result = getFirstCallWithState(DialerCallState.ACTIVE);
     }
     if (result == null) {
       result = getDisconnectingCall();
@@ -592,9 +592,9 @@
    */
   public boolean hasNonParentActiveOrBackgroundCall() {
     for (DialerCall call : callById.values()) {
-      if ((call.getState() == State.ACTIVE
-              || call.getState() == State.ONHOLD
-              || call.getState() == State.CONFERENCED)
+      if ((call.getState() == DialerCallState.ACTIVE
+              || call.getState() == DialerCallState.ONHOLD
+              || call.getState() == DialerCallState.CONFERENCED)
           && !call.wasParentCall()) {
         return true;
       }
@@ -611,11 +611,11 @@
   public void clearOnDisconnect() {
     for (DialerCall call : callById.values()) {
       final int state = call.getState();
-      if (state != DialerCall.State.IDLE
-          && state != DialerCall.State.INVALID
-          && state != DialerCall.State.DISCONNECTED) {
+      if (state != DialerCallState.IDLE
+          && state != DialerCallState.INVALID
+          && state != DialerCallState.DISCONNECTED) {
 
-        call.setState(DialerCall.State.DISCONNECTED);
+        call.setState(DialerCallState.DISCONNECTED);
         call.setDisconnectCause(new DisconnectCause(DisconnectCause.UNKNOWN));
         updateCallInMap(call);
       }
@@ -688,7 +688,7 @@
 
     boolean updated = false;
 
-    if (call.getState() == DialerCall.State.DISCONNECTED) {
+    if (call.getState() == DialerCallState.DISCONNECTED) {
       // update existing (but do not add!!) disconnected calls
       if (callById.containsKey(call.getId())) {
         // For disconnected calls, we want to keep them alive for a few seconds so that the
@@ -718,7 +718,7 @@
   }
 
   private int getDelayForDisconnect(DialerCall call) {
-    if (call.getState() != DialerCall.State.DISCONNECTED) {
+    if (call.getState() != DialerCallState.DISCONNECTED) {
       throw new IllegalStateException();
     }
 
@@ -748,7 +748,7 @@
 
   private boolean isCallDead(DialerCall call) {
     final int state = call.getState();
-    return DialerCall.State.IDLE == state || DialerCall.State.INVALID == state;
+    return DialerCallState.IDLE == state || DialerCallState.INVALID == state;
   }
 
   /** Sets up a call for deletion and notifies listeners of change. */
@@ -756,7 +756,7 @@
     if (pendingDisconnectCalls.contains(call)) {
       pendingDisconnectCalls.remove(call);
     }
-    call.setState(DialerCall.State.IDLE);
+    call.setState(DialerCallState.IDLE);
     updateCallInMap(call);
     notifyGenericListeners();
   }
diff --git a/java/com/android/incallui/call/DialerCall.java b/java/com/android/incallui/call/DialerCall.java
index da05b9d..d57de15 100644
--- a/java/com/android/incallui/call/DialerCall.java
+++ b/java/com/android/incallui/call/DialerCall.java
@@ -81,6 +81,7 @@
 import com.android.dialer.theme.R;
 import com.android.dialer.util.PermissionsUtil;
 import com.android.incallui.audiomode.AudioModeProvider;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.latencyreport.LatencyReport;
 import com.android.incallui.speakeasy.runtime.Constraints;
 import com.android.incallui.videotech.VideoTech;
@@ -146,7 +147,7 @@
   private boolean isSpeakEasyCall;
   private boolean isEmergencyCall;
   private Uri handle;
-  private int state = State.INVALID;
+  private int state = DialerCallState.INVALID;
   private DisconnectCause disconnectCause;
 
   private boolean hasShownLteToWiFiHandoverToast;
@@ -200,7 +201,8 @@
 
   /**
    * Whether the call is put on hold by remote party. This is different than the {@link
-   * State#ONHOLD} state which indicates that the call is being held locally on the device.
+   * DialerCallState#ONHOLD} state which indicates that the call is being held locally on the
+   * device.
    */
   private boolean isRemotelyHeld;
 
@@ -427,25 +429,25 @@
     switch (state) {
       case Call.STATE_NEW:
       case Call.STATE_CONNECTING:
-        return DialerCall.State.CONNECTING;
+        return DialerCallState.CONNECTING;
       case Call.STATE_SELECT_PHONE_ACCOUNT:
-        return DialerCall.State.SELECT_PHONE_ACCOUNT;
+        return DialerCallState.SELECT_PHONE_ACCOUNT;
       case Call.STATE_DIALING:
-        return DialerCall.State.DIALING;
+        return DialerCallState.DIALING;
       case Call.STATE_PULLING_CALL:
-        return DialerCall.State.PULLING;
+        return DialerCallState.PULLING;
       case Call.STATE_RINGING:
-        return DialerCall.State.INCOMING;
+        return DialerCallState.INCOMING;
       case Call.STATE_ACTIVE:
-        return DialerCall.State.ACTIVE;
+        return DialerCallState.ACTIVE;
       case Call.STATE_HOLDING:
-        return DialerCall.State.ONHOLD;
+        return DialerCallState.ONHOLD;
       case Call.STATE_DISCONNECTED:
-        return DialerCall.State.DISCONNECTED;
+        return DialerCallState.DISCONNECTED;
       case Call.STATE_DISCONNECTING:
-        return DialerCall.State.DISCONNECTING;
+        return DialerCallState.DISCONNECTING;
       default:
-        return DialerCall.State.INVALID;
+        return DialerCallState.INVALID;
     }
   }
 
@@ -570,7 +572,7 @@
     videoTech = null;
     // We want to potentially register a video call callback here.
     updateFromTelecomCall();
-    if (oldState != getState() && getState() == DialerCall.State.DISCONNECTED) {
+    if (oldState != getState() && getState() == DialerCallState.DISCONNECTED) {
       for (DialerCallListener listener : listeners) {
         listener.onDialerCallDisconnect();
       }
@@ -596,7 +598,7 @@
     videoTechManager.dispatchCallStateChanged(telecomCall.getState(), getAccountHandle());
 
     final int translatedState = translateState(telecomCall.getState());
-    if (state != State.BLOCKED) {
+    if (state != DialerCallState.BLOCKED) {
       setState(translatedState);
       setDisconnectCause(telecomCall.getDetails().getDisconnectCause());
     }
@@ -805,7 +807,7 @@
 
   public void blockCall() {
     telecomCall.reject(false, null);
-    setState(State.BLOCKED);
+    setState(DialerCallState.BLOCKED);
   }
 
   @Nullable
@@ -846,7 +848,7 @@
 
   public int getState() {
     if (telecomCall != null && telecomCall.getParent() != null) {
-      return State.CONFERENCED;
+      return DialerCallState.CONFERENCED;
     } else {
       return state;
     }
@@ -857,9 +859,9 @@
   }
 
   public void setState(int state) {
-    if (state == State.INCOMING) {
+    if (state == DialerCallState.INCOMING) {
       logState.isIncoming = true;
-    } else if (state == State.DISCONNECTED) {
+    } else if (state == DialerCallState.DISCONNECTED) {
       long newDuration =
           getConnectTimeMillis() == 0 ? 0 : System.currentTimeMillis() - getConnectTimeMillis();
       if (this.state != state) {
@@ -927,7 +929,7 @@
 
   /** Returns call disconnect cause, defined by {@link DisconnectCause}. */
   public DisconnectCause getDisconnectCause() {
-    if (state == State.DISCONNECTED || state == State.IDLE) {
+    if (state == DialerCallState.DISCONNECTED || state == DialerCallState.IDLE) {
       return disconnectCause;
     }
 
@@ -1146,7 +1148,7 @@
               .setCallInitiationType(CallInitiationType.Type.EXTERNAL_INITIATION)
               .build();
     }
-    if (getState() == State.INCOMING) {
+    if (getState() == DialerCallState.INCOMING) {
       logState.callSpecificAppData =
           logState
               .callSpecificAppData
@@ -1169,7 +1171,7 @@
         "[%s, %s, %s, %s, children:%s, parent:%s, "
             + "conferenceable:%s, videoState:%s, mSessionModificationState:%d, CameraDir:%s]",
         id,
-        State.toString(getState()),
+        DialerCallState.toString(getState()),
         Details.capabilitiesToString(telecomCall.getDetails().getCallCapabilities()),
         Details.propertiesToString(telecomCall.getDetails().getCallProperties()),
         childCallIds,
@@ -1366,7 +1368,7 @@
 
   public void disconnect() {
     LogUtil.i("DialerCall.disconnect", "");
-    setState(DialerCall.State.DISCONNECTING);
+    setState(DialerCallState.DISCONNECTING);
     for (DialerCallListener listener : listeners) {
       listener.onDialerCallUpdate();
     }
@@ -1686,88 +1688,6 @@
   @Retention(RetentionPolicy.SOURCE)
   public @interface CallHistoryStatus {}
 
-  /* Defines different states of this call */
-  public static class State {
-
-    public static final int INVALID = 0;
-    public static final int NEW = 1; /* The call is new. */
-    public static final int IDLE = 2; /* The call is idle.  Nothing active */
-    public static final int ACTIVE = 3; /* There is an active call */
-    public static final int INCOMING = 4; /* A normal incoming phone call */
-    public static final int CALL_WAITING = 5; /* Incoming call while another is active */
-    public static final int DIALING = 6; /* An outgoing call during dial phase */
-    public static final int REDIALING = 7; /* Subsequent dialing attempt after a failure */
-    public static final int ONHOLD = 8; /* An active phone call placed on hold */
-    public static final int DISCONNECTING = 9; /* A call is being ended. */
-    public static final int DISCONNECTED = 10; /* State after a call disconnects */
-    public static final int CONFERENCED = 11; /* DialerCall part of a conference call */
-    public static final int SELECT_PHONE_ACCOUNT = 12; /* Waiting for account selection */
-    public static final int CONNECTING = 13; /* Waiting for Telecom broadcast to finish */
-    public static final int BLOCKED = 14; /* The number was found on the block list */
-    public static final int PULLING = 15; /* An external call being pulled to the device */
-    public static final int CALL_PENDING = 16; /* A call is pending on a long process to finish */
-
-    public static boolean isConnectingOrConnected(int state) {
-      switch (state) {
-        case ACTIVE:
-        case INCOMING:
-        case CALL_WAITING:
-        case CONNECTING:
-        case DIALING:
-        case PULLING:
-        case REDIALING:
-        case ONHOLD:
-        case CONFERENCED:
-          return true;
-        default:
-          return false;
-      }
-    }
-
-    public static boolean isDialing(int state) {
-      return state == DIALING || state == PULLING || state == REDIALING;
-    }
-
-    public static String toString(int state) {
-      switch (state) {
-        case INVALID:
-          return "INVALID";
-        case NEW:
-          return "NEW";
-        case IDLE:
-          return "IDLE";
-        case ACTIVE:
-          return "ACTIVE";
-        case INCOMING:
-          return "INCOMING";
-        case CALL_WAITING:
-          return "CALL_WAITING";
-        case DIALING:
-          return "DIALING";
-        case PULLING:
-          return "PULLING";
-        case REDIALING:
-          return "REDIALING";
-        case ONHOLD:
-          return "ONHOLD";
-        case DISCONNECTING:
-          return "DISCONNECTING";
-        case DISCONNECTED:
-          return "DISCONNECTED";
-        case CONFERENCED:
-          return "CONFERENCED";
-        case SELECT_PHONE_ACCOUNT:
-          return "SELECT_PHONE_ACCOUNT";
-        case CONNECTING:
-          return "CONNECTING";
-        case BLOCKED:
-          return "BLOCKED";
-        default:
-          return "UNKNOWN";
-      }
-    }
-  }
-
   /** Camera direction constants */
   public static class CameraDirection {
     public static final int CAMERA_DIRECTION_UNKNOWN = -1;
diff --git a/java/com/android/incallui/call/state/DialerCallState.java b/java/com/android/incallui/call/state/DialerCallState.java
new file mode 100644
index 0000000..266d6d6
--- /dev/null
+++ b/java/com/android/incallui/call/state/DialerCallState.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2018 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.call.state;
+
+/** Defines different states of {@link com.android.incallui.call.DialerCall} */
+public class DialerCallState {
+
+  public static final int INVALID = 0;
+  public static final int NEW = 1; /* The call is new. */
+  public static final int IDLE = 2; /* The call is idle.  Nothing active */
+  public static final int ACTIVE = 3; /* There is an active call */
+  public static final int INCOMING = 4; /* A normal incoming phone call */
+  public static final int CALL_WAITING = 5; /* Incoming call while another is active */
+  public static final int DIALING = 6; /* An outgoing call during dial phase */
+  public static final int REDIALING = 7; /* Subsequent dialing attempt after a failure */
+  public static final int ONHOLD = 8; /* An active phone call placed on hold */
+  public static final int DISCONNECTING = 9; /* A call is being ended. */
+  public static final int DISCONNECTED = 10; /* State after a call disconnects */
+  public static final int CONFERENCED = 11; /* DialerCall part of a conference call */
+  public static final int SELECT_PHONE_ACCOUNT = 12; /* Waiting for account selection */
+  public static final int CONNECTING = 13; /* Waiting for Telecom broadcast to finish */
+  public static final int BLOCKED = 14; /* The number was found on the block list */
+  public static final int PULLING = 15; /* An external call being pulled to the device */
+  public static final int CALL_PENDING = 16; /* A call is pending on a long process to finish */
+
+  public static boolean isConnectingOrConnected(int state) {
+    switch (state) {
+      case ACTIVE:
+      case INCOMING:
+      case CALL_WAITING:
+      case CONNECTING:
+      case DIALING:
+      case PULLING:
+      case REDIALING:
+      case ONHOLD:
+      case CONFERENCED:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  public static boolean isDialing(int state) {
+    return state == DIALING || state == PULLING || state == REDIALING;
+  }
+
+  public static String toString(int state) {
+    switch (state) {
+      case INVALID:
+        return "INVALID";
+      case NEW:
+        return "NEW";
+      case IDLE:
+        return "IDLE";
+      case ACTIVE:
+        return "ACTIVE";
+      case INCOMING:
+        return "INCOMING";
+      case CALL_WAITING:
+        return "CALL_WAITING";
+      case DIALING:
+        return "DIALING";
+      case PULLING:
+        return "PULLING";
+      case REDIALING:
+        return "REDIALING";
+      case ONHOLD:
+        return "ONHOLD";
+      case DISCONNECTING:
+        return "DISCONNECTING";
+      case DISCONNECTED:
+        return "DISCONNECTED";
+      case CONFERENCED:
+        return "CONFERENCED";
+      case SELECT_PHONE_ACCOUNT:
+        return "SELECT_PHONE_ACCOUNT";
+      case CONNECTING:
+        return "CONNECTING";
+      case BLOCKED:
+        return "BLOCKED";
+      default:
+        return "UNKNOWN";
+    }
+  }
+}
diff --git a/java/com/android/incallui/callpending/CallPendingActivity.java b/java/com/android/incallui/callpending/CallPendingActivity.java
index 831ebbd..3c69f97 100644
--- a/java/com/android/incallui/callpending/CallPendingActivity.java
+++ b/java/com/android/incallui/callpending/CallPendingActivity.java
@@ -31,7 +31,7 @@
 import com.android.dialer.enrichedcall.Session;
 import com.android.dialer.multimedia.MultimediaData;
 import com.android.incallui.audiomode.AudioModeProvider;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.incall.bindings.InCallBindings;
 import com.android.incallui.incall.protocol.ContactPhotoType;
 import com.android.incallui.incall.protocol.InCallButtonIds;
@@ -148,7 +148,7 @@
     inCallScreen.setPrimary(createPrimaryInfo());
     inCallScreen.setCallState(
         PrimaryCallState.builder()
-            .setState(State.CALL_PENDING)
+            .setState(DialerCallState.CALL_PENDING)
             .setCustomLabel(getCallPendingLabel())
             .build());
     inCallScreen.setEndCallButtonEnabled(true, true);
diff --git a/java/com/android/incallui/contactgrid/BottomRow.java b/java/com/android/incallui/contactgrid/BottomRow.java
index dc86d81..7388c50 100644
--- a/java/com/android/incallui/contactgrid/BottomRow.java
+++ b/java/com/android/incallui/contactgrid/BottomRow.java
@@ -22,7 +22,7 @@
 import android.text.BidiFormatter;
 import android.text.TextDirectionHeuristics;
 import android.text.TextUtils;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.incall.protocol.PrimaryCallState;
 import com.android.incallui.incall.protocol.PrimaryInfo;
 
@@ -74,7 +74,7 @@
 
   public static Info getInfo(Context context, PrimaryCallState state, PrimaryInfo primaryInfo) {
     CharSequence label;
-    boolean isTimerVisible = state.state() == State.ACTIVE;
+    boolean isTimerVisible = state.state() == DialerCallState.ACTIVE;
     boolean isForwardIconVisible = state.isForwardedNumber();
     boolean isWorkIconVisible = state.isWorkCall();
     boolean isHdIconVisible = state.isHdAudioCall() && !isForwardIconVisible;
@@ -86,13 +86,13 @@
       label = context.getString(R.string.contact_grid_incoming_suspected_spam);
       isSpamIconVisible = true;
       isHdIconVisible = false;
-    } else if (state.state() == State.DISCONNECTING) {
+    } else if (state.state() == DialerCallState.DISCONNECTING) {
       // While in the DISCONNECTING state we display a "Hanging up" message in order to make the UI
       // feel more responsive.  (In GSM it's normal to see a delay of a couple of seconds while
       // negotiating the disconnect with the network, so the "Hanging up" state at least lets the
       // user know that we're doing something.  This state is currently not used with CDMA.)
       label = context.getString(R.string.incall_hanging_up);
-    } else if (state.state() == State.DISCONNECTED) {
+    } else if (state.state() == DialerCallState.DISCONNECTED) {
       label = state.disconnectCause().getLabel();
       if (TextUtils.isEmpty(label)) {
         label = context.getString(R.string.incall_call_ended);
@@ -134,6 +134,7 @@
   }
 
   private static boolean isIncoming(PrimaryCallState state) {
-    return state.state() == State.INCOMING || state.state() == State.CALL_WAITING;
+    return state.state() == DialerCallState.INCOMING
+        || state.state() == DialerCallState.CALL_WAITING;
   }
 }
diff --git a/java/com/android/incallui/contactgrid/TopRow.java b/java/com/android/incallui/contactgrid/TopRow.java
index 89300ca..82a103a 100644
--- a/java/com/android/incallui/contactgrid/TopRow.java
+++ b/java/com/android/incallui/contactgrid/TopRow.java
@@ -25,7 +25,7 @@
 import android.text.TextUtils;
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.incall.protocol.PrimaryCallState;
 import com.android.incallui.incall.protocol.PrimaryInfo;
 import com.android.incallui.videotech.utils.SessionModificationState;
@@ -69,7 +69,8 @@
       icon = context.getDrawable(R.drawable.quantum_ic_network_wifi_vd_theme_24);
     }
 
-    if (state.state() == State.INCOMING || state.state() == State.CALL_WAITING) {
+    if (state.state() == DialerCallState.INCOMING
+        || state.state() == DialerCallState.CALL_WAITING) {
       // Call from
       // [Wi-Fi icon] Video call from
       // Hey Jake, pick up!
@@ -87,18 +88,20 @@
     } else if (VideoUtils.hasSentVideoUpgradeRequest(state.sessionModificationState())
         || VideoUtils.hasReceivedVideoUpgradeRequest(state.sessionModificationState())) {
       label = getLabelForVideoRequest(context, state);
-    } else if (state.state() == State.PULLING) {
+    } else if (state.state() == DialerCallState.PULLING) {
       label = context.getString(R.string.incall_transferring);
-    } else if (state.state() == State.DIALING || state.state() == State.CONNECTING) {
+    } else if (state.state() == DialerCallState.DIALING
+        || state.state() == DialerCallState.CONNECTING) {
       // [Wi-Fi icon] Calling via Google Guest
       // Calling...
       label = getLabelForDialing(context, state);
-    } else if (state.state() == State.ACTIVE && state.isRemotelyHeld()) {
+    } else if (state.state() == DialerCallState.ACTIVE && state.isRemotelyHeld()) {
       label = context.getString(R.string.incall_remotely_held);
-    } else if (state.state() == State.ACTIVE
+    } else if (state.state() == DialerCallState.ACTIVE
         && shouldShowNumber(primaryInfo, false /* isIncoming */)) {
       label = spanDisplayNumber(primaryInfo.number());
-    } else if (state.state() == State.CALL_PENDING && !TextUtils.isEmpty(state.customLabel())) {
+    } else if (state.state() == DialerCallState.CALL_PENDING
+        && !TextUtils.isEmpty(state.customLabel())) {
       label = state.customLabel();
     } else {
       // Video calling...
diff --git a/java/com/android/incallui/incall/protocol/PrimaryCallState.java b/java/com/android/incallui/incall/protocol/PrimaryCallState.java
index 1d23036..423f868 100644
--- a/java/com/android/incallui/incall/protocol/PrimaryCallState.java
+++ b/java/com/android/incallui/incall/protocol/PrimaryCallState.java
@@ -24,8 +24,7 @@
 import com.android.dialer.assisteddialing.TransformationInfo;
 import com.android.dialer.common.Assert;
 import com.android.dialer.preferredsim.suggestion.SuggestionProvider;
-import com.android.incallui.call.DialerCall;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.videotech.utils.SessionModificationState;
 import com.google.auto.value.AutoValue;
 import java.lang.annotation.Retention;
@@ -111,7 +110,7 @@
 
   public static Builder builder() {
     return new AutoValue_PrimaryCallState.Builder()
-        .setState(DialerCall.State.IDLE)
+        .setState(DialerCallState.IDLE)
         .setIsVideoCall(false)
         .setSessionModificationState(SessionModificationState.NO_REQUEST)
         .setDisconnectCause(new DisconnectCause(DisconnectCause.UNKNOWN))
@@ -193,7 +192,7 @@
     public PrimaryCallState build() {
       PrimaryCallState primaryCallState = autoBuild();
       if (!TextUtils.isEmpty(primaryCallState.customLabel())) {
-        Assert.checkArgument(primaryCallState.state() == State.CALL_PENDING);
+        Assert.checkArgument(primaryCallState.state() == DialerCallState.CALL_PENDING);
       }
       return primaryCallState;
     }
diff --git a/java/com/android/incallui/ringtone/DialerRingtoneManager.java b/java/com/android/incallui/ringtone/DialerRingtoneManager.java
index b8a3071..777133e 100644
--- a/java/com/android/incallui/ringtone/DialerRingtoneManager.java
+++ b/java/com/android/incallui/ringtone/DialerRingtoneManager.java
@@ -22,7 +22,7 @@
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import com.android.incallui.call.CallList;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import java.util.Objects;
 
 /**
@@ -44,7 +44,7 @@
    * Creates the DialerRingtoneManager with the given {@link InCallTonePlayer}.
    *
    * @param inCallTonePlayer the tone player used to play in-call tones.
-   * @param callList the CallList used to check for {@link State#CALL_WAITING}
+   * @param callList the CallList used to check for {@link DialerCallState#CALL_WAITING}
    * @throws NullPointerException if inCallTonePlayer or callList are null
    */
   public DialerRingtoneManager(
@@ -54,8 +54,8 @@
   }
 
   /**
-   * Determines if a ringtone should be played for the given call state (see {@link State}) and
-   * {@link Uri}.
+   * Determines if a ringtone should be played for the given call state (see {@link
+   * DialerCallState}) and {@link Uri}.
    *
    * @param callState the call state for the call being checked.
    * @param ringtoneUri the ringtone to potentially play.
@@ -63,7 +63,7 @@
    */
   public boolean shouldPlayRingtone(int callState, @Nullable Uri ringtoneUri) {
     return isDialerRingingEnabled()
-        && translateCallStateForCallWaiting(callState) == State.INCOMING
+        && translateCallStateForCallWaiting(callState) == DialerCallState.INCOMING
         && ringtoneUri != null;
   }
 
@@ -79,14 +79,16 @@
   }
 
   /**
-   * The incoming callState is never set as {@link State#CALL_WAITING} because {@link
+   * The incoming callState is never set as {@link DialerCallState#CALL_WAITING} because {@link
    * DialerCall#translateState(int)} doesn't account for that case, check for it here
    */
   private int translateCallStateForCallWaiting(int callState) {
-    if (callState != State.INCOMING) {
+    if (callState != DialerCallState.INCOMING) {
       return callState;
     }
-    return callList.getActiveCall() == null ? State.INCOMING : State.CALL_WAITING;
+    return callList.getActiveCall() == null
+        ? DialerCallState.INCOMING
+        : DialerCallState.CALL_WAITING;
   }
 
   private boolean isDialerRingingEnabled() {
@@ -97,14 +99,14 @@
 
   /**
    * Determines if a call waiting tone should be played for the the given call state (see {@link
-   * State}).
+   * DialerCallState}).
    *
    * @param callState the call state for the call being checked.
    * @return {@code true} if the call waiting tone should be played, {@code false} otherwise.
    */
   public boolean shouldPlayCallWaitingTone(int callState) {
     return isDialerRingingEnabled()
-        && translateCallStateForCallWaiting(callState) == State.CALL_WAITING
+        && translateCallStateForCallWaiting(callState) == DialerCallState.CALL_WAITING
         && !inCallTonePlayer.isPlayingTone();
   }
 
diff --git a/java/com/android/incallui/rtt/impl/RttChatFragment.java b/java/com/android/incallui/rtt/impl/RttChatFragment.java
index 13e013f..1c43f51 100644
--- a/java/com/android/incallui/rtt/impl/RttChatFragment.java
+++ b/java/com/android/incallui/rtt/impl/RttChatFragment.java
@@ -55,7 +55,7 @@
 import com.android.dialer.rtt.RttTranscriptMessage;
 import com.android.dialer.util.DrawableConverter;
 import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment.AudioRouteSelectorPresenter;
-import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.state.DialerCallState;
 import com.android.incallui.hold.OnHoldFragment;
 import com.android.incallui.incall.protocol.ContactPhotoType;
 import com.android.incallui.incall.protocol.InCallButtonIds;
@@ -452,7 +452,7 @@
   public void setCallState(@NonNull PrimaryCallState primaryCallState) {
     LogUtil.i("RttChatFragment.setCallState", primaryCallState.toString());
     this.primaryCallState = primaryCallState;
-    if (!isTimerStarted && primaryCallState.state() == State.ACTIVE) {
+    if (!isTimerStarted && primaryCallState.state() == DialerCallState.ACTIVE) {
       LogUtil.i(
           "RttChatFragment.setCallState", "starting timer with base: %d", chronometer.getBase());
       chronometer.setBase(
@@ -469,12 +469,12 @@
       }
       adapter.showAdvisory();
     }
-    if (primaryCallState.state() == State.DIALING) {
+    if (primaryCallState.state() == DialerCallState.DIALING) {
       showWaitingForJoinBanner();
     } else {
       hideWaitingForJoinBanner();
     }
-    if (primaryCallState.state() == State.DISCONNECTED) {
+    if (primaryCallState.state() == DialerCallState.DISCONNECTED) {
       rttCallScreenDelegate.onSaveRttTranscript();
     }
   }