diff --git a/java/com/android/incallui/AccelerometerListener.java b/java/com/android/incallui/AccelerometerListener.java
new file mode 100644
index 0000000..01f8843
--- /dev/null
+++ b/java/com/android/incallui/AccelerometerListener.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+/**
+ * This class is used to listen to the accelerometer to monitor the orientation of the phone. The
+ * client of this class is notified when the orientation changes between horizontal and vertical.
+ */
+public class AccelerometerListener {
+
+  // Device orientation
+  public static final int ORIENTATION_UNKNOWN = 0;
+  public static final int ORIENTATION_VERTICAL = 1;
+  public static final int ORIENTATION_HORIZONTAL = 2;
+  private static final String TAG = "AccelerometerListener";
+  private static final boolean DEBUG = true;
+  private static final boolean VDEBUG = false;
+  private static final int ORIENTATION_CHANGED = 1234;
+  private static final int VERTICAL_DEBOUNCE = 100;
+  private static final int HORIZONTAL_DEBOUNCE = 500;
+  private static final double VERTICAL_ANGLE = 50.0;
+  private SensorManager mSensorManager;
+  private Sensor mSensor;
+  // mOrientation is the orientation value most recently reported to the client.
+  private int mOrientation;
+  // mPendingOrientation is the latest orientation computed based on the sensor value.
+  // This is sent to the client after a rebounce delay, at which point it is copied to
+  // mOrientation.
+  private int mPendingOrientation;
+  private OrientationListener mListener;
+  Handler mHandler =
+      new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+          switch (msg.what) {
+            case ORIENTATION_CHANGED:
+              synchronized (this) {
+                mOrientation = mPendingOrientation;
+                if (DEBUG) {
+                  Log.d(
+                      TAG,
+                      "orientation: "
+                          + (mOrientation == ORIENTATION_HORIZONTAL
+                              ? "horizontal"
+                              : (mOrientation == ORIENTATION_VERTICAL ? "vertical" : "unknown")));
+                }
+                if (mListener != null) {
+                  mListener.orientationChanged(mOrientation);
+                }
+              }
+              break;
+          }
+        }
+      };
+  SensorEventListener mSensorListener =
+      new SensorEventListener() {
+        @Override
+        public void onSensorChanged(SensorEvent event) {
+          onSensorEvent(event.values[0], event.values[1], event.values[2]);
+        }
+
+        @Override
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {
+          // ignore
+        }
+      };
+
+  public AccelerometerListener(Context context) {
+    mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+    mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+  }
+
+  public void setListener(OrientationListener listener) {
+    mListener = listener;
+  }
+
+  public void enable(boolean enable) {
+    if (DEBUG) {
+      Log.d(TAG, "enable(" + enable + ")");
+    }
+    synchronized (this) {
+      if (enable) {
+        mOrientation = ORIENTATION_UNKNOWN;
+        mPendingOrientation = ORIENTATION_UNKNOWN;
+        mSensorManager.registerListener(
+            mSensorListener, mSensor, SensorManager.SENSOR_DELAY_NORMAL);
+      } else {
+        mSensorManager.unregisterListener(mSensorListener);
+        mHandler.removeMessages(ORIENTATION_CHANGED);
+      }
+    }
+  }
+
+  private void setOrientation(int orientation) {
+    synchronized (this) {
+      if (mPendingOrientation == orientation) {
+        // Pending orientation has not changed, so do nothing.
+        return;
+      }
+
+      // Cancel any pending messages.
+      // We will either start a new timer or cancel alltogether
+      // if the orientation has not changed.
+      mHandler.removeMessages(ORIENTATION_CHANGED);
+
+      if (mOrientation != orientation) {
+        // Set timer to send an event if the orientation has changed since its
+        // previously reported value.
+        mPendingOrientation = orientation;
+        final Message m = mHandler.obtainMessage(ORIENTATION_CHANGED);
+        // set delay to our debounce timeout
+        int delay = (orientation == ORIENTATION_VERTICAL ? VERTICAL_DEBOUNCE : HORIZONTAL_DEBOUNCE);
+        mHandler.sendMessageDelayed(m, delay);
+      } else {
+        // no message is pending
+        mPendingOrientation = ORIENTATION_UNKNOWN;
+      }
+    }
+  }
+
+  private void onSensorEvent(double x, double y, double z) {
+    if (VDEBUG) {
+      Log.d(TAG, "onSensorEvent(" + x + ", " + y + ", " + z + ")");
+    }
+
+    // If some values are exactly zero, then likely the sensor is not powered up yet.
+    // ignore these events to avoid false horizontal positives.
+    if (x == 0.0 || y == 0.0 || z == 0.0) {
+      return;
+    }
+
+    // magnitude of the acceleration vector projected onto XY plane
+    final double xy = Math.hypot(x, y);
+    // compute the vertical angle
+    double angle = Math.atan2(xy, z);
+    // convert to degrees
+    angle = angle * 180.0 / Math.PI;
+    final int orientation =
+        (angle > VERTICAL_ANGLE ? ORIENTATION_VERTICAL : ORIENTATION_HORIZONTAL);
+    if (VDEBUG) {
+      Log.d(TAG, "angle: " + angle + " orientation: " + orientation);
+    }
+    setOrientation(orientation);
+  }
+
+  public interface OrientationListener {
+
+    void orientationChanged(int orientation);
+  }
+}
diff --git a/java/com/android/incallui/AndroidManifest.xml b/java/com/android/incallui/AndroidManifest.xml
new file mode 100644
index 0000000..276b47a
--- /dev/null
+++ b/java/com/android/incallui/AndroidManifest.xml
@@ -0,0 +1,121 @@
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.android.incallui">
+
+  <uses-sdk
+    android:minSdkVersion="23"
+    android:targetSdkVersion="25"/>
+
+  <uses-permission android:name="android.permission.CONTROL_INCALL_EXPERIENCE"/>
+  <!-- We use this to disable the status bar buttons of home, back and recent
+  during an incoming call. By doing so this allows us to not show the user
+  is viewing the activity in full screen alert, on a fresh system/factory
+  reset state of the app. -->
+  <uses-permission android:name="android.permission.STATUS_BAR"/>
+  <uses-permission android:name="android.permission.CAMERA"/>
+  <!-- Warning: setting the required boolean to true would prevent installation of Dialer on
+       devices which do not support a camera. -->
+  <uses-feature
+    android:name="android.hardware.camera.any"
+    android:required="false"/>
+
+  <!-- Testing location -->
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+
+  <!-- Set android:taskAffinity="com.android.incallui" for all activities to ensure proper
+  navigation. Otherwise system could bring up DialtactsActivity instead, e.g. when user unmerge a
+  call.
+       Set taskAffinity for application is not working because it will be merged and the result is
+  that all activities here still have same taskAffinity as activities under dialer. -->
+  <application>
+    <meta-data android:name="android.telephony.hide_voicemail_settings_menu"
+      android:value="true"/>
+    <activity
+      android:directBootAware="true"
+      android:excludeFromRecents="true"
+      android:exported="false"
+      android:label="@string/phoneAppLabel"
+      android:taskAffinity="com.android.incallui"
+      android:launchMode="singleInstance"
+      android:name="com.android.incallui.InCallActivity"
+      android:resizeableActivity="true"
+      android:screenOrientation="nosensor"
+      android:theme="@style/Theme.InCallScreen">
+    </activity>
+
+    <activity
+      android:directBootAware="true"
+      android:excludeFromRecents="true"
+      android:noHistory="true"
+      android:exported="false"
+      android:label="@string/manageConferenceLabel"
+      android:taskAffinity="com.android.incallui"
+      android:launchMode="singleTask"
+      android:name="com.android.incallui.ManageConferenceActivity"
+      android:resizeableActivity="true"
+      android:theme="@style/Theme.InCallScreen.ManageConference"/>
+
+    <service
+      android:directBootAware="true"
+      android:exported="true"
+      android:name="com.android.incallui.InCallServiceImpl"
+      android:permission="android.permission.BIND_INCALL_SERVICE">
+      <meta-data
+        android:name="android.telecom.IN_CALL_SERVICE_UI"
+        android:value="true"/>
+      <meta-data
+        android:name="android.telecom.IN_CALL_SERVICE_RINGING"
+        android:value="false"/>
+      <meta-data
+        android:name="android.telecom.INCLUDE_EXTERNAL_CALLS"
+        android:value="true"/>
+
+      <intent-filter>
+        <action android:name="android.telecom.InCallService"/>
+      </intent-filter>
+    </service>
+
+    <!--
+       Comments for attributes in SpamNotificationActivity:
+       taskAffinity=""             -> Open the dialog without opening the dialer app behind it
+       noHistory="true"            -> Navigating away finishes activity
+       excludeFromRecents="true"   -> Don't show in "recent apps" screen
+       -->
+    <activity
+      android:excludeFromRecents="true"
+      android:exported="false"
+      android:name="com.android.incallui.spam.SpamNotificationActivity"
+      android:noHistory="true"
+      android:taskAffinity=""
+      android:theme="@style/AfterCallNotificationTheme">
+    </activity>
+
+    <service
+      android:exported="false"
+      android:name="com.android.incallui.spam.SpamNotificationService"/>
+
+    <!-- BroadcastReceiver for receiving Intents from Notification mechanism. -->
+    <receiver
+      android:directBootAware="true"
+      android:exported="false"
+      android:name="com.android.incallui.NotificationBroadcastReceiver"/>
+
+  </application>
+
+</manifest>
+
diff --git a/java/com/android/incallui/AnswerScreenPresenter.java b/java/com/android/incallui/AnswerScreenPresenter.java
new file mode 100644
index 0000000..a21876b
--- /dev/null
+++ b/java/com/android/incallui/AnswerScreenPresenter.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.support.annotation.FloatRange;
+import android.support.annotation.NonNull;
+import android.support.v4.os.UserManagerCompat;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.answer.protocol.AnswerScreen;
+import com.android.incallui.answer.protocol.AnswerScreenDelegate;
+import com.android.incallui.answerproximitysensor.AnswerProximitySensor;
+import com.android.incallui.answerproximitysensor.PseudoScreenState;
+import com.android.incallui.call.DialerCall;
+
+/** Manages changes for an incoming call screen. */
+public class AnswerScreenPresenter
+    implements AnswerScreenDelegate, DialerCall.CannedTextResponsesLoadedListener {
+  @NonNull private final Context context;
+  @NonNull private final AnswerScreen answerScreen;
+  @NonNull private final DialerCall call;
+
+  public AnswerScreenPresenter(
+      @NonNull Context context, @NonNull AnswerScreen answerScreen, @NonNull DialerCall call) {
+    LogUtil.i("AnswerScreenPresenter.constructor", null);
+    this.context = Assert.isNotNull(context);
+    this.answerScreen = Assert.isNotNull(answerScreen);
+    this.call = Assert.isNotNull(call);
+    if (isSmsResponseAllowed(call)) {
+      answerScreen.setTextResponses(call.getCannedSmsResponses());
+    }
+    call.addCannedTextResponsesLoadedListener(this);
+
+    PseudoScreenState pseudoScreenState = InCallPresenter.getInstance().getPseudoScreenState();
+    if (AnswerProximitySensor.shouldUse(context, call)) {
+      new AnswerProximitySensor(context, call, pseudoScreenState);
+    } else {
+      pseudoScreenState.setOn(true);
+    }
+  }
+
+  @Override
+  public void onAnswerScreenUnready() {
+    call.removeCannedTextResponsesLoadedListener(this);
+  }
+
+  @Override
+  public void onDismissDialog() {
+    InCallPresenter.getInstance().onDismissDialog();
+  }
+
+  @Override
+  public void onRejectCallWithMessage(String message) {
+    call.reject(true /* rejectWithMessage */, message);
+    onDismissDialog();
+  }
+
+  @Override
+  public void onAnswer(int videoState) {
+    if (answerScreen.isVideoUpgradeRequest()) {
+      call.acceptUpgradeRequest(videoState);
+    } else {
+      call.answer(videoState);
+    }
+  }
+
+  @Override
+  public void onReject() {
+    if (answerScreen.isVideoUpgradeRequest()) {
+      call.declineUpgradeRequest();
+    } else {
+      call.reject(false /* rejectWithMessage */, null);
+    }
+  }
+
+  @Override
+  public void onCannedTextResponsesLoaded(DialerCall call) {
+    if (isSmsResponseAllowed(call)) {
+      answerScreen.setTextResponses(call.getCannedSmsResponses());
+    }
+  }
+
+  @Override
+  public void updateWindowBackgroundColor(@FloatRange(from = -1f, to = 1.0f) float progress) {
+    InCallActivity activity = (InCallActivity) answerScreen.getAnswerScreenFragment().getActivity();
+    if (activity != null) {
+      activity.updateWindowBackgroundColor(progress);
+    }
+  }
+
+  private boolean isSmsResponseAllowed(DialerCall call) {
+    return UserManagerCompat.isUserUnlocked(context)
+        && call.can(android.telecom.Call.Details.CAPABILITY_RESPOND_VIA_TEXT);
+  }
+}
diff --git a/java/com/android/incallui/AnswerScreenPresenterStub.java b/java/com/android/incallui/AnswerScreenPresenterStub.java
new file mode 100644
index 0000000..fc47bf5
--- /dev/null
+++ b/java/com/android/incallui/AnswerScreenPresenterStub.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.support.annotation.FloatRange;
+import com.android.incallui.answer.protocol.AnswerScreenDelegate;
+
+/**
+ * Stub implementation of the answer screen delegate. Used to keep the answer fragment visible when
+ * no call exists.
+ */
+public class AnswerScreenPresenterStub implements AnswerScreenDelegate {
+  @Override
+  public void onAnswerScreenUnready() {}
+
+  @Override
+  public void onDismissDialog() {}
+
+  @Override
+  public void onRejectCallWithMessage(String message) {}
+
+  @Override
+  public void onAnswer(int videoState) {}
+
+  @Override
+  public void onReject() {}
+
+  @Override
+  public void updateWindowBackgroundColor(@FloatRange(from = -1f, to = 1.0f) float progress) {}
+}
diff --git a/java/com/android/incallui/AudioModeProvider.java b/java/com/android/incallui/AudioModeProvider.java
new file mode 100644
index 0000000..698db0a
--- /dev/null
+++ b/java/com/android/incallui/AudioModeProvider.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.telecom.CallAudioState;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Proxy class for getting and setting the audio mode. */
+public class AudioModeProvider {
+  private static final int SUPPORTED_AUDIO_ROUTE_ALL =
+      CallAudioState.ROUTE_EARPIECE
+          | CallAudioState.ROUTE_BLUETOOTH
+          | CallAudioState.ROUTE_WIRED_HEADSET
+          | CallAudioState.ROUTE_SPEAKER;
+
+  private static final AudioModeProvider instance = new AudioModeProvider();
+  private final List<AudioModeListener> listeners = new ArrayList<>();
+  private CallAudioState audioState =
+      new CallAudioState(false, CallAudioState.ROUTE_EARPIECE, SUPPORTED_AUDIO_ROUTE_ALL);
+
+  public static AudioModeProvider getInstance() {
+    return instance;
+  }
+
+  public void onAudioStateChanged(CallAudioState audioState) {
+    if (!this.audioState.equals(audioState)) {
+      this.audioState = audioState;
+      for (AudioModeListener listener : listeners) {
+        listener.onAudioStateChanged(audioState);
+      }
+    }
+  }
+
+  public void addListener(AudioModeListener listener) {
+    if (!listeners.contains(listener)) {
+      listeners.add(listener);
+      listener.onAudioStateChanged(audioState);
+    }
+  }
+
+  public void removeListener(AudioModeListener listener) {
+    listeners.remove(listener);
+  }
+
+  public CallAudioState getAudioState() {
+    return audioState;
+  }
+
+  /** Notified on changes to audio mode. */
+  public interface AudioModeListener {
+
+    void onAudioStateChanged(CallAudioState audioState);
+  }
+}
diff --git a/java/com/android/incallui/Bindings.java b/java/com/android/incallui/Bindings.java
new file mode 100644
index 0000000..4f142ff
--- /dev/null
+++ b/java/com/android/incallui/Bindings.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import com.android.incallui.bindings.InCallUiBindings;
+import com.android.incallui.bindings.InCallUiBindingsFactory;
+import com.android.incallui.bindings.InCallUiBindingsStub;
+import java.util.Objects;
+
+/** Accessor for the in call UI bindings. */
+public class Bindings {
+
+  private static InCallUiBindings instance;
+
+  private Bindings() {}
+
+  public static InCallUiBindings get(Context context) {
+    Objects.requireNonNull(context);
+    if (instance != null) {
+      return instance;
+    }
+
+    Context application = context.getApplicationContext();
+    if (application instanceof InCallUiBindingsFactory) {
+      instance = ((InCallUiBindingsFactory) application).newInCallUiBindings();
+    }
+
+    if (instance == null) {
+      instance = new InCallUiBindingsStub();
+    }
+    return instance;
+  }
+
+  public static void setForTesting(InCallUiBindings testInstance) {
+    instance = testInstance;
+  }
+}
diff --git a/java/com/android/incallui/CallButtonPresenter.java b/java/com/android/incallui/CallButtonPresenter.java
new file mode 100644
index 0000000..d6f4cdd
--- /dev/null
+++ b/java/com/android/incallui/CallButtonPresenter.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.os.UserManagerCompat;
+import android.telecom.CallAudioState;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+import com.android.contacts.common.compat.CallCompat;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.SdkVersionOverride;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.incallui.AudioModeProvider.AudioModeListener;
+import com.android.incallui.InCallCameraManager.Listener;
+import com.android.incallui.InCallPresenter.CanAddCallListener;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import com.android.incallui.incall.protocol.InCallButtonUi;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+
+/** Logic for call buttons. */
+public class CallButtonPresenter
+    implements InCallStateListener,
+        AudioModeListener,
+        IncomingCallListener,
+        InCallDetailsListener,
+        CanAddCallListener,
+        Listener,
+        InCallButtonUiDelegate {
+
+  private static final String KEY_AUTOMATICALLY_MUTED = "incall_key_automatically_muted";
+  private static final String KEY_PREVIOUS_MUTE_STATE = "incall_key_previous_mute_state";
+
+  private final Context mContext;
+  private InCallButtonUi mInCallButtonUi;
+  private DialerCall mCall;
+  private boolean mAutomaticallyMuted = false;
+  private boolean mPreviousMuteState = false;
+  private boolean isInCallButtonUiReady;
+
+  public CallButtonPresenter(Context context) {
+    mContext = context.getApplicationContext();
+  }
+
+  @Override
+  public void onInCallButtonUiReady(InCallButtonUi ui) {
+    Assert.checkState(!isInCallButtonUiReady);
+    mInCallButtonUi = ui;
+    AudioModeProvider.getInstance().addListener(this);
+
+    // register for call state changes last
+    final InCallPresenter inCallPresenter = InCallPresenter.getInstance();
+    inCallPresenter.addListener(this);
+    inCallPresenter.addIncomingCallListener(this);
+    inCallPresenter.addDetailsListener(this);
+    inCallPresenter.addCanAddCallListener(this);
+    inCallPresenter.getInCallCameraManager().addCameraSelectionListener(this);
+
+    // Update the buttons state immediately for the current call
+    onStateChange(InCallState.NO_CALLS, inCallPresenter.getInCallState(), CallList.getInstance());
+    isInCallButtonUiReady = true;
+  }
+
+  @Override
+  public void onInCallButtonUiUnready() {
+    Assert.checkState(isInCallButtonUiReady);
+    mInCallButtonUi = null;
+    InCallPresenter.getInstance().removeListener(this);
+    AudioModeProvider.getInstance().removeListener(this);
+    InCallPresenter.getInstance().removeIncomingCallListener(this);
+    InCallPresenter.getInstance().removeDetailsListener(this);
+    InCallPresenter.getInstance().getInCallCameraManager().removeCameraSelectionListener(this);
+    InCallPresenter.getInstance().removeCanAddCallListener(this);
+    isInCallButtonUiReady = false;
+  }
+
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    if (newState == InCallState.OUTGOING) {
+      mCall = callList.getOutgoingCall();
+    } else if (newState == InCallState.INCALL) {
+      mCall = callList.getActiveOrBackgroundCall();
+
+      // When connected to voice mail, automatically shows the dialpad.
+      // (On previous releases we showed it when in-call shows up, before waiting for
+      // OUTGOING.  We may want to do that once we start showing "Voice mail" label on
+      // the dialpad too.)
+      if (oldState == InCallState.OUTGOING && mCall != null) {
+        if (CallerInfoUtils.isVoiceMailNumber(mContext, mCall) && getActivity() != null) {
+          getActivity().showDialpadFragment(true /* show */, true /* animate */);
+        }
+      }
+    } else if (newState == InCallState.INCOMING) {
+      if (getActivity() != null) {
+        getActivity().showDialpadFragment(false /* show */, true /* animate */);
+      }
+      mCall = callList.getIncomingCall();
+    } else {
+      mCall = null;
+    }
+    updateUi(newState, mCall);
+  }
+
+  /**
+   * Updates the user interface in response to a change in the details of a call. Currently handles
+   * changes to the call buttons in response to a change in the details for a call. This is
+   * important to ensure changes to the active call are reflected in the available buttons.
+   *
+   * @param call The active call.
+   * @param details The call details.
+   */
+  @Override
+  public void onDetailsChanged(DialerCall call, android.telecom.Call.Details details) {
+    // Only update if the changes are for the currently active call
+    if (mInCallButtonUi != null && call != null && call.equals(mCall)) {
+      updateButtonsState(call);
+    }
+  }
+
+  @Override
+  public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) {
+    onStateChange(oldState, newState, CallList.getInstance());
+  }
+
+  @Override
+  public void onCanAddCallChanged(boolean canAddCall) {
+    if (mInCallButtonUi != null && mCall != null) {
+      updateButtonsState(mCall);
+    }
+  }
+
+  @Override
+  public void onAudioStateChanged(CallAudioState audioState) {
+    if (mInCallButtonUi != null) {
+      mInCallButtonUi.setAudioState(audioState);
+    }
+  }
+
+  @Override
+  public CallAudioState getCurrentAudioState() {
+    return AudioModeProvider.getInstance().getAudioState();
+  }
+
+  @Override
+  public void setAudioRoute(int route) {
+    LogUtil.i(
+        "CallButtonPresenter.setAudioRoute",
+        "sending new audio route: " + CallAudioState.audioRouteToString(route));
+    TelecomAdapter.getInstance().setAudioRoute(route);
+  }
+
+  /** Function assumes that bluetooth is not supported. */
+  @Override
+  public void toggleSpeakerphone() {
+    // This function should not be called if bluetooth is available.
+    CallAudioState audioState = getCurrentAudioState();
+    if (0 != (CallAudioState.ROUTE_BLUETOOTH & audioState.getSupportedRouteMask())) {
+      // It's clear the UI is wrong, so update the supported mode once again.
+      LogUtil.e(
+          "CallButtonPresenter", "toggling speakerphone not allowed when bluetooth supported.");
+      mInCallButtonUi.setAudioState(audioState);
+      return;
+    }
+
+    int newRoute;
+    if (audioState.getRoute() == CallAudioState.ROUTE_SPEAKER) {
+      newRoute = CallAudioState.ROUTE_WIRED_OR_EARPIECE;
+      Logger.get(mContext)
+          .logCallImpression(
+              DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_WIRED_OR_EARPIECE,
+              mCall.getUniqueCallId(),
+              mCall.getTimeAddedMs());
+    } else {
+      newRoute = CallAudioState.ROUTE_SPEAKER;
+      Logger.get(mContext)
+          .logCallImpression(
+              DialerImpression.Type.IN_CALL_SCREEN_TURN_ON_SPEAKERPHONE,
+              mCall.getUniqueCallId(),
+              mCall.getTimeAddedMs());
+    }
+
+    setAudioRoute(newRoute);
+  }
+
+  @Override
+  public void muteClicked(boolean checked) {
+    LogUtil.v("CallButtonPresenter", "turning on mute: " + checked);
+    TelecomAdapter.getInstance().mute(checked);
+  }
+
+  @Override
+  public void holdClicked(boolean checked) {
+    if (mCall == null) {
+      return;
+    }
+    if (checked) {
+      LogUtil.i("CallButtonPresenter", "putting the call on hold: " + mCall);
+      mCall.hold();
+    } else {
+      LogUtil.i("CallButtonPresenter", "removing the call from hold: " + mCall);
+      mCall.unhold();
+    }
+  }
+
+  @Override
+  public void swapClicked() {
+    if (mCall == null) {
+      return;
+    }
+
+    LogUtil.i("CallButtonPresenter", "swapping the call: " + mCall);
+    TelecomAdapter.getInstance().swap(mCall.getId());
+  }
+
+  @Override
+  public void mergeClicked() {
+    TelecomAdapter.getInstance().merge(mCall.getId());
+  }
+
+  @Override
+  public void addCallClicked() {
+    // Automatically mute the current call
+    mAutomaticallyMuted = true;
+    mPreviousMuteState = AudioModeProvider.getInstance().getAudioState().isMuted();
+    // Simulate a click on the mute button
+    muteClicked(true);
+    TelecomAdapter.getInstance().addCall();
+  }
+
+  @Override
+  public void showDialpadClicked(boolean checked) {
+    LogUtil.v("CallButtonPresenter", "show dialpad " + String.valueOf(checked));
+    getActivity().showDialpadFragment(checked /* show */, true /* animate */);
+  }
+
+  @Override
+  public void changeToVideoClicked() {
+    VideoCall videoCall = mCall.getVideoCall();
+    if (videoCall == null) {
+      return;
+    }
+    int currVideoState = mCall.getVideoState();
+    int currUnpausedVideoState = VideoUtils.getUnPausedVideoState(currVideoState);
+    currUnpausedVideoState |= VideoProfile.STATE_BIDIRECTIONAL;
+
+    VideoProfile videoProfile = new VideoProfile(currUnpausedVideoState);
+    videoCall.sendSessionModifyRequest(videoProfile);
+    mCall.setSessionModificationState(
+        DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE);
+  }
+
+  @Override
+  public void onEndCallClicked() {
+    LogUtil.i("CallButtonPresenter.onEndCallClicked", "call: " + mCall);
+    if (mCall != null) {
+      mCall.disconnect();
+    }
+  }
+
+  @Override
+  public void showAudioRouteSelector() {
+    mInCallButtonUi.showAudioRouteSelector();
+  }
+
+  /**
+   * Switches the camera between the front-facing and back-facing camera.
+   *
+   * @param useFrontFacingCamera True if we should switch to using the front-facing camera, or false
+   *     if we should switch to using the back-facing camera.
+   */
+  @Override
+  public void switchCameraClicked(boolean useFrontFacingCamera) {
+    InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager();
+    cameraManager.setUseFrontFacingCamera(useFrontFacingCamera);
+
+    VideoCall videoCall = mCall.getVideoCall();
+    if (videoCall == null) {
+      return;
+    }
+
+    String cameraId = cameraManager.getActiveCameraId();
+    if (cameraId != null) {
+      final int cameraDir =
+          cameraManager.isUsingFrontFacingCamera()
+              ? DialerCall.VideoSettings.CAMERA_DIRECTION_FRONT_FACING
+              : DialerCall.VideoSettings.CAMERA_DIRECTION_BACK_FACING;
+      mCall.getVideoSettings().setCameraDir(cameraDir);
+      videoCall.setCamera(cameraId);
+      videoCall.requestCameraCapabilities();
+    }
+  }
+
+  @Override
+  public void toggleCameraClicked() {
+    LogUtil.i("CallButtonPresenter.toggleCameraClicked", "");
+    switchCameraClicked(
+        !InCallPresenter.getInstance().getInCallCameraManager().isUsingFrontFacingCamera());
+  }
+
+  /**
+   * Stop or start client's video transmission.
+   *
+   * @param pause True if pausing the local user's video, or false if starting the local user's
+   *     video.
+   */
+  @Override
+  public void pauseVideoClicked(boolean pause) {
+    LogUtil.i("CallButtonPresenter.pauseVideoClicked", "%s", pause ? "pause" : "unpause");
+    VideoCall videoCall = mCall.getVideoCall();
+    if (videoCall == null) {
+      return;
+    }
+
+    int currUnpausedVideoState = VideoUtils.getUnPausedVideoState(mCall.getVideoState());
+    if (pause) {
+      videoCall.setCamera(null);
+      VideoProfile videoProfile =
+          new VideoProfile(currUnpausedVideoState & ~VideoProfile.STATE_TX_ENABLED);
+      videoCall.sendSessionModifyRequest(videoProfile);
+    } else {
+      InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager();
+      videoCall.setCamera(cameraManager.getActiveCameraId());
+      VideoProfile videoProfile =
+          new VideoProfile(currUnpausedVideoState | VideoProfile.STATE_TX_ENABLED);
+      videoCall.sendSessionModifyRequest(videoProfile);
+      mCall.setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_RESPONSE);
+    }
+
+    mInCallButtonUi.setVideoPaused(pause);
+    mInCallButtonUi.enableButton(InCallButtonIds.BUTTON_PAUSE_VIDEO, false);
+  }
+
+  private void updateUi(InCallState state, DialerCall call) {
+    LogUtil.v("CallButtonPresenter", "updating call UI for call: ", call);
+
+    if (mInCallButtonUi == null) {
+      return;
+    }
+
+    if (call != null) {
+      mInCallButtonUi.updateInCallButtonUiColors();
+    }
+
+    final boolean isEnabled =
+        state.isConnectingOrConnected() && !state.isIncoming() && call != null;
+    mInCallButtonUi.setEnabled(isEnabled);
+
+    if (call == null) {
+      return;
+    }
+
+    updateButtonsState(call);
+  }
+
+  /**
+   * Updates the buttons applicable for the UI.
+   *
+   * @param call The active call.
+   */
+  private void updateButtonsState(DialerCall call) {
+    LogUtil.v("CallButtonPresenter.updateButtonsState", "");
+    final boolean isVideo = VideoUtils.isVideoCall(call);
+
+    // Common functionality (audio, hold, etc).
+    // Show either HOLD or SWAP, but not both. If neither HOLD or SWAP is available:
+    //     (1) If the device normally can hold, show HOLD in a disabled state.
+    //     (2) If the device doesn't have the concept of hold/swap, remove the button.
+    final boolean showSwap = call.can(android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE);
+    final boolean showHold =
+        !showSwap
+            && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORT_HOLD)
+            && call.can(android.telecom.Call.Details.CAPABILITY_HOLD);
+    final boolean isCallOnHold = call.getState() == DialerCall.State.ONHOLD;
+
+    final boolean showAddCall =
+        TelecomAdapter.getInstance().canAddCall() && UserManagerCompat.isUserUnlocked(mContext);
+    final boolean showMerge = call.can(android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE);
+    final boolean showUpgradeToVideo = !isVideo && hasVideoCallCapabilities(call);
+    final boolean showDowngradeToAudio = isVideo && isDowngradeToAudioSupported(call);
+    final boolean showMute = call.can(android.telecom.Call.Details.CAPABILITY_MUTE);
+
+    final boolean hasCameraPermission =
+        isVideo && VideoUtils.hasCameraPermissionAndAllowedByUser(mContext);
+    // Disabling local video doesn't seem to work when dialing. See b/30256571.
+    final boolean showPauseVideo =
+        isVideo
+            && call.getState() != DialerCall.State.DIALING
+            && call.getState() != DialerCall.State.CONNECTING;
+
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_AUDIO, true);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_SWAP, showSwap);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_HOLD, showHold);
+    mInCallButtonUi.setHold(isCallOnHold);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_MUTE, showMute);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_ADD_CALL, true);
+    mInCallButtonUi.enableButton(InCallButtonIds.BUTTON_ADD_CALL, showAddCall);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO, showUpgradeToVideo);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_DOWNGRADE_TO_AUDIO, showDowngradeToAudio);
+    mInCallButtonUi.showButton(
+        InCallButtonIds.BUTTON_SWITCH_CAMERA, isVideo && hasCameraPermission);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_PAUSE_VIDEO, showPauseVideo);
+    if (isVideo) {
+      mInCallButtonUi.setVideoPaused(
+          !VideoUtils.isTransmissionEnabled(call) || !hasCameraPermission);
+    }
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_DIALPAD, true);
+    mInCallButtonUi.showButton(InCallButtonIds.BUTTON_MERGE, showMerge);
+
+    mInCallButtonUi.updateButtonStates();
+  }
+
+  private boolean hasVideoCallCapabilities(DialerCall call) {
+    if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+      return call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX)
+          && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX);
+    }
+    // In L, this single flag represents both video transmitting and receiving capabilities
+    return call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX);
+  }
+
+  /**
+   * Determines if downgrading from a video call to an audio-only call is supported. In order to
+   * support downgrade to audio, the SDK version must be >= N and the call should NOT have the
+   * {@link android.telecom.Call.Details#CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO}.
+   *
+   * @param call The call.
+   * @return {@code true} if downgrading to an audio-only call from a video call is supported.
+   */
+  private boolean isDowngradeToAudioSupported(DialerCall call) {
+    return !call.can(CallCompat.Details.CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO);
+  }
+
+  @Override
+  public void refreshMuteState() {
+    // Restore the previous mute state
+    if (mAutomaticallyMuted
+        && AudioModeProvider.getInstance().getAudioState().isMuted() != mPreviousMuteState) {
+      if (mInCallButtonUi == null) {
+        return;
+      }
+      muteClicked(mPreviousMuteState);
+    }
+    mAutomaticallyMuted = false;
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    outState.putBoolean(KEY_AUTOMATICALLY_MUTED, mAutomaticallyMuted);
+    outState.putBoolean(KEY_PREVIOUS_MUTE_STATE, mPreviousMuteState);
+  }
+
+  @Override
+  public void onRestoreInstanceState(Bundle savedInstanceState) {
+    mAutomaticallyMuted =
+        savedInstanceState.getBoolean(KEY_AUTOMATICALLY_MUTED, mAutomaticallyMuted);
+    mPreviousMuteState = savedInstanceState.getBoolean(KEY_PREVIOUS_MUTE_STATE, mPreviousMuteState);
+  }
+
+  @Override
+  public void onCameraPermissionGranted() {
+    if (mCall != null) {
+      updateButtonsState(mCall);
+    }
+  }
+
+  @Override
+  public void onActiveCameraSelectionChanged(boolean isUsingFrontFacingCamera) {
+    if (mInCallButtonUi == null) {
+      return;
+    }
+    mInCallButtonUi.setCameraSwitched(!isUsingFrontFacingCamera);
+  }
+
+  @Override
+  public Context getContext() {
+    return mContext;
+  }
+
+  private InCallActivity getActivity() {
+    if (mInCallButtonUi != null) {
+      Fragment fragment = mInCallButtonUi.getInCallButtonUiFragment();
+      if (fragment != null) {
+        return (InCallActivity) fragment.getActivity();
+      }
+    }
+    return null;
+  }
+}
diff --git a/java/com/android/incallui/CallCardPresenter.java b/java/com/android/incallui/CallCardPresenter.java
new file mode 100644
index 0000000..9307757
--- /dev/null
+++ b/java/com/android/incallui/CallCardPresenter.java
@@ -0,0 +1,1110 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import static com.android.contacts.common.compat.CallCompat.Details.PROPERTY_ENTERPRISE_CALL;
+
+import android.Manifest;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.Drawable;
+import android.hardware.display.DisplayManager;
+import android.os.BatteryManager;
+import android.os.Handler;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v4.content.ContextCompat;
+import android.telecom.Call.Details;
+import android.telecom.StatusHints;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.view.Display;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityManager;
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.enrichedcall.EnrichedCallManager;
+import com.android.dialer.enrichedcall.Session;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallEventListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCallListener;
+import com.android.incallui.incall.protocol.ContactPhotoType;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import java.lang.ref.WeakReference;
+
+/**
+ * Controller for the Call Card Fragment. This class listens for changes to InCallState and passes
+ * it along to the fragment.
+ */
+public class CallCardPresenter
+    implements InCallStateListener,
+        IncomingCallListener,
+        InCallDetailsListener,
+        InCallEventListener,
+        InCallScreenDelegate,
+        DialerCallListener,
+        EnrichedCallManager.StateChangedListener {
+
+  /**
+   * Amount of time to wait before sending an announcement via the accessibility manager. When the
+   * call state changes to an outgoing or incoming state for the first time, the UI can often be
+   * changing due to call updates or contact lookup. This allows the UI to settle to a stable state
+   * to ensure that the correct information is announced.
+   */
+  private static final long ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS = 500;
+
+  /** Flag to allow the user's current location to be shown during emergency calls. */
+  private static final String CONFIG_ENABLE_EMERGENCY_LOCATION = "config_enable_emergency_location";
+
+  private static final boolean CONFIG_ENABLE_EMERGENCY_LOCATION_DEFAULT = true;
+
+  /**
+   * Make it possible to not get location during an emergency call if the battery is too low, since
+   * doing so could trigger gps and thus potentially cause the phone to die in the middle of the
+   * call.
+   */
+  private static final String CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION =
+      "min_battery_percent_for_emergency_location";
+
+  private static final long CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT = 10;
+
+  private final Context mContext;
+  private final Handler handler = new Handler();
+
+  private DialerCall mPrimary;
+  private DialerCall mSecondary;
+  private ContactCacheEntry mPrimaryContactInfo;
+  private ContactCacheEntry mSecondaryContactInfo;
+  @Nullable private ContactsPreferences mContactsPreferences;
+  private boolean mIsFullscreen = false;
+  private InCallScreen mInCallScreen;
+  private boolean isInCallScreenReady;
+  private boolean shouldSendAccessibilityEvent;
+  private final String locationModule = null;
+  private final Runnable sendAccessibilityEventRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          shouldSendAccessibilityEvent = !sendAccessibilityEvent(mContext, getUi());
+          LogUtil.i(
+              "CallCardPresenter.sendAccessibilityEventRunnable",
+              "still should send: %b",
+              shouldSendAccessibilityEvent);
+          if (!shouldSendAccessibilityEvent) {
+            handler.removeCallbacks(this);
+          }
+        }
+      };
+
+  public CallCardPresenter(Context context) {
+    LogUtil.i("CallCardController.constructor", null);
+    mContext = Assert.isNotNull(context).getApplicationContext();
+  }
+
+  private static boolean hasCallSubject(DialerCall call) {
+    return !TextUtils.isEmpty(call.getCallSubject());
+  }
+
+  @Override
+  public void onInCallScreenDelegateInit(InCallScreen inCallScreen) {
+    Assert.isNotNull(inCallScreen);
+    mInCallScreen = inCallScreen;
+    mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+
+    // Call may be null if disconnect happened already.
+    DialerCall call = CallList.getInstance().getFirstCall();
+    if (call != null) {
+      mPrimary = call;
+      if (shouldShowNoteSentToast(mPrimary)) {
+        mInCallScreen.showNoteSentToast();
+      }
+      call.addListener(this);
+
+      // start processing lookups right away.
+      if (!call.isConferenceCall()) {
+        startContactInfoSearch(call, true, call.getState() == DialerCall.State.INCOMING);
+      } else {
+        updateContactEntry(null, true);
+      }
+    }
+
+    onStateChange(null, InCallPresenter.getInstance().getInCallState(), CallList.getInstance());
+  }
+
+  @Override
+  public void onInCallScreenReady() {
+    LogUtil.i("CallCardController.onInCallScreenReady", null);
+    Assert.checkState(!isInCallScreenReady);
+    if (mContactsPreferences != null) {
+      mContactsPreferences.refreshValue(ContactsPreferences.DISPLAY_ORDER_KEY);
+    }
+
+    EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+        .registerStateChangedListener(this);
+
+    // Contact search may have completed before ui is ready.
+    if (mPrimaryContactInfo != null) {
+      updatePrimaryDisplayInfo();
+    }
+
+    // Register for call state changes last
+    InCallPresenter.getInstance().addListener(this);
+    InCallPresenter.getInstance().addIncomingCallListener(this);
+    InCallPresenter.getInstance().addDetailsListener(this);
+    InCallPresenter.getInstance().addInCallEventListener(this);
+    isInCallScreenReady = true;
+  }
+
+  @Override
+  public void onInCallScreenUnready() {
+    LogUtil.i("CallCardController.onInCallScreenUnready", null);
+    Assert.checkState(isInCallScreenReady);
+
+    EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+        .unregisterStateChangedListener(this);
+    // stop getting call state changes
+    InCallPresenter.getInstance().removeListener(this);
+    InCallPresenter.getInstance().removeIncomingCallListener(this);
+    InCallPresenter.getInstance().removeDetailsListener(this);
+    InCallPresenter.getInstance().removeInCallEventListener(this);
+    if (mPrimary != null) {
+      mPrimary.removeListener(this);
+    }
+
+    mPrimary = null;
+    mPrimaryContactInfo = null;
+    mSecondaryContactInfo = null;
+    isInCallScreenReady = false;
+  }
+
+  @Override
+  public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) {
+    // same logic should happen as with onStateChange()
+    onStateChange(oldState, newState, CallList.getInstance());
+  }
+
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    LogUtil.v("CallCardPresenter.onStateChange", "" + newState);
+    if (mInCallScreen == null) {
+      return;
+    }
+
+    DialerCall primary = null;
+    DialerCall secondary = null;
+
+    if (newState == InCallState.INCOMING) {
+      primary = callList.getIncomingCall();
+    } else if (newState == InCallState.PENDING_OUTGOING || newState == InCallState.OUTGOING) {
+      primary = callList.getOutgoingCall();
+      if (primary == null) {
+        primary = callList.getPendingOutgoingCall();
+      }
+
+      // getCallToDisplay doesn't go through outgoing or incoming calls. It will return the
+      // highest priority call to display as the secondary call.
+      secondary = getCallToDisplay(callList, null, true);
+    } else if (newState == InCallState.INCALL) {
+      primary = getCallToDisplay(callList, null, false);
+      secondary = getCallToDisplay(callList, primary, true);
+    }
+
+    LogUtil.v("CallCardPresenter.onStateChange", "primary call: " + primary);
+    LogUtil.v("CallCardPresenter.onStateChange", "secondary call: " + secondary);
+
+    final boolean primaryChanged =
+        !(DialerCall.areSame(mPrimary, primary) && DialerCall.areSameNumber(mPrimary, primary));
+    final boolean secondaryChanged =
+        !(DialerCall.areSame(mSecondary, secondary)
+            && DialerCall.areSameNumber(mSecondary, secondary));
+
+    mSecondary = secondary;
+    DialerCall previousPrimary = mPrimary;
+    mPrimary = primary;
+
+    if (mPrimary != null) {
+      InCallPresenter.getInstance().onForegroundCallChanged(mPrimary);
+      mInCallScreen.updateInCallScreenColors();
+    }
+
+    if (primaryChanged && shouldShowNoteSentToast(primary)) {
+      mInCallScreen.showNoteSentToast();
+    }
+
+    // Refresh primary call information if either:
+    // 1. Primary call changed.
+    // 2. The call's ability to manage conference has changed.
+    if (shouldRefreshPrimaryInfo(primaryChanged)) {
+      // primary call has changed
+      if (previousPrimary != null) {
+        previousPrimary.removeListener(this);
+      }
+      mPrimary.addListener(this);
+
+      mPrimaryContactInfo =
+          ContactInfoCache.buildCacheEntryFromCall(
+              mContext, mPrimary, mPrimary.getState() == DialerCall.State.INCOMING);
+      updatePrimaryDisplayInfo();
+      maybeStartSearch(mPrimary, true);
+      maybeClearSessionModificationState(mPrimary);
+    }
+
+    if (previousPrimary != null && mPrimary == null) {
+      previousPrimary.removeListener(this);
+    }
+
+    if (mSecondary == null) {
+      // Secondary call may have ended.  Update the ui.
+      mSecondaryContactInfo = null;
+      updateSecondaryDisplayInfo();
+    } else if (secondaryChanged) {
+      // secondary call has changed
+      mSecondaryContactInfo =
+          ContactInfoCache.buildCacheEntryFromCall(
+              mContext, mSecondary, mSecondary.getState() == DialerCall.State.INCOMING);
+      updateSecondaryDisplayInfo();
+      maybeStartSearch(mSecondary, false);
+      maybeClearSessionModificationState(mSecondary);
+    }
+
+    // Set the call state
+    int callState = DialerCall.State.IDLE;
+    if (mPrimary != null) {
+      callState = mPrimary.getState();
+      updatePrimaryCallState();
+    } else {
+      getUi().setCallState(PrimaryCallState.createEmptyPrimaryCallState());
+    }
+
+    maybeShowManageConferenceCallButton();
+
+    // Hide the end call button instantly if we're receiving an incoming call.
+    getUi()
+        .setEndCallButtonEnabled(
+            shouldShowEndCallButton(mPrimary, callState),
+            callState != DialerCall.State.INCOMING /* animate */);
+
+    maybeSendAccessibilityEvent(oldState, newState, primaryChanged);
+  }
+
+  @Override
+  public void onDetailsChanged(DialerCall call, Details details) {
+    updatePrimaryCallState();
+
+    if (call.can(Details.CAPABILITY_MANAGE_CONFERENCE)
+        != details.can(Details.CAPABILITY_MANAGE_CONFERENCE)) {
+      maybeShowManageConferenceCallButton();
+    }
+  }
+
+  @Override
+  public void onDialerCallDisconnect() {}
+
+  @Override
+  public void onDialerCallUpdate() {
+    // No-op; specific call updates handled elsewhere.
+  }
+
+  @Override
+  public void onWiFiToLteHandover() {}
+
+  @Override
+  public void onHandoverToWifiFailure() {}
+
+  /** Handles a change to the child number by refreshing the primary call info. */
+  @Override
+  public void onDialerCallChildNumberChange() {
+    LogUtil.v("CallCardPresenter.onDialerCallChildNumberChange", "");
+
+    if (mPrimary == null) {
+      return;
+    }
+    updatePrimaryDisplayInfo();
+  }
+
+  /** Handles a change to the last forwarding number by refreshing the primary call info. */
+  @Override
+  public void onDialerCallLastForwardedNumberChange() {
+    LogUtil.v("CallCardPresenter.onDialerCallLastForwardedNumberChange", "");
+
+    if (mPrimary == null) {
+      return;
+    }
+    updatePrimaryDisplayInfo();
+    updatePrimaryCallState();
+  }
+
+  @Override
+  public void onDialerCallUpgradeToVideo() {}
+
+  /**
+   * Handles a change to the session modification state for a call.
+   *
+   * @param sessionModificationState The new session modification state.
+   */
+  @Override
+  public void onDialerCallSessionModificationStateChange(
+      @SessionModificationState int sessionModificationState) {
+    LogUtil.v(
+        "CallCardPresenter.onDialerCallSessionModificationStateChange",
+        "state: " + sessionModificationState);
+
+    if (mPrimary == null) {
+      return;
+    }
+    getUi()
+        .setEndCallButtonEnabled(
+            sessionModificationState
+                != DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST,
+            true /* shouldAnimate */);
+    updatePrimaryCallState();
+  }
+
+  @Override
+  public void onEnrichedCallStateChanged() {
+    LogUtil.enterBlock("CallCardPresenter.onEnrichedCallStateChanged");
+    updatePrimaryDisplayInfo();
+  }
+
+  private boolean shouldRefreshPrimaryInfo(boolean primaryChanged) {
+    if (mPrimary == null) {
+      return false;
+    }
+    return primaryChanged
+        || mInCallScreen.isManageConferenceVisible() != shouldShowManageConference();
+  }
+
+  private void updatePrimaryCallState() {
+    if (getUi() != null && mPrimary != null) {
+      boolean isWorkCall =
+          mPrimary.hasProperty(PROPERTY_ENTERPRISE_CALL)
+              || (mPrimaryContactInfo != null
+                  && mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+      boolean isHdAudioCall =
+          isPrimaryCallActive() && mPrimary.hasProperty(Details.PROPERTY_HIGH_DEF_AUDIO);
+      // Check for video state change and update the visibility of the contact photo.  The contact
+      // photo is hidden when the incoming video surface is shown.
+      // The contact photo visibility can also change in setPrimary().
+      boolean shouldShowContactPhoto =
+          !VideoCallPresenter.showIncomingVideo(mPrimary.getVideoState(), mPrimary.getState());
+      getUi()
+          .setCallState(
+              new PrimaryCallState(
+                  mPrimary.getState(),
+                  mPrimary.getVideoState(),
+                  mPrimary.getSessionModificationState(),
+                  mPrimary.getDisconnectCause(),
+                  getConnectionLabel(),
+                  getCallStateIcon(),
+                  getGatewayNumber(),
+                  shouldShowCallSubject(mPrimary) ? mPrimary.getCallSubject() : null,
+                  mPrimary.getCallbackNumber(),
+                  mPrimary.hasProperty(Details.PROPERTY_WIFI),
+                  mPrimary.isConferenceCall(),
+                  isWorkCall,
+                  isHdAudioCall,
+                  !TextUtils.isEmpty(mPrimary.getLastForwardedNumber()),
+                  shouldShowContactPhoto,
+                  mPrimary.getConnectTimeMillis(),
+                  CallerInfoUtils.isVoiceMailNumber(mContext, mPrimary),
+                  mPrimary.isRemotelyHeld()));
+
+      InCallActivity activity =
+          (InCallActivity) (mInCallScreen.getInCallScreenFragment().getActivity());
+      if (activity != null) {
+        activity.onPrimaryCallStateChanged();
+      }
+    }
+  }
+
+  /** Only show the conference call button if we can manage the conference. */
+  private void maybeShowManageConferenceCallButton() {
+    getUi().showManageConferenceCallButton(shouldShowManageConference());
+  }
+
+  /**
+   * Determines if the manage conference button should be visible, based on the current primary
+   * call.
+   *
+   * @return {@code True} if the manage conference button should be visible.
+   */
+  private boolean shouldShowManageConference() {
+    if (mPrimary == null) {
+      return false;
+    }
+
+    return mPrimary.can(android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE)
+        && !mIsFullscreen;
+  }
+
+  @Override
+  public void onCallStateButtonClicked() {
+    Intent broadcastIntent = Bindings.get(mContext).getCallStateButtonBroadcastIntent(mContext);
+    if (broadcastIntent != null) {
+      LogUtil.v(
+          "CallCardPresenter.onCallStateButtonClicked",
+          "sending call state button broadcast: " + broadcastIntent);
+      mContext.sendBroadcast(broadcastIntent, Manifest.permission.READ_PHONE_STATE);
+    }
+  }
+
+  @Override
+  public void onManageConferenceClicked() {
+    InCallActivity activity =
+        (InCallActivity) (mInCallScreen.getInCallScreenFragment().getActivity());
+    activity.showConferenceFragment(true);
+  }
+
+  @Override
+  public void onShrinkAnimationComplete() {
+    InCallPresenter.getInstance().onShrinkAnimationComplete();
+  }
+
+  @Override
+  public Drawable getDefaultContactPhotoDrawable() {
+    return ContactInfoCache.getInstance(mContext).getDefaultContactPhotoDrawable();
+  }
+
+  private void maybeStartSearch(DialerCall call, boolean isPrimary) {
+    // no need to start search for conference calls which show generic info.
+    if (call != null && !call.isConferenceCall()) {
+      startContactInfoSearch(call, isPrimary, call.getState() == DialerCall.State.INCOMING);
+    }
+  }
+
+  private void maybeClearSessionModificationState(DialerCall call) {
+    @SessionModificationState int state = call.getSessionModificationState();
+    if (state != DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST
+        && state != DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      LogUtil.i("CallCardPresenter.maybeClearSessionModificationState", "clearing state");
+      call.setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    }
+  }
+
+  /** Starts a query for more contact data for the save primary and secondary calls. */
+  private void startContactInfoSearch(
+      final DialerCall call, final boolean isPrimary, boolean isIncoming) {
+    final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
+
+    cache.findInfo(call, isIncoming, new ContactLookupCallback(this, isPrimary));
+  }
+
+  private void onContactInfoComplete(String callId, ContactCacheEntry entry, boolean isPrimary) {
+    final boolean entryMatchesExistingCall =
+        (isPrimary && mPrimary != null && TextUtils.equals(callId, mPrimary.getId()))
+            || (!isPrimary && mSecondary != null && TextUtils.equals(callId, mSecondary.getId()));
+    if (entryMatchesExistingCall) {
+      updateContactEntry(entry, isPrimary);
+    } else {
+      LogUtil.e(
+          "CallCardPresenter.onContactInfoComplete",
+          "dropping stale contact lookup info for " + callId);
+    }
+
+    final DialerCall call = CallList.getInstance().getCallById(callId);
+    if (call != null) {
+      call.getLogState().contactLookupResult = entry.contactLookupResult;
+    }
+    if (entry.contactUri != null) {
+      CallerInfoUtils.sendViewNotification(mContext, entry.contactUri);
+    }
+  }
+
+  private void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+    if (getUi() == null) {
+      return;
+    }
+
+    if (entry.photo != null) {
+      if (mPrimary != null && callId.equals(mPrimary.getId())) {
+        updateContactEntry(entry, true /* isPrimary */);
+      } else if (mSecondary != null && callId.equals(mSecondary.getId())) {
+        updateContactEntry(entry, false /* isPrimary */);
+      }
+    }
+  }
+
+  private void updateContactEntry(ContactCacheEntry entry, boolean isPrimary) {
+    if (isPrimary) {
+      mPrimaryContactInfo = entry;
+      updatePrimaryDisplayInfo();
+    } else {
+      mSecondaryContactInfo = entry;
+      updateSecondaryDisplayInfo();
+    }
+  }
+
+  /**
+   * Get the highest priority call to display. Goes through the calls and chooses which to return
+   * based on priority of which type of call to display to the user. Callers can use the "ignore"
+   * feature to get the second best call by passing a previously found primary call as ignore.
+   *
+   * @param ignore A call to ignore if found.
+   */
+  private DialerCall getCallToDisplay(
+      CallList callList, DialerCall ignore, boolean skipDisconnected) {
+    // Active calls come second.  An active call always gets precedent.
+    DialerCall retval = callList.getActiveCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Sometimes there is intemediate state that two calls are in active even one is about
+    // to be on hold.
+    retval = callList.getSecondActiveCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Disconnected calls get primary position if there are no active calls
+    // to let user know quickly what call has disconnected. Disconnected
+    // calls are very short lived.
+    if (!skipDisconnected) {
+      retval = callList.getDisconnectingCall();
+      if (retval != null && retval != ignore) {
+        return retval;
+      }
+      retval = callList.getDisconnectedCall();
+      if (retval != null && retval != ignore) {
+        return retval;
+      }
+    }
+
+    // Then we go to background call (calls on hold)
+    retval = callList.getBackgroundCall();
+    if (retval != null && retval != ignore) {
+      return retval;
+    }
+
+    // Lastly, we go to a second background call.
+    retval = callList.getSecondBackgroundCall();
+
+    return retval;
+  }
+
+  private void updatePrimaryDisplayInfo() {
+    if (mInCallScreen == null) {
+      // TODO: May also occur if search result comes back after ui is destroyed. Look into
+      // removing that case completely.
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "updatePrimaryDisplayInfo called but ui is null!");
+      return;
+    }
+
+    if (mPrimary == null) {
+      // Clear the primary display info.
+      mInCallScreen.setPrimary(PrimaryInfo.createEmptyPrimaryInfo());
+      return;
+    }
+
+    // Hide the contact photo if we are in a video call and the incoming video surface is
+    // showing.
+    boolean showContactPhoto =
+        !VideoCallPresenter.showIncomingVideo(mPrimary.getVideoState(), mPrimary.getState());
+
+    // DialerCall placed through a work phone account.
+    boolean hasWorkCallProperty = mPrimary.hasProperty(PROPERTY_ENTERPRISE_CALL);
+
+    Session enrichedCallSession =
+        mPrimary.getNumber() == null
+            ? null
+            : EnrichedCallManager.Accessor.getInstance(((Application) mContext))
+                .getSession(mPrimary.getNumber());
+    MultimediaData enrichedCallMultimediaData =
+        enrichedCallSession == null ? null : enrichedCallSession.getMultimediaData();
+
+    if (mPrimary.isConferenceCall()) {
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "update primary display info for conference call.");
+
+      mInCallScreen.setPrimary(
+          new PrimaryInfo(
+              null /* number */,
+              getConferenceString(mPrimary),
+              false /* nameIsNumber */,
+              null /* location */,
+              null /* label */,
+              getConferencePhoto(mPrimary),
+              ContactPhotoType.DEFAULT_PLACEHOLDER,
+              false /* isSipCall */,
+              showContactPhoto,
+              hasWorkCallProperty,
+              false /* isSpam */,
+              false /* answeringDisconnectsOngoingCall */,
+              shouldShowLocation(),
+              null /* contactInfoLookupKey */,
+              null /* enrichedCallMultimediaData */));
+    } else if (mPrimaryContactInfo != null) {
+      LogUtil.v(
+          "CallCardPresenter.updatePrimaryDisplayInfo",
+          "update primary display info for " + mPrimaryContactInfo);
+
+      String name = getNameForCall(mPrimaryContactInfo);
+      String number;
+
+      boolean isChildNumberShown = !TextUtils.isEmpty(mPrimary.getChildNumber());
+      boolean isForwardedNumberShown = !TextUtils.isEmpty(mPrimary.getLastForwardedNumber());
+      boolean isCallSubjectShown = shouldShowCallSubject(mPrimary);
+
+      if (isCallSubjectShown) {
+        number = null;
+      } else if (isChildNumberShown) {
+        number = mContext.getString(R.string.child_number, mPrimary.getChildNumber());
+      } else if (isForwardedNumberShown) {
+        // Use last forwarded number instead of second line, if present.
+        number = mPrimary.getLastForwardedNumber();
+      } else {
+        number = mPrimaryContactInfo.number;
+      }
+
+      boolean nameIsNumber = name != null && name.equals(mPrimaryContactInfo.number);
+      // DialerCall with caller that is a work contact.
+      boolean isWorkContact = (mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+      mInCallScreen.setPrimary(
+          new PrimaryInfo(
+              number,
+              name,
+              nameIsNumber,
+              mPrimaryContactInfo.location,
+              isChildNumberShown || isCallSubjectShown ? null : mPrimaryContactInfo.label,
+              mPrimaryContactInfo.photo,
+              mPrimaryContactInfo.photoType,
+              mPrimaryContactInfo.isSipCall,
+              showContactPhoto,
+              hasWorkCallProperty || isWorkContact,
+              mPrimary.isSpam(),
+              mPrimary.answeringDisconnectsForegroundVideoCall(),
+              shouldShowLocation(),
+              mPrimaryContactInfo.lookupKey,
+              enrichedCallMultimediaData));
+    } else {
+      // Clear the primary display info.
+      mInCallScreen.setPrimary(PrimaryInfo.createEmptyPrimaryInfo());
+    }
+
+    mInCallScreen.showLocationUi(null);
+  }
+
+  private boolean shouldShowLocation() {
+    if (isOutgoingEmergencyCall(mPrimary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "new emergency call");
+      return true;
+    } else if (isIncomingEmergencyCall(mPrimary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "potential emergency callback");
+      return true;
+    } else if (isIncomingEmergencyCall(mSecondary)) {
+      LogUtil.i("CallCardPresenter.shouldShowLocation", "has potential emergency callback");
+      return true;
+    }
+    return false;
+  }
+
+  private static boolean isOutgoingEmergencyCall(@Nullable DialerCall call) {
+    return call != null && !call.isIncoming() && call.isEmergencyCall();
+  }
+
+  private static boolean isIncomingEmergencyCall(@Nullable DialerCall call) {
+    return call != null && call.isIncoming() && call.isPotentialEmergencyCallback();
+  }
+
+  private boolean hasLocationPermission() {
+    return ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION)
+        == PackageManager.PERMISSION_GRANTED;
+  }
+
+  private boolean isBatteryTooLowForEmergencyLocation() {
+    Intent batteryStatus =
+        mContext.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+    int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
+    if (status == BatteryManager.BATTERY_STATUS_CHARGING
+        || status == BatteryManager.BATTERY_STATUS_FULL) {
+      // Plugged in or full battery
+      return false;
+    }
+    int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
+    int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
+    float batteryPercent = (100f * level) / scale;
+    long threshold =
+        ConfigProviderBindings.get(mContext)
+            .getLong(
+                CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION,
+                CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT);
+    LogUtil.i(
+        "CallCardPresenter.isBatteryTooLowForEmergencyLocation",
+        "percent charged: " + batteryPercent + ", min required charge: " + threshold);
+    return batteryPercent < threshold;
+  }
+
+  private void updateSecondaryDisplayInfo() {
+    if (mInCallScreen == null) {
+      return;
+    }
+
+    if (mSecondary == null) {
+      // Clear the secondary display info.
+      mInCallScreen.setSecondary(SecondaryInfo.createEmptySecondaryInfo(mIsFullscreen));
+      return;
+    }
+
+    if (mSecondary.isConferenceCall()) {
+      mInCallScreen.setSecondary(
+          new SecondaryInfo(
+              true /* show */,
+              getConferenceString(mSecondary),
+              false /* nameIsNumber */,
+              null /* label */,
+              mSecondary.getCallProviderLabel(),
+              true /* isConference */,
+              mSecondary.isVideoCall(),
+              mIsFullscreen));
+    } else if (mSecondaryContactInfo != null) {
+      LogUtil.v("CallCardPresenter.updateSecondaryDisplayInfo", "" + mSecondaryContactInfo);
+      String name = getNameForCall(mSecondaryContactInfo);
+      boolean nameIsNumber = name != null && name.equals(mSecondaryContactInfo.number);
+      mInCallScreen.setSecondary(
+          new SecondaryInfo(
+              true /* show */,
+              name,
+              nameIsNumber,
+              mSecondaryContactInfo.label,
+              mSecondary.getCallProviderLabel(),
+              false /* isConference */,
+              mSecondary.isVideoCall(),
+              mIsFullscreen));
+    } else {
+      // Clear the secondary display info.
+      mInCallScreen.setSecondary(SecondaryInfo.createEmptySecondaryInfo(mIsFullscreen));
+    }
+  }
+
+  /** Returns the gateway number for any existing outgoing call. */
+  private String getGatewayNumber() {
+    if (hasOutgoingGatewayCall()) {
+      return DialerCall.getNumberFromHandle(mPrimary.getGatewayInfo().getGatewayAddress());
+    }
+    return null;
+  }
+
+  /**
+   * Returns the label (line of text above the number/name) for any given call. For example,
+   * "calling via [Account/Google Voice]" for outgoing calls.
+   */
+  private String getConnectionLabel() {
+    if (ContextCompat.checkSelfPermission(mContext, Manifest.permission.READ_PHONE_STATE)
+        != PackageManager.PERMISSION_GRANTED) {
+      return null;
+    }
+    StatusHints statusHints = mPrimary.getStatusHints();
+    if (statusHints != null && !TextUtils.isEmpty(statusHints.getLabel())) {
+      return statusHints.getLabel().toString();
+    }
+
+    if (hasOutgoingGatewayCall() && getUi() != null) {
+      // Return the label for the gateway app on outgoing calls.
+      final PackageManager pm = mContext.getPackageManager();
+      try {
+        ApplicationInfo info =
+            pm.getApplicationInfo(mPrimary.getGatewayInfo().getGatewayProviderPackageName(), 0);
+        return pm.getApplicationLabel(info).toString();
+      } catch (PackageManager.NameNotFoundException e) {
+        LogUtil.e("CallCardPresenter.getConnectionLabel", "gateway Application Not Found.", e);
+        return null;
+      }
+    }
+    return mPrimary.getCallProviderLabel();
+  }
+
+  private Drawable getCallStateIcon() {
+    // Return connection icon if one exists.
+    StatusHints statusHints = mPrimary.getStatusHints();
+    if (statusHints != null && statusHints.getIcon() != null) {
+      Drawable icon = statusHints.getIcon().loadDrawable(mContext);
+      if (icon != null) {
+        return icon;
+      }
+    }
+
+    return null;
+  }
+
+  private boolean hasOutgoingGatewayCall() {
+    // We only display the gateway information while STATE_DIALING so return false for any other
+    // call state.
+    // TODO: mPrimary can be null because this is called from updatePrimaryDisplayInfo which
+    // is also called after a contact search completes (call is not present yet).  Split the
+    // UI update so it can receive independent updates.
+    if (mPrimary == null) {
+      return false;
+    }
+    return DialerCall.State.isDialing(mPrimary.getState())
+        && mPrimary.getGatewayInfo() != null
+        && !mPrimary.getGatewayInfo().isEmpty();
+  }
+
+  /** Gets the name to display for the call. */
+  String getNameForCall(ContactCacheEntry contactInfo) {
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, mContactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return contactInfo.number;
+    }
+    return preferredName;
+  }
+
+  /** Gets the number to display for a call. */
+  String getNumberForCall(ContactCacheEntry contactInfo) {
+    // If the name is empty, we use the number for the name...so don't show a second
+    // number in the number field
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, mContactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return contactInfo.location;
+    }
+    return contactInfo.number;
+  }
+
+  @Override
+  public void onSecondaryInfoClicked() {
+    if (mSecondary == null) {
+      LogUtil.e(
+          "CallCardPresenter.onSecondaryInfoClicked",
+          "secondary info clicked but no secondary call.");
+      return;
+    }
+
+    LogUtil.i(
+        "CallCardPresenter.onSecondaryInfoClicked", "swapping call to foreground: " + mSecondary);
+    mSecondary.unhold();
+  }
+
+  @Override
+  public void onEndCallClicked() {
+    LogUtil.i("CallCardPresenter.onEndCallClicked", "disconnecting call: " + mPrimary);
+    if (mPrimary != null) {
+      mPrimary.disconnect();
+    }
+  }
+
+  /**
+   * Handles a change to the fullscreen mode of the in-call UI.
+   *
+   * @param isFullscreenMode {@code True} if the in-call UI is entering full screen mode.
+   */
+  @Override
+  public void onFullscreenModeChanged(boolean isFullscreenMode) {
+    mIsFullscreen = isFullscreenMode;
+    if (mInCallScreen == null) {
+      return;
+    }
+    maybeShowManageConferenceCallButton();
+  }
+
+  private boolean isPrimaryCallActive() {
+    return mPrimary != null && mPrimary.getState() == DialerCall.State.ACTIVE;
+  }
+
+  private String getConferenceString(DialerCall call) {
+    boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+    LogUtil.v("CallCardPresenter.getConferenceString", "" + isGenericConference);
+
+    final int resId =
+        isGenericConference ? R.string.generic_conference_call_name : R.string.conference_call_name;
+    return mContext.getResources().getString(resId);
+  }
+
+  private Drawable getConferencePhoto(DialerCall call) {
+    boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+    LogUtil.v("CallCardPresenter.getConferencePhoto", "" + isGenericConference);
+
+    final int resId = isGenericConference ? R.drawable.img_phone : R.drawable.img_conference;
+    Drawable photo = mContext.getResources().getDrawable(resId);
+    photo.setAutoMirrored(true);
+    return photo;
+  }
+
+  private boolean shouldShowEndCallButton(DialerCall primary, int callState) {
+    if (primary == null) {
+      return false;
+    }
+    if ((!DialerCall.State.isConnectingOrConnected(callState)
+            && callState != DialerCall.State.DISCONNECTING
+            && callState != DialerCall.State.DISCONNECTED)
+        || callState == DialerCall.State.INCOMING) {
+      return false;
+    }
+    if (mPrimary.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  public void onInCallScreenResumed() {
+    if (shouldSendAccessibilityEvent) {
+      handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS);
+    }
+  }
+
+  static boolean sendAccessibilityEvent(Context context, InCallScreen inCallScreen) {
+    AccessibilityManager am =
+        (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    if (!am.isEnabled()) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "accessibility is off");
+      return false;
+    }
+    if (inCallScreen == null) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "incallscreen is null");
+      return false;
+    }
+    Fragment fragment = inCallScreen.getInCallScreenFragment();
+    if (fragment == null || fragment.getView() == null || fragment.getView().getParent() == null) {
+      LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "fragment/view/parent is null");
+      return false;
+    }
+
+    DisplayManager displayManager =
+        (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
+    Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY);
+    boolean screenIsOn = display.getState() == Display.STATE_ON;
+    LogUtil.d("CallCardPresenter.sendAccessibilityEvent", "screen is on: %b", screenIsOn);
+    if (!screenIsOn) {
+      return false;
+    }
+
+    AccessibilityEvent event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_ANNOUNCEMENT);
+    inCallScreen.dispatchPopulateAccessibilityEvent(event);
+    View view = inCallScreen.getInCallScreenFragment().getView();
+    view.getParent().requestSendAccessibilityEvent(view, event);
+    return true;
+  }
+
+  private void maybeSendAccessibilityEvent(
+      InCallState oldState, final InCallState newState, boolean primaryChanged) {
+    shouldSendAccessibilityEvent = false;
+    if (mContext == null) {
+      return;
+    }
+    final AccessibilityManager am =
+        (AccessibilityManager) mContext.getSystemService(Context.ACCESSIBILITY_SERVICE);
+    if (!am.isEnabled()) {
+      return;
+    }
+    // Announce the current call if it's new incoming/outgoing call or primary call is changed
+    // due to switching calls between two ongoing calls (one is on hold).
+    if ((oldState != InCallState.OUTGOING && newState == InCallState.OUTGOING)
+        || (oldState != InCallState.INCOMING && newState == InCallState.INCOMING)
+        || primaryChanged) {
+      LogUtil.i(
+          "CallCardPresenter.maybeSendAccessibilityEvent", "schedule accessibility announcement");
+      shouldSendAccessibilityEvent = true;
+      handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS);
+    }
+  }
+
+  /**
+   * Determines whether the call subject should be visible on the UI. For the call subject to be
+   * visible, the call has to be in an incoming or waiting state, and the subject must not be empty.
+   *
+   * @param call The call.
+   * @return {@code true} if the subject should be shown, {@code false} otherwise.
+   */
+  private boolean shouldShowCallSubject(DialerCall call) {
+    if (call == null) {
+      return false;
+    }
+
+    boolean isIncomingOrWaiting =
+        mPrimary.getState() == DialerCall.State.INCOMING
+            || mPrimary.getState() == DialerCall.State.CALL_WAITING;
+    return isIncomingOrWaiting
+        && !TextUtils.isEmpty(call.getCallSubject())
+        && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED
+        && call.isCallSubjectSupported();
+  }
+
+  /**
+   * Determines whether the "note sent" toast should be shown. It should be shown for a new outgoing
+   * call with a subject.
+   *
+   * @param call The call
+   * @return {@code true} if the toast should be shown, {@code false} otherwise.
+   */
+  private boolean shouldShowNoteSentToast(DialerCall call) {
+    return call != null
+        && hasCallSubject(call)
+        && (call.getState() == DialerCall.State.DIALING
+            || call.getState() == DialerCall.State.CONNECTING);
+  }
+
+  private InCallScreen getUi() {
+    return mInCallScreen;
+  }
+
+  public static class ContactLookupCallback implements ContactInfoCacheCallback {
+
+    private final WeakReference<CallCardPresenter> mCallCardPresenter;
+    private final boolean mIsPrimary;
+
+    public ContactLookupCallback(CallCardPresenter callCardPresenter, boolean isPrimary) {
+      mCallCardPresenter = new WeakReference<CallCardPresenter>(callCardPresenter);
+      mIsPrimary = isPrimary;
+    }
+
+    @Override
+    public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+      CallCardPresenter presenter = mCallCardPresenter.get();
+      if (presenter != null) {
+        presenter.onContactInfoComplete(callId, entry, mIsPrimary);
+      }
+    }
+
+    @Override
+    public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+      CallCardPresenter presenter = mCallCardPresenter.get();
+      if (presenter != null) {
+        presenter.onImageLoadComplete(callId, entry);
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/CallerInfo.java b/java/com/android/incallui/CallerInfo.java
new file mode 100644
index 0000000..473bb8f
--- /dev/null
+++ b/java/com/android/incallui/CallerInfo.java
@@ -0,0 +1,573 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.PhoneLookup;
+import android.provider.ContactsContract.RawContacts;
+import android.support.annotation.RequiresApi;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.ContactsUtils.UserType;
+import com.android.contacts.common.util.TelephonyManagerUtils;
+import com.android.dialer.phonenumbercache.ContactInfoHelper;
+import com.android.dialer.phonenumbercache.PhoneLookupUtil;
+import com.android.dialer.phonenumberutil.PhoneNumberHelper;
+
+/**
+ * Looks up caller information for the given phone number. This is intermediate data and should NOT
+ * be used by any UI.
+ */
+public class CallerInfo {
+
+  private static final String TAG = "CallerInfo";
+
+  // We should always use this projection starting from N onward.
+  @RequiresApi(VERSION_CODES.N)
+  private static final String[] DEFAULT_PHONELOOKUP_PROJECTION =
+      new String[] {
+        PhoneLookup.CONTACT_ID,
+        PhoneLookup.DISPLAY_NAME,
+        PhoneLookup.LOOKUP_KEY,
+        PhoneLookup.NUMBER,
+        PhoneLookup.NORMALIZED_NUMBER,
+        PhoneLookup.LABEL,
+        PhoneLookup.TYPE,
+        PhoneLookup.PHOTO_URI,
+        PhoneLookup.CUSTOM_RINGTONE,
+        PhoneLookup.SEND_TO_VOICEMAIL
+      };
+
+  // In pre-N, contact id is stored in {@link PhoneLookup._ID} in non-sip query.
+  private static final String[] BACKWARD_COMPATIBLE_NON_SIP_DEFAULT_PHONELOOKUP_PROJECTION =
+      new String[] {
+        PhoneLookup._ID,
+        PhoneLookup.DISPLAY_NAME,
+        PhoneLookup.LOOKUP_KEY,
+        PhoneLookup.NUMBER,
+        PhoneLookup.NORMALIZED_NUMBER,
+        PhoneLookup.LABEL,
+        PhoneLookup.TYPE,
+        PhoneLookup.PHOTO_URI,
+        PhoneLookup.CUSTOM_RINGTONE,
+        PhoneLookup.SEND_TO_VOICEMAIL
+      };
+  /**
+   * Please note that, any one of these member variables can be null, and any accesses to them
+   * should be prepared to handle such a case.
+   *
+   * <p>Also, it is implied that phoneNumber is more often populated than name is, (think of calls
+   * being dialed/received using numbers where names are not known to the device), so phoneNumber
+   * should serve as a dependable fallback when name is unavailable.
+   *
+   * <p>One other detail here is that this CallerInfo object reflects information found on a
+   * connection, it is an OUTPUT that serves mainly to display information to the user. In no way is
+   * this object used as input to make a connection, so we can choose to display whatever
+   * human-readable text makes sense to the user for a connection. This is especially relevant for
+   * the phone number field, since it is the one field that is most likely exposed to the user.
+   *
+   * <p>As an example: 1. User dials "911" 2. Device recognizes that this is an emergency number 3.
+   * We use the "Emergency Number" string instead of "911" in the phoneNumber field.
+   *
+   * <p>What we're really doing here is treating phoneNumber as an essential field here, NOT name.
+   * We're NOT always guaranteed to have a name for a connection, but the number should be
+   * displayable.
+   */
+  public String name;
+
+  public String nameAlternative;
+  public String phoneNumber;
+  public String normalizedNumber;
+  public String forwardingNumber;
+  public String geoDescription;
+  public String cnapName;
+  public int numberPresentation;
+  public int namePresentation;
+  public boolean contactExists;
+  public String phoneLabel;
+  /* Split up the phoneLabel into number type and label name */
+  public int numberType;
+  public String numberLabel;
+  public int photoResource;
+  // Contact ID, which will be 0 if a contact comes from the corp CP2.
+  public long contactIdOrZero;
+  public String lookupKeyOrNull;
+  public boolean needUpdate;
+  public Uri contactRefUri;
+  public @UserType long userType;
+  /**
+   * Contact display photo URI. If a contact has no display photo but a thumbnail, it'll be the
+   * thumbnail URI instead.
+   */
+  public Uri contactDisplayPhotoUri;
+  // fields to hold individual contact preference data,
+  // including the send to voicemail flag and the ringtone
+  // uri reference.
+  public Uri contactRingtoneUri;
+  public boolean shouldSendToVoicemail;
+  /**
+   * Drawable representing the caller image. This is essentially a cache for the image data tied
+   * into the connection / callerinfo object.
+   *
+   * <p>This might be a high resolution picture which is more suitable for full-screen image view
+   * than for smaller icons used in some kinds of notifications.
+   *
+   * <p>The {@link #isCachedPhotoCurrent} flag indicates if the image data needs to be reloaded.
+   */
+  public Drawable cachedPhoto;
+  /**
+   * Bitmap representing the caller image which has possibly lower resolution than {@link
+   * #cachedPhoto} and thus more suitable for icons (like notification icons).
+   *
+   * <p>In usual cases this is just down-scaled image of {@link #cachedPhoto}. If the down-scaling
+   * fails, this will just become null.
+   *
+   * <p>The {@link #isCachedPhotoCurrent} flag indicates if the image data needs to be reloaded.
+   */
+  public Bitmap cachedPhotoIcon;
+  /**
+   * Boolean which indicates if {@link #cachedPhoto} and {@link #cachedPhotoIcon} is fresh enough.
+   * If it is false, those images aren't pointing to valid objects.
+   */
+  public boolean isCachedPhotoCurrent;
+  /**
+   * String which holds the call subject sent as extra from the lower layers for this call. This is
+   * used to display the no-caller ID reason for restricted/unknown number presentation.
+   */
+  public String callSubject;
+
+  private boolean mIsEmergency;
+  private boolean mIsVoiceMail;
+
+  public CallerInfo() {
+    // TODO: Move all the basic initialization here?
+    mIsEmergency = false;
+    mIsVoiceMail = false;
+    userType = ContactsUtils.USER_TYPE_CURRENT;
+  }
+
+  public static String[] getDefaultPhoneLookupProjection(Uri phoneLookupUri) {
+    if (VERSION.SDK_INT >= VERSION_CODES.N) {
+      return DEFAULT_PHONELOOKUP_PROJECTION;
+    }
+    // Pre-N
+    boolean isSip =
+        phoneLookupUri.getBooleanQueryParameter(
+            ContactsContract.PhoneLookup.QUERY_PARAMETER_SIP_ADDRESS, false);
+    return (isSip)
+        ? DEFAULT_PHONELOOKUP_PROJECTION
+        : BACKWARD_COMPATIBLE_NON_SIP_DEFAULT_PHONELOOKUP_PROJECTION;
+  }
+
+  /**
+   * getCallerInfo given a Cursor.
+   *
+   * @param context the context used to retrieve string constants
+   * @param contactRef the URI to attach to this CallerInfo object
+   * @param cursor the first object in the cursor is used to build the CallerInfo object.
+   * @return the CallerInfo which contains the caller id for the given number. The returned
+   *     CallerInfo is null if no number is supplied.
+   */
+  public static CallerInfo getCallerInfo(Context context, Uri contactRef, Cursor cursor) {
+    CallerInfo info = new CallerInfo();
+    info.photoResource = 0;
+    info.phoneLabel = null;
+    info.numberType = 0;
+    info.numberLabel = null;
+    info.cachedPhoto = null;
+    info.isCachedPhotoCurrent = false;
+    info.contactExists = false;
+    info.userType = ContactsUtils.USER_TYPE_CURRENT;
+
+    Log.v(TAG, "getCallerInfo() based on cursor...");
+
+    if (cursor != null) {
+      if (cursor.moveToFirst()) {
+        // TODO: photo_id is always available but not taken
+        // care of here. Maybe we should store it in the
+        // CallerInfo object as well.
+
+        long contactId = 0L;
+        int columnIndex;
+
+        // Look for the name
+        columnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
+        if (columnIndex != -1) {
+          info.name = cursor.getString(columnIndex);
+        }
+
+        // Look for the number
+        columnIndex = cursor.getColumnIndex(PhoneLookup.NUMBER);
+        if (columnIndex != -1) {
+          info.phoneNumber = cursor.getString(columnIndex);
+        }
+
+        // Look for the normalized number
+        columnIndex = cursor.getColumnIndex(PhoneLookup.NORMALIZED_NUMBER);
+        if (columnIndex != -1) {
+          info.normalizedNumber = cursor.getString(columnIndex);
+        }
+
+        // Look for the label/type combo
+        columnIndex = cursor.getColumnIndex(PhoneLookup.LABEL);
+        if (columnIndex != -1) {
+          int typeColumnIndex = cursor.getColumnIndex(PhoneLookup.TYPE);
+          if (typeColumnIndex != -1) {
+            info.numberType = cursor.getInt(typeColumnIndex);
+            info.numberLabel = cursor.getString(columnIndex);
+            info.phoneLabel =
+                Phone.getTypeLabel(context.getResources(), info.numberType, info.numberLabel)
+                    .toString();
+          }
+        }
+
+        // cache the lookup key for later use to create lookup URIs
+        columnIndex = cursor.getColumnIndex(PhoneLookup.LOOKUP_KEY);
+        if (columnIndex != -1) {
+          info.lookupKeyOrNull = cursor.getString(columnIndex);
+        }
+
+        // Look for the person_id.
+        columnIndex = getColumnIndexForPersonId(contactRef, cursor);
+        if (columnIndex != -1) {
+          contactId = cursor.getLong(columnIndex);
+          // QuickContacts in M doesn't support enterprise contact id
+          if (contactId != 0
+              && (VERSION.SDK_INT >= VERSION_CODES.N
+                  || !Contacts.isEnterpriseContactId(contactId))) {
+            info.contactIdOrZero = contactId;
+            Log.v(TAG, "==> got info.contactIdOrZero: " + info.contactIdOrZero);
+          }
+        } else {
+          // No valid columnIndex, so we can't look up person_id.
+          Log.v(TAG, "Couldn't find contactId column for " + contactRef);
+          // Watch out: this means that anything that depends on
+          // person_id will be broken (like contact photo lookups in
+          // the in-call UI, for example.)
+        }
+
+        // Display photo URI.
+        columnIndex = cursor.getColumnIndex(PhoneLookup.PHOTO_URI);
+        if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
+          info.contactDisplayPhotoUri = Uri.parse(cursor.getString(columnIndex));
+        } else {
+          info.contactDisplayPhotoUri = null;
+        }
+
+        // look for the custom ringtone, create from the string stored
+        // in the database.
+        columnIndex = cursor.getColumnIndex(PhoneLookup.CUSTOM_RINGTONE);
+        if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
+          if (TextUtils.isEmpty(cursor.getString(columnIndex))) {
+            // make it consistent with frameworks/base/.../CallerInfo.java
+            info.contactRingtoneUri = Uri.EMPTY;
+          } else {
+            info.contactRingtoneUri = Uri.parse(cursor.getString(columnIndex));
+          }
+        } else {
+          info.contactRingtoneUri = null;
+        }
+
+        // look for the send to voicemail flag, set it to true only
+        // under certain circumstances.
+        columnIndex = cursor.getColumnIndex(PhoneLookup.SEND_TO_VOICEMAIL);
+        info.shouldSendToVoicemail = (columnIndex != -1) && ((cursor.getInt(columnIndex)) == 1);
+        info.contactExists = true;
+
+        // Determine userType by directoryId and contactId
+        final String directory =
+            contactRef == null
+                ? null
+                : contactRef.getQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY);
+        Long directoryId = null;
+        if (directory != null) {
+          try {
+            directoryId = Long.parseLong(directory);
+          } catch (NumberFormatException e) {
+            // do nothing
+          }
+        }
+        info.userType = ContactsUtils.determineUserType(directoryId, contactId);
+
+        info.nameAlternative =
+            ContactInfoHelper.lookUpDisplayNameAlternative(
+                context, info.lookupKeyOrNull, info.userType, directoryId);
+      }
+      cursor.close();
+    }
+
+    info.needUpdate = false;
+    info.name = normalize(info.name);
+    info.contactRefUri = contactRef;
+
+    return info;
+  }
+
+  /**
+   * getCallerInfo given a URI, look up in the call-log database for the uri unique key.
+   *
+   * @param context the context used to get the ContentResolver
+   * @param contactRef the URI used to lookup caller id
+   * @return the CallerInfo which contains the caller id for the given number. The returned
+   *     CallerInfo is null if no number is supplied.
+   */
+  private static CallerInfo getCallerInfo(Context context, Uri contactRef) {
+
+    return getCallerInfo(
+        context,
+        contactRef,
+        context.getContentResolver().query(contactRef, null, null, null, null));
+  }
+
+  /**
+   * Performs another lookup if previous lookup fails and it's a SIP call and the peer's username is
+   * all numeric. Look up the username as it could be a PSTN number in the contact database.
+   *
+   * @param context the query context
+   * @param number the original phone number, could be a SIP URI
+   * @param previousResult the result of previous lookup
+   * @return previousResult if it's not the case
+   */
+  static CallerInfo doSecondaryLookupIfNecessary(
+      Context context, String number, CallerInfo previousResult) {
+    if (!previousResult.contactExists && PhoneNumberHelper.isUriNumber(number)) {
+      String username = PhoneNumberHelper.getUsernameFromUriNumber(number);
+      if (PhoneNumberUtils.isGlobalPhoneNumber(username)) {
+        previousResult =
+            getCallerInfo(
+                context,
+                Uri.withAppendedPath(
+                    PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, Uri.encode(username)));
+      }
+    }
+    return previousResult;
+  }
+
+  // Accessors
+
+  private static String normalize(String s) {
+    if (s == null || s.length() > 0) {
+      return s;
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Returns the column index to use to find the "person_id" field in the specified cursor, based on
+   * the contact URI that was originally queried.
+   *
+   * <p>This is a helper function for the getCallerInfo() method that takes a Cursor. Looking up the
+   * person_id is nontrivial (compared to all the other CallerInfo fields) since the column we need
+   * to use depends on what query we originally ran.
+   *
+   * <p>Watch out: be sure to not do any database access in this method, since it's run from the UI
+   * thread (see comments below for more info.)
+   *
+   * @return the columnIndex to use (with cursor.getLong()) to get the person_id, or -1 if we
+   *     couldn't figure out what colum to use.
+   *     <p>TODO: Add a unittest for this method. (This is a little tricky to test, since we'll need
+   *     a live contacts database to test against, preloaded with at least some phone numbers and
+   *     SIP addresses. And we'll probably have to hardcode the column indexes we expect, so the
+   *     test might break whenever the contacts schema changes. But we can at least make sure we
+   *     handle all the URI patterns we claim to, and that the mime types match what we expect...)
+   */
+  private static int getColumnIndexForPersonId(Uri contactRef, Cursor cursor) {
+    // TODO: This is pretty ugly now, see bug 2269240 for
+    // more details. The column to use depends upon the type of URL:
+    // - content://com.android.contacts/data/phones ==> use the "contact_id" column
+    // - content://com.android.contacts/phone_lookup ==> use the "_ID" column
+    // - content://com.android.contacts/data ==> use the "contact_id" column
+    // If it's none of the above, we leave columnIndex=-1 which means
+    // that the person_id field will be left unset.
+    //
+    // The logic here *used* to be based on the mime type of contactRef
+    // (for example Phone.CONTENT_ITEM_TYPE would tell us to use the
+    // RawContacts.CONTACT_ID column).  But looking up the mime type requires
+    // a call to context.getContentResolver().getType(contactRef), which
+    // isn't safe to do from the UI thread since it can cause an ANR if
+    // the contacts provider is slow or blocked (like during a sync.)
+    //
+    // So instead, figure out the column to use for person_id by just
+    // looking at the URI itself.
+
+    Log.v(TAG, "- getColumnIndexForPersonId: contactRef URI = '" + contactRef + "'...");
+    // Warning: Do not enable the following logging (due to ANR risk.)
+    // if (VDBG) Rlog.v(TAG, "- MIME type: "
+    //                 + context.getContentResolver().getType(contactRef));
+
+    String url = contactRef.toString();
+    String columnName = null;
+    if (url.startsWith("content://com.android.contacts/data/phones")) {
+      // Direct lookup in the Phone table.
+      // MIME type: Phone.CONTENT_ITEM_TYPE (= "vnd.android.cursor.item/phone_v2")
+      Log.v(TAG, "'data/phones' URI; using RawContacts.CONTACT_ID");
+      columnName = RawContacts.CONTACT_ID;
+    } else if (url.startsWith("content://com.android.contacts/data")) {
+      // Direct lookup in the Data table.
+      // MIME type: Data.CONTENT_TYPE (= "vnd.android.cursor.dir/data")
+      Log.v(TAG, "'data' URI; using Data.CONTACT_ID");
+      // (Note Data.CONTACT_ID and RawContacts.CONTACT_ID are equivalent.)
+      columnName = Data.CONTACT_ID;
+    } else if (url.startsWith("content://com.android.contacts/phone_lookup")) {
+      // Lookup in the PhoneLookup table, which provides "fuzzy matching"
+      // for phone numbers.
+      // MIME type: PhoneLookup.CONTENT_TYPE (= "vnd.android.cursor.dir/phone_lookup")
+      Log.v(TAG, "'phone_lookup' URI; using PhoneLookup._ID");
+      columnName = PhoneLookupUtil.getContactIdColumnNameForUri(contactRef);
+    } else {
+      Log.v(TAG, "Unexpected prefix for contactRef '" + url + "'");
+    }
+    int columnIndex = (columnName != null) ? cursor.getColumnIndex(columnName) : -1;
+    Log.v(
+        TAG,
+        "==> Using column '"
+            + columnName
+            + "' (columnIndex = "
+            + columnIndex
+            + ") for person_id lookup...");
+    return columnIndex;
+  }
+
+  /** @return true if the caller info is an emergency number. */
+  public boolean isEmergencyNumber() {
+    return mIsEmergency;
+  }
+
+  /** @return true if the caller info is a voicemail number. */
+  public boolean isVoiceMailNumber() {
+    return mIsVoiceMail;
+  }
+
+  /**
+   * Mark this CallerInfo as an emergency call.
+   *
+   * @param context To lookup the localized 'Emergency Number' string.
+   * @return this instance.
+   */
+  /* package */ CallerInfo markAsEmergency(Context context) {
+    name = context.getString(R.string.emergency_call_dialog_number_for_display);
+    phoneNumber = null;
+
+    photoResource = R.drawable.img_phone;
+    mIsEmergency = true;
+    return this;
+  }
+
+  /**
+   * Mark this CallerInfo as a voicemail call. The voicemail label is obtained from the telephony
+   * manager. Caller must hold the READ_PHONE_STATE permission otherwise the phoneNumber will be set
+   * to null.
+   *
+   * @return this instance.
+   */
+  /* package */ CallerInfo markAsVoiceMail(Context context) {
+    mIsVoiceMail = true;
+
+    try {
+      // For voicemail calls, we display the voice mail tag
+      // instead of the real phone number in the "number"
+      // field.
+      name = TelephonyManagerUtils.getVoiceMailAlphaTag(context);
+      phoneNumber = null;
+    } catch (SecurityException se) {
+      // Should never happen: if this process does not have
+      // permission to retrieve VM tag, it should not have
+      // permission to retrieve VM number and would not call
+      // this method.
+      // Leave phoneNumber untouched.
+      Log.e(TAG, "Cannot access VoiceMail.", se);
+    }
+    // TODO: There is no voicemail picture?
+    // FIXME: FIND ANOTHER ICON
+    // photoResource = android.R.drawable.badge_voicemail;
+    return this;
+  }
+
+  /**
+   * Updates this CallerInfo's geoDescription field, based on the raw phone number in the
+   * phoneNumber field.
+   *
+   * <p>(Note that the various getCallerInfo() methods do *not* set the geoDescription
+   * automatically; you need to call this method explicitly to get it.)
+   *
+   * @param context the context used to look up the current locale / country
+   * @param fallbackNumber if this CallerInfo's phoneNumber field is empty, this specifies a
+   *     fallback number to use instead.
+   */
+  public void updateGeoDescription(Context context, String fallbackNumber) {
+    String number = TextUtils.isEmpty(phoneNumber) ? fallbackNumber : phoneNumber;
+    geoDescription = PhoneNumberHelper.getGeoDescription(context, number);
+  }
+
+  /** @return a string debug representation of this instance. */
+  @Override
+  public String toString() {
+    // Warning: never check in this file with VERBOSE_DEBUG = true
+    // because that will result in PII in the system log.
+    final boolean VERBOSE_DEBUG = false;
+
+    if (VERBOSE_DEBUG) {
+      return new StringBuilder(384)
+          .append(super.toString() + " { ")
+          .append("\nname: " + name)
+          .append("\nphoneNumber: " + phoneNumber)
+          .append("\nnormalizedNumber: " + normalizedNumber)
+          .append("\forwardingNumber: " + forwardingNumber)
+          .append("\ngeoDescription: " + geoDescription)
+          .append("\ncnapName: " + cnapName)
+          .append("\nnumberPresentation: " + numberPresentation)
+          .append("\nnamePresentation: " + namePresentation)
+          .append("\ncontactExists: " + contactExists)
+          .append("\nphoneLabel: " + phoneLabel)
+          .append("\nnumberType: " + numberType)
+          .append("\nnumberLabel: " + numberLabel)
+          .append("\nphotoResource: " + photoResource)
+          .append("\ncontactIdOrZero: " + contactIdOrZero)
+          .append("\nneedUpdate: " + needUpdate)
+          .append("\ncontactRefUri: " + contactRefUri)
+          .append("\ncontactRingtoneUri: " + contactRingtoneUri)
+          .append("\ncontactDisplayPhotoUri: " + contactDisplayPhotoUri)
+          .append("\nshouldSendToVoicemail: " + shouldSendToVoicemail)
+          .append("\ncachedPhoto: " + cachedPhoto)
+          .append("\nisCachedPhotoCurrent: " + isCachedPhotoCurrent)
+          .append("\nemergency: " + mIsEmergency)
+          .append("\nvoicemail: " + mIsVoiceMail)
+          .append("\nuserType: " + userType)
+          .append(" }")
+          .toString();
+    } else {
+      return new StringBuilder(128)
+          .append(super.toString() + " { ")
+          .append("name " + ((name == null) ? "null" : "non-null"))
+          .append(", phoneNumber " + ((phoneNumber == null) ? "null" : "non-null"))
+          .append(" }")
+          .toString();
+    }
+  }
+}
diff --git a/java/com/android/incallui/CallerInfoAsyncQuery.java b/java/com/android/incallui/CallerInfoAsyncQuery.java
new file mode 100644
index 0000000..f8d7ac6
--- /dev/null
+++ b/java/com/android/incallui/CallerInfoAsyncQuery.java
@@ -0,0 +1,638 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.Manifest;
+import android.annotation.TargetApi;
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Directory;
+import android.support.annotation.MainThread;
+import android.support.annotation.RequiresPermission;
+import android.support.annotation.WorkerThread;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import com.android.contacts.common.compat.DirectoryCompat;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService.CachedContactInfo;
+import com.android.dialer.phonenumbercache.ContactInfoHelper;
+import com.android.dialer.phonenumbercache.PhoneNumberCache;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Helper class to make it easier to run asynchronous caller-id lookup queries.
+ *
+ * @see CallerInfo
+ */
+@TargetApi(VERSION_CODES.M)
+public class CallerInfoAsyncQuery {
+
+  /** Interface for a CallerInfoAsyncQueryHandler result return. */
+  public interface OnQueryCompleteListener {
+
+    /** Called when the query is complete. */
+    @MainThread
+    void onQueryComplete(int token, Object cookie, CallerInfo ci);
+
+    /** Called when data is loaded. Must be called in worker thread. */
+    @WorkerThread
+    void onDataLoaded(int token, Object cookie, CallerInfo ci);
+  }
+
+  private static final boolean DBG = false;
+  private static final String LOG_TAG = "CallerInfoAsyncQuery";
+
+  private static final int EVENT_NEW_QUERY = 1;
+  private static final int EVENT_ADD_LISTENER = 2;
+  private static final int EVENT_EMERGENCY_NUMBER = 3;
+  private static final int EVENT_VOICEMAIL_NUMBER = 4;
+  // If the CallerInfo query finds no contacts, should we use the
+  // PhoneNumberOfflineGeocoder to look up a "geo description"?
+  // (TODO: This could become a flag in config.xml if it ever needs to be
+  // configured on a per-product basis.)
+  private static final boolean ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION = true;
+  /* Directory lookup related code - START */
+  private static final String[] DIRECTORY_PROJECTION = new String[] {Directory._ID};
+
+  /** Private constructor for factory methods. */
+  private CallerInfoAsyncQuery() {}
+
+  @RequiresPermission(Manifest.permission.READ_CONTACTS)
+  public static void startQuery(
+      final int token,
+      final Context context,
+      final CallerInfo info,
+      final OnQueryCompleteListener listener,
+      final Object cookie) {
+    Log.d(LOG_TAG, "##### CallerInfoAsyncQuery startContactProviderQuery()... #####");
+    Log.d(LOG_TAG, "- number: " + info.phoneNumber);
+    Log.d(LOG_TAG, "- cookie: " + cookie);
+
+    OnQueryCompleteListener contactsProviderQueryCompleteListener =
+        new OnQueryCompleteListener() {
+          @Override
+          public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
+            Log.d(LOG_TAG, "contactsProviderQueryCompleteListener done");
+            // If there are no other directory queries, make sure that the listener is
+            // notified of this result.  see b/27621628
+            if ((ci != null && ci.contactExists)
+                || !startOtherDirectoriesQuery(token, context, info, listener, cookie)) {
+              if (listener != null && ci != null) {
+                listener.onQueryComplete(token, cookie, ci);
+              }
+            }
+          }
+
+          @Override
+          public void onDataLoaded(int token, Object cookie, CallerInfo ci) {
+            listener.onDataLoaded(token, cookie, ci);
+          }
+        };
+    startDefaultDirectoryQuery(token, context, info, contactsProviderQueryCompleteListener, cookie);
+  }
+
+  // Private methods
+  private static void startDefaultDirectoryQuery(
+      int token,
+      Context context,
+      CallerInfo info,
+      OnQueryCompleteListener listener,
+      Object cookie) {
+    // Construct the URI object and query params, and start the query.
+    Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber);
+    startQueryInternal(token, context, info, listener, cookie, uri);
+  }
+
+  /**
+   * Factory method to start the query based on a CallerInfo object.
+   *
+   * <p>Note: if the number contains an "@" character we treat it as a SIP address, and look it up
+   * directly in the Data table rather than using the PhoneLookup table. TODO: But eventually we
+   * should expose two separate methods, one for numbers and one for SIP addresses, and then have
+   * PhoneUtils.startGetCallerInfo() decide which one to call based on the phone type of the
+   * incoming connection.
+   */
+  private static void startQueryInternal(
+      int token,
+      Context context,
+      CallerInfo info,
+      OnQueryCompleteListener listener,
+      Object cookie,
+      Uri contactRef) {
+    if (DBG) {
+      Log.d(LOG_TAG, "==> contactRef: " + sanitizeUriToString(contactRef));
+    }
+
+    if ((context == null) || (contactRef == null)) {
+      throw new QueryPoolException("Bad context or query uri.");
+    }
+    CallerInfoAsyncQueryHandler handler = new CallerInfoAsyncQueryHandler(context, contactRef);
+
+    //create cookieWrapper, start query
+    CookieWrapper cw = new CookieWrapper();
+    cw.listener = listener;
+    cw.cookie = cookie;
+    cw.number = info.phoneNumber;
+
+    // check to see if these are recognized numbers, and use shortcuts if we can.
+    if (PhoneNumberUtils.isLocalEmergencyNumber(context, info.phoneNumber)) {
+      cw.event = EVENT_EMERGENCY_NUMBER;
+    } else if (info.isVoiceMailNumber()) {
+      cw.event = EVENT_VOICEMAIL_NUMBER;
+    } else {
+      cw.event = EVENT_NEW_QUERY;
+    }
+
+    String[] proejection = CallerInfo.getDefaultPhoneLookupProjection(contactRef);
+    handler.startQuery(
+        token,
+        cw, // cookie
+        contactRef, // uri
+        proejection, // projection
+        null, // selection
+        null, // selectionArgs
+        null); // orderBy
+  }
+
+  // Return value indicates if listener was notified.
+  private static boolean startOtherDirectoriesQuery(
+      int token,
+      Context context,
+      CallerInfo info,
+      OnQueryCompleteListener listener,
+      Object cookie) {
+    long[] directoryIds = getDirectoryIds(context);
+    int size = directoryIds.length;
+    if (size == 0) {
+      return false;
+    }
+
+    DirectoryQueryCompleteListenerFactory listenerFactory =
+        new DirectoryQueryCompleteListenerFactory(context, size, listener);
+
+    // The current implementation of multiple async query runs in single handler thread
+    // in AsyncQueryHandler.
+    // intermediateListener.onQueryComplete is also called from the same caller thread.
+    // TODO(b/26019872): use thread pool instead of single thread.
+    for (int i = 0; i < size; i++) {
+      long directoryId = directoryIds[i];
+      Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber, directoryId);
+      if (DBG) {
+        Log.d(LOG_TAG, "directoryId: " + directoryId + " uri: " + uri);
+      }
+      OnQueryCompleteListener intermediateListener = listenerFactory.newListener(directoryId);
+      startQueryInternal(token, context, info, intermediateListener, cookie, uri);
+    }
+    return true;
+  }
+
+  private static long[] getDirectoryIds(Context context) {
+    ArrayList<Long> results = new ArrayList<>();
+
+    Uri uri = Directory.CONTENT_URI;
+    if (VERSION.SDK_INT >= VERSION_CODES.N) {
+      uri = Uri.withAppendedPath(ContactsContract.AUTHORITY_URI, "directories_enterprise");
+    }
+
+    ContentResolver cr = context.getContentResolver();
+    Cursor cursor = cr.query(uri, DIRECTORY_PROJECTION, null, null, null);
+    addDirectoryIdsFromCursor(cursor, results);
+
+    long[] result = new long[results.size()];
+    for (int i = 0; i < results.size(); i++) {
+      result[i] = results.get(i);
+    }
+    return result;
+  }
+
+  private static void addDirectoryIdsFromCursor(Cursor cursor, ArrayList<Long> results) {
+    if (cursor != null) {
+      int idIndex = cursor.getColumnIndex(Directory._ID);
+      while (cursor.moveToNext()) {
+        long id = cursor.getLong(idIndex);
+        if (DirectoryCompat.isRemoteDirectoryId(id)) {
+          results.add(id);
+        }
+      }
+      cursor.close();
+    }
+  }
+
+  private static String sanitizeUriToString(Uri uri) {
+    if (uri != null) {
+      String uriString = uri.toString();
+      int indexOfLastSlash = uriString.lastIndexOf('/');
+      if (indexOfLastSlash > 0) {
+        return uriString.substring(0, indexOfLastSlash) + "/xxxxxxx";
+      } else {
+        return uriString;
+      }
+    } else {
+      return "";
+    }
+  }
+
+  /** Wrap the cookie from the WorkerArgs with additional information needed by our classes. */
+  private static final class CookieWrapper {
+
+    public OnQueryCompleteListener listener;
+    public Object cookie;
+    public int event;
+    public String number;
+  }
+  /* Directory lookup related code - END */
+
+  /** Simple exception used to communicate problems with the query pool. */
+  public static class QueryPoolException extends SQLException {
+
+    public QueryPoolException(String error) {
+      super(error);
+    }
+  }
+
+  private static final class DirectoryQueryCompleteListenerFactory {
+
+    private final OnQueryCompleteListener mListener;
+    private final Context mContext;
+    // Make sure listener to be called once and only once
+    private int mCount;
+    private boolean mIsListenerCalled;
+
+    DirectoryQueryCompleteListenerFactory(
+        Context context, int size, OnQueryCompleteListener listener) {
+      mCount = size;
+      mListener = listener;
+      mIsListenerCalled = false;
+      mContext = context;
+    }
+
+    private void onDirectoryQueryComplete(
+        int token, Object cookie, CallerInfo ci, long directoryId) {
+      boolean shouldCallListener = false;
+      synchronized (this) {
+        mCount = mCount - 1;
+        if (!mIsListenerCalled && (ci.contactExists || mCount == 0)) {
+          mIsListenerCalled = true;
+          shouldCallListener = true;
+        }
+      }
+
+      // Don't call callback in synchronized block because mListener.onQueryComplete may
+      // take long time to complete
+      if (shouldCallListener && mListener != null) {
+        addCallerInfoIntoCache(ci, directoryId);
+        mListener.onQueryComplete(token, cookie, ci);
+      }
+    }
+
+    private void addCallerInfoIntoCache(CallerInfo ci, long directoryId) {
+      CachedNumberLookupService cachedNumberLookupService =
+          PhoneNumberCache.get(mContext).getCachedNumberLookupService();
+      if (ci.contactExists && cachedNumberLookupService != null) {
+        // 1. Cache caller info
+        CachedContactInfo cachedContactInfo =
+            CallerInfoUtils.buildCachedContactInfo(cachedNumberLookupService, ci);
+        String directoryLabel = mContext.getString(R.string.directory_search_label);
+        cachedContactInfo.setDirectorySource(directoryLabel, directoryId);
+        cachedNumberLookupService.addContact(mContext, cachedContactInfo);
+
+        // 2. Cache photo
+        if (ci.contactDisplayPhotoUri != null && ci.normalizedNumber != null) {
+          try (InputStream in =
+              mContext.getContentResolver().openInputStream(ci.contactDisplayPhotoUri)) {
+            if (in != null) {
+              cachedNumberLookupService.addPhoto(mContext, ci.normalizedNumber, in);
+            }
+          } catch (IOException e) {
+            Log.e(LOG_TAG, "failed to fetch directory contact photo", e);
+          }
+        }
+      }
+    }
+
+    public OnQueryCompleteListener newListener(long directoryId) {
+      return new DirectoryQueryCompleteListener(directoryId);
+    }
+
+    private class DirectoryQueryCompleteListener implements OnQueryCompleteListener {
+
+      private final long mDirectoryId;
+
+      DirectoryQueryCompleteListener(long directoryId) {
+        mDirectoryId = directoryId;
+      }
+
+      @Override
+      public void onDataLoaded(int token, Object cookie, CallerInfo ci) {
+        mListener.onDataLoaded(token, cookie, ci);
+      }
+
+      @Override
+      public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
+        onDirectoryQueryComplete(token, cookie, ci, mDirectoryId);
+      }
+    }
+  }
+
+  /** Our own implementation of the AsyncQueryHandler. */
+  private static class CallerInfoAsyncQueryHandler extends AsyncQueryHandler {
+
+    /**
+     * The information relevant to each CallerInfo query. Each query may have multiple listeners, so
+     * each AsyncCursorInfo is associated with 2 or more CookieWrapper objects in the queue (one
+     * with a new query event, and one with a end event, with 0 or more additional listeners in
+     * between).
+     */
+    private Context mQueryContext;
+
+    private Uri mQueryUri;
+    private CallerInfo mCallerInfo;
+
+    /** Asynchronous query handler class for the contact / callerinfo object. */
+    private CallerInfoAsyncQueryHandler(Context context, Uri contactRef) {
+      super(context.getContentResolver());
+      this.mQueryContext = context;
+      this.mQueryUri = contactRef;
+    }
+
+    @Override
+    public void startQuery(
+        int token,
+        Object cookie,
+        Uri uri,
+        String[] projection,
+        String selection,
+        String[] selectionArgs,
+        String orderBy) {
+      if (DBG) {
+        // Show stack trace with the arguments.
+        Log.d(
+            LOG_TAG,
+            "InCall: startQuery: url="
+                + uri
+                + " projection=["
+                + Arrays.toString(projection)
+                + "]"
+                + " selection="
+                + selection
+                + " "
+                + " args=["
+                + Arrays.toString(selectionArgs)
+                + "]",
+            new RuntimeException("STACKTRACE"));
+      }
+      super.startQuery(token, cookie, uri, projection, selection, selectionArgs, orderBy);
+    }
+
+    @Override
+    protected Handler createHandler(Looper looper) {
+      return new CallerInfoWorkerHandler(looper);
+    }
+
+    /**
+     * Overrides onQueryComplete from AsyncQueryHandler.
+     *
+     * <p>This method takes into account the state of this class; we construct the CallerInfo object
+     * only once for each set of listeners. When the query thread has done its work and calls this
+     * method, we inform the remaining listeners in the queue, until we're out of listeners. Once we
+     * get the message indicating that we should expect no new listeners for this CallerInfo object,
+     * we release the AsyncCursorInfo back into the pool.
+     */
+    @Override
+    protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+      Log.d(this, "##### onQueryComplete() #####   query complete for token: " + token);
+
+      CookieWrapper cw = (CookieWrapper) cookie;
+
+      if (cw.listener != null) {
+        Log.d(
+            this,
+            "notifying listener: "
+                + cw.listener.getClass().toString()
+                + " for token: "
+                + token
+                + mCallerInfo);
+        cw.listener.onQueryComplete(token, cw.cookie, mCallerInfo);
+      }
+      mQueryContext = null;
+      mQueryUri = null;
+      mCallerInfo = null;
+    }
+
+    protected void updateData(int token, Object cookie, Cursor cursor) {
+      try {
+        Log.d(this, "##### updateData() #####  for token: " + token);
+
+        //get the cookie and notify the listener.
+        CookieWrapper cw = (CookieWrapper) cookie;
+        if (cw == null) {
+          // Normally, this should never be the case for calls originating
+          // from within this code.
+          // However, if there is any code that calls this method, we should
+          // check the parameters to make sure they're viable.
+          Log.d(this, "Cookie is null, ignoring onQueryComplete() request.");
+          return;
+        }
+
+        // check the token and if needed, create the callerinfo object.
+        if (mCallerInfo == null) {
+          if ((mQueryContext == null) || (mQueryUri == null)) {
+            throw new QueryPoolException(
+                "Bad context or query uri, or CallerInfoAsyncQuery already released.");
+          }
+
+          // adjust the callerInfo data as needed, and only if it was set from the
+          // initial query request.
+          // Change the callerInfo number ONLY if it is an emergency number or the
+          // voicemail number, and adjust other data (including photoResource)
+          // accordingly.
+          if (cw.event == EVENT_EMERGENCY_NUMBER) {
+            // Note we're setting the phone number here (refer to javadoc
+            // comments at the top of CallerInfo class).
+            mCallerInfo = new CallerInfo().markAsEmergency(mQueryContext);
+          } else if (cw.event == EVENT_VOICEMAIL_NUMBER) {
+            mCallerInfo = new CallerInfo().markAsVoiceMail(mQueryContext);
+          } else {
+            mCallerInfo = CallerInfo.getCallerInfo(mQueryContext, mQueryUri, cursor);
+            Log.d(this, "==> Got mCallerInfo: " + mCallerInfo);
+
+            CallerInfo newCallerInfo =
+                CallerInfo.doSecondaryLookupIfNecessary(mQueryContext, cw.number, mCallerInfo);
+            if (newCallerInfo != mCallerInfo) {
+              mCallerInfo = newCallerInfo;
+              Log.d(this, "#####async contact look up with numeric username" + mCallerInfo);
+            }
+
+            // Final step: look up the geocoded description.
+            if (ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION) {
+              // Note we do this only if we *don't* have a valid name (i.e. if
+              // no contacts matched the phone number of the incoming call),
+              // since that's the only case where the incoming-call UI cares
+              // about this field.
+              //
+              // (TODO: But if we ever want the UI to show the geoDescription
+              // even when we *do* match a contact, we'll need to either call
+              // updateGeoDescription() unconditionally here, or possibly add a
+              // new parameter to CallerInfoAsyncQuery.startQuery() to force
+              // the geoDescription field to be populated.)
+
+              if (TextUtils.isEmpty(mCallerInfo.name)) {
+                // Actually when no contacts match the incoming phone number,
+                // the CallerInfo object is totally blank here (i.e. no name
+                // *or* phoneNumber).  So we need to pass in cw.number as
+                // a fallback number.
+                mCallerInfo.updateGeoDescription(mQueryContext, cw.number);
+              }
+            }
+
+            // Use the number entered by the user for display.
+            if (!TextUtils.isEmpty(cw.number)) {
+              mCallerInfo.phoneNumber = cw.number;
+            }
+          }
+
+          Log.d(this, "constructing CallerInfo object for token: " + token);
+
+          if (cw.listener != null) {
+            cw.listener.onDataLoaded(token, cw.cookie, mCallerInfo);
+          }
+        }
+
+      } finally {
+        // The cursor may have been closed in CallerInfo.getCallerInfo()
+        if (cursor != null && !cursor.isClosed()) {
+          cursor.close();
+        }
+      }
+    }
+
+    /**
+     * Our own query worker thread.
+     *
+     * <p>This thread handles the messages enqueued in the looper. The normal sequence of events is
+     * that a new query shows up in the looper queue, followed by 0 or more add listener requests,
+     * and then an end request. Of course, these requests can be interlaced with requests from other
+     * tokens, but is irrelevant to this handler since the handler has no state.
+     *
+     * <p>Note that we depend on the queue to keep things in order; in other words, the looper queue
+     * must be FIFO with respect to input from the synchronous startQuery calls and output to this
+     * handleMessage call.
+     *
+     * <p>This use of the queue is required because CallerInfo objects may be accessed multiple
+     * times before the query is complete. All accesses (listeners) must be queued up and informed
+     * in order when the query is complete.
+     */
+    protected class CallerInfoWorkerHandler extends WorkerHandler {
+
+      public CallerInfoWorkerHandler(Looper looper) {
+        super(looper);
+      }
+
+      @Override
+      public void handleMessage(Message msg) {
+        WorkerArgs args = (WorkerArgs) msg.obj;
+        CookieWrapper cw = (CookieWrapper) args.cookie;
+
+        if (cw == null) {
+          // Normally, this should never be the case for calls originating
+          // from within this code.
+          // However, if there is any code that this Handler calls (such as in
+          // super.handleMessage) that DOES place unexpected messages on the
+          // queue, then we need pass these messages on.
+          Log.d(
+              this,
+              "Unexpected command (CookieWrapper is null): "
+                  + msg.what
+                  + " ignored by CallerInfoWorkerHandler, passing onto parent.");
+
+          super.handleMessage(msg);
+        } else {
+          Log.d(
+              this,
+              "Processing event: "
+                  + cw.event
+                  + " token (arg1): "
+                  + msg.arg1
+                  + " command: "
+                  + msg.what
+                  + " query URI: "
+                  + sanitizeUriToString(args.uri));
+
+          switch (cw.event) {
+            case EVENT_NEW_QUERY:
+              final ContentResolver resolver = mQueryContext.getContentResolver();
+
+              // This should never happen.
+              if (resolver == null) {
+                Log.e(this, "Content Resolver is null!");
+                return;
+              }
+              //start the sql command.
+              Cursor cursor;
+              try {
+                cursor =
+                    resolver.query(
+                        args.uri,
+                        args.projection,
+                        args.selection,
+                        args.selectionArgs,
+                        args.orderBy);
+                // Calling getCount() causes the cursor window to be filled,
+                // which will make the first access on the main thread a lot faster.
+                if (cursor != null) {
+                  cursor.getCount();
+                }
+              } catch (Exception e) {
+                Log.e(this, "Exception thrown during handling EVENT_ARG_QUERY", e);
+                cursor = null;
+              }
+
+              args.result = cursor;
+              updateData(msg.arg1, cw, cursor);
+              break;
+
+              // shortcuts to avoid query for recognized numbers.
+            case EVENT_EMERGENCY_NUMBER:
+            case EVENT_VOICEMAIL_NUMBER:
+            case EVENT_ADD_LISTENER:
+              updateData(msg.arg1, cw, (Cursor) args.result);
+              break;
+            default:
+          }
+          Message reply = args.handler.obtainMessage(msg.what);
+          reply.obj = args;
+          reply.arg1 = msg.arg1;
+
+          reply.sendToTarget();
+        }
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/CallerInfoUtils.java b/java/com/android/incallui/CallerInfoUtils.java
new file mode 100644
index 0000000..9f57fba
--- /dev/null
+++ b/java/com/android/incallui/CallerInfoUtils.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.Manifest.permission;
+import android.content.Context;
+import android.content.Loader;
+import android.content.Loader.OnLoadCompleteListener;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.support.v4.content.ContextCompat;
+import android.telecom.PhoneAccount;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import com.android.contacts.common.model.Contact;
+import com.android.contacts.common.model.ContactLoader;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService.CachedContactInfo;
+import com.android.dialer.phonenumbercache.ContactInfo;
+import com.android.dialer.phonenumberutil.PhoneNumberHelper;
+import com.android.dialer.telecom.TelecomUtil;
+import com.android.dialer.util.PermissionsUtil;
+import com.android.incallui.call.DialerCall;
+import java.util.Arrays;
+
+/** Utility methods for contact and caller info related functionality */
+public class CallerInfoUtils {
+
+  private static final String TAG = CallerInfoUtils.class.getSimpleName();
+
+  private static final int QUERY_TOKEN = -1;
+
+  public CallerInfoUtils() {}
+
+  /**
+   * This is called to get caller info for a call. This will return a CallerInfo object immediately
+   * based off information in the call, but more information is returned to the
+   * OnQueryCompleteListener (which contains information about the phone number label, user's name,
+   * etc).
+   */
+  public static CallerInfo getCallerInfoForCall(
+      Context context,
+      DialerCall call,
+      Object cookie,
+      CallerInfoAsyncQuery.OnQueryCompleteListener listener) {
+    CallerInfo info = buildCallerInfo(context, call);
+
+    // TODO: Have phoneapp send a Uri when it knows the contact that triggered this call.
+
+    if (info.numberPresentation == TelecomManager.PRESENTATION_ALLOWED) {
+      if (PermissionsUtil.hasContactsPermissions(context)) {
+        // Start the query with the number provided from the call.
+        LogUtil.d(
+            "CallerInfoUtils.getCallerInfoForCall",
+            "Actually starting CallerInfoAsyncQuery.startQuery()...");
+
+        //noinspection MissingPermission
+        CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, info, listener, cookie);
+      } else {
+        LogUtil.w(
+            "CallerInfoUtils.getCallerInfoForCall",
+            "Dialer doesn't have permission to read contacts."
+                + " Not calling CallerInfoAsyncQuery.startQuery().");
+      }
+    }
+    return info;
+  }
+
+  public static CallerInfo buildCallerInfo(Context context, DialerCall call) {
+    CallerInfo info = new CallerInfo();
+
+    // Store CNAP information retrieved from the Connection (we want to do this
+    // here regardless of whether the number is empty or not).
+    info.cnapName = call.getCnapName();
+    info.name = info.cnapName;
+    info.numberPresentation = call.getNumberPresentation();
+    info.namePresentation = call.getCnapNamePresentation();
+    info.callSubject = call.getCallSubject();
+
+    String number = call.getNumber();
+    if (!TextUtils.isEmpty(number)) {
+      // Don't split it if it's a SIP number.
+      if (!PhoneNumberHelper.isUriNumber(number)) {
+        final String[] numbers = number.split("&");
+        number = numbers[0];
+        if (numbers.length > 1) {
+          info.forwardingNumber = numbers[1];
+        }
+        number = modifyForSpecialCnapCases(context, info, number, info.numberPresentation);
+      }
+      info.phoneNumber = number;
+    }
+
+    // Because the InCallUI is immediately launched before the call is connected, occasionally
+    // a voicemail call will be passed to InCallUI as a "voicemail:" URI without a number.
+    // This call should still be handled as a voicemail call.
+    if ((call.getHandle() != null
+            && PhoneAccount.SCHEME_VOICEMAIL.equals(call.getHandle().getScheme()))
+        || isVoiceMailNumber(context, call)) {
+      info.markAsVoiceMail(context);
+    }
+
+    ContactInfoCache.getInstance(context).maybeInsertCnapInformationIntoCache(context, call, info);
+
+    return info;
+  }
+
+  /**
+   * Creates a new {@link CachedContactInfo} from a {@link CallerInfo}
+   *
+   * @param lookupService the {@link CachedNumberLookupService} used to build a new {@link
+   *     CachedContactInfo}
+   * @param {@link CallerInfo} object
+   * @return a CachedContactInfo object created from this CallerInfo
+   * @throws NullPointerException if lookupService or ci are null
+   */
+  public static CachedContactInfo buildCachedContactInfo(
+      CachedNumberLookupService lookupService, CallerInfo ci) {
+    ContactInfo info = new ContactInfo();
+    info.name = ci.name;
+    info.type = ci.numberType;
+    info.label = ci.phoneLabel;
+    info.number = ci.phoneNumber;
+    info.normalizedNumber = ci.normalizedNumber;
+    info.photoUri = ci.contactDisplayPhotoUri;
+    info.userType = ci.userType;
+
+    CachedContactInfo cacheInfo = lookupService.buildCachedContactInfo(info);
+    cacheInfo.setLookupKey(ci.lookupKeyOrNull);
+    return cacheInfo;
+  }
+
+  public static boolean isVoiceMailNumber(Context context, DialerCall call) {
+    if (ContextCompat.checkSelfPermission(context, permission.READ_PHONE_STATE)
+        != PackageManager.PERMISSION_GRANTED) {
+      return false;
+    }
+    return TelecomUtil.isVoicemailNumber(context, call.getAccountHandle(), call.getNumber());
+  }
+
+  /**
+   * Handles certain "corner cases" for CNAP. When we receive weird phone numbers from the network
+   * to indicate different number presentations, convert them to expected number and presentation
+   * values within the CallerInfo object.
+   *
+   * @param number number we use to verify if we are in a corner case
+   * @param presentation presentation value used to verify if we are in a corner case
+   * @return the new String that should be used for the phone number
+   */
+  /* package */
+  static String modifyForSpecialCnapCases(
+      Context context, CallerInfo ci, String number, int presentation) {
+    // Obviously we return number if ci == null, but still return number if
+    // number == null, because in these cases the correct string will still be
+    // displayed/logged after this function returns based on the presentation value.
+    if (ci == null || number == null) {
+      return number;
+    }
+
+    LogUtil.d(
+        "CallerInfoUtils.modifyForSpecialCnapCases",
+        "modifyForSpecialCnapCases: initially, number="
+            + toLogSafePhoneNumber(number)
+            + ", presentation="
+            + presentation
+            + " ci "
+            + ci);
+
+    // "ABSENT NUMBER" is a possible value we could get from the network as the
+    // phone number, so if this happens, change it to "Unknown" in the CallerInfo
+    // and fix the presentation to be the same.
+    final String[] absentNumberValues = context.getResources().getStringArray(R.array.absent_num);
+    if (Arrays.asList(absentNumberValues).contains(number)
+        && presentation == TelecomManager.PRESENTATION_ALLOWED) {
+      number = context.getString(R.string.unknown);
+      ci.numberPresentation = TelecomManager.PRESENTATION_UNKNOWN;
+    }
+
+    // Check for other special "corner cases" for CNAP and fix them similarly. Corner
+    // cases only apply if we received an allowed presentation from the network, so check
+    // if we think we have an allowed presentation, or if the CallerInfo presentation doesn't
+    // match the presentation passed in for verification (meaning we changed it previously
+    // because it's a corner case and we're being called from a different entry point).
+    if (ci.numberPresentation == TelecomManager.PRESENTATION_ALLOWED
+        || (ci.numberPresentation != presentation
+            && presentation == TelecomManager.PRESENTATION_ALLOWED)) {
+      // For all special strings, change number & numberPrentation.
+      if (isCnapSpecialCaseRestricted(number)) {
+        number = PhoneNumberHelper.getDisplayNameForRestrictedNumber(context).toString();
+        ci.numberPresentation = TelecomManager.PRESENTATION_RESTRICTED;
+      } else if (isCnapSpecialCaseUnknown(number)) {
+        number = context.getString(R.string.unknown);
+        ci.numberPresentation = TelecomManager.PRESENTATION_UNKNOWN;
+      }
+      LogUtil.d(
+          "CallerInfoUtils.modifyForSpecialCnapCases",
+          "SpecialCnap: number="
+              + toLogSafePhoneNumber(number)
+              + "; presentation now="
+              + ci.numberPresentation);
+    }
+    LogUtil.d(
+        "CallerInfoUtils.modifyForSpecialCnapCases",
+        "returning number string=" + toLogSafePhoneNumber(number));
+    return number;
+  }
+
+  private static boolean isCnapSpecialCaseRestricted(String n) {
+    return n.equals("PRIVATE") || n.equals("P") || n.equals("RES") || n.equals("PRIVATENUMBER");
+  }
+
+  private static boolean isCnapSpecialCaseUnknown(String n) {
+    return n.equals("UNAVAILABLE") || n.equals("UNKNOWN") || n.equals("UNA") || n.equals("U");
+  }
+
+  /* package */
+  static String toLogSafePhoneNumber(String number) {
+    // For unknown number, log empty string.
+    if (number == null) {
+      return "";
+    }
+
+    // Todo: Figure out an equivalent for VDBG
+    if (false) {
+      // When VDBG is true we emit PII.
+      return number;
+    }
+
+    // Do exactly same thing as Uri#toSafeString() does, which will enable us to compare
+    // sanitized phone numbers.
+    StringBuilder builder = new StringBuilder();
+    for (int i = 0; i < number.length(); i++) {
+      char c = number.charAt(i);
+      if (c == '-' || c == '@' || c == '.' || c == '&') {
+        builder.append(c);
+      } else {
+        builder.append('x');
+      }
+    }
+    return builder.toString();
+  }
+
+  /**
+   * Send a notification using a {@link ContactLoader} to inform the sync adapter that we are
+   * viewing a particular contact, so that it can download the high-res photo.
+   */
+  public static void sendViewNotification(Context context, Uri contactUri) {
+    final ContactLoader loader =
+        new ContactLoader(context, contactUri, true /* postViewNotification */);
+    loader.registerListener(
+        0,
+        new OnLoadCompleteListener<Contact>() {
+          @Override
+          public void onLoadComplete(Loader<Contact> loader, Contact contact) {
+            try {
+              loader.reset();
+            } catch (RuntimeException e) {
+              LogUtil.e("CallerInfoUtils.onLoadComplete", "Error resetting loader", e);
+            }
+          }
+        });
+    loader.startLoading();
+  }
+}
diff --git a/java/com/android/incallui/ConferenceManagerFragment.java b/java/com/android/incallui/ConferenceManagerFragment.java
new file mode 100644
index 0000000..8696bb8
--- /dev/null
+++ b/java/com/android/incallui/ConferenceManagerFragment.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ListView;
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.ScreenEvent;
+import com.android.incallui.ConferenceManagerPresenter.ConferenceManagerUi;
+import com.android.incallui.baseui.BaseFragment;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import java.util.List;
+
+/** Fragment that allows the user to manage a conference call. */
+public class ConferenceManagerFragment
+    extends BaseFragment<ConferenceManagerPresenter, ConferenceManagerUi>
+    implements ConferenceManagerPresenter.ConferenceManagerUi {
+
+  private ListView mConferenceParticipantList;
+  private ContactPhotoManager mContactPhotoManager;
+  private ConferenceParticipantListAdapter mConferenceParticipantListAdapter;
+
+  @Override
+  public ConferenceManagerPresenter createPresenter() {
+    return new ConferenceManagerPresenter();
+  }
+
+  @Override
+  public ConferenceManagerPresenter.ConferenceManagerUi getUi() {
+    return this;
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    if (savedInstanceState != null) {
+      Logger.get(getContext()).logScreenView(ScreenEvent.Type.CONFERENCE_MANAGEMENT, getActivity());
+    }
+  }
+
+  @Override
+  public View onCreateView(
+      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    final View parent = inflater.inflate(R.layout.conference_manager_fragment, container, false);
+
+    mConferenceParticipantList = (ListView) parent.findViewById(R.id.participantList);
+    mContactPhotoManager = ContactPhotoManager.getInstance(getActivity().getApplicationContext());
+
+    return parent;
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    final CallList calls = CallList.getInstance();
+    getPresenter().init(calls);
+    // Request focus on the list of participants for accessibility purposes.  This ensures
+    // that once the list of participants is shown, the first participant is announced.
+    mConferenceParticipantList.requestFocus();
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+  }
+
+  @Override
+  public boolean isFragmentVisible() {
+    return isVisible();
+  }
+
+  @Override
+  public void update(List<DialerCall> participants, boolean parentCanSeparate) {
+    if (mConferenceParticipantListAdapter == null) {
+      mConferenceParticipantListAdapter =
+          new ConferenceParticipantListAdapter(mConferenceParticipantList, mContactPhotoManager);
+
+      mConferenceParticipantList.setAdapter(mConferenceParticipantListAdapter);
+    }
+    mConferenceParticipantListAdapter.updateParticipants(participants, parentCanSeparate);
+  }
+
+  @Override
+  public void refreshCall(DialerCall call) {
+    mConferenceParticipantListAdapter.refreshCall(call);
+  }
+}
diff --git a/java/com/android/incallui/ConferenceManagerPresenter.java b/java/com/android/incallui/ConferenceManagerPresenter.java
new file mode 100644
index 0000000..226741d
--- /dev/null
+++ b/java/com/android/incallui/ConferenceManagerPresenter.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import com.android.incallui.ConferenceManagerPresenter.ConferenceManagerUi;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.baseui.Presenter;
+import com.android.incallui.baseui.Ui;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Logic for call buttons. */
+public class ConferenceManagerPresenter extends Presenter<ConferenceManagerUi>
+    implements InCallStateListener, InCallDetailsListener, IncomingCallListener {
+
+  @Override
+  public void onUiReady(ConferenceManagerUi ui) {
+    super.onUiReady(ui);
+
+    // register for call state changes last
+    InCallPresenter.getInstance().addListener(this);
+    InCallPresenter.getInstance().addIncomingCallListener(this);
+  }
+
+  @Override
+  public void onUiUnready(ConferenceManagerUi ui) {
+    super.onUiUnready(ui);
+
+    InCallPresenter.getInstance().removeListener(this);
+    InCallPresenter.getInstance().removeIncomingCallListener(this);
+  }
+
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    if (getUi().isFragmentVisible()) {
+      Log.v(this, "onStateChange" + newState);
+      if (newState == InCallState.INCALL) {
+        final DialerCall call = callList.getActiveOrBackgroundCall();
+        if (call != null && call.isConferenceCall()) {
+          Log.v(
+              this, "Number of existing calls is " + String.valueOf(call.getChildCallIds().size()));
+          update(callList);
+        } else {
+          InCallPresenter.getInstance().showConferenceCallManager(false);
+        }
+      } else {
+        InCallPresenter.getInstance().showConferenceCallManager(false);
+      }
+    }
+  }
+
+  @Override
+  public void onDetailsChanged(DialerCall call, android.telecom.Call.Details details) {
+    boolean canDisconnect =
+        details.can(android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE);
+    boolean canSeparate =
+        details.can(android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE);
+
+    if (call.can(android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE)
+            != canDisconnect
+        || call.can(android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE)
+            != canSeparate) {
+      getUi().refreshCall(call);
+    }
+
+    if (!details.can(android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE)) {
+      InCallPresenter.getInstance().showConferenceCallManager(false);
+    }
+  }
+
+  @Override
+  public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) {
+    // When incoming call exists, set conference ui invisible.
+    if (getUi().isFragmentVisible()) {
+      Log.d(this, "onIncomingCall()... Conference ui is showing, hide it.");
+      InCallPresenter.getInstance().showConferenceCallManager(false);
+    }
+  }
+
+  public void init(CallList callList) {
+    update(callList);
+  }
+
+  /**
+   * Updates the conference participant adapter.
+   *
+   * @param callList The callList.
+   */
+  private void update(CallList callList) {
+    // callList is non null, but getActiveOrBackgroundCall() may return null
+    final DialerCall currentCall = callList.getActiveOrBackgroundCall();
+    if (currentCall == null) {
+      return;
+    }
+
+    ArrayList<DialerCall> calls = new ArrayList<>(currentCall.getChildCallIds().size());
+    for (String callerId : currentCall.getChildCallIds()) {
+      calls.add(callList.getCallById(callerId));
+    }
+
+    Log.d(this, "Number of calls is " + String.valueOf(calls.size()));
+
+    // Users can split out a call from the conference call if either the active call or the
+    // holding call is empty. If both are filled, users can not split out another call.
+    final boolean hasActiveCall = (callList.getActiveCall() != null);
+    final boolean hasHoldingCall = (callList.getBackgroundCall() != null);
+    boolean canSeparate = !(hasActiveCall && hasHoldingCall);
+
+    getUi().update(calls, canSeparate);
+  }
+
+  public interface ConferenceManagerUi extends Ui {
+
+    boolean isFragmentVisible();
+
+    void update(List<DialerCall> participants, boolean parentCanSeparate);
+
+    void refreshCall(DialerCall call);
+  }
+}
diff --git a/java/com/android/incallui/ConferenceParticipantListAdapter.java b/java/com/android/incallui/ConferenceParticipantListAdapter.java
new file mode 100644
index 0000000..72c0fcd
--- /dev/null
+++ b/java/com/android/incallui/ConferenceParticipantListAdapter.java
@@ -0,0 +1,523 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.net.Uri;
+import android.support.annotation.Nullable;
+import android.support.v4.util.ArrayMap;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.util.ArraySet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.ContactPhotoManager.DefaultImageRequest;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/** Adapter for a ListView containing conference call participant information. */
+public class ConferenceParticipantListAdapter extends BaseAdapter {
+
+  /** The ListView containing the participant information. */
+  private final ListView mListView;
+  /** Hashmap to make accessing participant info by call Id faster. */
+  private final Map<String, ParticipantInfo> mParticipantsByCallId = new ArrayMap<>();
+  /** ContactsPreferences used to lookup displayName preferences */
+  @Nullable private final ContactsPreferences mContactsPreferences;
+  /** Contact photo manager to retrieve cached contact photo information. */
+  private final ContactPhotoManager mContactPhotoManager;
+  /** Listener used to handle tap of the "disconnect' button for a participant. */
+  private View.OnClickListener mDisconnectListener =
+      new View.OnClickListener() {
+        @Override
+        public void onClick(View view) {
+          DialerCall call = getCallFromView(view);
+          LogUtil.i(
+              "ConferenceParticipantListAdapter.mDisconnectListener.onClick", "call: " + call);
+          if (call != null) {
+            call.disconnect();
+          }
+        }
+      };
+  /** Listener used to handle tap of the "separate' button for a participant. */
+  private View.OnClickListener mSeparateListener =
+      new View.OnClickListener() {
+        @Override
+        public void onClick(View view) {
+          DialerCall call = getCallFromView(view);
+          LogUtil.i("ConferenceParticipantListAdapter.mSeparateListener.onClick", "call: " + call);
+          if (call != null) {
+            call.splitFromConference();
+          }
+        }
+      };
+  /** The conference participants to show in the ListView. */
+  private List<ParticipantInfo> mConferenceParticipants = new ArrayList<>();
+  /** {@code True} if the conference parent supports separating calls from the conference. */
+  private boolean mParentCanSeparate;
+
+  /**
+   * Creates an instance of the ConferenceParticipantListAdapter.
+   *
+   * @param listView The listview.
+   * @param contactPhotoManager The contact photo manager, used to load contact photos.
+   */
+  public ConferenceParticipantListAdapter(
+      ListView listView, ContactPhotoManager contactPhotoManager) {
+
+    mListView = listView;
+    mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(getContext());
+    mContactPhotoManager = contactPhotoManager;
+  }
+
+  /**
+   * Updates the adapter with the new conference participant information provided.
+   *
+   * @param conferenceParticipants The list of conference participants.
+   * @param parentCanSeparate {@code True} if the parent supports separating calls from the
+   *     conference.
+   */
+  public void updateParticipants(
+      List<DialerCall> conferenceParticipants, boolean parentCanSeparate) {
+    if (mContactsPreferences != null) {
+      mContactsPreferences.refreshValue(ContactsPreferences.DISPLAY_ORDER_KEY);
+      mContactsPreferences.refreshValue(ContactsPreferences.SORT_ORDER_KEY);
+    }
+    mParentCanSeparate = parentCanSeparate;
+    updateParticipantInfo(conferenceParticipants);
+  }
+
+  /**
+   * Determines the number of participants in the conference.
+   *
+   * @return The number of participants.
+   */
+  @Override
+  public int getCount() {
+    return mConferenceParticipants.size();
+  }
+
+  /**
+   * Retrieves an item from the list of participants.
+   *
+   * @param position Position of the item whose data we want within the adapter's data set.
+   * @return The {@link ParticipantInfo}.
+   */
+  @Override
+  public Object getItem(int position) {
+    return mConferenceParticipants.get(position);
+  }
+
+  /**
+   * Retreives the adapter-specific item id for an item at a specified position.
+   *
+   * @param position The position of the item within the adapter's data set whose row id we want.
+   * @return The item id.
+   */
+  @Override
+  public long getItemId(int position) {
+    return position;
+  }
+
+  /**
+   * Refreshes call information for the call passed in.
+   *
+   * @param call The new call information.
+   */
+  public void refreshCall(DialerCall call) {
+    String callId = call.getId();
+
+    if (mParticipantsByCallId.containsKey(callId)) {
+      ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+      participantInfo.setCall(call);
+      refreshView(callId);
+    }
+  }
+
+  private Context getContext() {
+    return mListView.getContext();
+  }
+
+  /**
+   * Attempts to refresh the view for the specified call ID. This ensures the contact info and photo
+   * loaded from cache are updated.
+   *
+   * @param callId The call id.
+   */
+  private void refreshView(String callId) {
+    int first = mListView.getFirstVisiblePosition();
+    int last = mListView.getLastVisiblePosition();
+
+    for (int position = 0; position <= last - first; position++) {
+      View view = mListView.getChildAt(position);
+      String rowCallId = (String) view.getTag();
+      if (rowCallId.equals(callId)) {
+        getView(position + first, view, mListView);
+        break;
+      }
+    }
+  }
+
+  /**
+   * Creates or populates an existing conference participant row.
+   *
+   * @param position The position of the item within the adapter's data set of the item whose view
+   *     we want.
+   * @param convertView The old view to reuse, if possible.
+   * @param parent The parent that this view will eventually be attached to
+   * @return The populated view.
+   */
+  @Override
+  public View getView(int position, View convertView, ViewGroup parent) {
+    // Make sure we have a valid convertView to start with
+    final View result =
+        convertView == null
+            ? LayoutInflater.from(parent.getContext())
+                .inflate(R.layout.caller_in_conference, parent, false)
+            : convertView;
+
+    ParticipantInfo participantInfo = mConferenceParticipants.get(position);
+    DialerCall call = participantInfo.getCall();
+    ContactCacheEntry contactCache = participantInfo.getContactCacheEntry();
+
+    final ContactInfoCache cache = ContactInfoCache.getInstance(getContext());
+
+    // If a cache lookup has not yet been performed to retrieve the contact information and
+    // photo, do it now.
+    if (!participantInfo.isCacheLookupComplete()) {
+      cache.findInfo(
+          participantInfo.getCall(),
+          participantInfo.getCall().getState() == DialerCall.State.INCOMING,
+          new ContactLookupCallback(this));
+    }
+
+    boolean thisRowCanSeparate =
+        mParentCanSeparate
+            && call.can(android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE);
+    boolean thisRowCanDisconnect =
+        call.can(android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE);
+
+    setCallerInfoForRow(
+        result,
+        contactCache.namePrimary,
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactCache.namePrimary, contactCache.nameAlternative, mContactsPreferences),
+        contactCache.number,
+        contactCache.label,
+        contactCache.lookupKey,
+        contactCache.displayPhotoUri,
+        thisRowCanSeparate,
+        thisRowCanDisconnect);
+
+    // Tag the row in the conference participant list with the call id to make it easier to
+    // find calls when contact cache information is loaded.
+    result.setTag(call.getId());
+
+    return result;
+  }
+
+  /**
+   * Replaces the contact info for a participant and triggers a refresh of the UI.
+   *
+   * @param callId The call id.
+   * @param entry The new contact info.
+   */
+  /* package */ void updateContactInfo(String callId, ContactCacheEntry entry) {
+    if (mParticipantsByCallId.containsKey(callId)) {
+      ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+      participantInfo.setContactCacheEntry(entry);
+      participantInfo.setCacheLookupComplete(true);
+      refreshView(callId);
+    }
+  }
+
+  /**
+   * Sets the caller information for a row in the conference participant list.
+   *
+   * @param view The view to set the details on.
+   * @param callerName The participant's name.
+   * @param callerNumber The participant's phone number.
+   * @param callerNumberType The participant's phone number typ.e
+   * @param lookupKey The lookup key for the participant (for photo lookup).
+   * @param photoUri The URI of the contact photo.
+   * @param thisRowCanSeparate {@code True} if this participant can separate from the conference.
+   * @param thisRowCanDisconnect {@code True} if this participant can be disconnected.
+   */
+  private void setCallerInfoForRow(
+      View view,
+      String callerName,
+      String preferredName,
+      String callerNumber,
+      String callerNumberType,
+      String lookupKey,
+      Uri photoUri,
+      boolean thisRowCanSeparate,
+      boolean thisRowCanDisconnect) {
+
+    final ImageView photoView = (ImageView) view.findViewById(R.id.callerPhoto);
+    final TextView nameTextView = (TextView) view.findViewById(R.id.conferenceCallerName);
+    final TextView numberTextView = (TextView) view.findViewById(R.id.conferenceCallerNumber);
+    final TextView numberTypeTextView =
+        (TextView) view.findViewById(R.id.conferenceCallerNumberType);
+    final View endButton = view.findViewById(R.id.conferenceCallerDisconnect);
+    final View separateButton = view.findViewById(R.id.conferenceCallerSeparate);
+
+    endButton.setVisibility(thisRowCanDisconnect ? View.VISIBLE : View.GONE);
+    if (thisRowCanDisconnect) {
+      endButton.setOnClickListener(mDisconnectListener);
+    } else {
+      endButton.setOnClickListener(null);
+    }
+
+    separateButton.setVisibility(thisRowCanSeparate ? View.VISIBLE : View.GONE);
+    if (thisRowCanSeparate) {
+      separateButton.setOnClickListener(mSeparateListener);
+    } else {
+      separateButton.setOnClickListener(null);
+    }
+
+    DefaultImageRequest imageRequest =
+        (photoUri != null)
+            ? null
+            : new DefaultImageRequest(callerName, lookupKey, true /* isCircularPhoto */);
+
+    mContactPhotoManager.loadDirectoryPhoto(photoView, photoUri, false, true, imageRequest);
+
+    // set the caller name
+    nameTextView.setText(preferredName);
+
+    // set the caller number in subscript, or make the field disappear.
+    if (TextUtils.isEmpty(callerNumber)) {
+      numberTextView.setVisibility(View.GONE);
+      numberTypeTextView.setVisibility(View.GONE);
+    } else {
+      numberTextView.setVisibility(View.VISIBLE);
+      numberTextView.setText(
+          PhoneNumberUtilsCompat.createTtsSpannable(
+              BidiFormatter.getInstance().unicodeWrap(callerNumber, TextDirectionHeuristics.LTR)));
+      numberTypeTextView.setVisibility(View.VISIBLE);
+      numberTypeTextView.setText(callerNumberType);
+    }
+  }
+
+  /**
+   * Updates the participant info list which is bound to the ListView. Stores the call and contact
+   * info for all entries. The list is sorted alphabetically by participant name.
+   *
+   * @param conferenceParticipants The calls which make up the conference participants.
+   */
+  private void updateParticipantInfo(List<DialerCall> conferenceParticipants) {
+    final ContactInfoCache cache = ContactInfoCache.getInstance(getContext());
+    boolean newParticipantAdded = false;
+    Set<String> newCallIds = new ArraySet<>(conferenceParticipants.size());
+
+    // Update or add conference participant info.
+    for (DialerCall call : conferenceParticipants) {
+      String callId = call.getId();
+      newCallIds.add(callId);
+      ContactCacheEntry contactCache = cache.getInfo(callId);
+      if (contactCache == null) {
+        contactCache =
+            ContactInfoCache.buildCacheEntryFromCall(
+                getContext(), call, call.getState() == DialerCall.State.INCOMING);
+      }
+
+      if (mParticipantsByCallId.containsKey(callId)) {
+        ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+        participantInfo.setCall(call);
+        participantInfo.setContactCacheEntry(contactCache);
+      } else {
+        newParticipantAdded = true;
+        ParticipantInfo participantInfo = new ParticipantInfo(call, contactCache);
+        mConferenceParticipants.add(participantInfo);
+        mParticipantsByCallId.put(call.getId(), participantInfo);
+      }
+    }
+
+    // Remove any participants that no longer exist.
+    Iterator<Map.Entry<String, ParticipantInfo>> it = mParticipantsByCallId.entrySet().iterator();
+    while (it.hasNext()) {
+      Map.Entry<String, ParticipantInfo> entry = it.next();
+      String existingCallId = entry.getKey();
+      if (!newCallIds.contains(existingCallId)) {
+        ParticipantInfo existingInfo = entry.getValue();
+        mConferenceParticipants.remove(existingInfo);
+        it.remove();
+      }
+    }
+
+    if (newParticipantAdded) {
+      // Sort the list of participants by contact name.
+      sortParticipantList();
+    }
+    notifyDataSetChanged();
+  }
+
+  /** Sorts the participant list by contact name. */
+  private void sortParticipantList() {
+    Collections.sort(
+        mConferenceParticipants,
+        new Comparator<ParticipantInfo>() {
+          @Override
+          public int compare(ParticipantInfo p1, ParticipantInfo p2) {
+            // Contact names might be null, so replace with empty string.
+            ContactCacheEntry c1 = p1.getContactCacheEntry();
+            String p1Name =
+                ContactDisplayUtils.getPreferredSortName(
+                    c1.namePrimary, c1.nameAlternative, mContactsPreferences);
+            p1Name = p1Name != null ? p1Name : "";
+
+            ContactCacheEntry c2 = p2.getContactCacheEntry();
+            String p2Name =
+                ContactDisplayUtils.getPreferredSortName(
+                    c2.namePrimary, c2.nameAlternative, mContactsPreferences);
+            p2Name = p2Name != null ? p2Name : "";
+
+            return p1Name.compareToIgnoreCase(p2Name);
+          }
+        });
+  }
+
+  private DialerCall getCallFromView(View view) {
+    View parent = (View) view.getParent();
+    String callId = (String) parent.getTag();
+    return CallList.getInstance().getCallById(callId);
+  }
+
+  /**
+   * Callback class used when making requests to the {@link ContactInfoCache} to resolve contact
+   * info and contact photos for conference participants.
+   */
+  public static class ContactLookupCallback implements ContactInfoCache.ContactInfoCacheCallback {
+
+    private final WeakReference<ConferenceParticipantListAdapter> mListAdapter;
+
+    public ContactLookupCallback(ConferenceParticipantListAdapter listAdapter) {
+      mListAdapter = new WeakReference<>(listAdapter);
+    }
+
+    /**
+     * Called when contact info has been resolved.
+     *
+     * @param callId The call id.
+     * @param entry The new contact information.
+     */
+    @Override
+    public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+      update(callId, entry);
+    }
+
+    /**
+     * Called when contact photo has been loaded into the cache.
+     *
+     * @param callId The call id.
+     * @param entry The new contact information.
+     */
+    @Override
+    public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+      update(callId, entry);
+    }
+
+    /**
+     * Updates the contact information for a participant.
+     *
+     * @param callId The call id.
+     * @param entry The new contact information.
+     */
+    private void update(String callId, ContactCacheEntry entry) {
+      ConferenceParticipantListAdapter listAdapter = mListAdapter.get();
+      if (listAdapter != null) {
+        listAdapter.updateContactInfo(callId, entry);
+      }
+    }
+  }
+
+  /**
+   * Internal class which represents a participant. Includes a reference to the {@link DialerCall}
+   * and the corresponding {@link ContactCacheEntry} for the participant.
+   */
+  private static class ParticipantInfo {
+
+    private DialerCall mCall;
+    private ContactCacheEntry mContactCacheEntry;
+    private boolean mCacheLookupComplete = false;
+
+    public ParticipantInfo(DialerCall call, ContactCacheEntry contactCacheEntry) {
+      mCall = call;
+      mContactCacheEntry = contactCacheEntry;
+    }
+
+    public DialerCall getCall() {
+      return mCall;
+    }
+
+    public void setCall(DialerCall call) {
+      mCall = call;
+    }
+
+    public ContactCacheEntry getContactCacheEntry() {
+      return mContactCacheEntry;
+    }
+
+    public void setContactCacheEntry(ContactCacheEntry entry) {
+      mContactCacheEntry = entry;
+    }
+
+    public boolean isCacheLookupComplete() {
+      return mCacheLookupComplete;
+    }
+
+    public void setCacheLookupComplete(boolean cacheLookupComplete) {
+      mCacheLookupComplete = cacheLookupComplete;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (o instanceof ParticipantInfo) {
+        ParticipantInfo p = (ParticipantInfo) o;
+        return Objects.equals(p.getCall().getId(), mCall.getId());
+      }
+      return false;
+    }
+
+    @Override
+    public int hashCode() {
+      return mCall.getId().hashCode();
+    }
+  }
+}
diff --git a/java/com/android/incallui/ContactInfoCache.java b/java/com/android/incallui/ContactInfoCache.java
new file mode 100644
index 0000000..4d4d94a
--- /dev/null
+++ b/java/com/android/incallui/ContactInfoCache.java
@@ -0,0 +1,759 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.DisplayNameSources;
+import android.support.annotation.AnyThread;
+import android.support.annotation.MainThread;
+import android.support.annotation.NonNull;
+import android.support.annotation.WorkerThread;
+import android.support.v4.os.UserManagerCompat;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.util.ArrayMap;
+import android.util.ArraySet;
+import com.android.contacts.common.ContactsUtils;
+import com.android.dialer.common.Assert;
+import com.android.dialer.logging.nano.ContactLookupResult;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService;
+import com.android.dialer.phonenumbercache.CachedNumberLookupService.CachedContactInfo;
+import com.android.dialer.phonenumbercache.ContactInfo;
+import com.android.dialer.phonenumbercache.PhoneNumberCache;
+import com.android.dialer.phonenumberutil.PhoneNumberHelper;
+import com.android.dialer.util.MoreStrings;
+import com.android.incallui.CallerInfoAsyncQuery.OnQueryCompleteListener;
+import com.android.incallui.ContactsAsyncHelper.OnImageLoadCompleteListener;
+import com.android.incallui.bindings.PhoneNumberService;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.incall.protocol.ContactPhotoType;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Class responsible for querying Contact Information for DialerCall objects. Can perform
+ * asynchronous requests to the Contact Provider for information as well as respond synchronously
+ * for any data that it currently has cached from previous queries. This class always gets called
+ * from the UI thread so it does not need thread protection.
+ */
+public class ContactInfoCache implements OnImageLoadCompleteListener {
+
+  private static final String TAG = ContactInfoCache.class.getSimpleName();
+  private static final int TOKEN_UPDATE_PHOTO_FOR_CALL_STATE = 0;
+  private static ContactInfoCache sCache = null;
+  private final Context mContext;
+  private final PhoneNumberService mPhoneNumberService;
+  // Cache info map needs to be thread-safe since it could be modified by both main thread and
+  // worker thread.
+  private final Map<String, ContactCacheEntry> mInfoMap = new ConcurrentHashMap<>();
+  private final Map<String, Set<ContactInfoCacheCallback>> mCallBacks = new ArrayMap<>();
+  private Drawable mDefaultContactPhotoDrawable;
+  private Drawable mConferencePhotoDrawable;
+
+  private ContactInfoCache(Context context) {
+    mContext = context;
+    mPhoneNumberService = Bindings.get(context).newPhoneNumberService(context);
+  }
+
+  public static synchronized ContactInfoCache getInstance(Context mContext) {
+    if (sCache == null) {
+      sCache = new ContactInfoCache(mContext.getApplicationContext());
+    }
+    return sCache;
+  }
+
+  public static ContactCacheEntry buildCacheEntryFromCall(
+      Context context, DialerCall call, boolean isIncoming) {
+    final ContactCacheEntry entry = new ContactCacheEntry();
+
+    // TODO: get rid of caller info.
+    final CallerInfo info = CallerInfoUtils.buildCallerInfo(context, call);
+    ContactInfoCache.populateCacheEntry(
+        context, info, entry, call.getNumberPresentation(), isIncoming);
+    return entry;
+  }
+
+  /** Populate a cache entry from a call (which got converted into a caller info). */
+  public static void populateCacheEntry(
+      @NonNull Context context,
+      @NonNull CallerInfo info,
+      @NonNull ContactCacheEntry cce,
+      int presentation,
+      boolean isIncoming) {
+    Objects.requireNonNull(info);
+    String displayName = null;
+    String displayNumber = null;
+    String displayLocation = null;
+    String label = null;
+    boolean isSipCall = false;
+
+    // It appears that there is a small change in behaviour with the
+    // PhoneUtils' startGetCallerInfo whereby if we query with an
+    // empty number, we will get a valid CallerInfo object, but with
+    // fields that are all null, and the isTemporary boolean input
+    // parameter as true.
+
+    // In the past, we would see a NULL callerinfo object, but this
+    // ends up causing null pointer exceptions elsewhere down the
+    // line in other cases, so we need to make this fix instead. It
+    // appears that this was the ONLY call to PhoneUtils
+    // .getCallerInfo() that relied on a NULL CallerInfo to indicate
+    // an unknown contact.
+
+    // Currently, info.phoneNumber may actually be a SIP address, and
+    // if so, it might sometimes include the "sip:" prefix. That
+    // prefix isn't really useful to the user, though, so strip it off
+    // if present. (For any other URI scheme, though, leave the
+    // prefix alone.)
+    // TODO: It would be cleaner for CallerInfo to explicitly support
+    // SIP addresses instead of overloading the "phoneNumber" field.
+    // Then we could remove this hack, and instead ask the CallerInfo
+    // for a "user visible" form of the SIP address.
+    String number = info.phoneNumber;
+
+    if (!TextUtils.isEmpty(number)) {
+      isSipCall = PhoneNumberHelper.isUriNumber(number);
+      if (number.startsWith("sip:")) {
+        number = number.substring(4);
+      }
+    }
+
+    if (TextUtils.isEmpty(info.name)) {
+      // No valid "name" in the CallerInfo, so fall back to
+      // something else.
+      // (Typically, we promote the phone number up to the "name" slot
+      // onscreen, and possibly display a descriptive string in the
+      // "number" slot.)
+      if (TextUtils.isEmpty(number)) {
+        // No name *or* number! Display a generic "unknown" string
+        // (or potentially some other default based on the presentation.)
+        displayName = getPresentationString(context, presentation, info.callSubject);
+        Log.d(TAG, "  ==> no name *or* number! displayName = " + displayName);
+      } else if (presentation != TelecomManager.PRESENTATION_ALLOWED) {
+        // This case should never happen since the network should never send a phone #
+        // AND a restricted presentation. However we leave it here in case of weird
+        // network behavior
+        displayName = getPresentationString(context, presentation, info.callSubject);
+        Log.d(TAG, "  ==> presentation not allowed! displayName = " + displayName);
+      } else if (!TextUtils.isEmpty(info.cnapName)) {
+        // No name, but we do have a valid CNAP name, so use that.
+        displayName = info.cnapName;
+        info.name = info.cnapName;
+        displayNumber = PhoneNumberHelper.formatNumber(number, context);
+        Log.d(
+            TAG,
+            "  ==> cnapName available: displayName '"
+                + displayName
+                + "', displayNumber '"
+                + displayNumber
+                + "'");
+      } else {
+        // No name; all we have is a number. This is the typical
+        // case when an incoming call doesn't match any contact,
+        // or if you manually dial an outgoing number using the
+        // dialpad.
+        displayNumber = PhoneNumberHelper.formatNumber(number, context);
+
+        // Display a geographical description string if available
+        // (but only for incoming calls.)
+        if (isIncoming) {
+          // TODO (CallerInfoAsyncQuery cleanup): Fix the CallerInfo
+          // query to only do the geoDescription lookup in the first
+          // place for incoming calls.
+          displayLocation = info.geoDescription; // may be null
+          Log.d(TAG, "Geodescrption: " + info.geoDescription);
+        }
+
+        Log.d(
+            TAG,
+            "  ==>  no name; falling back to number:"
+                + " displayNumber '"
+                + Log.pii(displayNumber)
+                + "', displayLocation '"
+                + displayLocation
+                + "'");
+      }
+    } else {
+      // We do have a valid "name" in the CallerInfo. Display that
+      // in the "name" slot, and the phone number in the "number" slot.
+      if (presentation != TelecomManager.PRESENTATION_ALLOWED) {
+        // This case should never happen since the network should never send a name
+        // AND a restricted presentation. However we leave it here in case of weird
+        // network behavior
+        displayName = getPresentationString(context, presentation, info.callSubject);
+        Log.d(
+            TAG,
+            "  ==> valid name, but presentation not allowed!" + " displayName = " + displayName);
+      } else {
+        // Causes cce.namePrimary to be set as info.name below. CallCardPresenter will
+        // later determine whether to use the name or nameAlternative when presenting
+        displayName = info.name;
+        cce.nameAlternative = info.nameAlternative;
+        displayNumber = PhoneNumberHelper.formatNumber(number, context);
+        label = info.phoneLabel;
+        Log.d(
+            TAG,
+            "  ==>  name is present in CallerInfo: displayName '"
+                + displayName
+                + "', displayNumber '"
+                + displayNumber
+                + "'");
+      }
+    }
+
+    cce.namePrimary = displayName;
+    cce.number = displayNumber;
+    cce.location = displayLocation;
+    cce.label = label;
+    cce.isSipCall = isSipCall;
+    cce.userType = info.userType;
+
+    if (info.contactExists) {
+      cce.contactLookupResult = ContactLookupResult.Type.LOCAL_CONTACT;
+    }
+  }
+
+  /** Gets name strings based on some special presentation modes and the associated custom label. */
+  private static String getPresentationString(
+      Context context, int presentation, String customLabel) {
+    String name = context.getString(R.string.unknown);
+    if (!TextUtils.isEmpty(customLabel)
+        && ((presentation == TelecomManager.PRESENTATION_UNKNOWN)
+            || (presentation == TelecomManager.PRESENTATION_RESTRICTED))) {
+      name = customLabel;
+      return name;
+    } else {
+      if (presentation == TelecomManager.PRESENTATION_RESTRICTED) {
+        name = PhoneNumberHelper.getDisplayNameForRestrictedNumber(context).toString();
+      } else if (presentation == TelecomManager.PRESENTATION_PAYPHONE) {
+        name = context.getString(R.string.payphone);
+      }
+    }
+    return name;
+  }
+
+  public ContactCacheEntry getInfo(String callId) {
+    return mInfoMap.get(callId);
+  }
+
+  public void maybeInsertCnapInformationIntoCache(
+      Context context, final DialerCall call, final CallerInfo info) {
+    final CachedNumberLookupService cachedNumberLookupService =
+        PhoneNumberCache.get(context).getCachedNumberLookupService();
+    if (!UserManagerCompat.isUserUnlocked(context)) {
+      Log.i(TAG, "User locked, not inserting cnap info into cache");
+      return;
+    }
+    if (cachedNumberLookupService == null
+        || TextUtils.isEmpty(info.cnapName)
+        || mInfoMap.get(call.getId()) != null) {
+      return;
+    }
+    final Context applicationContext = context.getApplicationContext();
+    Log.i(TAG, "Found contact with CNAP name - inserting into cache");
+    new AsyncTask<Void, Void, Void>() {
+      @Override
+      protected Void doInBackground(Void... params) {
+        ContactInfo contactInfo = new ContactInfo();
+        CachedContactInfo cacheInfo = cachedNumberLookupService.buildCachedContactInfo(contactInfo);
+        cacheInfo.setSource(CachedContactInfo.SOURCE_TYPE_CNAP, "CNAP", 0);
+        contactInfo.name = info.cnapName;
+        contactInfo.number = call.getNumber();
+        contactInfo.type = ContactsContract.CommonDataKinds.Phone.TYPE_MAIN;
+        try {
+          final JSONObject contactRows =
+              new JSONObject()
+                  .put(
+                      Phone.CONTENT_ITEM_TYPE,
+                      new JSONObject()
+                          .put(Phone.NUMBER, contactInfo.number)
+                          .put(Phone.TYPE, Phone.TYPE_MAIN));
+          final String jsonString =
+              new JSONObject()
+                  .put(Contacts.DISPLAY_NAME, contactInfo.name)
+                  .put(Contacts.DISPLAY_NAME_SOURCE, DisplayNameSources.STRUCTURED_NAME)
+                  .put(Contacts.CONTENT_ITEM_TYPE, contactRows)
+                  .toString();
+          cacheInfo.setLookupKey(jsonString);
+        } catch (JSONException e) {
+          Log.w(TAG, "Creation of lookup key failed when caching CNAP information");
+        }
+        cachedNumberLookupService.addContact(applicationContext, cacheInfo);
+        return null;
+      }
+    }.execute();
+  }
+
+  /**
+   * Requests contact data for the DialerCall object passed in. Returns the data through callback.
+   * If callback is null, no response is made, however the query is still performed and cached.
+   *
+   * @param callback The function to call back when the call is found. Can be null.
+   */
+  @MainThread
+  public void findInfo(
+      @NonNull final DialerCall call,
+      final boolean isIncoming,
+      @NonNull ContactInfoCacheCallback callback) {
+    Assert.isMainThread();
+    Objects.requireNonNull(callback);
+
+    final String callId = call.getId();
+    final ContactCacheEntry cacheEntry = mInfoMap.get(callId);
+    Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+
+    // If we have a previously obtained intermediate result return that now
+    if (cacheEntry != null) {
+      Log.d(
+          TAG,
+          "Contact lookup. In memory cache hit; lookup "
+              + (callBacks == null ? "complete" : "still running"));
+      callback.onContactInfoComplete(callId, cacheEntry);
+      // If no other callbacks are in flight, we're done.
+      if (callBacks == null) {
+        return;
+      }
+    }
+
+    // If the entry already exists, add callback
+    if (callBacks != null) {
+      callBacks.add(callback);
+      return;
+    }
+    Log.d(TAG, "Contact lookup. In memory cache miss; searching provider.");
+    // New lookup
+    callBacks = new ArraySet<>();
+    callBacks.add(callback);
+    mCallBacks.put(callId, callBacks);
+
+    /**
+     * Performs a query for caller information. Save any immediate data we get from the query. An
+     * asynchronous query may also be made for any data that we do not already have. Some queries,
+     * such as those for voicemail and emergency call information, will not perform an additional
+     * asynchronous query.
+     */
+    final CallerInfo callerInfo =
+        CallerInfoUtils.getCallerInfoForCall(
+            mContext,
+            call,
+            new DialerCallCookieWrapper(callId, call.getNumberPresentation()),
+            new FindInfoCallback(isIncoming));
+
+    updateCallerInfoInCacheOnAnyThread(
+        callId, call.getNumberPresentation(), callerInfo, isIncoming, false);
+    sendInfoNotifications(callId, mInfoMap.get(callId));
+  }
+
+  @AnyThread
+  private void updateCallerInfoInCacheOnAnyThread(
+      String callId,
+      int numberPresentation,
+      CallerInfo callerInfo,
+      boolean isIncoming,
+      boolean didLocalLookup) {
+    int presentationMode = numberPresentation;
+    if (callerInfo.contactExists
+        || callerInfo.isEmergencyNumber()
+        || callerInfo.isVoiceMailNumber()) {
+      presentationMode = TelecomManager.PRESENTATION_ALLOWED;
+    }
+
+    synchronized (mInfoMap) {
+      ContactCacheEntry cacheEntry = mInfoMap.get(callId);
+      // Ensure we always have a cacheEntry. Replace the existing entry if
+      // it has no name or if we found a local contact.
+      if (cacheEntry == null
+          || TextUtils.isEmpty(cacheEntry.namePrimary)
+          || callerInfo.contactExists) {
+        cacheEntry = buildEntry(mContext, callerInfo, presentationMode, isIncoming);
+        mInfoMap.put(callId, cacheEntry);
+      }
+      if (didLocalLookup) {
+        // Before issuing a request for more data from other services, we only check that the
+        // contact wasn't found in the local DB.  We don't check the if the cache entry already
+        // has a name because we allow overriding cnap data with data from other services.
+        if (!callerInfo.contactExists && mPhoneNumberService != null) {
+          Log.d(TAG, "Contact lookup. Local contacts miss, checking remote");
+          final PhoneNumberServiceListener listener = new PhoneNumberServiceListener(callId);
+          mPhoneNumberService.getPhoneNumberInfo(cacheEntry.number, listener, listener, isIncoming);
+        } else if (cacheEntry.displayPhotoUri != null) {
+          Log.d(TAG, "Contact lookup. Local contact found, starting image load");
+          // Load the image with a callback to update the image state.
+          // When the load is finished, onImageLoadComplete() will be called.
+          cacheEntry.hasPhotoToLoad = true;
+          ContactsAsyncHelper.startObtainPhotoAsync(
+              TOKEN_UPDATE_PHOTO_FOR_CALL_STATE,
+              mContext,
+              cacheEntry.displayPhotoUri,
+              ContactInfoCache.this,
+              callId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface. Update contact photo
+   * when image is loaded in worker thread.
+   */
+  @WorkerThread
+  @Override
+  public void onImageLoaded(int token, Drawable photo, Bitmap photoIcon, Object cookie) {
+    Assert.isWorkerThread();
+    loadImage(photo, photoIcon, cookie);
+  }
+
+  private void loadImage(Drawable photo, Bitmap photoIcon, Object cookie) {
+    Log.d(this, "Image load complete with context: ", mContext);
+    // TODO: may be nice to update the image view again once the newer one
+    // is available on contacts database.
+    String callId = (String) cookie;
+    ContactCacheEntry entry = mInfoMap.get(callId);
+
+    if (entry == null) {
+      Log.e(this, "Image Load received for empty search entry.");
+      clearCallbacks(callId);
+      return;
+    }
+
+    Log.d(this, "setting photo for entry: ", entry);
+
+    // Conference call icons are being handled in CallCardPresenter.
+    if (photo != null) {
+      Log.v(this, "direct drawable: ", photo);
+      entry.photo = photo;
+      entry.photoType = ContactPhotoType.CONTACT;
+    } else if (photoIcon != null) {
+      Log.v(this, "photo icon: ", photoIcon);
+      entry.photo = new BitmapDrawable(mContext.getResources(), photoIcon);
+      entry.photoType = ContactPhotoType.CONTACT;
+    } else {
+      Log.v(this, "unknown photo");
+      entry.photo = null;
+      entry.photoType = ContactPhotoType.DEFAULT_PLACEHOLDER;
+    }
+  }
+
+  /**
+   * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface. make sure that the
+   * call state is reflected after the image is loaded.
+   */
+  @MainThread
+  @Override
+  public void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon, Object cookie) {
+    Assert.isMainThread();
+    String callId = (String) cookie;
+    ContactCacheEntry entry = mInfoMap.get(callId);
+    sendImageNotifications(callId, entry);
+
+    clearCallbacks(callId);
+  }
+
+  /** Blows away the stored cache values. */
+  public void clearCache() {
+    mInfoMap.clear();
+    mCallBacks.clear();
+  }
+
+  private ContactCacheEntry buildEntry(
+      Context context, CallerInfo info, int presentation, boolean isIncoming) {
+    final ContactCacheEntry cce = new ContactCacheEntry();
+    populateCacheEntry(context, info, cce, presentation, isIncoming);
+
+    // This will only be true for emergency numbers
+    if (info.photoResource != 0) {
+      cce.photo = context.getResources().getDrawable(info.photoResource);
+    } else if (info.isCachedPhotoCurrent) {
+      if (info.cachedPhoto != null) {
+        cce.photo = info.cachedPhoto;
+        cce.photoType = ContactPhotoType.CONTACT;
+      } else {
+        cce.photo = getDefaultContactPhotoDrawable();
+        cce.photoType = ContactPhotoType.DEFAULT_PLACEHOLDER;
+      }
+    } else if (info.contactDisplayPhotoUri == null) {
+      cce.photo = getDefaultContactPhotoDrawable();
+      cce.photoType = ContactPhotoType.DEFAULT_PLACEHOLDER;
+    } else {
+      cce.displayPhotoUri = info.contactDisplayPhotoUri;
+      cce.photo = null;
+    }
+
+    // Support any contact id in N because QuickContacts in N starts supporting enterprise
+    // contact id
+    if (info.lookupKeyOrNull != null
+        && (VERSION.SDK_INT >= VERSION_CODES.N || info.contactIdOrZero != 0)) {
+      cce.lookupUri = Contacts.getLookupUri(info.contactIdOrZero, info.lookupKeyOrNull);
+    } else {
+      Log.v(TAG, "lookup key is null or contact ID is 0 on M. Don't create a lookup uri.");
+      cce.lookupUri = null;
+    }
+
+    cce.lookupKey = info.lookupKeyOrNull;
+    cce.contactRingtoneUri = info.contactRingtoneUri;
+    if (cce.contactRingtoneUri == null || Uri.EMPTY.equals(cce.contactRingtoneUri)) {
+      cce.contactRingtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
+    }
+
+    return cce;
+  }
+
+  /** Sends the updated information to call the callbacks for the entry. */
+  private void sendInfoNotifications(String callId, ContactCacheEntry entry) {
+    final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+    if (callBacks != null) {
+      for (ContactInfoCacheCallback callBack : callBacks) {
+        callBack.onContactInfoComplete(callId, entry);
+      }
+    }
+  }
+
+  private void sendImageNotifications(String callId, ContactCacheEntry entry) {
+    final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+    if (callBacks != null && entry.photo != null) {
+      for (ContactInfoCacheCallback callBack : callBacks) {
+        callBack.onImageLoadComplete(callId, entry);
+      }
+    }
+  }
+
+  private void clearCallbacks(String callId) {
+    mCallBacks.remove(callId);
+  }
+
+  public Drawable getDefaultContactPhotoDrawable() {
+    if (mDefaultContactPhotoDrawable == null) {
+      mDefaultContactPhotoDrawable =
+          mContext.getResources().getDrawable(R.drawable.img_no_image_automirrored);
+    }
+    return mDefaultContactPhotoDrawable;
+  }
+
+  public Drawable getConferenceDrawable() {
+    if (mConferencePhotoDrawable == null) {
+      mConferencePhotoDrawable =
+          mContext.getResources().getDrawable(R.drawable.img_conference_automirrored);
+    }
+    return mConferencePhotoDrawable;
+  }
+
+  /** Callback interface for the contact query. */
+  public interface ContactInfoCacheCallback {
+
+    void onContactInfoComplete(String callId, ContactCacheEntry entry);
+
+    void onImageLoadComplete(String callId, ContactCacheEntry entry);
+  }
+
+  /** This is cached contact info, which should be the ONLY info used by UI. */
+  public static class ContactCacheEntry {
+
+    public String namePrimary;
+    public String nameAlternative;
+    public String number;
+    public String location;
+    public String label;
+    public Drawable photo;
+    @ContactPhotoType public int photoType;
+    public boolean isSipCall;
+    // Note in cache entry whether this is a pending async loading action to know whether to
+    // wait for its callback or not.
+    public boolean hasPhotoToLoad;
+    /** This will be used for the "view" notification. */
+    public Uri contactUri;
+    /** Either a display photo or a thumbnail URI. */
+    public Uri displayPhotoUri;
+
+    public Uri lookupUri; // Sent to NotificationMananger
+    public String lookupKey;
+    public int contactLookupResult = ContactLookupResult.Type.NOT_FOUND;
+    public long userType = ContactsUtils.USER_TYPE_CURRENT;
+    public Uri contactRingtoneUri;
+
+    @Override
+    public String toString() {
+      return "ContactCacheEntry{"
+          + "name='"
+          + MoreStrings.toSafeString(namePrimary)
+          + '\''
+          + ", nameAlternative='"
+          + MoreStrings.toSafeString(nameAlternative)
+          + '\''
+          + ", number='"
+          + MoreStrings.toSafeString(number)
+          + '\''
+          + ", location='"
+          + MoreStrings.toSafeString(location)
+          + '\''
+          + ", label='"
+          + label
+          + '\''
+          + ", photo="
+          + photo
+          + ", isSipCall="
+          + isSipCall
+          + ", contactUri="
+          + contactUri
+          + ", displayPhotoUri="
+          + displayPhotoUri
+          + ", contactLookupResult="
+          + contactLookupResult
+          + ", userType="
+          + userType
+          + ", contactRingtoneUri="
+          + contactRingtoneUri
+          + '}';
+    }
+  }
+
+  private static final class DialerCallCookieWrapper {
+    public final String callId;
+    public final int numberPresentation;
+
+    public DialerCallCookieWrapper(String callId, int numberPresentation) {
+      this.callId = callId;
+      this.numberPresentation = numberPresentation;
+    }
+  }
+
+  private class FindInfoCallback implements OnQueryCompleteListener {
+
+    private final boolean mIsIncoming;
+
+    public FindInfoCallback(boolean isIncoming) {
+      mIsIncoming = isIncoming;
+    }
+
+    @Override
+    public void onDataLoaded(int token, Object cookie, CallerInfo ci) {
+      Assert.isWorkerThread();
+      DialerCallCookieWrapper cw = (DialerCallCookieWrapper) cookie;
+      updateCallerInfoInCacheOnAnyThread(cw.callId, cw.numberPresentation, ci, mIsIncoming, true);
+    }
+
+    @Override
+    public void onQueryComplete(int token, Object cookie, CallerInfo callerInfo) {
+      Assert.isMainThread();
+      DialerCallCookieWrapper cw = (DialerCallCookieWrapper) cookie;
+      String callId = cw.callId;
+      ContactCacheEntry cacheEntry = mInfoMap.get(callId);
+      // This may happen only when InCallPresenter attempt to cleanup.
+      if (cacheEntry == null) {
+        Log.w(TAG, "Contact lookup done, but cache entry is not found.");
+        clearCallbacks(callId);
+        return;
+      }
+      sendInfoNotifications(callId, cacheEntry);
+      if (!cacheEntry.hasPhotoToLoad) {
+        if (callerInfo.contactExists) {
+          Log.d(TAG, "Contact lookup done. Local contact found, no image.");
+        } else {
+          Log.d(
+              TAG,
+              "Contact lookup done. Local contact not found and"
+                  + " no remote lookup service available.");
+        }
+        clearCallbacks(callId);
+      }
+    }
+  }
+
+  class PhoneNumberServiceListener
+      implements PhoneNumberService.NumberLookupListener, PhoneNumberService.ImageLookupListener {
+
+    private final String mCallId;
+
+    PhoneNumberServiceListener(String callId) {
+      mCallId = callId;
+    }
+
+    @Override
+    public void onPhoneNumberInfoComplete(final PhoneNumberService.PhoneNumberInfo info) {
+      // If we got a miss, this is the end of the lookup pipeline,
+      // so clear the callbacks and return.
+      if (info == null) {
+        Log.d(TAG, "Contact lookup done. Remote contact not found.");
+        clearCallbacks(mCallId);
+        return;
+      }
+
+      ContactCacheEntry entry = new ContactCacheEntry();
+      entry.namePrimary = info.getDisplayName();
+      entry.number = info.getNumber();
+      entry.contactLookupResult = info.getLookupSource();
+      final int type = info.getPhoneType();
+      final String label = info.getPhoneLabel();
+      if (type == Phone.TYPE_CUSTOM) {
+        entry.label = label;
+      } else {
+        final CharSequence typeStr = Phone.getTypeLabel(mContext.getResources(), type, label);
+        entry.label = typeStr == null ? null : typeStr.toString();
+      }
+      synchronized (mInfoMap) {
+        final ContactCacheEntry oldEntry = mInfoMap.get(mCallId);
+        if (oldEntry != null) {
+          // Location is only obtained from local lookup so persist
+          // the value for remote lookups. Once we have a name this
+          // field is no longer used; it is persisted here in case
+          // the UI is ever changed to use it.
+          entry.location = oldEntry.location;
+          // Contact specific ringtone is obtained from local lookup.
+          entry.contactRingtoneUri = oldEntry.contactRingtoneUri;
+        }
+
+        // If no image and it's a business, switch to using the default business avatar.
+        if (info.getImageUrl() == null && info.isBusiness()) {
+          Log.d(TAG, "Business has no image. Using default.");
+          entry.photo = mContext.getResources().getDrawable(R.drawable.img_business);
+          entry.photoType = ContactPhotoType.BUSINESS;
+        }
+
+        mInfoMap.put(mCallId, entry);
+      }
+      sendInfoNotifications(mCallId, entry);
+
+      entry.hasPhotoToLoad = info.getImageUrl() != null;
+
+      // If there is no image then we should not expect another callback.
+      if (!entry.hasPhotoToLoad) {
+        // We're done, so clear callbacks
+        clearCallbacks(mCallId);
+      }
+    }
+
+    @Override
+    public void onImageFetchComplete(Bitmap bitmap) {
+      loadImage(null, bitmap, mCallId);
+      onImageLoadComplete(TOKEN_UPDATE_PHOTO_FOR_CALL_STATE, null, bitmap, mCallId);
+    }
+  }
+}
diff --git a/java/com/android/incallui/ContactsAsyncHelper.java b/java/com/android/incallui/ContactsAsyncHelper.java
new file mode 100644
index 0000000..08ff74d
--- /dev/null
+++ b/java/com/android/incallui/ContactsAsyncHelper.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.Notification;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.support.annotation.MainThread;
+import android.support.annotation.WorkerThread;
+import java.io.IOException;
+import java.io.InputStream;
+
+/** Helper class for loading contacts photo asynchronously. */
+public class ContactsAsyncHelper {
+
+  /** Interface for a WorkerHandler result return. */
+  public interface OnImageLoadCompleteListener {
+
+    /**
+     * Called when the image load is complete. Must be called in main thread.
+     *
+     * @param token Integer passed in {@link ContactsAsyncHelper#startObtainPhotoAsync(int, Context,
+     *     Uri, OnImageLoadCompleteListener, Object)}.
+     * @param photo Drawable object obtained by the async load.
+     * @param photoIcon Bitmap object obtained by the async load.
+     * @param cookie Object passed in {@link ContactsAsyncHelper#startObtainPhotoAsync(int, Context,
+     *     Uri, OnImageLoadCompleteListener, Object)}. Can be null iff. the original cookie is null.
+     */
+    @MainThread
+    void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon, Object cookie);
+
+    /** Called when image is loaded to udpate data. Must be called in worker thread. */
+    @WorkerThread
+    void onImageLoaded(int token, Drawable photo, Bitmap photoIcon, Object cookie);
+  }
+
+  // constants
+  private static final int EVENT_LOAD_IMAGE = 1;
+  /** Handler run on a worker thread to load photo asynchronously. */
+  private static Handler sThreadHandler;
+  /** For forcing the system to call its constructor */
+  @SuppressWarnings("unused")
+  private static ContactsAsyncHelper sInstance;
+
+  static {
+    sInstance = new ContactsAsyncHelper();
+  }
+
+  private final Handler mResultHandler =
+      /** A handler that handles message to call listener notifying UI change on main thread. */
+      new Handler(Looper.getMainLooper()) {
+        @Override
+        public void handleMessage(Message msg) {
+          WorkerArgs args = (WorkerArgs) msg.obj;
+          switch (msg.arg1) {
+            case EVENT_LOAD_IMAGE:
+              if (args.listener != null) {
+                Log.d(
+                    this,
+                    "Notifying listener: "
+                        + args.listener.toString()
+                        + " image: "
+                        + args.displayPhotoUri
+                        + " completed");
+                args.listener.onImageLoadComplete(
+                    msg.what, args.photo, args.photoIcon, args.cookie);
+              }
+              break;
+            default:
+          }
+        }
+      };
+
+  /** Private constructor for static class */
+  private ContactsAsyncHelper() {
+    HandlerThread thread = new HandlerThread("ContactsAsyncWorker");
+    thread.start();
+    sThreadHandler = new WorkerHandler(thread.getLooper());
+  }
+
+  /**
+   * Starts an asynchronous image load. After finishing the load, {@link
+   * OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable, Bitmap, Object)} will be called.
+   *
+   * @param token Arbitrary integer which will be returned as the first argument of {@link
+   *     OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable, Bitmap, Object)}
+   * @param context Context object used to do the time-consuming operation.
+   * @param displayPhotoUri Uri to be used to fetch the photo
+   * @param listener Callback object which will be used when the asynchronous load is done. Can be
+   *     null, which means only the asynchronous load is done while there's no way to obtain the
+   *     loaded photos.
+   * @param cookie Arbitrary object the caller wants to remember, which will become the fourth
+   *     argument of {@link OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable, Bitmap,
+   *     Object)}. Can be null, at which the callback will also has null for the argument.
+   */
+  public static final void startObtainPhotoAsync(
+      int token,
+      Context context,
+      Uri displayPhotoUri,
+      OnImageLoadCompleteListener listener,
+      Object cookie) {
+    // in case the source caller info is null, the URI will be null as well.
+    // just update using the placeholder image in this case.
+    if (displayPhotoUri == null) {
+      Log.e("startObjectPhotoAsync", "Uri is missing");
+      return;
+    }
+
+    // Added additional Cookie field in the callee to handle arguments
+    // sent to the callback function.
+
+    // setup arguments
+    WorkerArgs args = new WorkerArgs();
+    args.cookie = cookie;
+    args.context = context;
+    args.displayPhotoUri = displayPhotoUri;
+    args.listener = listener;
+
+    // setup message arguments
+    Message msg = sThreadHandler.obtainMessage(token);
+    msg.arg1 = EVENT_LOAD_IMAGE;
+    msg.obj = args;
+
+    Log.d(
+        "startObjectPhotoAsync",
+        "Begin loading image: " + args.displayPhotoUri + ", displaying default image for now.");
+
+    // notify the thread to begin working
+    sThreadHandler.sendMessage(msg);
+  }
+
+  private static final class WorkerArgs {
+
+    public Context context;
+    public Uri displayPhotoUri;
+    public Drawable photo;
+    public Bitmap photoIcon;
+    public Object cookie;
+    public OnImageLoadCompleteListener listener;
+  }
+
+  /** Thread worker class that handles the task of opening the stream and loading the images. */
+  private class WorkerHandler extends Handler {
+
+    public WorkerHandler(Looper looper) {
+      super(looper);
+    }
+
+    @Override
+    public void handleMessage(Message msg) {
+      WorkerArgs args = (WorkerArgs) msg.obj;
+
+      switch (msg.arg1) {
+        case EVENT_LOAD_IMAGE:
+          InputStream inputStream = null;
+          try {
+            try {
+              inputStream = args.context.getContentResolver().openInputStream(args.displayPhotoUri);
+            } catch (Exception e) {
+              Log.e(this, "Error opening photo input stream", e);
+            }
+
+            if (inputStream != null) {
+              args.photo = Drawable.createFromStream(inputStream, args.displayPhotoUri.toString());
+
+              // This assumes Drawable coming from contact database is usually
+              // BitmapDrawable and thus we can have (down)scaled version of it.
+              args.photoIcon = getPhotoIconWhenAppropriate(args.context, args.photo);
+
+              Log.d(
+                  ContactsAsyncHelper.this,
+                  "Loading image: "
+                      + msg.arg1
+                      + " token: "
+                      + msg.what
+                      + " image URI: "
+                      + args.displayPhotoUri);
+            } else {
+              args.photo = null;
+              args.photoIcon = null;
+              Log.d(
+                  ContactsAsyncHelper.this,
+                  "Problem with image: "
+                      + msg.arg1
+                      + " token: "
+                      + msg.what
+                      + " image URI: "
+                      + args.displayPhotoUri
+                      + ", using default image.");
+            }
+            if (args.listener != null) {
+              args.listener.onImageLoaded(msg.what, args.photo, args.photoIcon, args.cookie);
+            }
+          } finally {
+            if (inputStream != null) {
+              try {
+                inputStream.close();
+              } catch (IOException e) {
+                Log.e(this, "Unable to close input stream.", e);
+              }
+            }
+          }
+          break;
+        default:
+      }
+
+      // send the reply to the enclosing class.
+      Message reply = ContactsAsyncHelper.this.mResultHandler.obtainMessage(msg.what);
+      reply.arg1 = msg.arg1;
+      reply.obj = msg.obj;
+      reply.sendToTarget();
+    }
+
+    /**
+     * Returns a Bitmap object suitable for {@link Notification}'s large icon. This might return
+     * null when the given Drawable isn't BitmapDrawable, or if the system fails to create a scaled
+     * Bitmap for the Drawable.
+     */
+    private Bitmap getPhotoIconWhenAppropriate(Context context, Drawable photo) {
+      if (!(photo instanceof BitmapDrawable)) {
+        return null;
+      }
+      int iconSize = context.getResources().getDimensionPixelSize(R.dimen.notification_icon_size);
+      Bitmap orgBitmap = ((BitmapDrawable) photo).getBitmap();
+      int orgWidth = orgBitmap.getWidth();
+      int orgHeight = orgBitmap.getHeight();
+      int longerEdge = orgWidth > orgHeight ? orgWidth : orgHeight;
+      // We want downscaled one only when the original icon is too big.
+      if (longerEdge > iconSize) {
+        float ratio = ((float) longerEdge) / iconSize;
+        int newWidth = (int) (orgWidth / ratio);
+        int newHeight = (int) (orgHeight / ratio);
+        // If the longer edge is much longer than the shorter edge, the latter may
+        // become 0 which will cause a crash.
+        if (newWidth <= 0 || newHeight <= 0) {
+          Log.w(this, "Photo icon's width or height become 0.");
+          return null;
+        }
+
+        // It is sure ratio >= 1.0f in any case and thus the newly created Bitmap
+        // should be smaller than the original.
+        return Bitmap.createScaledBitmap(orgBitmap, newWidth, newHeight, true);
+      } else {
+        return orgBitmap;
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/ContactsPreferencesFactory.java b/java/com/android/incallui/ContactsPreferencesFactory.java
new file mode 100644
index 0000000..429de7b
--- /dev/null
+++ b/java/com/android/incallui/ContactsPreferencesFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.support.v4.os.UserManagerCompat;
+import com.android.contacts.common.preference.ContactsPreferences;
+
+/** Factory class for {@link ContactsPreferences}. */
+public class ContactsPreferencesFactory {
+
+  private static boolean sUseTestInstance;
+  private static ContactsPreferences sTestInstance;
+
+  /**
+   * Creates a new {@link ContactsPreferences} object if possible.
+   *
+   * @param context the context to use when creating the ContactsPreferences.
+   * @return a new ContactsPreferences object or {@code null} if the user is locked.
+   */
+  @Nullable
+  public static ContactsPreferences newContactsPreferences(Context context) {
+    if (sUseTestInstance) {
+      return sTestInstance;
+    }
+    if (UserManagerCompat.isUserUnlocked(context)) {
+      return new ContactsPreferences(context);
+    }
+    return null;
+  }
+
+  /**
+   * Sets the instance to be returned by all calls to {@link #newContactsPreferences(Context)}.
+   *
+   * @param testInstance the instance to return.
+   */
+  static void setTestInstance(ContactsPreferences testInstance) {
+    sUseTestInstance = true;
+    sTestInstance = testInstance;
+  }
+}
diff --git a/java/com/android/incallui/DialpadFragment.java b/java/com/android/incallui/DialpadFragment.java
new file mode 100644
index 0000000..7f494aa
--- /dev/null
+++ b/java/com/android/incallui/DialpadFragment.java
@@ -0,0 +1,461 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.method.DialerKeyListener;
+import android.util.ArrayMap;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnKeyListener;
+import android.view.ViewGroup;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.dialer.dialpadview.DialpadKeyButton;
+import com.android.dialer.dialpadview.DialpadKeyButton.OnPressedListener;
+import com.android.dialer.dialpadview.DialpadView;
+import com.android.incallui.DialpadPresenter.DialpadUi;
+import com.android.incallui.baseui.BaseFragment;
+import java.util.Map;
+
+/** Fragment for call control buttons */
+public class DialpadFragment extends BaseFragment<DialpadPresenter, DialpadUi>
+    implements DialpadUi, OnKeyListener, OnClickListener, OnPressedListener {
+
+  /** Hash Map to map a view id to a character */
+  private static final Map<Integer, Character> mDisplayMap = new ArrayMap<>();
+
+  /** Set up the static maps */
+  static {
+    // Map the buttons to the display characters
+    mDisplayMap.put(R.id.one, '1');
+    mDisplayMap.put(R.id.two, '2');
+    mDisplayMap.put(R.id.three, '3');
+    mDisplayMap.put(R.id.four, '4');
+    mDisplayMap.put(R.id.five, '5');
+    mDisplayMap.put(R.id.six, '6');
+    mDisplayMap.put(R.id.seven, '7');
+    mDisplayMap.put(R.id.eight, '8');
+    mDisplayMap.put(R.id.nine, '9');
+    mDisplayMap.put(R.id.zero, '0');
+    mDisplayMap.put(R.id.pound, '#');
+    mDisplayMap.put(R.id.star, '*');
+  }
+
+  private final int[] mButtonIds =
+      new int[] {
+        R.id.zero,
+        R.id.one,
+        R.id.two,
+        R.id.three,
+        R.id.four,
+        R.id.five,
+        R.id.six,
+        R.id.seven,
+        R.id.eight,
+        R.id.nine,
+        R.id.star,
+        R.id.pound
+      };
+  private EditText mDtmfDialerField;
+  // KeyListener used with the "dialpad digits" EditText widget.
+  private DTMFKeyListener mDialerKeyListener;
+  private DialpadView mDialpadView;
+  private int mCurrentTextColor;
+
+  @Override
+  public void onClick(View v) {
+    if (v.getId() == R.id.dialpad_back) {
+      getActivity().onBackPressed();
+    }
+  }
+
+  @Override
+  public boolean onKey(View v, int keyCode, KeyEvent event) {
+    Log.d(this, "onKey:  keyCode " + keyCode + ", view " + v);
+
+    if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_ENTER) {
+      int viewId = v.getId();
+      if (mDisplayMap.containsKey(viewId)) {
+        switch (event.getAction()) {
+          case KeyEvent.ACTION_DOWN:
+            if (event.getRepeatCount() == 0) {
+              getPresenter().processDtmf(mDisplayMap.get(viewId));
+            }
+            break;
+          case KeyEvent.ACTION_UP:
+            getPresenter().stopDtmf();
+            break;
+        }
+        // do not return true [handled] here, since we want the
+        // press / click animation to be handled by the framework.
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public DialpadPresenter createPresenter() {
+    return new DialpadPresenter();
+  }
+
+  @Override
+  public DialpadPresenter.DialpadUi getUi() {
+    return this;
+  }
+
+  // TODO Adds hardware keyboard listener
+
+  @Override
+  public View onCreateView(
+      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    final View parent = inflater.inflate(R.layout.incall_dialpad_fragment, container, false);
+    mDialpadView = (DialpadView) parent.findViewById(R.id.dialpad_view);
+    mDialpadView.setCanDigitsBeEdited(false);
+    mDialpadView.setBackgroundResource(R.color.incall_dialpad_background);
+    mDtmfDialerField = (EditText) parent.findViewById(R.id.digits);
+    if (mDtmfDialerField != null) {
+      mDialerKeyListener = new DTMFKeyListener();
+      mDtmfDialerField.setKeyListener(mDialerKeyListener);
+      // remove the long-press context menus that support
+      // the edit (copy / paste / select) functions.
+      mDtmfDialerField.setLongClickable(false);
+      mDtmfDialerField.setElegantTextHeight(false);
+      configureKeypadListeners();
+    }
+    View backButton = mDialpadView.findViewById(R.id.dialpad_back);
+    backButton.setVisibility(View.VISIBLE);
+    backButton.setOnClickListener(this);
+
+    return parent;
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    updateColors();
+  }
+
+  public void updateColors() {
+    int textColor = InCallPresenter.getInstance().getThemeColorManager().getPrimaryColor();
+
+    if (mCurrentTextColor == textColor) {
+      return;
+    }
+
+    DialpadKeyButton dialpadKey;
+    for (int i = 0; i < mButtonIds.length; i++) {
+      dialpadKey = (DialpadKeyButton) mDialpadView.findViewById(mButtonIds[i]);
+      ((TextView) dialpadKey.findViewById(R.id.dialpad_key_number)).setTextColor(textColor);
+    }
+
+    mCurrentTextColor = textColor;
+  }
+
+  @Override
+  public void onDestroyView() {
+    mDialerKeyListener = null;
+    super.onDestroyView();
+  }
+
+  /**
+   * Getter for Dialpad text.
+   *
+   * @return String containing current Dialpad EditText text.
+   */
+  public String getDtmfText() {
+    return mDtmfDialerField.getText().toString();
+  }
+
+  /**
+   * Sets the Dialpad text field with some text.
+   *
+   * @param text Text to set Dialpad EditText to.
+   */
+  public void setDtmfText(String text) {
+    mDtmfDialerField.setText(PhoneNumberUtilsCompat.createTtsSpannable(text));
+  }
+
+  @Override
+  public void setVisible(boolean on) {
+    if (on) {
+      getView().setVisibility(View.VISIBLE);
+    } else {
+      getView().setVisibility(View.INVISIBLE);
+    }
+  }
+
+  /** Starts the slide up animation for the Dialpad keys when the Dialpad is revealed. */
+  public void animateShowDialpad() {
+    final DialpadView dialpadView = (DialpadView) getView().findViewById(R.id.dialpad_view);
+    dialpadView.animateShow();
+  }
+
+  @Override
+  public void appendDigitsToField(char digit) {
+    if (mDtmfDialerField != null) {
+      // TODO: maybe *don't* manually append this digit if
+      // mDialpadDigits is focused and this key came from the HW
+      // keyboard, since in that case the EditText field will
+      // get the key event directly and automatically appends
+      // whetever the user types.
+      // (Or, a cleaner fix would be to just make mDialpadDigits
+      // *not* handle HW key presses.  That seems to be more
+      // complicated than just setting focusable="false" on it,
+      // though.)
+      mDtmfDialerField.getText().append(digit);
+    }
+  }
+
+  /** Called externally (from InCallScreen) to play a DTMF Tone. */
+  /* package */ boolean onDialerKeyDown(KeyEvent event) {
+    Log.d(this, "Notifying dtmf key down.");
+    if (mDialerKeyListener != null) {
+      return mDialerKeyListener.onKeyDown(event);
+    } else {
+      return false;
+    }
+  }
+
+  /** Called externally (from InCallScreen) to cancel the last DTMF Tone played. */
+  public boolean onDialerKeyUp(KeyEvent event) {
+    Log.d(this, "Notifying dtmf key up.");
+    if (mDialerKeyListener != null) {
+      return mDialerKeyListener.onKeyUp(event);
+    } else {
+      return false;
+    }
+  }
+
+  private void configureKeypadListeners() {
+    DialpadKeyButton dialpadKey;
+    for (int i = 0; i < mButtonIds.length; i++) {
+      dialpadKey = (DialpadKeyButton) mDialpadView.findViewById(mButtonIds[i]);
+      dialpadKey.setOnKeyListener(this);
+      dialpadKey.setOnClickListener(this);
+      dialpadKey.setOnPressedListener(this);
+    }
+  }
+
+  @Override
+  public void onPressed(View view, boolean pressed) {
+    if (pressed && mDisplayMap.containsKey(view.getId())) {
+      Log.d(this, "onPressed: " + pressed + " " + mDisplayMap.get(view.getId()));
+      getPresenter().processDtmf(mDisplayMap.get(view.getId()));
+    }
+    if (!pressed) {
+      Log.d(this, "onPressed: " + pressed);
+      getPresenter().stopDtmf();
+    }
+  }
+
+  /**
+   * LinearLayout with getter and setter methods for the translationY property using floats, for
+   * animation purposes.
+   */
+  public static class DialpadSlidingLinearLayout extends LinearLayout {
+
+    public DialpadSlidingLinearLayout(Context context) {
+      super(context);
+    }
+
+    public DialpadSlidingLinearLayout(Context context, AttributeSet attrs) {
+      super(context, attrs);
+    }
+
+    public DialpadSlidingLinearLayout(Context context, AttributeSet attrs, int defStyle) {
+      super(context, attrs, defStyle);
+    }
+
+    public float getYFraction() {
+      final int height = getHeight();
+      if (height == 0) {
+        return 0;
+      }
+      return getTranslationY() / height;
+    }
+
+    public void setYFraction(float yFraction) {
+      setTranslationY(yFraction * getHeight());
+    }
+  }
+
+  /**
+   * Our own key listener, specialized for dealing with DTMF codes. 1. Ignore the backspace since it
+   * is irrelevant. 2. Allow ONLY valid DTMF characters to generate a tone and be sent as a DTMF
+   * code. 3. All other remaining characters are handled by the superclass.
+   *
+   * <p>This code is purely here to handle events from the hardware keyboard while the DTMF dialpad
+   * is up.
+   */
+  private class DTMFKeyListener extends DialerKeyListener {
+
+    /**
+     * Overrides the characters used in {@link DialerKeyListener#CHARACTERS} These are the valid
+     * dtmf characters.
+     */
+    public final char[] DTMF_CHARACTERS =
+        new char[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '#', '*'};
+
+    private DTMFKeyListener() {
+      super();
+    }
+
+    /** Overriden to return correct DTMF-dialable characters. */
+    @Override
+    protected char[] getAcceptedChars() {
+      return DTMF_CHARACTERS;
+    }
+
+    /** special key listener ignores backspace. */
+    @Override
+    public boolean backspace(View view, Editable content, int keyCode, KeyEvent event) {
+      return false;
+    }
+
+    /**
+     * Overriden so that with each valid button press, we start sending a dtmf code and play a local
+     * dtmf tone.
+     */
+    @Override
+    public boolean onKeyDown(View view, Editable content, int keyCode, KeyEvent event) {
+      // if (DBG) log("DTMFKeyListener.onKeyDown, keyCode " + keyCode + ", view " + view);
+
+      // find the character
+      char c = (char) lookup(event, content);
+
+      // if not a long press, and parent onKeyDown accepts the input
+      if (event.getRepeatCount() == 0 && super.onKeyDown(view, content, keyCode, event)) {
+
+        boolean keyOK = ok(getAcceptedChars(), c);
+
+        // if the character is a valid dtmf code, start playing the tone and send the
+        // code.
+        if (keyOK) {
+          Log.d(this, "DTMFKeyListener reading '" + c + "' from input.");
+          getPresenter().processDtmf(c);
+        } else {
+          Log.d(this, "DTMFKeyListener rejecting '" + c + "' from input.");
+        }
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Overriden so that with each valid button up, we stop sending a dtmf code and the dtmf tone.
+     */
+    @Override
+    public boolean onKeyUp(View view, Editable content, int keyCode, KeyEvent event) {
+      // if (DBG) log("DTMFKeyListener.onKeyUp, keyCode " + keyCode + ", view " + view);
+
+      super.onKeyUp(view, content, keyCode, event);
+
+      // find the character
+      char c = (char) lookup(event, content);
+
+      boolean keyOK = ok(getAcceptedChars(), c);
+
+      if (keyOK) {
+        Log.d(this, "Stopping the tone for '" + c + "'");
+        getPresenter().stopDtmf();
+        return true;
+      }
+
+      return false;
+    }
+
+    /** Handle individual keydown events when we DO NOT have an Editable handy. */
+    public boolean onKeyDown(KeyEvent event) {
+      char c = lookup(event);
+      Log.d(this, "DTMFKeyListener.onKeyDown: event '" + c + "'");
+
+      // if not a long press, and parent onKeyDown accepts the input
+      if (event.getRepeatCount() == 0 && c != 0) {
+        // if the character is a valid dtmf code, start playing the tone and send the
+        // code.
+        if (ok(getAcceptedChars(), c)) {
+          Log.d(this, "DTMFKeyListener reading '" + c + "' from input.");
+          getPresenter().processDtmf(c);
+          return true;
+        } else {
+          Log.d(this, "DTMFKeyListener rejecting '" + c + "' from input.");
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Handle individual keyup events.
+     *
+     * @param event is the event we are trying to stop. If this is null, then we just force-stop the
+     *     last tone without checking if the event is an acceptable dialer event.
+     */
+    public boolean onKeyUp(KeyEvent event) {
+      if (event == null) {
+        //the below piece of code sends stopDTMF event unnecessarily even when a null event
+        //is received, hence commenting it.
+        /*if (DBG) log("Stopping the last played tone.");
+        stopTone();*/
+        return true;
+      }
+
+      char c = lookup(event);
+      Log.d(this, "DTMFKeyListener.onKeyUp: event '" + c + "'");
+
+      // TODO: stopTone does not take in character input, we may want to
+      // consider checking for this ourselves.
+      if (ok(getAcceptedChars(), c)) {
+        Log.d(this, "Stopping the tone for '" + c + "'");
+        getPresenter().stopDtmf();
+        return true;
+      }
+
+      return false;
+    }
+
+    /**
+     * Find the Dialer Key mapped to this event.
+     *
+     * @return The char value of the input event, otherwise 0 if no matching character was found.
+     */
+    private char lookup(KeyEvent event) {
+      // This code is similar to {@link DialerKeyListener#lookup(KeyEvent, Spannable) lookup}
+      int meta = event.getMetaState();
+      int number = event.getNumber();
+
+      if (!((meta & (KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON)) == 0) || (number == 0)) {
+        int match = event.getMatch(getAcceptedChars(), meta);
+        number = (match != 0) ? match : number;
+      }
+
+      return (char) number;
+    }
+
+    /** Check to see if the keyEvent is dialable. */
+    boolean isKeyEventAcceptable(KeyEvent event) {
+      return (ok(getAcceptedChars(), lookup(event)));
+    }
+  }
+}
diff --git a/java/com/android/incallui/DialpadPresenter.java b/java/com/android/incallui/DialpadPresenter.java
new file mode 100644
index 0000000..7a784c2
--- /dev/null
+++ b/java/com/android/incallui/DialpadPresenter.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.telephony.PhoneNumberUtils;
+import com.android.incallui.DialpadPresenter.DialpadUi;
+import com.android.incallui.baseui.Presenter;
+import com.android.incallui.baseui.Ui;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.TelecomAdapter;
+
+/** Logic for call buttons. */
+public class DialpadPresenter extends Presenter<DialpadUi>
+    implements InCallPresenter.InCallStateListener {
+
+  private DialerCall mCall;
+
+  @Override
+  public void onUiReady(DialpadUi ui) {
+    super.onUiReady(ui);
+    InCallPresenter.getInstance().addListener(this);
+    mCall = CallList.getInstance().getOutgoingOrActive();
+  }
+
+  @Override
+  public void onUiUnready(DialpadUi ui) {
+    super.onUiUnready(ui);
+    InCallPresenter.getInstance().removeListener(this);
+  }
+
+  @Override
+  public void onStateChange(
+      InCallPresenter.InCallState oldState,
+      InCallPresenter.InCallState newState,
+      CallList callList) {
+    mCall = callList.getOutgoingOrActive();
+    Log.d(this, "DialpadPresenter mCall = " + mCall);
+  }
+
+  /**
+   * Processes the specified digit as a DTMF key, by playing the appropriate DTMF tone, and
+   * appending the digit to the EditText field that displays the DTMF digits sent so far.
+   */
+  public final void processDtmf(char c) {
+    Log.d(this, "Processing dtmf key " + c);
+    // if it is a valid key, then update the display and send the dtmf tone.
+    if (PhoneNumberUtils.is12Key(c) && mCall != null) {
+      Log.d(this, "updating display and sending dtmf tone for '" + c + "'");
+
+      // Append this key to the "digits" widget.
+      DialpadUi dialpadUi = getUi();
+      if (dialpadUi != null) {
+        dialpadUi.appendDigitsToField(c);
+      }
+      // Plays the tone through Telecom.
+      TelecomAdapter.getInstance().playDtmfTone(mCall.getId(), c);
+    } else {
+      Log.d(this, "ignoring dtmf request for '" + c + "'");
+    }
+  }
+
+  /** Stops the local tone based on the phone type. */
+  public void stopDtmf() {
+    if (mCall != null) {
+      Log.d(this, "stopping remote tone");
+      TelecomAdapter.getInstance().stopDtmfTone(mCall.getId());
+    }
+  }
+
+  public interface DialpadUi extends Ui {
+
+    void setVisible(boolean on);
+
+    void appendDigitsToField(char digit);
+  }
+}
diff --git a/java/com/android/incallui/ExternalCallNotifier.java b/java/com/android/incallui/ExternalCallNotifier.java
new file mode 100644
index 0000000..466e12a
--- /dev/null
+++ b/java/com/android/incallui/ExternalCallNotifier.java
@@ -0,0 +1,465 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.annotation.TargetApi;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.net.Uri;
+import android.os.Build.VERSION_CODES;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.telecom.Call;
+import android.telecom.PhoneAccount;
+import android.telecom.VideoProfile;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.util.ArrayMap;
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.compat.CallCompat;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.BitmapUtil;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCallDelegate;
+import com.android.incallui.call.ExternalCallList;
+import com.android.incallui.latencyreport.LatencyReport;
+import com.android.incallui.util.TelecomCallUtil;
+import java.util.Map;
+
+/**
+ * Handles the display of notifications for "external calls".
+ *
+ * <p>External calls are a representation of a call which is in progress on the user's other device
+ * (e.g. another phone, or a watch).
+ */
+public class ExternalCallNotifier implements ExternalCallList.ExternalCallListener {
+
+  /** Tag used with the notification manager to uniquely identify external call notifications. */
+  private static final String NOTIFICATION_TAG = "EXTERNAL_CALL";
+
+  private static final int SUMMARY_ID = -1;
+  private final Context mContext;
+  private final ContactInfoCache mContactInfoCache;
+  private Map<Call, NotificationInfo> mNotifications = new ArrayMap<>();
+  private int mNextUniqueNotificationId;
+  private ContactsPreferences mContactsPreferences;
+  private boolean mShowingSummary;
+
+  /** Initializes a new instance of the external call notifier. */
+  public ExternalCallNotifier(
+      @NonNull Context context, @NonNull ContactInfoCache contactInfoCache) {
+    mContext = context;
+    mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+    mContactInfoCache = contactInfoCache;
+  }
+
+  /**
+   * Handles the addition of a new external call by showing a new notification. Triggered by {@link
+   * CallList#onCallAdded(android.telecom.Call)}.
+   */
+  @Override
+  public void onExternalCallAdded(android.telecom.Call call) {
+    Log.i(this, "onExternalCallAdded " + call);
+    if (mNotifications.containsKey(call)) {
+      throw new IllegalArgumentException();
+    }
+    NotificationInfo info = new NotificationInfo(call, mNextUniqueNotificationId++);
+    mNotifications.put(call, info);
+
+    showNotifcation(info);
+  }
+
+  /**
+   * Handles the removal of an external call by hiding its associated notification. Triggered by
+   * {@link CallList#onCallRemoved(android.telecom.Call)}.
+   */
+  @Override
+  public void onExternalCallRemoved(android.telecom.Call call) {
+    Log.i(this, "onExternalCallRemoved " + call);
+
+    dismissNotification(call);
+  }
+
+  /** Handles updates to an external call. */
+  @Override
+  public void onExternalCallUpdated(Call call) {
+    if (!mNotifications.containsKey(call)) {
+      throw new IllegalArgumentException();
+    }
+    postNotification(mNotifications.get(call));
+  }
+
+  @Override
+  public void onExternalCallPulled(Call call) {
+    // no-op; if an external call is pulled, it will be removed via onExternalCallRemoved.
+  }
+
+  /**
+   * Initiates a call pull given a notification ID.
+   *
+   * @param notificationId The notification ID associated with the external call which is to be
+   *     pulled.
+   */
+  @TargetApi(VERSION_CODES.N_MR1)
+  public void pullExternalCall(int notificationId) {
+    for (NotificationInfo info : mNotifications.values()) {
+      if (info.getNotificationId() == notificationId
+          && CallCompat.canPullExternalCall(info.getCall())) {
+        info.getCall().pullExternalCall();
+        return;
+      }
+    }
+  }
+
+  /**
+   * Shows a notification for a new external call. Performs a contact cache lookup to find any
+   * associated photo and information for the call.
+   */
+  private void showNotifcation(final NotificationInfo info) {
+    // We make a call to the contact info cache to query for supplemental data to what the
+    // call provides.  This includes the contact name and photo.
+    // This callback will always get called immediately and synchronously with whatever data
+    // it has available, and may make a subsequent call later (same thread) if it had to
+    // call into the contacts provider for more data.
+    DialerCall dialerCall =
+        new DialerCall(
+            mContext,
+            new DialerCallDelegateStub(),
+            info.getCall(),
+            new LatencyReport(),
+            false /* registerCallback */);
+
+    mContactInfoCache.findInfo(
+        dialerCall,
+        false /* isIncoming */,
+        new ContactInfoCache.ContactInfoCacheCallback() {
+          @Override
+          public void onContactInfoComplete(
+              String callId, ContactInfoCache.ContactCacheEntry entry) {
+
+            // Ensure notification still exists as the external call could have been
+            // removed during async contact info lookup.
+            if (mNotifications.containsKey(info.getCall())) {
+              saveContactInfo(info, entry);
+            }
+          }
+
+          @Override
+          public void onImageLoadComplete(String callId, ContactInfoCache.ContactCacheEntry entry) {
+
+            // Ensure notification still exists as the external call could have been
+            // removed during async contact info lookup.
+            if (mNotifications.containsKey(info.getCall())) {
+              savePhoto(info, entry);
+            }
+          }
+        });
+  }
+
+  /** Dismisses a notification for an external call. */
+  private void dismissNotification(Call call) {
+    if (!mNotifications.containsKey(call)) {
+      throw new IllegalArgumentException();
+    }
+
+    NotificationManager notificationManager =
+        (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+    notificationManager.cancel(NOTIFICATION_TAG, mNotifications.get(call).getNotificationId());
+
+    mNotifications.remove(call);
+
+    if (mShowingSummary && mNotifications.size() <= 1) {
+      // Where a summary notification is showing and there is now not enough notifications to
+      // necessitate a summary, cancel the summary.
+      notificationManager.cancel(NOTIFICATION_TAG, SUMMARY_ID);
+      mShowingSummary = false;
+
+      // If there is still a single call requiring a notification, re-post the notification as a
+      // standalone notification without a summary notification.
+      if (mNotifications.size() == 1) {
+        postNotification(mNotifications.values().iterator().next());
+      }
+    }
+  }
+
+  /**
+   * Attempts to build a large icon to use for the notification based on the contact info and post
+   * the updated notification to the notification manager.
+   */
+  private void savePhoto(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
+    Bitmap largeIcon = getLargeIconToDisplay(mContext, entry, info.getCall());
+    if (largeIcon != null) {
+      largeIcon = getRoundedIcon(mContext, largeIcon);
+    }
+    info.setLargeIcon(largeIcon);
+    postNotification(info);
+  }
+
+  /**
+   * Builds and stores the contact information the notification will display and posts the updated
+   * notification to the notification manager.
+   */
+  private void saveContactInfo(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
+    info.setContentTitle(getContentTitle(mContext, mContactsPreferences, entry, info.getCall()));
+    info.setPersonReference(getPersonReference(entry, info.getCall()));
+    postNotification(info);
+  }
+
+  /** Rebuild an existing or show a new notification given {@link NotificationInfo}. */
+  private void postNotification(NotificationInfo info) {
+    Notification.Builder builder = new Notification.Builder(mContext);
+    // Set notification as ongoing since calls are long-running versus a point-in-time notice.
+    builder.setOngoing(true);
+    // Make the notification prioritized over the other normal notifications.
+    builder.setPriority(Notification.PRIORITY_HIGH);
+    builder.setGroup(NOTIFICATION_TAG);
+
+    boolean isVideoCall = VideoProfile.isVideo(info.getCall().getDetails().getVideoState());
+    // Set the content ("Ongoing call on another device")
+    builder.setContentText(
+        mContext.getString(
+            isVideoCall
+                ? R.string.notification_external_video_call
+                : R.string.notification_external_call));
+    builder.setSmallIcon(R.drawable.quantum_ic_call_white_24);
+    builder.setContentTitle(info.getContentTitle());
+    builder.setLargeIcon(info.getLargeIcon());
+    builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
+    builder.addPerson(info.getPersonReference());
+
+    // Where the external call supports being transferred to the local device, add an action
+    // to the notification to initiate the call pull process.
+    if (CallCompat.canPullExternalCall(info.getCall())) {
+
+      Intent intent =
+          new Intent(
+              NotificationBroadcastReceiver.ACTION_PULL_EXTERNAL_CALL,
+              null,
+              mContext,
+              NotificationBroadcastReceiver.class);
+      intent.putExtra(
+          NotificationBroadcastReceiver.EXTRA_NOTIFICATION_ID, info.getNotificationId());
+      builder.addAction(
+          new Notification.Action.Builder(
+                  R.drawable.quantum_ic_call_white_24,
+                  mContext.getString(
+                      isVideoCall
+                          ? R.string.notification_take_video_call
+                          : R.string.notification_take_call),
+                  PendingIntent.getBroadcast(mContext, info.getNotificationId(), intent, 0))
+              .build());
+    }
+
+    /**
+     * This builder is used for the notification shown when the device is locked and the user has
+     * set their notification settings to 'hide sensitive content' {@see
+     * Notification.Builder#setPublicVersion}.
+     */
+    Notification.Builder publicBuilder = new Notification.Builder(mContext);
+    publicBuilder.setSmallIcon(R.drawable.quantum_ic_call_white_24);
+    publicBuilder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
+
+    builder.setPublicVersion(publicBuilder.build());
+    Notification notification = builder.build();
+
+    NotificationManager notificationManager =
+        (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+    notificationManager.notify(NOTIFICATION_TAG, info.getNotificationId(), notification);
+
+    if (!mShowingSummary && mNotifications.size() > 1) {
+      // If the number of notifications shown is > 1, and we're not already showing a group summary,
+      // build one now.  This will ensure the like notifications are grouped together.
+
+      Notification.Builder summary = new Notification.Builder(mContext);
+      // Set notification as ongoing since calls are long-running versus a point-in-time notice.
+      summary.setOngoing(true);
+      // Make the notification prioritized over the other normal notifications.
+      summary.setPriority(Notification.PRIORITY_HIGH);
+      summary.setGroup(NOTIFICATION_TAG);
+      summary.setGroupSummary(true);
+      summary.setSmallIcon(R.drawable.quantum_ic_call_white_24);
+      notificationManager.notify(NOTIFICATION_TAG, SUMMARY_ID, summary.build());
+      mShowingSummary = true;
+    }
+  }
+
+  /**
+   * Finds a large icon to display in a notification for a call. For conference calls, a conference
+   * call icon is used, otherwise if contact info is specified, the user's contact photo or avatar
+   * is used.
+   *
+   * @param context The context.
+   * @param contactInfo The contact cache info.
+   * @param call The call.
+   * @return The large icon to use for the notification.
+   */
+  private @Nullable Bitmap getLargeIconToDisplay(
+      Context context, ContactInfoCache.ContactCacheEntry contactInfo, android.telecom.Call call) {
+
+    Bitmap largeIcon = null;
+    if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE)
+        && !call.getDetails()
+            .hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {
+
+      largeIcon = BitmapFactory.decodeResource(context.getResources(), R.drawable.img_conference);
+    }
+    if (contactInfo.photo != null && (contactInfo.photo instanceof BitmapDrawable)) {
+      largeIcon = ((BitmapDrawable) contactInfo.photo).getBitmap();
+    }
+    return largeIcon;
+  }
+
+  /**
+   * Given a bitmap, returns a rounded version of the icon suitable for display in a notification.
+   *
+   * @param context The context.
+   * @param bitmap The bitmap to round.
+   * @return The rounded bitmap.
+   */
+  private @Nullable Bitmap getRoundedIcon(Context context, @Nullable Bitmap bitmap) {
+    if (bitmap == null) {
+      return null;
+    }
+    final int height =
+        (int) context.getResources().getDimension(android.R.dimen.notification_large_icon_height);
+    final int width =
+        (int) context.getResources().getDimension(android.R.dimen.notification_large_icon_width);
+    return BitmapUtil.getRoundedBitmap(bitmap, width, height);
+  }
+
+  /**
+   * Builds a notification content title for a call. If the call is a conference call, it is
+   * identified as such. Otherwise an attempt is made to show an associated contact name or phone
+   * number.
+   *
+   * @param context The context.
+   * @param contactsPreferences Contacts preferences, used to determine the preferred formatting for
+   *     contact names.
+   * @param contactInfo The contact info which was looked up in the contact cache.
+   * @param call The call to generate a title for.
+   * @return The content title.
+   */
+  private @Nullable String getContentTitle(
+      Context context,
+      @Nullable ContactsPreferences contactsPreferences,
+      ContactInfoCache.ContactCacheEntry contactInfo,
+      android.telecom.Call call) {
+
+    if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE)
+        && !call.getDetails()
+            .hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {
+
+      return context.getResources().getString(R.string.conference_call_name);
+    }
+
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, contactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return TextUtils.isEmpty(contactInfo.number)
+          ? null
+          : BidiFormatter.getInstance()
+              .unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR);
+    }
+    return preferredName;
+  }
+
+  /**
+   * Gets a "person reference" for a notification, used by the system to determine whether the
+   * notification should be allowed past notification interruption filters.
+   *
+   * @param contactInfo The contact info from cache.
+   * @param call The call.
+   * @return the person reference.
+   */
+  private String getPersonReference(ContactInfoCache.ContactCacheEntry contactInfo, Call call) {
+
+    String number = TelecomCallUtil.getNumber(call);
+    // Query {@link Contacts#CONTENT_LOOKUP_URI} directly with work lookup key is not allowed.
+    // So, do not pass {@link Contacts#CONTENT_LOOKUP_URI} to NotificationManager to avoid
+    // NotificationManager using it.
+    if (contactInfo.lookupUri != null && contactInfo.userType != ContactsUtils.USER_TYPE_WORK) {
+      return contactInfo.lookupUri.toString();
+    } else if (!TextUtils.isEmpty(number)) {
+      return Uri.fromParts(PhoneAccount.SCHEME_TEL, number, null).toString();
+    }
+    return "";
+  }
+
+  private static class DialerCallDelegateStub implements DialerCallDelegate {
+
+    @Override
+    public DialerCall getDialerCallFromTelecomCall(Call telecomCall) {
+      return null;
+    }
+  }
+
+  /** Represents a call and associated cached notification data. */
+  private static class NotificationInfo {
+
+    @NonNull private final Call mCall;
+    private final int mNotificationId;
+    @Nullable private String mContentTitle;
+    @Nullable private Bitmap mLargeIcon;
+    @Nullable private String mPersonReference;
+
+    public NotificationInfo(@NonNull Call call, int notificationId) {
+      mCall = call;
+      mNotificationId = notificationId;
+    }
+
+    public Call getCall() {
+      return mCall;
+    }
+
+    public int getNotificationId() {
+      return mNotificationId;
+    }
+
+    public @Nullable String getContentTitle() {
+      return mContentTitle;
+    }
+
+    public void setContentTitle(@Nullable String contentTitle) {
+      mContentTitle = contentTitle;
+    }
+
+    public @Nullable Bitmap getLargeIcon() {
+      return mLargeIcon;
+    }
+
+    public void setLargeIcon(@Nullable Bitmap largeIcon) {
+      mLargeIcon = largeIcon;
+    }
+
+    public @Nullable String getPersonReference() {
+      return mPersonReference;
+    }
+
+    public void setPersonReference(@Nullable String personReference) {
+      mPersonReference = personReference;
+    }
+  }
+}
diff --git a/java/com/android/incallui/InCallActivity.java b/java/com/android/incallui/InCallActivity.java
new file mode 100644
index 0000000..3074159
--- /dev/null
+++ b/java/com/android/incallui/InCallActivity.java
@@ -0,0 +1,756 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.drawable.GradientDrawable;
+import android.graphics.drawable.GradientDrawable.Orientation;
+import android.os.Bundle;
+import android.support.annotation.ColorInt;
+import android.support.annotation.FloatRange;
+import android.support.annotation.Nullable;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.graphics.ColorUtils;
+import android.telecom.DisconnectCause;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.ActivityCompat;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.ScreenEvent;
+import com.android.incallui.answer.bindings.AnswerBindings;
+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.answerproximitysensor.PseudoScreenState;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.incall.bindings.InCallBindings;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegateFactory;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.InCallScreenDelegateFactory;
+import com.android.incallui.video.bindings.VideoBindings;
+import com.android.incallui.video.protocol.VideoCallScreen;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+import com.android.incallui.video.protocol.VideoCallScreenDelegateFactory;
+
+/** Version of {@link InCallActivity} that shows the new UI */
+public class InCallActivity extends TransactionSafeFragmentActivity
+    implements AnswerScreenDelegateFactory,
+        InCallScreenDelegateFactory,
+        InCallButtonUiDelegateFactory,
+        VideoCallScreenDelegateFactory,
+        PseudoScreenState.StateChangedListener {
+
+  private static final String TAG_IN_CALL_SCREEN = "tag_in_call_screen";
+  private static final String TAG_ANSWER_SCREEN = "tag_answer_screen";
+  private static final String TAG_VIDEO_CALL_SCREEN = "tag_video_call_screen";
+
+  private static final String DID_SHOW_ANSWER_SCREEN_KEY = "did_show_answer_screen";
+  private static final String DID_SHOW_IN_CALL_SCREEN_KEY = "did_show_in_call_screen";
+  private static final String DID_SHOW_VIDEO_CALL_SCREEN_KEY = "did_show_video_call_screen";
+
+  private final InCallActivityCommon common;
+  private boolean didShowAnswerScreen;
+  private boolean didShowInCallScreen;
+  private boolean didShowVideoCallScreen;
+  private int[] backgroundDrawableColors;
+  private GradientDrawable backgroundDrawable;
+  private boolean isVisible;
+  private View pseudoBlackScreenOverlay;
+  private boolean touchDownWhenPseudoScreenOff;
+  private boolean isInShowMainInCallFragment;
+  private boolean needDismissPendingDialogs;
+
+  public InCallActivity() {
+    common = new InCallActivityCommon(this);
+  }
+
+  public static Intent getIntent(
+      Context context,
+      boolean showDialpad,
+      boolean newOutgoingCall,
+      boolean isVideoCall,
+      boolean isForFullScreen) {
+    Intent intent = new Intent(Intent.ACTION_MAIN, null);
+    intent.setFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION | Intent.FLAG_ACTIVITY_NEW_TASK);
+    intent.setClass(context, InCallActivity.class);
+    InCallActivityCommon.setIntentExtras(intent, showDialpad, newOutgoingCall, isForFullScreen);
+    return intent;
+  }
+
+  @Override
+  protected void onResumeFragments() {
+    super.onResumeFragments();
+    if (needDismissPendingDialogs) {
+      dismissPendingDialogs();
+    }
+  }
+
+  @Override
+  protected void onCreate(Bundle icicle) {
+    LogUtil.i("InCallActivity.onCreate", "");
+    super.onCreate(icicle);
+
+    if (icicle != null) {
+      didShowAnswerScreen = icicle.getBoolean(DID_SHOW_ANSWER_SCREEN_KEY);
+      didShowInCallScreen = icicle.getBoolean(DID_SHOW_IN_CALL_SCREEN_KEY);
+      didShowVideoCallScreen = icicle.getBoolean(DID_SHOW_VIDEO_CALL_SCREEN_KEY);
+    }
+
+    common.onCreate(icicle);
+
+    getWindow()
+        .getDecorView()
+        .setSystemUiVisibility(
+            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
+
+    pseudoBlackScreenOverlay = findViewById(R.id.psuedo_black_screen_overlay);
+  }
+
+  @Override
+  protected void onSaveInstanceState(Bundle out) {
+    LogUtil.i("InCallActivity.onSaveInstanceState", "");
+    common.onSaveInstanceState(out);
+    out.putBoolean(DID_SHOW_ANSWER_SCREEN_KEY, didShowAnswerScreen);
+    out.putBoolean(DID_SHOW_IN_CALL_SCREEN_KEY, didShowInCallScreen);
+    out.putBoolean(DID_SHOW_VIDEO_CALL_SCREEN_KEY, didShowVideoCallScreen);
+    super.onSaveInstanceState(out);
+    isVisible = false;
+  }
+
+  @Override
+  protected void onStart() {
+    LogUtil.i("InCallActivity.onStart", "");
+    super.onStart();
+    isVisible = true;
+    showMainInCallFragment();
+    common.onStart();
+    if (ActivityCompat.isInMultiWindowMode(this)
+        && !getResources().getBoolean(R.bool.incall_dialpad_allowed)) {
+      // Hide the dialpad because there may not be enough room
+      showDialpadFragment(false, false);
+    }
+  }
+
+  @Override
+  protected void onResume() {
+    LogUtil.i("InCallActivity.onResume", "");
+    super.onResume();
+    common.onResume();
+    PseudoScreenState pseudoScreenState = InCallPresenter.getInstance().getPseudoScreenState();
+    pseudoScreenState.addListener(this);
+    onPseudoScreenStateChanged(pseudoScreenState.isOn());
+  }
+
+  /** onPause is guaranteed to be called when the InCallActivity goes in the background. */
+  @Override
+  protected void onPause() {
+    LogUtil.i("InCallActivity.onPause", "");
+    super.onPause();
+    common.onPause();
+    InCallPresenter.getInstance().getPseudoScreenState().removeListener(this);
+  }
+
+  @Override
+  protected void onStop() {
+    LogUtil.i("InCallActivity.onStop", "");
+    super.onStop();
+    common.onStop();
+    isVisible = false;
+  }
+
+  @Override
+  protected void onDestroy() {
+    LogUtil.i("InCallActivity.onDestroy", "");
+    super.onDestroy();
+    common.onDestroy();
+  }
+
+  @Override
+  public void finish() {
+    if (shouldCloseActivityOnFinish()) {
+      super.finish();
+    }
+  }
+
+  private boolean shouldCloseActivityOnFinish() {
+    if (!isVisible()) {
+      LogUtil.i(
+          "InCallActivity.shouldCloseActivityOnFinish",
+          "allowing activity to be closed because it's not visible");
+      return true;
+    }
+
+    if (common.hasPendingDialogs()) {
+      LogUtil.i(
+          "InCallActivity.shouldCloseActivityOnFinish", "dialog is visible, not closing activity");
+      return false;
+    }
+
+    AnswerScreen answerScreen = getAnswerScreen();
+    if (answerScreen != null && answerScreen.hasPendingDialogs()) {
+      LogUtil.i(
+          "InCallActivity.shouldCloseActivityOnFinish",
+          "answer screen dialog is visible, not closing activity");
+      return false;
+    }
+
+    LogUtil.i(
+        "InCallActivity.shouldCloseActivityOnFinish",
+        "activity is visible and has no dialogs, allowing activity to close");
+    return true;
+  }
+
+  @Override
+  protected void onNewIntent(Intent intent) {
+    LogUtil.i("InCallActivity.onNewIntent", "");
+    common.onNewIntent(intent);
+
+    // If the screen is off, we need to make sure it gets turned on for incoming calls.
+    // This normally works just fine thanks to FLAG_TURN_SCREEN_ON but that only works
+    // when the activity is first created. Therefore, to ensure the screen is turned on
+    // for the call waiting case, we recreate() the current activity. There should be no jank from
+    // this since the screen is already off and will remain so until our new activity is up.
+    if (!isVisible()) {
+      LogUtil.i("InCallActivity.onNewIntent", "Restarting InCallActivity to force screen on.");
+      recreate();
+    }
+  }
+
+  @Override
+  public void onBackPressed() {
+    LogUtil.i("InCallActivity.onBackPressed", "");
+    if (!common.onBackPressed(didShowInCallScreen || didShowVideoCallScreen)) {
+      super.onBackPressed();
+    }
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    LogUtil.i("InCallActivity.onOptionsItemSelected", "item: " + item);
+    if (item.getItemId() == android.R.id.home) {
+      onBackPressed();
+      return true;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    if (common.onKeyUp(keyCode, event)) {
+      return true;
+    }
+    return super.onKeyUp(keyCode, event);
+  }
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (common.onKeyDown(keyCode, event)) {
+      return true;
+    }
+    return super.onKeyDown(keyCode, event);
+  }
+
+  public boolean isInCallScreenAnimating() {
+    return false;
+  }
+
+  public void showConferenceFragment(boolean show) {
+    if (show) {
+      startActivity(new Intent(this, ManageConferenceActivity.class));
+    }
+  }
+
+  public boolean showDialpadFragment(boolean show, boolean animate) {
+    boolean didChange = common.showDialpadFragment(show, animate);
+    if (didChange) {
+      // Note:  onInCallScreenDialpadVisibilityChange is called here to ensure that the dialpad FAB
+      // repositions itself.
+      getInCallScreen().onInCallScreenDialpadVisibilityChange(show);
+    }
+    return didChange;
+  }
+
+  public boolean isDialpadVisible() {
+    return common.isDialpadVisible();
+  }
+
+  public void onForegroundCallChanged(DialerCall newForegroundCall) {
+    common.updateTaskDescription();
+    if (didShowAnswerScreen && newForegroundCall != null) {
+      if (newForegroundCall.getState() == State.DISCONNECTED
+          || newForegroundCall.getState() == State.IDLE) {
+        LogUtil.i(
+            "InCallActivity.onForegroundCallChanged",
+            "rejecting incoming call, not updating " + "window background color");
+      }
+    } else {
+      LogUtil.v("InCallActivity.onForegroundCallChanged", "resetting background color");
+      updateWindowBackgroundColor(0);
+    }
+  }
+
+  public void updateWindowBackgroundColor(@FloatRange(from = -1f, to = 1.0f) float progress) {
+    ThemeColorManager themeColorManager = InCallPresenter.getInstance().getThemeColorManager();
+    @ColorInt int top;
+    @ColorInt int middle;
+    @ColorInt int bottom;
+    @ColorInt int gray = 0x66000000;
+
+    if (ActivityCompat.isInMultiWindowMode(this)) {
+      top = themeColorManager.getBackgroundColorSolid();
+      middle = themeColorManager.getBackgroundColorSolid();
+      bottom = themeColorManager.getBackgroundColorSolid();
+    } else {
+      top = themeColorManager.getBackgroundColorTop();
+      middle = themeColorManager.getBackgroundColorMiddle();
+      bottom = themeColorManager.getBackgroundColorBottom();
+    }
+
+    if (progress < 0) {
+      float correctedProgress = Math.abs(progress);
+      top = ColorUtils.blendARGB(top, gray, correctedProgress);
+      middle = ColorUtils.blendARGB(middle, gray, correctedProgress);
+      bottom = ColorUtils.blendARGB(bottom, gray, correctedProgress);
+    }
+
+    boolean backgroundDirty = false;
+    if (backgroundDrawable == null) {
+      backgroundDrawableColors = new int[] {top, middle, bottom};
+      backgroundDrawable = new GradientDrawable(Orientation.TOP_BOTTOM, backgroundDrawableColors);
+      backgroundDirty = true;
+    } else {
+      if (backgroundDrawableColors[0] != top) {
+        backgroundDrawableColors[0] = top;
+        backgroundDirty = true;
+      }
+      if (backgroundDrawableColors[1] != middle) {
+        backgroundDrawableColors[1] = middle;
+        backgroundDirty = true;
+      }
+      if (backgroundDrawableColors[2] != bottom) {
+        backgroundDrawableColors[2] = bottom;
+        backgroundDirty = true;
+      }
+      if (backgroundDirty) {
+        backgroundDrawable.setColors(backgroundDrawableColors);
+      }
+    }
+
+    if (backgroundDirty) {
+      getWindow().setBackgroundDrawable(backgroundDrawable);
+    }
+  }
+
+  public boolean isVisible() {
+    return isVisible;
+  }
+
+  public boolean getCallCardFragmentVisible() {
+    return didShowInCallScreen || didShowVideoCallScreen;
+  }
+
+  public void dismissKeyguard(boolean dismiss) {
+    common.dismissKeyguard(dismiss);
+  }
+
+  public void showPostCharWaitDialog(String callId, String chars) {
+    common.showPostCharWaitDialog(callId, chars);
+  }
+
+  public void maybeShowErrorDialogOnDisconnect(DisconnectCause disconnectCause) {
+    common.maybeShowErrorDialogOnDisconnect(disconnectCause);
+  }
+
+  public void dismissPendingDialogs() {
+    if (isVisible) {
+      LogUtil.i("InCallActivity.dismissPendingDialogs", "");
+      common.dismissPendingDialogs();
+      AnswerScreen answerScreen = getAnswerScreen();
+      if (answerScreen != null) {
+        answerScreen.dismissPendingDialogs();
+      }
+      needDismissPendingDialogs = false;
+    } else {
+      // The activity is not visible and onSaveInstanceState may have been called so defer the
+      // dismissing action.
+      LogUtil.i(
+          "InCallActivity.dismissPendingDialogs", "defer actions since activity is not visible");
+      needDismissPendingDialogs = true;
+    }
+  }
+
+  private void enableInCallOrientationEventListener(boolean enable) {
+    common.enableInCallOrientationEventListener(enable);
+  }
+
+  public void setExcludeFromRecents(boolean exclude) {
+    common.setExcludeFromRecents(exclude);
+  }
+
+  public void onResolveIntent(
+      DialerCall outgoingCall, boolean isNewOutgoingCall, boolean didShowAccountSelectionDialog) {
+    if (didShowAccountSelectionDialog) {
+      hideMainInCallFragment();
+    }
+  }
+
+  @Nullable
+  public FragmentManager getDialpadFragmentManager() {
+    InCallScreen inCallScreen = getInCallScreen();
+    if (inCallScreen != null) {
+      return inCallScreen.getInCallScreenFragment().getChildFragmentManager();
+    }
+    return null;
+  }
+
+  public int getDialpadContainerId() {
+    return getInCallScreen().getAnswerAndDialpadContainerResourceId();
+  }
+
+  @Override
+  public AnswerScreenDelegate newAnswerScreenDelegate(AnswerScreen answerScreen) {
+    DialerCall call = CallList.getInstance().getCallById(answerScreen.getCallId());
+    if (call == null) {
+      // This is a work around for a bug where we attempt to create a new delegate after the call
+      // has already been removed. An example of when this can happen is:
+      // 1. incoming video call in landscape mode
+      // 2. remote party hangs up
+      // 3. activity switches from landscape to portrait
+      // At step #3 the answer fragment will try to create a new answer delegate but the call won't
+      // exist. In this case we'll simply return a stub delegate that does nothing. This is ok
+      // because this new state is transient and the activity will be destroyed soon.
+      LogUtil.i("InCallActivity.onPrimaryCallStateChanged", "call doesn't exist, using stub");
+      return new AnswerScreenPresenterStub();
+    } else {
+      return new AnswerScreenPresenter(
+          this, answerScreen, CallList.getInstance().getCallById(answerScreen.getCallId()));
+    }
+  }
+
+  @Override
+  public InCallScreenDelegate newInCallScreenDelegate() {
+    return new CallCardPresenter(this);
+  }
+
+  @Override
+  public InCallButtonUiDelegate newInCallButtonUiDelegate() {
+    return new CallButtonPresenter(this);
+  }
+
+  @Override
+  public VideoCallScreenDelegate newVideoCallScreenDelegate() {
+    return new VideoCallPresenter();
+  }
+
+  public void onPrimaryCallStateChanged() {
+    LogUtil.i("InCallActivity.onPrimaryCallStateChanged", "");
+    showMainInCallFragment();
+  }
+
+  public void onWiFiToLteHandover(DialerCall call) {
+    common.showWifiToLteHandoverToast(call);
+  }
+
+  public void onHandoverToWifiFailed(DialerCall call) {
+    common.showWifiFailedDialog(call);
+  }
+
+  public void setAllowOrientationChange(boolean allowOrientationChange) {
+    if (!allowOrientationChange) {
+      setRequestedOrientation(InCallOrientationEventListener.ACTIVITY_PREFERENCE_DISALLOW_ROTATION);
+    } else {
+      setRequestedOrientation(InCallOrientationEventListener.ACTIVITY_PREFERENCE_ALLOW_ROTATION);
+    }
+    enableInCallOrientationEventListener(allowOrientationChange);
+  }
+
+  private void hideMainInCallFragment() {
+    LogUtil.i("InCallActivity.hideMainInCallFragment", "");
+    if (didShowInCallScreen || didShowVideoCallScreen) {
+      FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
+      hideInCallScreenFragment(transaction);
+      hideVideoCallScreenFragment(transaction);
+      transaction.commitAllowingStateLoss();
+      getSupportFragmentManager().executePendingTransactions();
+    }
+  }
+
+  private void showMainInCallFragment() {
+    // If the activity's onStart method hasn't been called yet then defer doing any work.
+    if (!isVisible) {
+      LogUtil.i("InCallActivity.showMainInCallFragment", "not visible yet/anymore");
+      return;
+    }
+
+    // Don't let this be reentrant.
+    if (isInShowMainInCallFragment) {
+      LogUtil.i("InCallActivity.showMainInCallFragment", "already in method, bailing");
+      return;
+    }
+
+    isInShowMainInCallFragment = true;
+    ShouldShowAnswerUiResult shouldShowAnswerUi = getShouldShowAnswerUi();
+    boolean shouldShowVideoUi = getShouldShowVideoUi();
+    LogUtil.i(
+        "InCallActivity.showMainInCallFragment",
+        "shouldShowAnswerUi: %b, shouldShowVideoUi: %b, "
+            + "didShowAnswerScreen: %b, didShowInCallScreen: %b, didShowVideoCallScreen: %b",
+        shouldShowAnswerUi.shouldShow,
+        shouldShowVideoUi,
+        didShowAnswerScreen,
+        didShowInCallScreen,
+        didShowVideoCallScreen);
+    // Only video call ui allows orientation change.
+    setAllowOrientationChange(shouldShowVideoUi);
+
+    FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
+    boolean didChangeInCall;
+    boolean didChangeVideo;
+    boolean didChangeAnswer;
+    if (shouldShowAnswerUi.shouldShow) {
+      didChangeInCall = hideInCallScreenFragment(transaction);
+      didChangeVideo = hideVideoCallScreenFragment(transaction);
+      didChangeAnswer = showAnswerScreenFragment(transaction, shouldShowAnswerUi.call);
+    } else if (shouldShowVideoUi) {
+      didChangeInCall = hideInCallScreenFragment(transaction);
+      didChangeVideo = showVideoCallScreenFragment(transaction);
+      didChangeAnswer = hideAnswerScreenFragment(transaction);
+    } else {
+      didChangeInCall = showInCallScreenFragment(transaction);
+      didChangeVideo = hideVideoCallScreenFragment(transaction);
+      didChangeAnswer = hideAnswerScreenFragment(transaction);
+    }
+
+    if (didChangeInCall || didChangeVideo || didChangeAnswer) {
+      transaction.commitNow();
+      Logger.get(this).logScreenView(ScreenEvent.Type.INCALL, this);
+    }
+    isInShowMainInCallFragment = false;
+  }
+
+  private ShouldShowAnswerUiResult getShouldShowAnswerUi() {
+    DialerCall call = CallList.getInstance().getIncomingCall();
+    if (call != null) {
+      LogUtil.i("InCallActivity.getShouldShowAnswerUi", "found incoming call");
+      return new ShouldShowAnswerUiResult(true, call);
+    }
+
+    call = CallList.getInstance().getVideoUpgradeRequestCall();
+    if (call != null) {
+      LogUtil.i("InCallActivity.getShouldShowAnswerUi", "found video upgrade request");
+      return new ShouldShowAnswerUiResult(true, call);
+    }
+
+    // Check if we're showing the answer screen and the call is disconnected. If this condition is
+    // true then we won't switch from the answer UI to the in call UI. This prevents flicker when
+    // the user rejects an incoming call.
+    call = CallList.getInstance().getFirstCall();
+    if (call == null) {
+      call = CallList.getInstance().getBackgroundCall();
+    }
+    if (didShowAnswerScreen && (call == null || call.getState() == State.DISCONNECTED)) {
+      LogUtil.i("InCallActivity.getShouldShowAnswerUi", "found disconnecting incoming call");
+      return new ShouldShowAnswerUiResult(true, call);
+    }
+
+    return new ShouldShowAnswerUiResult(false, null);
+  }
+
+  private boolean getShouldShowVideoUi() {
+    DialerCall call = CallList.getInstance().getFirstCall();
+    if (call == null) {
+      LogUtil.i("InCallActivity.getShouldShowVideoUi", "null call");
+      return false;
+    }
+
+    if (VideoUtils.isVideoCall(call)) {
+      LogUtil.i("InCallActivity.getShouldShowVideoUi", "found video call");
+      return true;
+    }
+
+    if (VideoUtils.hasSentVideoUpgradeRequest(call)) {
+      LogUtil.i("InCallActivity.getShouldShowVideoUi", "upgrading to video");
+      return true;
+    }
+
+    return false;
+  }
+
+  private boolean showAnswerScreenFragment(FragmentTransaction transaction, DialerCall call) {
+    // When rejecting a call the active call can become null in which case we should continue
+    // showing the answer screen.
+    if (didShowAnswerScreen && call == null) {
+      return false;
+    }
+
+    boolean isVideoUpgradeRequest = VideoUtils.hasReceivedVideoUpgradeRequest(call);
+    int videoState = isVideoUpgradeRequest ? call.getRequestedVideoState() : call.getVideoState();
+
+    // Check if we're already showing an answer screen for this call.
+    if (didShowAnswerScreen) {
+      AnswerScreen answerScreen = getAnswerScreen();
+      if (answerScreen.getCallId().equals(call.getId())
+          && answerScreen.getVideoState() == videoState
+          && answerScreen.isVideoUpgradeRequest() == isVideoUpgradeRequest) {
+        return false;
+      }
+      LogUtil.i(
+          "InCallActivity.showAnswerScreenFragment",
+          "answer fragment exists but arguments do not match");
+      hideAnswerScreenFragment(transaction);
+    }
+
+    // Show a new answer screen.
+    AnswerScreen answerScreen =
+        AnswerBindings.createAnswerScreen(call.getId(), videoState, isVideoUpgradeRequest);
+    transaction.add(R.id.main, answerScreen.getAnswerScreenFragment(), TAG_ANSWER_SCREEN);
+
+    Logger.get(this).logScreenView(ScreenEvent.Type.INCOMING_CALL, this);
+    didShowAnswerScreen = true;
+    return true;
+  }
+
+  private boolean hideAnswerScreenFragment(FragmentTransaction transaction) {
+    if (!didShowAnswerScreen) {
+      return false;
+    }
+    AnswerScreen answerScreen = getAnswerScreen();
+    if (answerScreen != null) {
+      transaction.remove(answerScreen.getAnswerScreenFragment());
+    }
+
+    didShowAnswerScreen = false;
+    return true;
+  }
+
+  private boolean showInCallScreenFragment(FragmentTransaction transaction) {
+    if (didShowInCallScreen) {
+      return false;
+    }
+    InCallScreen inCallScreen = getInCallScreen();
+    if (inCallScreen == null) {
+      inCallScreen = InCallBindings.createInCallScreen();
+      transaction.add(R.id.main, inCallScreen.getInCallScreenFragment(), TAG_IN_CALL_SCREEN);
+    } else {
+      transaction.show(inCallScreen.getInCallScreenFragment());
+    }
+    Logger.get(this).logScreenView(ScreenEvent.Type.INCALL, this);
+    didShowInCallScreen = true;
+    return true;
+  }
+
+  private boolean hideInCallScreenFragment(FragmentTransaction transaction) {
+    if (!didShowInCallScreen) {
+      return false;
+    }
+    InCallScreen inCallScreen = getInCallScreen();
+    if (inCallScreen != null) {
+      transaction.hide(inCallScreen.getInCallScreenFragment());
+    }
+    didShowInCallScreen = false;
+    return true;
+  }
+
+  private boolean showVideoCallScreenFragment(FragmentTransaction transaction) {
+    if (didShowVideoCallScreen) {
+      return false;
+    }
+
+    VideoCallScreen videoCallScreen = VideoBindings.createVideoCallScreen();
+    transaction.add(R.id.main, videoCallScreen.getVideoCallScreenFragment(), TAG_VIDEO_CALL_SCREEN);
+
+    Logger.get(this).logScreenView(ScreenEvent.Type.INCALL, this);
+    didShowVideoCallScreen = true;
+    return true;
+  }
+
+  private boolean hideVideoCallScreenFragment(FragmentTransaction transaction) {
+    if (!didShowVideoCallScreen) {
+      return false;
+    }
+    VideoCallScreen videoCallScreen = getVideoCallScreen();
+    if (videoCallScreen != null) {
+      transaction.remove(videoCallScreen.getVideoCallScreenFragment());
+    }
+    didShowVideoCallScreen = false;
+    return true;
+  }
+
+  AnswerScreen getAnswerScreen() {
+    return (AnswerScreen) getSupportFragmentManager().findFragmentByTag(TAG_ANSWER_SCREEN);
+  }
+
+  InCallScreen getInCallScreen() {
+    return (InCallScreen) getSupportFragmentManager().findFragmentByTag(TAG_IN_CALL_SCREEN);
+  }
+
+  VideoCallScreen getVideoCallScreen() {
+    return (VideoCallScreen) getSupportFragmentManager().findFragmentByTag(TAG_VIDEO_CALL_SCREEN);
+  }
+
+  @Override
+  public void onPseudoScreenStateChanged(boolean isOn) {
+    LogUtil.i("InCallActivity.onPseudoScreenStateChanged", "isOn: " + isOn);
+    pseudoBlackScreenOverlay.setVisibility(isOn ? View.GONE : View.VISIBLE);
+  }
+
+  /**
+   * For some touch related issue, turning off the screen can be faked by drawing a black view over
+   * the activity. All touch events started when the screen is "off" is rejected.
+   *
+   * @see PseudoScreenState
+   */
+  @Override
+  public boolean dispatchTouchEvent(MotionEvent event) {
+    // Reject any gesture that started when the screen is in the fake off state.
+    if (touchDownWhenPseudoScreenOff) {
+      if (event.getAction() == MotionEvent.ACTION_UP) {
+        touchDownWhenPseudoScreenOff = false;
+      }
+      return true;
+    }
+    // Reject all touch event when the screen is in the fake off state.
+    if (!InCallPresenter.getInstance().getPseudoScreenState().isOn()) {
+      if (event.getAction() == MotionEvent.ACTION_DOWN) {
+        touchDownWhenPseudoScreenOff = true;
+        LogUtil.i("InCallActivity.dispatchTouchEvent", "touchDownWhenPseudoScreenOff");
+      }
+      return true;
+    }
+    return super.dispatchTouchEvent(event);
+  }
+
+  private static class ShouldShowAnswerUiResult {
+    public final boolean shouldShow;
+    public final DialerCall call;
+
+    ShouldShowAnswerUiResult(boolean shouldShow, DialerCall call) {
+      this.shouldShow = shouldShow;
+      this.call = call;
+    }
+  }
+}
diff --git a/java/com/android/incallui/InCallActivityCommon.java b/java/com/android/incallui/InCallActivityCommon.java
new file mode 100644
index 0000000..a2467dd
--- /dev/null
+++ b/java/com/android/incallui/InCallActivityCommon.java
@@ -0,0 +1,820 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.AppTask;
+import android.app.ActivityManager.TaskDescription;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.content.res.ResourcesCompat;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccountHandle;
+import android.text.TextUtils;
+import android.util.Pair;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.CheckBox;
+import android.widget.Toast;
+import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment;
+import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment.SelectPhoneAccountListener;
+import com.android.dialer.animation.AnimUtils;
+import com.android.dialer.animation.AnimationListenerAdapter;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.CompatUtils;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.ScreenEvent;
+import com.android.dialer.util.ViewUtil;
+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.wifi.EnableWifiCallingPrompt;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Shared functionality between the new and old in call activity. */
+public class InCallActivityCommon {
+
+  private static final String INTENT_EXTRA_SHOW_DIALPAD = "InCallActivity.show_dialpad";
+  private static final String INTENT_EXTRA_NEW_OUTGOING_CALL = "InCallActivity.new_outgoing_call";
+  private static final String INTENT_EXTRA_FOR_FULL_SCREEN =
+      "InCallActivity.for_full_screen_intent";
+
+  private static final String DIALPAD_TEXT_KEY = "InCallActivity.dialpad_text";
+
+  private static final String TAG_SELECT_ACCOUNT_FRAGMENT = "tag_select_account_fragment";
+  private static final String TAG_DIALPAD_FRAGMENT = "tag_dialpad_fragment";
+
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({
+    DIALPAD_REQUEST_NONE,
+    DIALPAD_REQUEST_SHOW,
+    DIALPAD_REQUEST_HIDE,
+  })
+  @interface DialpadRequestType {}
+
+  private static final int DIALPAD_REQUEST_NONE = 1;
+  private static final int DIALPAD_REQUEST_SHOW = 2;
+  private static final int DIALPAD_REQUEST_HIDE = 3;
+
+  private final InCallActivity inCallActivity;
+  private boolean dismissKeyguard;
+  private boolean showPostCharWaitDialogOnResume;
+  private String showPostCharWaitDialogCallId;
+  private String showPostCharWaitDialogChars;
+  private Dialog dialog;
+  private InCallOrientationEventListener inCallOrientationEventListener;
+  private Animation dialpadSlideInAnimation;
+  private Animation dialpadSlideOutAnimation;
+  private boolean animateDialpadOnShow;
+  private String dtmfTextToPreopulate;
+  @DialpadRequestType private int showDialpadRequest = DIALPAD_REQUEST_NONE;
+
+  private SelectPhoneAccountListener selectAccountListener =
+      new SelectPhoneAccountListener() {
+        @Override
+        public void onPhoneAccountSelected(
+            PhoneAccountHandle selectedAccountHandle, boolean setDefault, String callId) {
+          DialerCall call = CallList.getInstance().getCallById(callId);
+          LogUtil.i(
+              "InCallActivityCommon.SelectPhoneAccountListener.onPhoneAccountSelected",
+              "call: " + call);
+          if (call != null) {
+            call.phoneAccountSelected(selectedAccountHandle, setDefault);
+          }
+        }
+
+        @Override
+        public void onDialogDismissed(String callId) {
+          DialerCall call = CallList.getInstance().getCallById(callId);
+          LogUtil.i(
+              "InCallActivityCommon.SelectPhoneAccountListener.onDialogDismissed",
+              "disconnecting call: " + call);
+          if (call != null) {
+            call.disconnect();
+          }
+        }
+      };
+
+  public static void setIntentExtras(
+      Intent intent, boolean showDialpad, boolean newOutgoingCall, boolean isForFullScreen) {
+    if (showDialpad) {
+      intent.putExtra(INTENT_EXTRA_SHOW_DIALPAD, true);
+    }
+    intent.putExtra(INTENT_EXTRA_NEW_OUTGOING_CALL, newOutgoingCall);
+    intent.putExtra(INTENT_EXTRA_FOR_FULL_SCREEN, isForFullScreen);
+  }
+
+  public InCallActivityCommon(InCallActivity inCallActivity) {
+    this.inCallActivity = inCallActivity;
+  }
+
+  public void onCreate(Bundle icicle) {
+    // set this flag so this activity will stay in front of the keyguard
+    // Have the WindowManager filter out touch events that are "too fat".
+    int flags =
+        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
+            | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+            | WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;
+
+    inCallActivity.getWindow().addFlags(flags);
+
+    inCallActivity.setContentView(R.layout.incall_screen);
+
+    internalResolveIntent(inCallActivity.getIntent());
+
+    boolean isLandscape =
+        inCallActivity.getResources().getConfiguration().orientation
+            == Configuration.ORIENTATION_LANDSCAPE;
+    boolean isRtl = ViewUtil.isRtl();
+
+    if (isLandscape) {
+      dialpadSlideInAnimation =
+          AnimationUtils.loadAnimation(
+              inCallActivity, isRtl ? R.anim.dialpad_slide_in_left : R.anim.dialpad_slide_in_right);
+      dialpadSlideOutAnimation =
+          AnimationUtils.loadAnimation(
+              inCallActivity,
+              isRtl ? R.anim.dialpad_slide_out_left : R.anim.dialpad_slide_out_right);
+    } else {
+      dialpadSlideInAnimation =
+          AnimationUtils.loadAnimation(inCallActivity, R.anim.dialpad_slide_in_bottom);
+      dialpadSlideOutAnimation =
+          AnimationUtils.loadAnimation(inCallActivity, R.anim.dialpad_slide_out_bottom);
+    }
+
+    dialpadSlideInAnimation.setInterpolator(AnimUtils.EASE_IN);
+    dialpadSlideOutAnimation.setInterpolator(AnimUtils.EASE_OUT);
+
+    dialpadSlideOutAnimation.setAnimationListener(
+        new AnimationListenerAdapter() {
+          @Override
+          public void onAnimationEnd(Animation animation) {
+            performHideDialpadFragment();
+          }
+        });
+
+    if (icicle != null) {
+      // If the dialpad was shown before, set variables indicating it should be shown and
+      // populated with the previous DTMF text.  The dialpad is actually shown and populated
+      // in onResume() to ensure the hosting fragment has been inflated and is ready to receive it.
+      if (icicle.containsKey(INTENT_EXTRA_SHOW_DIALPAD)) {
+        boolean showDialpad = icicle.getBoolean(INTENT_EXTRA_SHOW_DIALPAD);
+        showDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_HIDE;
+        animateDialpadOnShow = false;
+      }
+      dtmfTextToPreopulate = icicle.getString(DIALPAD_TEXT_KEY);
+
+      SelectPhoneAccountDialogFragment dialogFragment =
+          (SelectPhoneAccountDialogFragment)
+              inCallActivity.getFragmentManager().findFragmentByTag(TAG_SELECT_ACCOUNT_FRAGMENT);
+      if (dialogFragment != null) {
+        dialogFragment.setListener(selectAccountListener);
+      }
+    }
+
+    inCallOrientationEventListener = new InCallOrientationEventListener(inCallActivity);
+  }
+
+  public void onSaveInstanceState(Bundle out) {
+    // TODO: The dialpad fragment should handle this as part of its own state
+    out.putBoolean(INTENT_EXTRA_SHOW_DIALPAD, isDialpadVisible());
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    if (dialpadFragment != null) {
+      out.putString(DIALPAD_TEXT_KEY, dialpadFragment.getDtmfText());
+    }
+  }
+
+  public void onStart() {
+    // setting activity should be last thing in setup process
+    InCallPresenter.getInstance().setActivity(inCallActivity);
+    enableInCallOrientationEventListener(
+        inCallActivity.getRequestedOrientation()
+            == InCallOrientationEventListener.ACTIVITY_PREFERENCE_ALLOW_ROTATION);
+
+    InCallPresenter.getInstance().onActivityStarted();
+  }
+
+  public void onResume() {
+    if (InCallPresenter.getInstance().isReadyForTearDown()) {
+      LogUtil.i(
+          "InCallActivityCommon.onResume",
+          "InCallPresenter is ready for tear down, not sending updates");
+    } else {
+      updateTaskDescription();
+      InCallPresenter.getInstance().onUiShowing(true);
+    }
+
+    // If there is a pending request to show or hide the dialpad, handle that now.
+    if (showDialpadRequest != DIALPAD_REQUEST_NONE) {
+      if (showDialpadRequest == DIALPAD_REQUEST_SHOW) {
+        // Exit fullscreen so that the user has access to the dialpad hide/show button and
+        // can hide the dialpad.  Important when showing the dialpad from within dialer.
+        InCallPresenter.getInstance().setFullScreen(false, true /* force */);
+
+        inCallActivity.showDialpadFragment(true /* show */, animateDialpadOnShow /* animate */);
+        animateDialpadOnShow = false;
+
+        DialpadFragment dialpadFragment = getDialpadFragment();
+        if (dialpadFragment != null) {
+          dialpadFragment.setDtmfText(dtmfTextToPreopulate);
+          dtmfTextToPreopulate = null;
+        }
+      } else {
+        LogUtil.i("InCallActivityCommon.onResume", "force hide dialpad");
+        if (getDialpadFragment() != null) {
+          inCallActivity.showDialpadFragment(false /* show */, false /* animate */);
+        }
+      }
+      showDialpadRequest = DIALPAD_REQUEST_NONE;
+    }
+
+    if (showPostCharWaitDialogOnResume) {
+      showPostCharWaitDialog(showPostCharWaitDialogCallId, showPostCharWaitDialogChars);
+    }
+
+    CallList.getInstance()
+        .onInCallUiShown(
+            inCallActivity.getIntent().getBooleanExtra(INTENT_EXTRA_FOR_FULL_SCREEN, false));
+  }
+
+  // onPause is guaranteed to be called when the InCallActivity goes
+  // in the background.
+  public void onPause() {
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    if (dialpadFragment != null) {
+      dialpadFragment.onDialerKeyUp(null);
+    }
+
+    InCallPresenter.getInstance().onUiShowing(false);
+    if (inCallActivity.isFinishing()) {
+      InCallPresenter.getInstance().unsetActivity(inCallActivity);
+    }
+  }
+
+  public void onStop() {
+    enableInCallOrientationEventListener(false);
+    InCallPresenter.getInstance().updateIsChangingConfigurations();
+    InCallPresenter.getInstance().onActivityStopped();
+  }
+
+  public void onDestroy() {
+    InCallPresenter.getInstance().unsetActivity(inCallActivity);
+    InCallPresenter.getInstance().updateIsChangingConfigurations();
+  }
+
+  public void onNewIntent(Intent intent) {
+    LogUtil.i("InCallActivityCommon.onNewIntent", "");
+
+    // We're being re-launched with a new Intent.  Since it's possible for a
+    // single InCallActivity instance to persist indefinitely (even if we
+    // finish() ourselves), this sequence can potentially happen any time
+    // the InCallActivity needs to be displayed.
+
+    // Stash away the new intent so that we can get it in the future
+    // by calling getIntent().  (Otherwise getIntent() will return the
+    // original Intent from when we first got created!)
+    inCallActivity.setIntent(intent);
+
+    // Activities are always paused before receiving a new intent, so
+    // we can count on our onResume() method being called next.
+
+    // Just like in onCreate(), handle the intent.
+    internalResolveIntent(intent);
+  }
+
+  public boolean onBackPressed(boolean isInCallScreenVisible) {
+    LogUtil.i("InCallActivityCommon.onBackPressed", "");
+
+    // BACK is also used to exit out of any "special modes" of the
+    // in-call UI:
+    if (!inCallActivity.isVisible()) {
+      return true;
+    }
+
+    if (!isInCallScreenVisible) {
+      return true;
+    }
+
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    if (dialpadFragment != null && dialpadFragment.isVisible()) {
+      inCallActivity.showDialpadFragment(false /* show */, true /* animate */);
+      return true;
+    }
+
+    // Always disable the Back key while an incoming call is ringing
+    DialerCall call = CallList.getInstance().getIncomingCall();
+    if (call != null) {
+      LogUtil.i("InCallActivityCommon.onBackPressed", "consume Back press for an incoming call");
+      return true;
+    }
+
+    // Nothing special to do. Fall back to the default behavior.
+    return false;
+  }
+
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    // push input to the dialer.
+    if (dialpadFragment != null
+        && (dialpadFragment.isVisible())
+        && (dialpadFragment.onDialerKeyUp(event))) {
+      return true;
+    } else if (keyCode == KeyEvent.KEYCODE_CALL) {
+      // Always consume CALL to be sure the PhoneWindow won't do anything with it
+      return true;
+    }
+    return false;
+  }
+
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    switch (keyCode) {
+      case KeyEvent.KEYCODE_CALL:
+        boolean handled = InCallPresenter.getInstance().handleCallKey();
+        if (!handled) {
+          LogUtil.e(
+              "InCallActivityCommon.onKeyDown",
+              "InCallPresenter should always handle KEYCODE_CALL in onKeyDown");
+        }
+        // Always consume CALL to be sure the PhoneWindow won't do anything with it
+        return true;
+
+        // Note there's no KeyEvent.KEYCODE_ENDCALL case here.
+        // The standard system-wide handling of the ENDCALL key
+        // (see PhoneWindowManager's handling of KEYCODE_ENDCALL)
+        // already implements exactly what the UI spec wants,
+        // namely (1) "hang up" if there's a current active call,
+        // or (2) "don't answer" if there's a current ringing call.
+
+      case KeyEvent.KEYCODE_CAMERA:
+        // Disable the CAMERA button while in-call since it's too
+        // easy to press accidentally.
+        return true;
+
+      case KeyEvent.KEYCODE_VOLUME_UP:
+      case KeyEvent.KEYCODE_VOLUME_DOWN:
+      case KeyEvent.KEYCODE_VOLUME_MUTE:
+        // Ringer silencing handled by PhoneWindowManager.
+        break;
+
+      case KeyEvent.KEYCODE_MUTE:
+        TelecomAdapter.getInstance()
+            .mute(!AudioModeProvider.getInstance().getAudioState().isMuted());
+        return true;
+
+        // Various testing/debugging features, enabled ONLY when VERBOSE == true.
+      case KeyEvent.KEYCODE_SLASH:
+        if (LogUtil.isVerboseEnabled()) {
+          LogUtil.v(
+              "InCallActivityCommon.onKeyDown",
+              "----------- InCallActivity View dump --------------");
+          // Dump starting from the top-level view of the entire activity:
+          Window w = inCallActivity.getWindow();
+          View decorView = w.getDecorView();
+          LogUtil.v("InCallActivityCommon.onKeyDown", "View dump:" + decorView);
+          return true;
+        }
+        break;
+      case KeyEvent.KEYCODE_EQUALS:
+        break;
+    }
+
+    return event.getRepeatCount() == 0 && handleDialerKeyDown(keyCode, event);
+  }
+
+  private boolean handleDialerKeyDown(int keyCode, KeyEvent event) {
+    LogUtil.v("InCallActivityCommon.handleDialerKeyDown", "keyCode %d, event: %s", keyCode, event);
+
+    // As soon as the user starts typing valid dialable keys on the
+    // keyboard (presumably to type DTMF tones) we start passing the
+    // key events to the DTMFDialer's onDialerKeyDown.
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    if (dialpadFragment != null && dialpadFragment.isVisible()) {
+      return dialpadFragment.onDialerKeyDown(event);
+    }
+
+    return false;
+  }
+
+  public void dismissKeyguard(boolean dismiss) {
+    if (dismissKeyguard == dismiss) {
+      return;
+    }
+    dismissKeyguard = dismiss;
+    if (dismiss) {
+      inCallActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
+    } else {
+      inCallActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
+    }
+  }
+
+  public void showPostCharWaitDialog(String callId, String chars) {
+    if (inCallActivity.isVisible()) {
+      PostCharDialogFragment fragment = new PostCharDialogFragment(callId, chars);
+      fragment.show(inCallActivity.getSupportFragmentManager(), "postCharWait");
+
+      showPostCharWaitDialogOnResume = false;
+      showPostCharWaitDialogCallId = null;
+      showPostCharWaitDialogChars = null;
+    } else {
+      showPostCharWaitDialogOnResume = true;
+      showPostCharWaitDialogCallId = callId;
+      showPostCharWaitDialogChars = chars;
+    }
+  }
+
+  public void maybeShowErrorDialogOnDisconnect(DisconnectCause cause) {
+    LogUtil.i(
+        "InCallActivityCommon.maybeShowErrorDialogOnDisconnect", "disconnect cause: %s", cause);
+
+    if (!inCallActivity.isFinishing()) {
+      if (EnableWifiCallingPrompt.shouldShowPrompt(cause)) {
+        Pair<Dialog, CharSequence> pair =
+            EnableWifiCallingPrompt.createDialog(inCallActivity, cause);
+        showErrorDialog(pair.first, pair.second);
+      } else if (shouldShowDisconnectErrorDialog(cause)) {
+        Pair<Dialog, CharSequence> pair = getDisconnectErrorDialog(inCallActivity, cause);
+        showErrorDialog(pair.first, pair.second);
+      }
+    }
+  }
+
+  /**
+   * When relaunching from the dialer app, {@code showDialpad} indicates whether the dialpad should
+   * be shown on launch.
+   *
+   * @param showDialpad {@code true} to indicate the dialpad should be shown on launch, and {@code
+   *     false} to indicate no change should be made to the dialpad visibility.
+   */
+  private void relaunchedFromDialer(boolean showDialpad) {
+    showDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_NONE;
+    animateDialpadOnShow = true;
+
+    if (showDialpadRequest == DIALPAD_REQUEST_SHOW) {
+      // 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) {
+        call.unhold();
+      }
+    }
+  }
+
+  public void dismissPendingDialogs() {
+    if (dialog != null) {
+      dialog.dismiss();
+      dialog = null;
+    }
+  }
+
+  private static boolean shouldShowDisconnectErrorDialog(@NonNull DisconnectCause cause) {
+    return !TextUtils.isEmpty(cause.getDescription())
+        && (cause.getCode() == DisconnectCause.ERROR
+            || cause.getCode() == DisconnectCause.RESTRICTED);
+  }
+
+  private static Pair<Dialog, CharSequence> getDisconnectErrorDialog(
+      @NonNull Context context, @NonNull DisconnectCause cause) {
+    CharSequence message = cause.getDescription();
+    Dialog dialog =
+        new AlertDialog.Builder(context)
+            .setMessage(message)
+            .setPositiveButton(android.R.string.ok, null)
+            .create();
+    return new Pair<>(dialog, message);
+  }
+
+  private void showErrorDialog(Dialog dialog, CharSequence message) {
+    LogUtil.i("InCallActivityCommon.showErrorDialog", "message: %s", message);
+    inCallActivity.dismissPendingDialogs();
+
+    // Show toast if apps is in background when dialog won't be visible.
+    if (!inCallActivity.isVisible()) {
+      Toast.makeText(inCallActivity.getApplicationContext(), message, Toast.LENGTH_LONG).show();
+      return;
+    }
+
+    this.dialog = dialog;
+    dialog.setOnDismissListener(
+        new OnDismissListener() {
+          @Override
+          public void onDismiss(DialogInterface dialog) {
+            LogUtil.i("InCallActivityCommon.showErrorDialog", "dialog dismissed");
+            onDialogDismissed();
+          }
+        });
+    dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
+    dialog.show();
+  }
+
+  private void onDialogDismissed() {
+    dialog = null;
+    CallList.getInstance().onErrorDialogDismissed();
+    InCallPresenter.getInstance().onDismissDialog();
+  }
+
+  public void enableInCallOrientationEventListener(boolean enable) {
+    if (enable) {
+      inCallOrientationEventListener.enable(true);
+    } else {
+      inCallOrientationEventListener.disable();
+    }
+  }
+
+  public void setExcludeFromRecents(boolean exclude) {
+    List<AppTask> tasks = inCallActivity.getSystemService(ActivityManager.class).getAppTasks();
+    int taskId = inCallActivity.getTaskId();
+    for (int i = 0; i < tasks.size(); i++) {
+      ActivityManager.AppTask task = tasks.get(i);
+      try {
+        if (task.getTaskInfo().id == taskId) {
+          task.setExcludeFromRecents(exclude);
+        }
+      } catch (RuntimeException e) {
+        LogUtil.e(
+            "InCallActivityCommon.setExcludeFromRecents",
+            "RuntimeException when excluding task from recents.",
+            e);
+      }
+    }
+  }
+
+  public void showWifiToLteHandoverToast(DialerCall call) {
+    if (call.hasShownWiFiToLteHandoverToast()) {
+      return;
+    }
+    Toast.makeText(
+            inCallActivity, R.string.video_call_wifi_to_lte_handover_toast, Toast.LENGTH_LONG)
+        .show();
+    call.setHasShownWiFiToLteHandoverToast();
+  }
+
+  public void showWifiFailedDialog(final DialerCall call) {
+    if (call.showWifiHandoverAlertAsToast()) {
+      LogUtil.i("InCallActivityCommon.showWifiFailedDialog", "as toast");
+      Toast.makeText(
+              inCallActivity, R.string.video_call_lte_to_wifi_failed_message, Toast.LENGTH_SHORT)
+          .show();
+      return;
+    }
+
+    dismissPendingDialogs();
+
+    AlertDialog.Builder builder =
+        new AlertDialog.Builder(inCallActivity)
+            .setTitle(R.string.video_call_lte_to_wifi_failed_title);
+
+    // This allows us to use the theme of the dialog instead of the activity
+    View dialogCheckBoxView =
+        View.inflate(builder.getContext(), R.layout.video_call_lte_to_wifi_failed, null);
+    final CheckBox wifiHandoverFailureCheckbox =
+        (CheckBox) dialogCheckBoxView.findViewById(R.id.video_call_lte_to_wifi_failed_checkbox);
+    wifiHandoverFailureCheckbox.setChecked(false);
+
+    dialog =
+        builder
+            .setView(dialogCheckBoxView)
+            .setMessage(R.string.video_call_lte_to_wifi_failed_message)
+            .setOnCancelListener(
+                new OnCancelListener() {
+                  @Override
+                  public void onCancel(DialogInterface dialog) {
+                    onDialogDismissed();
+                  }
+                })
+            .setPositiveButton(
+                android.R.string.ok,
+                new DialogInterface.OnClickListener() {
+                  @Override
+                  public void onClick(DialogInterface dialog, int id) {
+                    call.setDoNotShowDialogForHandoffToWifiFailure(
+                        wifiHandoverFailureCheckbox.isChecked());
+                    dialog.cancel();
+                    onDialogDismissed();
+                  }
+                })
+            .create();
+
+    LogUtil.i("InCallActivityCommon.showWifiFailedDialog", "as dialog");
+    dialog.show();
+  }
+
+  public boolean showDialpadFragment(boolean show, boolean animate) {
+    // If the dialpad is already visible, don't animate in. If it's gone, don't animate out.
+    boolean isDialpadVisible = isDialpadVisible();
+    LogUtil.i(
+        "InCallActivityCommon.showDialpadFragment",
+        "show: %b, animate: %b, " + "isDialpadVisible: %b",
+        show,
+        animate,
+        isDialpadVisible);
+    if (show == isDialpadVisible) {
+      return false;
+    }
+
+    FragmentManager dialpadFragmentManager = inCallActivity.getDialpadFragmentManager();
+    if (dialpadFragmentManager == null) {
+      LogUtil.i(
+          "InCallActivityCommon.showDialpadFragment", "unable to show or hide dialpad fragment");
+      return false;
+    }
+
+    // We don't do a FragmentTransaction on the hide case because it will be dealt with when
+    // the listener is fired after an animation finishes.
+    if (!animate) {
+      if (show) {
+        performShowDialpadFragment(dialpadFragmentManager);
+      } else {
+        performHideDialpadFragment();
+      }
+    } else {
+      if (show) {
+        performShowDialpadFragment(dialpadFragmentManager);
+        getDialpadFragment().animateShowDialpad();
+      }
+      getDialpadFragment()
+          .getView()
+          .startAnimation(show ? dialpadSlideInAnimation : dialpadSlideOutAnimation);
+    }
+
+    ProximitySensor sensor = InCallPresenter.getInstance().getProximitySensor();
+    if (sensor != null) {
+      sensor.onDialpadVisible(show);
+    }
+    showDialpadRequest = DIALPAD_REQUEST_NONE;
+    return true;
+  }
+
+  private void performShowDialpadFragment(@NonNull FragmentManager dialpadFragmentManager) {
+    FragmentTransaction transaction = dialpadFragmentManager.beginTransaction();
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    if (dialpadFragment == null) {
+      transaction.add(
+          inCallActivity.getDialpadContainerId(), new DialpadFragment(), TAG_DIALPAD_FRAGMENT);
+    } else {
+      transaction.show(dialpadFragment);
+    }
+
+    transaction.commitAllowingStateLoss();
+    dialpadFragmentManager.executePendingTransactions();
+
+    Logger.get(inCallActivity).logScreenView(ScreenEvent.Type.INCALL_DIALPAD, inCallActivity);
+  }
+
+  private void performHideDialpadFragment() {
+    FragmentManager fragmentManager = inCallActivity.getDialpadFragmentManager();
+    if (fragmentManager == null) {
+      LogUtil.e(
+          "InCallActivityCommon.performHideDialpadFragment", "child fragment manager is null");
+      return;
+    }
+
+    Fragment fragment = fragmentManager.findFragmentByTag(TAG_DIALPAD_FRAGMENT);
+    if (fragment != null) {
+      FragmentTransaction transaction = fragmentManager.beginTransaction();
+      transaction.hide(fragment);
+      transaction.commitAllowingStateLoss();
+      fragmentManager.executePendingTransactions();
+    }
+  }
+
+  public boolean isDialpadVisible() {
+    DialpadFragment dialpadFragment = getDialpadFragment();
+    return dialpadFragment != null && dialpadFragment.isVisible();
+  }
+
+  /** Returns the {@link DialpadFragment} that's shown by this activity, or {@code null} */
+  @Nullable
+  private DialpadFragment getDialpadFragment() {
+    FragmentManager fragmentManager = inCallActivity.getDialpadFragmentManager();
+    if (fragmentManager == null) {
+      return null;
+    }
+    return (DialpadFragment) fragmentManager.findFragmentByTag(TAG_DIALPAD_FRAGMENT);
+  }
+
+  public void updateTaskDescription() {
+    Resources resources = inCallActivity.getResources();
+    int color;
+    if (resources.getBoolean(R.bool.is_layout_landscape)) {
+      color =
+          ResourcesCompat.getColor(
+              resources, R.color.statusbar_background_color, inCallActivity.getTheme());
+    } else {
+      color = InCallPresenter.getInstance().getThemeColorManager().getSecondaryColor();
+    }
+
+    TaskDescription td =
+        new TaskDescription(resources.getString(R.string.notification_ongoing_call), null, color);
+    inCallActivity.setTaskDescription(td);
+  }
+
+  public boolean hasPendingDialogs() {
+    return dialog != null;
+  }
+
+  private void internalResolveIntent(Intent intent) {
+    if (!intent.getAction().equals(Intent.ACTION_MAIN)) {
+      return;
+    }
+
+    if (intent.hasExtra(INTENT_EXTRA_SHOW_DIALPAD)) {
+      // SHOW_DIALPAD_EXTRA can be used here to specify whether the DTMF
+      // dialpad should be initially visible.  If the extra isn't
+      // present at all, we just leave the dialpad in its previous state.
+      boolean showDialpad = intent.getBooleanExtra(INTENT_EXTRA_SHOW_DIALPAD, false);
+      LogUtil.i("InCallActivityCommon.internalResolveIntent", "SHOW_DIALPAD_EXTRA: " + showDialpad);
+
+      relaunchedFromDialer(showDialpad);
+    }
+
+    DialerCall outgoingCall = CallList.getInstance().getOutgoingCall();
+    if (outgoingCall == null) {
+      outgoingCall = CallList.getInstance().getPendingOutgoingCall();
+    }
+
+    boolean isNewOutgoingCall = false;
+    if (intent.getBooleanExtra(INTENT_EXTRA_NEW_OUTGOING_CALL, false)) {
+      isNewOutgoingCall = true;
+      intent.removeExtra(INTENT_EXTRA_NEW_OUTGOING_CALL);
+
+      // InCallActivity is responsible for disconnecting a new outgoing call if there
+      // is no way of making it (i.e. no valid call capable accounts).
+      // If the version is not MSIM compatible, then ignore this code.
+      if (CompatUtils.isMSIMCompatible()
+          && InCallPresenter.isCallWithNoValidAccounts(outgoingCall)) {
+        LogUtil.i(
+            "InCallActivityCommon.internalResolveIntent",
+            "call with no valid accounts, disconnecting");
+        outgoingCall.disconnect();
+      }
+
+      dismissKeyguard(true);
+    }
+
+    boolean didShowAccountSelectionDialog = maybeShowAccountSelectionDialog();
+    inCallActivity.onResolveIntent(outgoingCall, isNewOutgoingCall, didShowAccountSelectionDialog);
+  }
+
+  private boolean maybeShowAccountSelectionDialog() {
+    DialerCall call = CallList.getInstance().getWaitingForAccountCall();
+    if (call == null) {
+      return false;
+    }
+
+    Bundle extras = call.getIntentExtras();
+    List<PhoneAccountHandle> phoneAccountHandles;
+    if (extras != null) {
+      phoneAccountHandles =
+          extras.getParcelableArrayList(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+    } else {
+      phoneAccountHandles = new ArrayList<>();
+    }
+
+    DialogFragment dialogFragment =
+        SelectPhoneAccountDialogFragment.newInstance(
+            R.string.select_phone_account_for_calls,
+            true,
+            phoneAccountHandles,
+            selectAccountListener,
+            call.getId());
+    dialogFragment.show(inCallActivity.getFragmentManager(), TAG_SELECT_ACCOUNT_FRAGMENT);
+    return true;
+  }
+}
diff --git a/java/com/android/incallui/InCallCameraManager.java b/java/com/android/incallui/InCallCameraManager.java
new file mode 100644
index 0000000..fdb4226
--- /dev/null
+++ b/java/com/android/incallui/InCallCameraManager.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/** Used to track which camera is used for outgoing video. */
+public class InCallCameraManager {
+
+  private final Set<Listener> mCameraSelectionListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<Listener, Boolean>(8, 0.9f, 1));
+  /** The camera ID for the front facing camera. */
+  private String mFrontFacingCameraId;
+  /** The camera ID for the rear facing camera. */
+  private String mRearFacingCameraId;
+  /** The currently active camera. */
+  private boolean mUseFrontFacingCamera;
+  /**
+   * Indicates whether the list of cameras has been initialized yet. Initialization is delayed until
+   * a video call is present.
+   */
+  private boolean mIsInitialized = false;
+  /** The context. */
+  private Context mContext;
+
+  /**
+   * Initializes the InCall CameraManager.
+   *
+   * @param context The current context.
+   */
+  public InCallCameraManager(Context context) {
+    mUseFrontFacingCamera = true;
+    mContext = context;
+  }
+
+  /**
+   * Sets whether the front facing camera should be used or not.
+   *
+   * @param useFrontFacingCamera {@code True} if the front facing camera is to be used.
+   */
+  public void setUseFrontFacingCamera(boolean useFrontFacingCamera) {
+    mUseFrontFacingCamera = useFrontFacingCamera;
+    for (Listener listener : mCameraSelectionListeners) {
+      listener.onActiveCameraSelectionChanged(mUseFrontFacingCamera);
+    }
+  }
+
+  /**
+   * Determines whether the front facing camera is currently in use.
+   *
+   * @return {@code True} if the front facing camera is in use.
+   */
+  public boolean isUsingFrontFacingCamera() {
+    return mUseFrontFacingCamera;
+  }
+
+  /**
+   * Determines the active camera ID.
+   *
+   * @return The active camera ID.
+   */
+  public String getActiveCameraId() {
+    maybeInitializeCameraList(mContext);
+
+    if (mUseFrontFacingCamera) {
+      return mFrontFacingCameraId;
+    } else {
+      return mRearFacingCameraId;
+    }
+  }
+
+  /** Calls when camera permission is granted by user. */
+  public void onCameraPermissionGranted() {
+    for (Listener listener : mCameraSelectionListeners) {
+      listener.onCameraPermissionGranted();
+    }
+  }
+
+  /**
+   * Get the list of cameras available for use.
+   *
+   * @param context The context.
+   */
+  private void maybeInitializeCameraList(Context context) {
+    if (mIsInitialized || context == null) {
+      return;
+    }
+
+    Log.v(this, "initializeCameraList");
+
+    CameraManager cameraManager = null;
+    try {
+      cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+    } catch (Exception e) {
+      Log.e(this, "Could not get camera service.");
+      return;
+    }
+
+    if (cameraManager == null) {
+      return;
+    }
+
+    String[] cameraIds = {};
+    try {
+      cameraIds = cameraManager.getCameraIdList();
+    } catch (CameraAccessException e) {
+      Log.d(this, "Could not access camera: " + e);
+      // Camera disabled by device policy.
+      return;
+    }
+
+    for (int i = 0; i < cameraIds.length; i++) {
+      CameraCharacteristics c = null;
+      try {
+        c = cameraManager.getCameraCharacteristics(cameraIds[i]);
+      } catch (IllegalArgumentException e) {
+        // Device Id is unknown.
+      } catch (CameraAccessException e) {
+        // Camera disabled by device policy.
+      }
+      if (c != null) {
+        int facingCharacteristic = c.get(CameraCharacteristics.LENS_FACING);
+        if (facingCharacteristic == CameraCharacteristics.LENS_FACING_FRONT) {
+          mFrontFacingCameraId = cameraIds[i];
+        } else if (facingCharacteristic == CameraCharacteristics.LENS_FACING_BACK) {
+          mRearFacingCameraId = cameraIds[i];
+        }
+      }
+    }
+
+    mIsInitialized = true;
+    Log.v(this, "initializeCameraList : done");
+  }
+
+  public void addCameraSelectionListener(Listener listener) {
+    if (listener != null) {
+      mCameraSelectionListeners.add(listener);
+    }
+  }
+
+  public void removeCameraSelectionListener(Listener listener) {
+    if (listener != null) {
+      mCameraSelectionListeners.remove(listener);
+    }
+  }
+
+  public interface Listener {
+
+    void onActiveCameraSelectionChanged(boolean isUsingFrontFacingCamera);
+
+    void onCameraPermissionGranted();
+  }
+}
diff --git a/java/com/android/incallui/InCallOrientationEventListener.java b/java/com/android/incallui/InCallOrientationEventListener.java
new file mode 100644
index 0000000..e6b0bc0
--- /dev/null
+++ b/java/com/android/incallui/InCallOrientationEventListener.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.support.annotation.IntDef;
+import android.view.OrientationEventListener;
+import com.android.dialer.common.LogUtil;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * This class listens to Orientation events and overrides onOrientationChanged which gets invoked
+ * when an orientation change occurs. When that happens, we notify InCallUI registrants of the
+ * change.
+ */
+public class InCallOrientationEventListener extends OrientationEventListener {
+
+  public static final int SCREEN_ORIENTATION_0 = 0;
+  public static final int SCREEN_ORIENTATION_90 = 90;
+  public static final int SCREEN_ORIENTATION_180 = 180;
+  public static final int SCREEN_ORIENTATION_270 = 270;
+  public static final int SCREEN_ORIENTATION_360 = 360;
+
+  /** Screen orientation angles one of 0, 90, 180, 270, 360 in degrees. */
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({
+    SCREEN_ORIENTATION_0,
+    SCREEN_ORIENTATION_90,
+    SCREEN_ORIENTATION_180,
+    SCREEN_ORIENTATION_270,
+    SCREEN_ORIENTATION_360,
+    SCREEN_ORIENTATION_UNKNOWN
+  })
+  public @interface ScreenOrientation {}
+
+  // We use SCREEN_ORIENTATION_USER so that reverse-portrait is not allowed.
+  public static final int ACTIVITY_PREFERENCE_ALLOW_ROTATION = ActivityInfo.SCREEN_ORIENTATION_USER;
+
+  public static final int ACTIVITY_PREFERENCE_DISALLOW_ROTATION =
+      ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
+
+  /**
+   * This is to identify dead zones where we won't notify others of orientation changed. Say for e.g
+   * our threshold is x degrees. We will only notify UI when our current rotation is within x
+   * degrees right or left of the screen orientation angles. If it's not within those ranges, we
+   * return SCREEN_ORIENTATION_UNKNOWN and ignore it.
+   */
+  public static final int SCREEN_ORIENTATION_UNKNOWN = -1;
+
+  // Rotation threshold is 10 degrees. So if the rotation angle is within 10 degrees of any of
+  // the above angles, we will notify orientation changed.
+  private static final int ROTATION_THRESHOLD = 10;
+
+  /** Cache the current rotation of the device. */
+  @ScreenOrientation private static int sCurrentOrientation = SCREEN_ORIENTATION_0;
+
+  private boolean mEnabled = false;
+
+  public InCallOrientationEventListener(Context context) {
+    super(context);
+  }
+
+  private static boolean isWithinRange(int value, int begin, int end) {
+    return value >= begin && value < end;
+  }
+
+  private static boolean isWithinThreshold(int value, int center, int threshold) {
+    return isWithinRange(value, center - threshold, center + threshold);
+  }
+
+  private static boolean isInLeftRange(int value, int center, int threshold) {
+    return isWithinRange(value, center - threshold, center);
+  }
+
+  private static boolean isInRightRange(int value, int center, int threshold) {
+    return isWithinRange(value, center, center + threshold);
+  }
+
+  @ScreenOrientation
+  public static int getCurrentOrientation() {
+    return sCurrentOrientation;
+  }
+
+  /**
+   * Handles changes in device orientation. Notifies InCallPresenter of orientation changes.
+   *
+   * <p>Note that this API receives sensor rotation in degrees as a param and we convert that to one
+   * of our screen orientation constants - (one of: {@link #SCREEN_ORIENTATION_0}, {@link
+   * #SCREEN_ORIENTATION_90}, {@link #SCREEN_ORIENTATION_180}, {@link #SCREEN_ORIENTATION_270}).
+   *
+   * @param rotation The new device sensor rotation in degrees
+   */
+  @Override
+  public void onOrientationChanged(int rotation) {
+    if (rotation == OrientationEventListener.ORIENTATION_UNKNOWN) {
+      return;
+    }
+
+    final int orientation = toScreenOrientation(rotation);
+
+    if (orientation != SCREEN_ORIENTATION_UNKNOWN && sCurrentOrientation != orientation) {
+      LogUtil.i(
+          "InCallOrientationEventListener.onOrientationChanged",
+          "orientation: %d -> %d",
+          sCurrentOrientation,
+          orientation);
+      sCurrentOrientation = orientation;
+      InCallPresenter.getInstance().onDeviceOrientationChange(sCurrentOrientation);
+    }
+  }
+
+  /**
+   * Enables the OrientationEventListener and notifies listeners of current orientation if notify
+   * flag is true
+   *
+   * @param notify true or false. Notify device orientation changed if true.
+   */
+  public void enable(boolean notify) {
+    if (mEnabled) {
+      Log.v(this, "enable: Orientation listener is already enabled. Ignoring...");
+      return;
+    }
+
+    super.enable();
+    mEnabled = true;
+    if (notify) {
+      InCallPresenter.getInstance().onDeviceOrientationChange(sCurrentOrientation);
+    }
+  }
+
+  /** Enables the OrientationEventListener with notify flag defaulting to false. */
+  @Override
+  public void enable() {
+    enable(false);
+  }
+
+  /** Disables the OrientationEventListener. */
+  @Override
+  public void disable() {
+    if (!mEnabled) {
+      Log.v(this, "enable: Orientation listener is already disabled. Ignoring...");
+      return;
+    }
+
+    mEnabled = false;
+    super.disable();
+  }
+
+  /** Returns true the OrientationEventListener is enabled, false otherwise. */
+  public boolean isEnabled() {
+    return mEnabled;
+  }
+
+  /**
+   * Converts sensor rotation in degrees to screen orientation constants.
+   *
+   * @param rotation sensor rotation angle in degrees
+   * @return Screen orientation angle in degrees (0, 90, 180, 270). Returns -1 for degrees not
+   *     within threshold to identify zones where orientation change should not be trigerred.
+   */
+  @ScreenOrientation
+  private int toScreenOrientation(int rotation) {
+    // Sensor orientation 90 is equivalent to screen orientation 270 and vice versa. This
+    // function returns the screen orientation. So we convert sensor rotation 90 to 270 and
+    // vice versa here.
+    if (isInLeftRange(rotation, SCREEN_ORIENTATION_360, ROTATION_THRESHOLD)
+        || isInRightRange(rotation, SCREEN_ORIENTATION_0, ROTATION_THRESHOLD)) {
+      return SCREEN_ORIENTATION_0;
+    } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_90, ROTATION_THRESHOLD)) {
+      return SCREEN_ORIENTATION_270;
+    } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_180, ROTATION_THRESHOLD)) {
+      return SCREEN_ORIENTATION_180;
+    } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_270, ROTATION_THRESHOLD)) {
+      return SCREEN_ORIENTATION_90;
+    }
+    return SCREEN_ORIENTATION_UNKNOWN;
+  }
+}
diff --git a/java/com/android/incallui/InCallPresenter.java b/java/com/android/incallui/InCallPresenter.java
new file mode 100644
index 0000000..97105fb
--- /dev/null
+++ b/java/com/android/incallui/InCallPresenter.java
@@ -0,0 +1,1679 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Point;
+import android.os.Bundle;
+import android.os.Handler;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import android.telecom.Call.Details;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.view.Window;
+import android.view.WindowManager;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.CallCompat;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler.OnCheckBlockedListener;
+import com.android.dialer.blocking.FilteredNumbersUtil;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.InteractionEvent;
+import com.android.dialer.telecom.TelecomUtil;
+import com.android.dialer.util.TouchPointManager;
+import com.android.incallui.InCallOrientationEventListener.ScreenOrientation;
+import com.android.incallui.answerproximitysensor.PseudoScreenState;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.ExternalCallList;
+import com.android.incallui.call.InCallVideoCallCallbackNotifier;
+import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.latencyreport.LatencyReport;
+import com.android.incallui.legacyblocking.BlockedNumberContentObserver;
+import com.android.incallui.spam.SpamCallListListener;
+import com.android.incallui.util.TelecomCallUtil;
+import com.android.incallui.videosurface.bindings.VideoSurfaceBindings;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Takes updates from the CallList and notifies the InCallActivity (UI) of the changes. Responsible
+ * for starting the activity for a new call and finishing the activity when all calls are
+ * disconnected. Creates and manages the in-call state and provides a listener pattern for the
+ * presenters that want to listen in on the in-call state changes. TODO: This class has become more
+ * of a state machine at this point. Consider renaming.
+ */
+public class InCallPresenter
+    implements CallList.Listener, InCallVideoCallCallbackNotifier.SessionModificationListener {
+
+  private static final String EXTRA_FIRST_TIME_SHOWN =
+      "com.android.incallui.intent.extra.FIRST_TIME_SHOWN";
+
+  private static final long BLOCK_QUERY_TIMEOUT_MS = 1000;
+
+  private static final Bundle EMPTY_EXTRAS = new Bundle();
+
+  private static InCallPresenter sInCallPresenter;
+
+  /**
+   * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is load factor before
+   * resizing, 1 means we only expect a single thread to access the map so make only a single shard
+   */
+  private final Set<InCallStateListener> mListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<InCallStateListener, Boolean>(8, 0.9f, 1));
+
+  private final List<IncomingCallListener> mIncomingCallListeners = new CopyOnWriteArrayList<>();
+  private final Set<InCallDetailsListener> mDetailsListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<InCallDetailsListener, Boolean>(8, 0.9f, 1));
+  private final Set<CanAddCallListener> mCanAddCallListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<CanAddCallListener, Boolean>(8, 0.9f, 1));
+  private final Set<InCallUiListener> mInCallUiListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<InCallUiListener, Boolean>(8, 0.9f, 1));
+  private final Set<InCallOrientationListener> mOrientationListeners =
+      Collections.newSetFromMap(
+          new ConcurrentHashMap<InCallOrientationListener, Boolean>(8, 0.9f, 1));
+  private final Set<InCallEventListener> mInCallEventListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<InCallEventListener, Boolean>(8, 0.9f, 1));
+
+  private StatusBarNotifier mStatusBarNotifier;
+  private ExternalCallNotifier mExternalCallNotifier;
+  private ContactInfoCache mContactInfoCache;
+  private Context mContext;
+  private final OnCheckBlockedListener mOnCheckBlockedListener =
+      new OnCheckBlockedListener() {
+        @Override
+        public void onCheckComplete(final Integer id) {
+          if (id != null && id != FilteredNumberAsyncQueryHandler.INVALID_ID) {
+            // Silence the ringer now to prevent ringing and vibration before the call is
+            // terminated when Telecom attempts to add it.
+            TelecomUtil.silenceRinger(mContext);
+          }
+        }
+      };
+  private CallList mCallList;
+  private ExternalCallList mExternalCallList;
+  private InCallActivity mInCallActivity;
+  private ManageConferenceActivity mManageConferenceActivity;
+  private final android.telecom.Call.Callback mCallCallback =
+      new android.telecom.Call.Callback() {
+        @Override
+        public void onPostDialWait(
+            android.telecom.Call telecomCall, String remainingPostDialSequence) {
+          final DialerCall call = mCallList.getDialerCallFromTelecomCall(telecomCall);
+          if (call == null) {
+            Log.w(this, "DialerCall not found in call list: " + telecomCall);
+            return;
+          }
+          onPostDialCharWait(call.getId(), remainingPostDialSequence);
+        }
+
+        @Override
+        public void onDetailsChanged(
+            android.telecom.Call telecomCall, android.telecom.Call.Details details) {
+          final DialerCall call = mCallList.getDialerCallFromTelecomCall(telecomCall);
+          if (call == null) {
+            Log.w(this, "DialerCall not found in call list: " + telecomCall);
+            return;
+          }
+
+          if (details.hasProperty(Details.PROPERTY_IS_EXTERNAL_CALL)
+              && !mExternalCallList.isCallTracked(telecomCall)) {
+
+            // A regular call became an external call so swap call lists.
+            Log.i(this, "Call became external: " + telecomCall);
+            mCallList.onInternalCallMadeExternal(mContext, telecomCall);
+            mExternalCallList.onCallAdded(telecomCall);
+            return;
+          }
+
+          for (InCallDetailsListener listener : mDetailsListeners) {
+            listener.onDetailsChanged(call, details);
+          }
+        }
+
+        @Override
+        public void onConferenceableCallsChanged(
+            android.telecom.Call telecomCall, List<android.telecom.Call> conferenceableCalls) {
+          Log.i(this, "onConferenceableCallsChanged: " + telecomCall);
+          onDetailsChanged(telecomCall, telecomCall.getDetails());
+        }
+      };
+  private InCallState mInCallState = InCallState.NO_CALLS;
+  private ProximitySensor mProximitySensor;
+  private final PseudoScreenState mPseudoScreenState = new PseudoScreenState();
+  private boolean mServiceConnected;
+  private boolean mAccountSelectionCancelled;
+  private InCallCameraManager mInCallCameraManager;
+  private FilteredNumberAsyncQueryHandler mFilteredQueryHandler;
+  private CallList.Listener mSpamCallListListener;
+  /** Whether or not we are currently bound and waiting for Telecom to send us a new call. */
+  private boolean mBoundAndWaitingForOutgoingCall;
+  /** Determines if the InCall UI is in fullscreen mode or not. */
+  private boolean mIsFullScreen = false;
+
+  private PhoneStateListener mPhoneStateListener =
+      new PhoneStateListener() {
+        @Override
+        public void onCallStateChanged(int state, String incomingNumber) {
+          if (state == TelephonyManager.CALL_STATE_RINGING) {
+            if (FilteredNumbersUtil.hasRecentEmergencyCall(mContext)) {
+              return;
+            }
+            // Check if the number is blocked, to silence the ringer.
+            String countryIso = GeoUtil.getCurrentCountryIso(mContext);
+            mFilteredQueryHandler.isBlockedNumber(
+                mOnCheckBlockedListener, incomingNumber, countryIso);
+          }
+        }
+      };
+  /**
+   * Is true when the activity has been previously started. Some code needs to know not just if the
+   * activity is currently up, but if it had been previously shown in foreground for this in-call
+   * session (e.g., StatusBarNotifier). This gets reset when the session ends in the tear-down
+   * method.
+   */
+  private boolean mIsActivityPreviouslyStarted = false;
+
+  /** Whether or not InCallService is bound to Telecom. */
+  private boolean mServiceBound = false;
+
+  /**
+   * When configuration changes Android kills the current activity and starts a new one. The flag is
+   * used to check if full clean up is necessary (activity is stopped and new activity won't be
+   * started), or if a new activity will be started right after the current one is destroyed, and
+   * therefore no need in release all resources.
+   */
+  private boolean mIsChangingConfigurations = false;
+
+  private boolean mAwaitingCallListUpdate = false;
+
+  private ExternalCallList.ExternalCallListener mExternalCallListener =
+      new ExternalCallList.ExternalCallListener() {
+
+        @Override
+        public void onExternalCallPulled(android.telecom.Call call) {
+          // Note: keep this code in sync with InCallPresenter#onCallAdded
+          LatencyReport latencyReport = new LatencyReport(call);
+          latencyReport.onCallBlockingDone();
+          // Note: External calls do not require spam checking.
+          mCallList.onCallAdded(mContext, call, latencyReport);
+          call.registerCallback(mCallCallback);
+        }
+
+        @Override
+        public void onExternalCallAdded(android.telecom.Call call) {
+          // No-op
+        }
+
+        @Override
+        public void onExternalCallRemoved(android.telecom.Call call) {
+          // No-op
+        }
+
+        @Override
+        public void onExternalCallUpdated(android.telecom.Call call) {
+          // No-op
+        }
+      };
+
+  private ThemeColorManager mThemeColorManager;
+  private VideoSurfaceTexture mLocalVideoSurfaceTexture;
+  private VideoSurfaceTexture mRemoteVideoSurfaceTexture;
+
+  /** Inaccessible constructor. Must use getInstance() to get this singleton. */
+  @VisibleForTesting
+  InCallPresenter() {}
+
+  public static synchronized InCallPresenter getInstance() {
+    if (sInCallPresenter == null) {
+      sInCallPresenter = new InCallPresenter();
+    }
+    return sInCallPresenter;
+  }
+
+  /**
+   * Determines whether or not a call has no valid phone accounts that can be used to make the call
+   * with. Emergency calls do not require a phone account.
+   *
+   * @param call to check accounts for.
+   * @return {@code true} if the call has no call capable phone accounts set, {@code false} if the
+   *     call contains a phone account that could be used to initiate it with, or is an emergency
+   *     call.
+   */
+  public static boolean isCallWithNoValidAccounts(DialerCall call) {
+    if (call != null && !call.isEmergencyCall()) {
+      Bundle extras = call.getIntentExtras();
+
+      if (extras == null) {
+        extras = EMPTY_EXTRAS;
+      }
+
+      final List<PhoneAccountHandle> phoneAccountHandles =
+          extras.getParcelableArrayList(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+
+      if ((call.getAccountHandle() == null
+          && (phoneAccountHandles == null || phoneAccountHandles.isEmpty()))) {
+        Log.i(InCallPresenter.getInstance(), "No valid accounts for call " + call);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public InCallState getInCallState() {
+    return mInCallState;
+  }
+
+  public CallList getCallList() {
+    return mCallList;
+  }
+
+  public void setUp(
+      @NonNull Context context,
+      CallList callList,
+      ExternalCallList externalCallList,
+      StatusBarNotifier statusBarNotifier,
+      ExternalCallNotifier externalCallNotifier,
+      ContactInfoCache contactInfoCache,
+      ProximitySensor proximitySensor) {
+    if (mServiceConnected) {
+      Log.i(this, "New service connection replacing existing one.");
+      if (context != mContext || callList != mCallList) {
+        throw new IllegalStateException();
+      }
+      return;
+    }
+
+    Objects.requireNonNull(context);
+    mContext = context;
+
+    mContactInfoCache = contactInfoCache;
+
+    mStatusBarNotifier = statusBarNotifier;
+    mExternalCallNotifier = externalCallNotifier;
+    addListener(mStatusBarNotifier);
+
+    mProximitySensor = proximitySensor;
+    addListener(mProximitySensor);
+
+    mThemeColorManager =
+        new ThemeColorManager(new InCallUIMaterialColorMapUtils(mContext.getResources()));
+
+    mCallList = callList;
+    mExternalCallList = externalCallList;
+    externalCallList.addExternalCallListener(mExternalCallNotifier);
+    externalCallList.addExternalCallListener(mExternalCallListener);
+
+    // This only gets called by the service so this is okay.
+    mServiceConnected = true;
+
+    // The final thing we do in this set up is add ourselves as a listener to CallList.  This
+    // will kick off an update and the whole process can start.
+    mCallList.addListener(this);
+
+    // Create spam call list listener and add it to the list of listeners
+    mSpamCallListListener = new SpamCallListListener(context);
+    mCallList.addListener(mSpamCallListListener);
+
+    VideoPauseController.getInstance().setUp(this);
+    InCallVideoCallCallbackNotifier.getInstance().addSessionModificationListener(this);
+
+    mFilteredQueryHandler = new FilteredNumberAsyncQueryHandler(context);
+    mContext
+        .getSystemService(TelephonyManager.class)
+        .listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
+
+    Log.d(this, "Finished InCallPresenter.setUp");
+  }
+
+  /**
+   * Called when the telephony service has disconnected from us. This will happen when there are no
+   * more active calls. However, we may still want to continue showing the UI for certain cases like
+   * showing "Call Ended". What we really want is to wait for the activity and the service to both
+   * disconnect before we tear things down. This method sets a serviceConnected boolean and calls a
+   * secondary method that performs the aforementioned logic.
+   */
+  public void tearDown() {
+    Log.d(this, "tearDown");
+    mCallList.clearOnDisconnect();
+
+    mServiceConnected = false;
+
+    mContext
+        .getSystemService(TelephonyManager.class)
+        .listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+
+    attemptCleanup();
+    VideoPauseController.getInstance().tearDown();
+    InCallVideoCallCallbackNotifier.getInstance().removeSessionModificationListener(this);
+  }
+
+  private void attemptFinishActivity() {
+    final boolean doFinish = (mInCallActivity != null && isActivityStarted());
+    Log.i(this, "Hide in call UI: " + doFinish);
+    if (doFinish) {
+      mInCallActivity.setExcludeFromRecents(true);
+      mInCallActivity.finish();
+
+      if (mAccountSelectionCancelled) {
+        // This finish is a result of account selection cancellation
+        // do not include activity ending transition
+        mInCallActivity.overridePendingTransition(0, 0);
+      }
+    }
+  }
+
+  /**
+   * Called when the UI ends. Attempts to tear down everything if necessary. See {@link #tearDown()}
+   * for more insight on the tear-down process.
+   */
+  public void unsetActivity(InCallActivity inCallActivity) {
+    if (inCallActivity == null) {
+      throw new IllegalArgumentException("unregisterActivity cannot be called with null");
+    }
+    if (mInCallActivity == null) {
+      Log.i(this, "No InCallActivity currently set, no need to unset.");
+      return;
+    }
+    if (mInCallActivity != inCallActivity) {
+      Log.w(
+          this,
+          "Second instance of InCallActivity is trying to unregister when another"
+              + " instance is active. Ignoring.");
+      return;
+    }
+    updateActivity(null);
+  }
+
+  /**
+   * Updates the current instance of {@link InCallActivity} with the provided one. If a {@code null}
+   * activity is provided, it means that the activity was finished and we should attempt to cleanup.
+   */
+  private void updateActivity(InCallActivity inCallActivity) {
+    boolean updateListeners = false;
+    boolean doAttemptCleanup = false;
+
+    if (inCallActivity != null) {
+      if (mInCallActivity == null) {
+        updateListeners = true;
+        Log.i(this, "UI Initialized");
+      } else {
+        // since setActivity is called onStart(), it can be called multiple times.
+        // This is fine and ignorable, but we do not want to update the world every time
+        // this happens (like going to/from background) so we do not set updateListeners.
+      }
+
+      mInCallActivity = inCallActivity;
+      mInCallActivity.setExcludeFromRecents(false);
+
+      // By the time the UI finally comes up, the call may already be disconnected.
+      // If that's the case, we may need to show an error dialog.
+      if (mCallList != null && mCallList.getDisconnectedCall() != null) {
+        maybeShowErrorDialogOnDisconnect(mCallList.getDisconnectedCall());
+      }
+
+      // When the UI comes up, we need to first check the in-call state.
+      // If we are showing NO_CALLS, that means that a call probably connected and
+      // then immediately disconnected before the UI was able to come up.
+      // If we dont have any calls, start tearing down the UI instead.
+      // NOTE: This code relies on {@link #mInCallActivity} being set so we run it after
+      // it has been set.
+      if (mInCallState == InCallState.NO_CALLS) {
+        Log.i(this, "UI Initialized, but no calls left.  shut down.");
+        attemptFinishActivity();
+        return;
+      }
+    } else {
+      Log.i(this, "UI Destroyed");
+      updateListeners = true;
+      mInCallActivity = null;
+
+      // We attempt cleanup for the destroy case but only after we recalculate the state
+      // to see if we need to come back up or stay shut down. This is why we do the
+      // cleanup after the call to onCallListChange() instead of directly here.
+      doAttemptCleanup = true;
+    }
+
+    // Messages can come from the telephony layer while the activity is coming up
+    // and while the activity is going down.  So in both cases we need to recalculate what
+    // state we should be in after they complete.
+    // Examples: (1) A new incoming call could come in and then get disconnected before
+    //               the activity is created.
+    //           (2) All calls could disconnect and then get a new incoming call before the
+    //               activity is destroyed.
+    //
+    // b/1122139 - We previously had a check for mServiceConnected here as well, but there are
+    // cases where we need to recalculate the current state even if the service in not
+    // connected.  In particular the case where startOrFinish() is called while the app is
+    // already finish()ing. In that case, we skip updating the state with the knowledge that
+    // we will check again once the activity has finished. That means we have to recalculate the
+    // state here even if the service is disconnected since we may not have finished a state
+    // transition while finish()ing.
+    if (updateListeners) {
+      onCallListChange(mCallList);
+    }
+
+    if (doAttemptCleanup) {
+      attemptCleanup();
+    }
+  }
+
+  public void setManageConferenceActivity(
+      @Nullable ManageConferenceActivity manageConferenceActivity) {
+    mManageConferenceActivity = manageConferenceActivity;
+  }
+
+  public void onBringToForeground(boolean showDialpad) {
+    Log.i(this, "Bringing UI to foreground.");
+    bringToForeground(showDialpad);
+  }
+
+  public void onCallAdded(final android.telecom.Call call) {
+    LatencyReport latencyReport = new LatencyReport(call);
+    if (shouldAttemptBlocking(call)) {
+      maybeBlockCall(call, latencyReport);
+    } else {
+      if (call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+        mExternalCallList.onCallAdded(call);
+      } else {
+        latencyReport.onCallBlockingDone();
+        mCallList.onCallAdded(mContext, call, latencyReport);
+      }
+    }
+
+    // Since a call has been added we are no longer waiting for Telecom to send us a call.
+    setBoundAndWaitingForOutgoingCall(false, null);
+    call.registerCallback(mCallCallback);
+  }
+
+  private boolean shouldAttemptBlocking(android.telecom.Call call) {
+    if (call.getState() != android.telecom.Call.STATE_RINGING) {
+      return false;
+    }
+    if (TelecomCallUtil.isEmergencyCall(call)) {
+      Log.i(this, "Not attempting to block incoming emergency call");
+      return false;
+    }
+    if (FilteredNumbersUtil.hasRecentEmergencyCall(mContext)) {
+      Log.i(this, "Not attempting to block incoming call due to recent emergency call");
+      return false;
+    }
+    if (call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Checks whether a call should be blocked, and blocks it if so. Otherwise, it adds the call to
+   * the CallList so it can proceed as normal. There is a timeout, so if the function for checking
+   * whether a function is blocked does not return in a reasonable time, we proceed with adding the
+   * call anyways.
+   */
+  private void maybeBlockCall(final android.telecom.Call call, final LatencyReport latencyReport) {
+    final String countryIso = GeoUtil.getCurrentCountryIso(mContext);
+    final String number = TelecomCallUtil.getNumber(call);
+    final long timeAdded = System.currentTimeMillis();
+
+    // Though AtomicBoolean's can be scary, don't fear, as in this case it is only used on the
+    // main UI thread. It is needed so we can change its value within different scopes, since
+    // that cannot be done with a final boolean.
+    final AtomicBoolean hasTimedOut = new AtomicBoolean(false);
+
+    final Handler handler = new Handler();
+
+    // Proceed if the query is slow; the call may still be blocked after the query returns.
+    final Runnable runnable =
+        new Runnable() {
+          @Override
+          public void run() {
+            hasTimedOut.set(true);
+            latencyReport.onCallBlockingDone();
+            mCallList.onCallAdded(mContext, call, latencyReport);
+          }
+        };
+    handler.postDelayed(runnable, BLOCK_QUERY_TIMEOUT_MS);
+
+    OnCheckBlockedListener onCheckBlockedListener =
+        new OnCheckBlockedListener() {
+          @Override
+          public void onCheckComplete(final Integer id) {
+            if (isReadyForTearDown()) {
+              Log.i(this, "InCallPresenter is torn down, not adding call");
+              return;
+            }
+            if (!hasTimedOut.get()) {
+              handler.removeCallbacks(runnable);
+            }
+            if (id == null) {
+              if (!hasTimedOut.get()) {
+                latencyReport.onCallBlockingDone();
+                mCallList.onCallAdded(mContext, call, latencyReport);
+              }
+            } else if (id == FilteredNumberAsyncQueryHandler.INVALID_ID) {
+              Log.d(this, "checkForBlockedCall: invalid number, skipping block checking");
+              if (!hasTimedOut.get()) {
+                handler.removeCallbacks(runnable);
+
+                latencyReport.onCallBlockingDone();
+                mCallList.onCallAdded(mContext, call, latencyReport);
+              }
+            } else {
+              Log.i(this, "Rejecting incoming call from blocked number");
+              call.reject(false, null);
+              Logger.get(mContext).logInteraction(InteractionEvent.Type.CALL_BLOCKED);
+
+              /*
+               * If mContext is null, then the InCallPresenter was torn down before the
+               * block check had a chance to complete. The context is no longer valid, so
+               * don't attempt to remove the call log entry.
+               */
+              if (mContext == null) {
+                return;
+              }
+              // Register observer to update the call log.
+              // BlockedNumberContentObserver will unregister after successful log or timeout.
+              BlockedNumberContentObserver contentObserver =
+                  new BlockedNumberContentObserver(mContext, new Handler(), number, timeAdded);
+              contentObserver.register();
+            }
+          }
+        };
+
+    mFilteredQueryHandler.isBlockedNumber(onCheckBlockedListener, number, countryIso);
+  }
+
+  public void onCallRemoved(android.telecom.Call call) {
+    if (call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+      mExternalCallList.onCallRemoved(call);
+    } else {
+      mCallList.onCallRemoved(mContext, call);
+      call.unregisterCallback(mCallCallback);
+    }
+  }
+
+  public void onCanAddCallChanged(boolean canAddCall) {
+    for (CanAddCallListener listener : mCanAddCallListeners) {
+      listener.onCanAddCallChanged(canAddCall);
+    }
+  }
+
+  @Override
+  public void onWiFiToLteHandover(DialerCall call) {
+    if (mInCallActivity != null) {
+      mInCallActivity.onWiFiToLteHandover(call);
+    }
+  }
+
+  @Override
+  public void onHandoverToWifiFailed(DialerCall call) {
+    if (mInCallActivity != null) {
+      mInCallActivity.onHandoverToWifiFailed(call);
+    }
+  }
+
+  /**
+   * Called when there is a change to the call list. Sets the In-Call state for the entire in-call
+   * app based on the information it gets from CallList. Dispatches the in-call state to all
+   * listeners. Can trigger the creation or destruction of the UI based on the states that is
+   * calculates.
+   */
+  @Override
+  public void onCallListChange(CallList callList) {
+    if (mInCallActivity != null && mInCallActivity.isInCallScreenAnimating()) {
+      mAwaitingCallListUpdate = true;
+      return;
+    }
+    if (callList == null) {
+      return;
+    }
+
+    mAwaitingCallListUpdate = false;
+
+    InCallState newState = getPotentialStateFromCallList(callList);
+    InCallState oldState = mInCallState;
+    Log.d(this, "onCallListChange oldState= " + oldState + " newState=" + newState);
+    newState = startOrFinishUi(newState);
+    Log.d(this, "onCallListChange newState changed to " + newState);
+
+    // Set the new state before announcing it to the world
+    Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+    mInCallState = newState;
+
+    // notify listeners of new state
+    for (InCallStateListener listener : mListeners) {
+      Log.d(this, "Notify " + listener + " of state " + mInCallState.toString());
+      listener.onStateChange(oldState, mInCallState, callList);
+    }
+
+    if (isActivityStarted()) {
+      final boolean hasCall =
+          callList.getActiveOrBackgroundCall() != null || callList.getOutgoingCall() != null;
+      mInCallActivity.dismissKeyguard(hasCall);
+    }
+  }
+
+  /** Called when there is a new incoming call. */
+  @Override
+  public void onIncomingCall(DialerCall call) {
+    InCallState newState = startOrFinishUi(InCallState.INCOMING);
+    InCallState oldState = mInCallState;
+
+    Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+    mInCallState = newState;
+
+    for (IncomingCallListener listener : mIncomingCallListeners) {
+      listener.onIncomingCall(oldState, mInCallState, call);
+    }
+
+    if (mInCallActivity != null) {
+      // Re-evaluate which fragment is being shown.
+      mInCallActivity.onPrimaryCallStateChanged();
+    }
+  }
+
+  @Override
+  public void onUpgradeToVideo(DialerCall call) {
+    if (call.getSessionModificationState()
+            == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST
+        && mInCallState == InCallPresenter.InCallState.INCOMING) {
+      LogUtil.i(
+          "InCallPresenter.onUpgradeToVideo",
+          "rejecting upgrade request due to existing incoming call");
+      call.declineUpgradeRequest();
+    }
+
+    if (mInCallActivity != null) {
+      // Re-evaluate which fragment is being shown.
+      mInCallActivity.onPrimaryCallStateChanged();
+    }
+  }
+
+  @Override
+  public void onSessionModificationStateChange(@SessionModificationState int newState) {
+    LogUtil.i("InCallPresenter.onSessionModificationStateChange", "state: %d", newState);
+    if (mProximitySensor == null) {
+      LogUtil.i("InCallPresenter.onSessionModificationStateChange", "proximitySensor is null");
+      return;
+    }
+    mProximitySensor.setIsAttemptingVideoCall(
+        VideoUtils.hasSentVideoUpgradeRequest(newState)
+            || VideoUtils.hasReceivedVideoUpgradeRequest(newState));
+    if (mInCallActivity != null) {
+      // Re-evaluate which fragment is being shown.
+      mInCallActivity.onPrimaryCallStateChanged();
+    }
+  }
+
+  /**
+   * Called when a call becomes disconnected. Called everytime an existing call changes from being
+   * connected (incoming/outgoing/active) to disconnected.
+   */
+  @Override
+  public void onDisconnect(DialerCall call) {
+    maybeShowErrorDialogOnDisconnect(call);
+
+    // We need to do the run the same code as onCallListChange.
+    onCallListChange(mCallList);
+
+    if (isActivityStarted()) {
+      mInCallActivity.dismissKeyguard(false);
+    }
+
+    if (call.isEmergencyCall()) {
+      FilteredNumbersUtil.recordLastEmergencyCallTime(mContext);
+    }
+  }
+
+  @Override
+  public void onUpgradeToVideoRequest(DialerCall call, int videoState) {
+    LogUtil.d(
+        "InCallPresenter.onUpgradeToVideoRequest",
+        "call = " + call + " video state = " + videoState);
+
+    if (call == null) {
+      return;
+    }
+
+    call.setRequestedVideoState(videoState);
+  }
+
+  /** Given the call list, return the state in which the in-call screen should be. */
+  public InCallState getPotentialStateFromCallList(CallList callList) {
+
+    InCallState newState = InCallState.NO_CALLS;
+
+    if (callList == null) {
+      return newState;
+    }
+    if (callList.getIncomingCall() != null) {
+      newState = InCallState.INCOMING;
+    } else if (callList.getWaitingForAccountCall() != null) {
+      newState = InCallState.WAITING_FOR_ACCOUNT;
+    } else if (callList.getPendingOutgoingCall() != null) {
+      newState = InCallState.PENDING_OUTGOING;
+    } else if (callList.getOutgoingCall() != null) {
+      newState = InCallState.OUTGOING;
+    } else if (callList.getActiveCall() != null
+        || callList.getBackgroundCall() != null
+        || callList.getDisconnectedCall() != null
+        || callList.getDisconnectingCall() != null) {
+      newState = InCallState.INCALL;
+    }
+
+    if (newState == InCallState.NO_CALLS) {
+      if (mBoundAndWaitingForOutgoingCall) {
+        return InCallState.OUTGOING;
+      }
+    }
+
+    return newState;
+  }
+
+  public boolean isBoundAndWaitingForOutgoingCall() {
+    return mBoundAndWaitingForOutgoingCall;
+  }
+
+  public void setBoundAndWaitingForOutgoingCall(boolean isBound, PhoneAccountHandle handle) {
+    Log.i(this, "setBoundAndWaitingForOutgoingCall: " + isBound);
+    mBoundAndWaitingForOutgoingCall = isBound;
+    mThemeColorManager.setPendingPhoneAccountHandle(handle);
+    if (isBound && mInCallState == InCallState.NO_CALLS) {
+      mInCallState = InCallState.OUTGOING;
+    }
+  }
+
+  public void onShrinkAnimationComplete() {
+    if (mAwaitingCallListUpdate) {
+      onCallListChange(mCallList);
+    }
+  }
+
+  public void addIncomingCallListener(IncomingCallListener listener) {
+    Objects.requireNonNull(listener);
+    mIncomingCallListeners.add(listener);
+  }
+
+  public void removeIncomingCallListener(IncomingCallListener listener) {
+    if (listener != null) {
+      mIncomingCallListeners.remove(listener);
+    }
+  }
+
+  public void addListener(InCallStateListener listener) {
+    Objects.requireNonNull(listener);
+    mListeners.add(listener);
+  }
+
+  public void removeListener(InCallStateListener listener) {
+    if (listener != null) {
+      mListeners.remove(listener);
+    }
+  }
+
+  public void addDetailsListener(InCallDetailsListener listener) {
+    Objects.requireNonNull(listener);
+    mDetailsListeners.add(listener);
+  }
+
+  public void removeDetailsListener(InCallDetailsListener listener) {
+    if (listener != null) {
+      mDetailsListeners.remove(listener);
+    }
+  }
+
+  public void addCanAddCallListener(CanAddCallListener listener) {
+    Objects.requireNonNull(listener);
+    mCanAddCallListeners.add(listener);
+  }
+
+  public void removeCanAddCallListener(CanAddCallListener listener) {
+    if (listener != null) {
+      mCanAddCallListeners.remove(listener);
+    }
+  }
+
+  public void addOrientationListener(InCallOrientationListener listener) {
+    Objects.requireNonNull(listener);
+    mOrientationListeners.add(listener);
+  }
+
+  public void removeOrientationListener(InCallOrientationListener listener) {
+    if (listener != null) {
+      mOrientationListeners.remove(listener);
+    }
+  }
+
+  public void addInCallEventListener(InCallEventListener listener) {
+    Objects.requireNonNull(listener);
+    mInCallEventListeners.add(listener);
+  }
+
+  public void removeInCallEventListener(InCallEventListener listener) {
+    if (listener != null) {
+      mInCallEventListeners.remove(listener);
+    }
+  }
+
+  public ProximitySensor getProximitySensor() {
+    return mProximitySensor;
+  }
+
+  public PseudoScreenState getPseudoScreenState() {
+    return mPseudoScreenState;
+  }
+
+  /** Returns true if the incall app is the foreground application. */
+  public boolean isShowingInCallUi() {
+    if (!isActivityStarted()) {
+      return false;
+    }
+    if (mManageConferenceActivity != null && mManageConferenceActivity.isVisible()) {
+      return true;
+    }
+    return mInCallActivity.isVisible();
+  }
+
+  /**
+   * Returns true if the activity has been created and is running. Returns true as long as activity
+   * is not destroyed or finishing. This ensures that we return true even if the activity is paused
+   * (not in foreground).
+   */
+  public boolean isActivityStarted() {
+    return (mInCallActivity != null
+        && !mInCallActivity.isDestroyed()
+        && !mInCallActivity.isFinishing());
+  }
+
+  /**
+   * Determines if the In-Call app is currently changing configuration.
+   *
+   * @return {@code true} if the In-Call app is changing configuration.
+   */
+  public boolean isChangingConfigurations() {
+    return mIsChangingConfigurations;
+  }
+
+  /**
+   * Tracks whether the In-Call app is currently in the process of changing configuration (i.e.
+   * screen orientation).
+   */
+  /*package*/
+  void updateIsChangingConfigurations() {
+    mIsChangingConfigurations = false;
+    if (mInCallActivity != null) {
+      mIsChangingConfigurations = mInCallActivity.isChangingConfigurations();
+    }
+    Log.v(this, "updateIsChangingConfigurations = " + mIsChangingConfigurations);
+  }
+
+  /** Called when the activity goes in/out of the foreground. */
+  public void onUiShowing(boolean showing) {
+    // We need to update the notification bar when we leave the UI because that
+    // could trigger it to show again.
+    if (mStatusBarNotifier != null) {
+      mStatusBarNotifier.updateNotification(mCallList);
+    }
+
+    if (mProximitySensor != null) {
+      mProximitySensor.onInCallShowing(showing);
+    }
+
+    Intent broadcastIntent = Bindings.get(mContext).getUiReadyBroadcastIntent(mContext);
+    if (broadcastIntent != null) {
+      broadcastIntent.putExtra(EXTRA_FIRST_TIME_SHOWN, !mIsActivityPreviouslyStarted);
+
+      if (showing) {
+        Log.d(this, "Sending sticky broadcast: ", broadcastIntent);
+        mContext.sendStickyBroadcast(broadcastIntent);
+      } else {
+        Log.d(this, "Removing sticky broadcast: ", broadcastIntent);
+        mContext.removeStickyBroadcast(broadcastIntent);
+      }
+    }
+
+    if (showing) {
+      mIsActivityPreviouslyStarted = true;
+    } else {
+      updateIsChangingConfigurations();
+    }
+
+    for (InCallUiListener listener : mInCallUiListeners) {
+      listener.onUiShowing(showing);
+    }
+
+    if (mInCallActivity != null) {
+      // Re-evaluate which fragment is being shown.
+      mInCallActivity.onPrimaryCallStateChanged();
+    }
+  }
+
+  public void addInCallUiListener(InCallUiListener listener) {
+    mInCallUiListeners.add(listener);
+  }
+
+  public boolean removeInCallUiListener(InCallUiListener listener) {
+    return mInCallUiListeners.remove(listener);
+  }
+
+  /*package*/
+  void onActivityStarted() {
+    Log.d(this, "onActivityStarted");
+    notifyVideoPauseController(true);
+    mStatusBarNotifier.updateNotification(mCallList);
+  }
+
+  /*package*/
+  void onActivityStopped() {
+    Log.d(this, "onActivityStopped");
+    notifyVideoPauseController(false);
+  }
+
+  private void notifyVideoPauseController(boolean showing) {
+    Log.d(
+        this, "notifyVideoPauseController: mIsChangingConfigurations=" + mIsChangingConfigurations);
+    if (!mIsChangingConfigurations) {
+      VideoPauseController.getInstance().onUiShowing(showing);
+    }
+  }
+
+  /** Brings the app into the foreground if possible. */
+  public void bringToForeground(boolean showDialpad) {
+    // Before we bring the incall UI to the foreground, we check to see if:
+    // 1. It is not currently in the foreground
+    // 2. We are in a state where we want to show the incall ui (i.e. there are calls to
+    // be displayed)
+    // If the activity hadn't actually been started previously, yet there are still calls
+    // present (e.g. a call was accepted by a bluetooth or wired headset), we want to
+    // bring it up the UI regardless.
+    if (!isShowingInCallUi() && mInCallState != InCallState.NO_CALLS) {
+      showInCall(showDialpad, false /* newOutgoingCall */, false /* isVideoCall */);
+    }
+  }
+
+  public void onPostDialCharWait(String callId, String chars) {
+    if (isActivityStarted()) {
+      mInCallActivity.showPostCharWaitDialog(callId, chars);
+    }
+  }
+
+  /**
+   * Handles the green CALL key while in-call.
+   *
+   * @return true if we consumed the event.
+   */
+  public boolean handleCallKey() {
+    LogUtil.v("InCallPresenter.handleCallKey", null);
+
+    // The green CALL button means either "Answer", "Unhold", or
+    // "Swap calls", or can be a no-op, depending on the current state
+    // of the Phone.
+
+    /** INCOMING CALL */
+    final CallList calls = mCallList;
+    final DialerCall incomingCall = calls.getIncomingCall();
+    LogUtil.v("InCallPresenter.handleCallKey", "incomingCall: " + incomingCall);
+
+    // (1) Attempt to answer a call
+    if (incomingCall != null) {
+      incomingCall.answer(VideoProfile.STATE_AUDIO_ONLY);
+      return true;
+    }
+
+    /** STATE_ACTIVE CALL */
+    final DialerCall activeCall = calls.getActiveCall();
+    if (activeCall != null) {
+      // TODO: This logic is repeated from CallButtonPresenter.java. We should
+      // consolidate this logic.
+      final boolean canMerge =
+          activeCall.can(android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE);
+      final boolean canSwap =
+          activeCall.can(android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE);
+
+      Log.v(
+          this, "activeCall: " + activeCall + ", canMerge: " + canMerge + ", canSwap: " + canSwap);
+
+      // (2) Attempt actions on conference calls
+      if (canMerge) {
+        TelecomAdapter.getInstance().merge(activeCall.getId());
+        return true;
+      } else if (canSwap) {
+        TelecomAdapter.getInstance().swap(activeCall.getId());
+        return true;
+      }
+    }
+
+    /** BACKGROUND CALL */
+    final DialerCall heldCall = calls.getBackgroundCall();
+    if (heldCall != null) {
+      // We have a hold call so presumeable it will always support HOLD...but
+      // there is no harm in double checking.
+      final boolean canHold = heldCall.can(android.telecom.Call.Details.CAPABILITY_HOLD);
+
+      Log.v(this, "heldCall: " + heldCall + ", canHold: " + canHold);
+
+      // (4) unhold call
+      if (heldCall.getState() == DialerCall.State.ONHOLD && canHold) {
+        heldCall.unhold();
+        return true;
+      }
+    }
+
+    // Always consume hard keys
+    return true;
+  }
+
+  /**
+   * A dialog could have prevented in-call screen from being previously finished. This function
+   * checks to see if there should be any UI left and if not attempts to tear down the UI.
+   */
+  public void onDismissDialog() {
+    Log.i(this, "Dialog dismissed");
+    if (mInCallState == InCallState.NO_CALLS) {
+      attemptFinishActivity();
+      attemptCleanup();
+    }
+  }
+
+  /** Clears the previous fullscreen state. */
+  public void clearFullscreen() {
+    mIsFullScreen = false;
+  }
+
+  /**
+   * Changes the fullscreen mode of the in-call UI.
+   *
+   * @param isFullScreen {@code true} if in-call should be in fullscreen mode, {@code false}
+   *     otherwise.
+   */
+  public void setFullScreen(boolean isFullScreen) {
+    setFullScreen(isFullScreen, false /* force */);
+  }
+
+  /**
+   * Changes the fullscreen mode of the in-call UI.
+   *
+   * @param isFullScreen {@code true} if in-call should be in fullscreen mode, {@code false}
+   *     otherwise.
+   * @param force {@code true} if fullscreen mode should be set regardless of its current state.
+   */
+  public void setFullScreen(boolean isFullScreen, boolean force) {
+    Log.i(this, "setFullScreen = " + isFullScreen);
+
+    // As a safeguard, ensure we cannot enter fullscreen if the dialpad is shown.
+    if (isDialpadVisible()) {
+      isFullScreen = false;
+      Log.v(this, "setFullScreen overridden as dialpad is shown = " + isFullScreen);
+    }
+
+    if (mIsFullScreen == isFullScreen && !force) {
+      Log.v(this, "setFullScreen ignored as already in that state.");
+      return;
+    }
+    mIsFullScreen = isFullScreen;
+    notifyFullscreenModeChange(mIsFullScreen);
+  }
+
+  /**
+   * @return {@code true} if the in-call ui is currently in fullscreen mode, {@code false}
+   *     otherwise.
+   */
+  public boolean isFullscreen() {
+    return mIsFullScreen;
+  }
+
+  /**
+   * Called by the {@link VideoCallPresenter} to inform of a change in full screen video status.
+   *
+   * @param isFullscreenMode {@code True} if entering full screen mode.
+   */
+  public void notifyFullscreenModeChange(boolean isFullscreenMode) {
+    for (InCallEventListener listener : mInCallEventListeners) {
+      listener.onFullscreenModeChanged(isFullscreenMode);
+    }
+  }
+
+  /**
+   * For some disconnected causes, we show a dialog. This calls into the activity to show the dialog
+   * if appropriate for the call.
+   */
+  private void maybeShowErrorDialogOnDisconnect(DialerCall call) {
+    // For newly disconnected calls, we may want to show a dialog on specific error conditions
+    if (isActivityStarted() && call.getState() == DialerCall.State.DISCONNECTED) {
+      if (call.getAccountHandle() == null && !call.isConferenceCall()) {
+        setDisconnectCauseForMissingAccounts(call);
+      }
+      mInCallActivity.maybeShowErrorDialogOnDisconnect(call.getDisconnectCause());
+    }
+  }
+
+  /**
+   * When the state of in-call changes, this is the first method to get called. It determines if the
+   * UI needs to be started or finished depending on the new state and does it.
+   */
+  private InCallState startOrFinishUi(InCallState newState) {
+    Log.d(this, "startOrFinishUi: " + mInCallState + " -> " + newState);
+
+    // TODO: Consider a proper state machine implementation
+
+    // If the state isn't changing we have already done any starting/stopping of activities in
+    // a previous pass...so lets cut out early
+    if (newState == mInCallState) {
+      return newState;
+    }
+
+    // A new Incoming call means that the user needs to be notified of the the call (since
+    // it wasn't them who initiated it).  We do this through full screen notifications and
+    // happens indirectly through {@link StatusBarNotifier}.
+    //
+    // The process for incoming calls is as follows:
+    //
+    // 1) CallList          - Announces existence of new INCOMING call
+    // 2) InCallPresenter   - Gets announcement and calculates that the new InCallState
+    //                      - should be set to INCOMING.
+    // 3) InCallPresenter   - This method is called to see if we need to start or finish
+    //                        the app given the new state.
+    // 4) StatusBarNotifier - Listens to InCallState changes. InCallPresenter calls
+    //                        StatusBarNotifier explicitly to issue a FullScreen Notification
+    //                        that will either start the InCallActivity or show the user a
+    //                        top-level notification dialog if the user is in an immersive app.
+    //                        That notification can also start the InCallActivity.
+    // 5) InCallActivity    - Main activity starts up and at the end of its onCreate will
+    //                        call InCallPresenter::setActivity() to let the presenter
+    //                        know that start-up is complete.
+    //
+    //          [ AND NOW YOU'RE IN THE CALL. voila! ]
+    //
+    // Our app is started using a fullScreen notification.  We need to do this whenever
+    // we get an incoming call. Depending on the current context of the device, either a
+    // incoming call HUN or the actual InCallActivity will be shown.
+    final boolean startIncomingCallSequence = (InCallState.INCOMING == newState);
+
+    // A dialog to show on top of the InCallUI to select a PhoneAccount
+    final boolean showAccountPicker = (InCallState.WAITING_FOR_ACCOUNT == newState);
+
+    // A new outgoing call indicates that the user just now dialed a number and when that
+    // happens we need to display the screen immediately or show an account picker dialog if
+    // no default is set. However, if the main InCallUI is already visible, we do not want to
+    // re-initiate the start-up animation, so we do not need to do anything here.
+    //
+    // It is also possible to go into an intermediate state where the call has been initiated
+    // but Telecom has not yet returned with the details of the call (handle, gateway, etc.).
+    // This pending outgoing state can also launch the call screen.
+    //
+    // This is different from the incoming call sequence because we do not need to shock the
+    // user with a top-level notification.  Just show the call UI normally.
+    boolean callCardFragmentVisible =
+        mInCallActivity != null && mInCallActivity.getCallCardFragmentVisible();
+    final boolean mainUiNotVisible = !isShowingInCallUi() || !callCardFragmentVisible;
+    boolean showCallUi = InCallState.OUTGOING == newState && mainUiNotVisible;
+
+    // Direct transition from PENDING_OUTGOING -> INCALL means that there was an error in the
+    // outgoing call process, so the UI should be brought up to show an error dialog.
+    showCallUi |=
+        (InCallState.PENDING_OUTGOING == mInCallState
+            && InCallState.INCALL == newState
+            && !isShowingInCallUi());
+
+    // Another exception - InCallActivity is in charge of disconnecting a call with no
+    // valid accounts set. Bring the UI up if this is true for the current pending outgoing
+    // call so that:
+    // 1) The call can be disconnected correctly
+    // 2) The UI comes up and correctly displays the error dialog.
+    // TODO: Remove these special case conditions by making InCallPresenter a true state
+    // machine. Telecom should also be the component responsible for disconnecting a call
+    // with no valid accounts.
+    showCallUi |=
+        InCallState.PENDING_OUTGOING == newState
+            && mainUiNotVisible
+            && isCallWithNoValidAccounts(mCallList.getPendingOutgoingCall());
+
+    // The only time that we have an instance of mInCallActivity and it isn't started is
+    // when it is being destroyed.  In that case, lets avoid bringing up another instance of
+    // the activity.  When it is finally destroyed, we double check if we should bring it back
+    // up so we aren't going to lose anything by avoiding a second startup here.
+    boolean activityIsFinishing = mInCallActivity != null && !isActivityStarted();
+    if (activityIsFinishing) {
+      Log.i(this, "Undo the state change: " + newState + " -> " + mInCallState);
+      return mInCallState;
+    }
+
+    // We're about the bring up the in-call UI for outgoing and incoming call. If we still have
+    // dialogs up, we need to clear them out before showing in-call screen. This is necessary
+    // to fix the bug that dialog will show up when data reaches limit even after makeing new
+    // outgoing call after user ignore it by pressing home button.
+    if ((newState == InCallState.INCOMING || newState == InCallState.PENDING_OUTGOING)
+        && !showCallUi
+        && isActivityStarted()) {
+      mInCallActivity.dismissPendingDialogs();
+    }
+
+    if (showCallUi || showAccountPicker) {
+      Log.i(this, "Start in call UI");
+      showInCall(false /* showDialpad */, !showAccountPicker /* newOutgoingCall */, false);
+    } else if (startIncomingCallSequence) {
+      Log.i(this, "Start Full Screen in call UI");
+
+      if (!startUi()) {
+        // startUI refused to start the UI. This indicates that it needed to restart the
+        // activity.  When it finally restarts, it will call us back, so we do not actually
+        // change the state yet (we return mInCallState instead of newState).
+        return mInCallState;
+      }
+    } else if (newState == InCallState.NO_CALLS) {
+      // The new state is the no calls state.  Tear everything down.
+      attemptFinishActivity();
+      attemptCleanup();
+    }
+
+    return newState;
+  }
+
+  /**
+   * Sets the DisconnectCause for a call that was disconnected because it was missing a PhoneAccount
+   * or PhoneAccounts to select from.
+   */
+  private void setDisconnectCauseForMissingAccounts(DialerCall call) {
+
+    Bundle extras = call.getIntentExtras();
+    // Initialize the extras bundle to avoid NPE
+    if (extras == null) {
+      extras = new Bundle();
+    }
+
+    final List<PhoneAccountHandle> phoneAccountHandles =
+        extras.getParcelableArrayList(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+
+    if (phoneAccountHandles == null || phoneAccountHandles.isEmpty()) {
+      String scheme = call.getHandle().getScheme();
+      final String errorMsg =
+          PhoneAccount.SCHEME_TEL.equals(scheme)
+              ? mContext.getString(R.string.callFailed_simError)
+              : mContext.getString(R.string.incall_error_supp_service_unknown);
+      DisconnectCause disconnectCause =
+          new DisconnectCause(DisconnectCause.ERROR, null, errorMsg, errorMsg);
+      call.setDisconnectCause(disconnectCause);
+    }
+  }
+
+  private boolean startUi() {
+    boolean isCallWaiting =
+        mCallList.getActiveCall() != null && mCallList.getIncomingCall() != null;
+
+    if (isCallWaiting) {
+      showInCall(false, false, false /* isVideoCall */);
+    } else {
+      mStatusBarNotifier.updateNotification(mCallList);
+    }
+    return true;
+  }
+
+  /**
+   * @return {@code true} if the InCallPresenter is ready to be torn down, {@code false} otherwise.
+   *     Calling classes should use this as an indication whether to interact with the
+   *     InCallPresenter or not.
+   */
+  public boolean isReadyForTearDown() {
+    return mInCallActivity == null && !mServiceConnected && mInCallState == InCallState.NO_CALLS;
+  }
+
+  /**
+   * Checks to see if both the UI is gone and the service is disconnected. If so, tear it all down.
+   */
+  private void attemptCleanup() {
+    if (isReadyForTearDown()) {
+      Log.i(this, "Cleaning up");
+
+      cleanupSurfaces();
+
+      mIsActivityPreviouslyStarted = false;
+      mIsChangingConfigurations = false;
+
+      // blow away stale contact info so that we get fresh data on
+      // the next set of calls
+      if (mContactInfoCache != null) {
+        mContactInfoCache.clearCache();
+      }
+      mContactInfoCache = null;
+
+      if (mProximitySensor != null) {
+        removeListener(mProximitySensor);
+        mProximitySensor.tearDown();
+      }
+      mProximitySensor = null;
+
+      if (mStatusBarNotifier != null) {
+        removeListener(mStatusBarNotifier);
+      }
+      if (mExternalCallNotifier != null && mExternalCallList != null) {
+        mExternalCallList.removeExternalCallListener(mExternalCallNotifier);
+      }
+      mStatusBarNotifier = null;
+
+      if (mCallList != null) {
+        mCallList.removeListener(this);
+        mCallList.removeListener(mSpamCallListListener);
+      }
+      mCallList = null;
+
+      mContext = null;
+      mInCallActivity = null;
+      mManageConferenceActivity = null;
+
+      mListeners.clear();
+      mIncomingCallListeners.clear();
+      mDetailsListeners.clear();
+      mCanAddCallListeners.clear();
+      mOrientationListeners.clear();
+      mInCallEventListeners.clear();
+      mInCallUiListeners.clear();
+
+      Log.d(this, "Finished InCallPresenter.CleanUp");
+    }
+  }
+
+  public void showInCall(boolean showDialpad, boolean newOutgoingCall, boolean isVideoCall) {
+    Log.i(this, "Showing InCallActivity");
+    mContext.startActivity(
+        InCallActivity.getIntent(
+            mContext, showDialpad, newOutgoingCall, isVideoCall, false /* forFullScreen */));
+  }
+
+  public void onServiceBind() {
+    mServiceBound = true;
+  }
+
+  public void onServiceUnbind() {
+    InCallPresenter.getInstance().setBoundAndWaitingForOutgoingCall(false, null);
+    mServiceBound = false;
+  }
+
+  public boolean isServiceBound() {
+    return mServiceBound;
+  }
+
+  public void maybeStartRevealAnimation(Intent intent) {
+    if (intent == null || mInCallActivity != null) {
+      return;
+    }
+    final Bundle extras = intent.getBundleExtra(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS);
+    if (extras == null) {
+      // Incoming call, just show the in-call UI directly.
+      return;
+    }
+
+    if (extras.containsKey(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS)) {
+      // Account selection dialog will show up so don't show the animation.
+      return;
+    }
+
+    final PhoneAccountHandle accountHandle =
+        intent.getParcelableExtra(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE);
+    final Point touchPoint = extras.getParcelable(TouchPointManager.TOUCH_POINT);
+    int videoState =
+        extras.getInt(
+            TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, VideoProfile.STATE_AUDIO_ONLY);
+
+    InCallPresenter.getInstance().setBoundAndWaitingForOutgoingCall(true, accountHandle);
+
+    final Intent activityIntent =
+        InCallActivity.getIntent(
+            mContext, false, true, VideoUtils.isVideoCall(videoState), false /* forFullScreen */);
+    activityIntent.putExtra(TouchPointManager.TOUCH_POINT, touchPoint);
+    mContext.startActivity(activityIntent);
+  }
+
+  /**
+   * Retrieves the current in-call camera manager instance, creating if necessary.
+   *
+   * @return The {@link InCallCameraManager}.
+   */
+  public InCallCameraManager getInCallCameraManager() {
+    synchronized (this) {
+      if (mInCallCameraManager == null) {
+        mInCallCameraManager = new InCallCameraManager(mContext);
+      }
+
+      return mInCallCameraManager;
+    }
+  }
+
+  /**
+   * Notifies listeners of changes in orientation and notify calls of rotation angle change.
+   *
+   * @param orientation The screen orientation of the device (one of: {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_0}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_90}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_180}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+   */
+  public void onDeviceOrientationChange(@ScreenOrientation int orientation) {
+    Log.d(this, "onDeviceOrientationChange: orientation= " + orientation);
+
+    if (mCallList != null) {
+      mCallList.notifyCallsOfDeviceRotation(orientation);
+    } else {
+      Log.w(this, "onDeviceOrientationChange: CallList is null.");
+    }
+
+    // Notify listeners of device orientation changed.
+    for (InCallOrientationListener listener : mOrientationListeners) {
+      listener.onDeviceOrientationChanged(orientation);
+    }
+  }
+
+  /**
+   * Configures the in-call UI activity so it can change orientations or not. Enables the
+   * orientation event listener if allowOrientationChange is true, disables it if false.
+   *
+   * @param allowOrientationChange {@code true} if the in-call UI can change between portrait and
+   *     landscape. {@code false} if the in-call UI should be locked in portrait.
+   */
+  public void setInCallAllowsOrientationChange(boolean allowOrientationChange) {
+    if (mInCallActivity == null) {
+      Log.e(this, "InCallActivity is null. Can't set requested orientation.");
+      return;
+    }
+    mInCallActivity.setAllowOrientationChange(allowOrientationChange);
+  }
+
+  public void enableScreenTimeout(boolean enable) {
+    Log.v(this, "enableScreenTimeout: value=" + enable);
+    if (mInCallActivity == null) {
+      Log.e(this, "enableScreenTimeout: InCallActivity is null.");
+      return;
+    }
+
+    final Window window = mInCallActivity.getWindow();
+    if (enable) {
+      window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    } else {
+      window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    }
+  }
+
+  /**
+   * Hides or shows the conference manager fragment.
+   *
+   * @param show {@code true} if the conference manager should be shown, {@code false} if it should
+   *     be hidden.
+   */
+  public void showConferenceCallManager(boolean show) {
+    if (mInCallActivity != null) {
+      mInCallActivity.showConferenceFragment(show);
+    }
+    if (!show && mManageConferenceActivity != null) {
+      mManageConferenceActivity.finish();
+    }
+  }
+
+  /**
+   * Determines if the dialpad is visible.
+   *
+   * @return {@code true} if the dialpad is visible, {@code false} otherwise.
+   */
+  public boolean isDialpadVisible() {
+    if (mInCallActivity == null) {
+      return false;
+    }
+    return mInCallActivity.isDialpadVisible();
+  }
+
+  public ThemeColorManager getThemeColorManager() {
+    return mThemeColorManager;
+  }
+
+  /** Called when the foreground call changes. */
+  public void onForegroundCallChanged(DialerCall newForegroundCall) {
+    mThemeColorManager.onForegroundCallChanged(mContext, newForegroundCall);
+    if (mInCallActivity != null) {
+      mInCallActivity.onForegroundCallChanged(newForegroundCall);
+    }
+  }
+
+  public InCallActivity getActivity() {
+    return mInCallActivity;
+  }
+
+  /** Called when the UI begins, and starts the callstate callbacks if necessary. */
+  public void setActivity(InCallActivity inCallActivity) {
+    if (inCallActivity == null) {
+      throw new IllegalArgumentException("registerActivity cannot be called with null");
+    }
+    if (mInCallActivity != null && mInCallActivity != inCallActivity) {
+      Log.w(this, "Setting a second activity before destroying the first.");
+    }
+    updateActivity(inCallActivity);
+  }
+
+  ExternalCallNotifier getExternalCallNotifier() {
+    return mExternalCallNotifier;
+  }
+
+  VideoSurfaceTexture getLocalVideoSurfaceTexture() {
+    if (mLocalVideoSurfaceTexture == null) {
+      mLocalVideoSurfaceTexture = VideoSurfaceBindings.createLocalVideoSurfaceTexture();
+    }
+    return mLocalVideoSurfaceTexture;
+  }
+
+  VideoSurfaceTexture getRemoteVideoSurfaceTexture() {
+    if (mRemoteVideoSurfaceTexture == null) {
+      mRemoteVideoSurfaceTexture = VideoSurfaceBindings.createRemoteVideoSurfaceTexture();
+    }
+    return mRemoteVideoSurfaceTexture;
+  }
+
+  void cleanupSurfaces() {
+    if (mRemoteVideoSurfaceTexture != null) {
+      mRemoteVideoSurfaceTexture.setDoneWithSurface();
+      mRemoteVideoSurfaceTexture = null;
+    }
+    if (mLocalVideoSurfaceTexture != null) {
+      mLocalVideoSurfaceTexture.setDoneWithSurface();
+      mLocalVideoSurfaceTexture = null;
+    }
+  }
+
+  /** All the main states of InCallActivity. */
+  public enum InCallState {
+    // InCall Screen is off and there are no calls
+    NO_CALLS,
+
+    // Incoming-call screen is up
+    INCOMING,
+
+    // In-call experience is showing
+    INCALL,
+
+    // Waiting for user input before placing outgoing call
+    WAITING_FOR_ACCOUNT,
+
+    // UI is starting up but no call has been initiated yet.
+    // The UI is waiting for Telecom to respond.
+    PENDING_OUTGOING,
+
+    // User is dialing out
+    OUTGOING;
+
+    public boolean isIncoming() {
+      return (this == INCOMING);
+    }
+
+    public boolean isConnectingOrConnected() {
+      return (this == INCOMING || this == OUTGOING || this == INCALL);
+    }
+  }
+
+  /** Interface implemented by classes that need to know about the InCall State. */
+  public interface InCallStateListener {
+
+    // TODO: Enhance state to contain the call objects instead of passing CallList
+    void onStateChange(InCallState oldState, InCallState newState, CallList callList);
+  }
+
+  public interface IncomingCallListener {
+
+    void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call);
+  }
+
+  public interface CanAddCallListener {
+
+    void onCanAddCallChanged(boolean canAddCall);
+  }
+
+  public interface InCallDetailsListener {
+
+    void onDetailsChanged(DialerCall call, android.telecom.Call.Details details);
+  }
+
+  public interface InCallOrientationListener {
+
+    void onDeviceOrientationChanged(@ScreenOrientation int orientation);
+  }
+
+  /**
+   * Interface implemented by classes that need to know about events which occur within the In-Call
+   * UI. Used as a means of communicating between fragments that make up the UI.
+   */
+  public interface InCallEventListener {
+
+    void onFullscreenModeChanged(boolean isFullscreenMode);
+  }
+
+  public interface InCallUiListener {
+
+    void onUiShowing(boolean showing);
+  }
+}
diff --git a/java/com/android/incallui/InCallServiceImpl.java b/java/com/android/incallui/InCallServiceImpl.java
new file mode 100644
index 0000000..33e8393
--- /dev/null
+++ b/java/com/android/incallui/InCallServiceImpl.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.telecom.Call;
+import android.telecom.CallAudioState;
+import android.telecom.InCallService;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.ExternalCallList;
+import com.android.incallui.call.TelecomAdapter;
+
+/**
+ * Used to receive updates about calls from the Telecom component. This service is bound to Telecom
+ * while there exist calls which potentially require UI. This includes ringing (incoming), dialing
+ * (outgoing), and active calls. When the last call is disconnected, Telecom will unbind to the
+ * service triggering InCallActivity (via CallList) to finish soon after.
+ */
+public class InCallServiceImpl extends InCallService {
+
+  @Override
+  public void onCallAudioStateChanged(CallAudioState audioState) {
+    AudioModeProvider.getInstance().onAudioStateChanged(audioState);
+  }
+
+  @Override
+  public void onBringToForeground(boolean showDialpad) {
+    InCallPresenter.getInstance().onBringToForeground(showDialpad);
+  }
+
+  @Override
+  public void onCallAdded(Call call) {
+    InCallPresenter.getInstance().onCallAdded(call);
+  }
+
+  @Override
+  public void onCallRemoved(Call call) {
+    InCallPresenter.getInstance().onCallRemoved(call);
+  }
+
+  @Override
+  public void onCanAddCallChanged(boolean canAddCall) {
+    InCallPresenter.getInstance().onCanAddCallChanged(canAddCall);
+  }
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    final Context context = getApplicationContext();
+    final ContactInfoCache contactInfoCache = ContactInfoCache.getInstance(context);
+    InCallPresenter.getInstance()
+        .setUp(
+            getApplicationContext(),
+            CallList.getInstance(),
+            new ExternalCallList(),
+            new StatusBarNotifier(context, contactInfoCache),
+            new ExternalCallNotifier(context, contactInfoCache),
+            contactInfoCache,
+            new ProximitySensor(
+                context, AudioModeProvider.getInstance(), new AccelerometerListener(context)));
+    InCallPresenter.getInstance().onServiceBind();
+    InCallPresenter.getInstance().maybeStartRevealAnimation(intent);
+    TelecomAdapter.getInstance().setInCallService(this);
+
+    return super.onBind(intent);
+  }
+
+  @Override
+  public boolean onUnbind(Intent intent) {
+    super.onUnbind(intent);
+
+    InCallPresenter.getInstance().onServiceUnbind();
+    tearDown();
+
+    return false;
+  }
+
+  private void tearDown() {
+    Log.v(this, "tearDown");
+    // Tear down the InCall system
+    TelecomAdapter.getInstance().clearInCallService();
+    InCallPresenter.getInstance().tearDown();
+  }
+}
diff --git a/java/com/android/incallui/InCallUIMaterialColorMapUtils.java b/java/com/android/incallui/InCallUIMaterialColorMapUtils.java
new file mode 100644
index 0000000..7b06a5e
--- /dev/null
+++ b/java/com/android/incallui/InCallUIMaterialColorMapUtils.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.telecom.PhoneAccount;
+import com.android.contacts.common.util.MaterialColorMapUtils;
+
+public class InCallUIMaterialColorMapUtils extends MaterialColorMapUtils {
+
+  private final TypedArray mPrimaryColors;
+  private final TypedArray mSecondaryColors;
+  private final Resources mResources;
+
+  public InCallUIMaterialColorMapUtils(Resources resources) {
+    super(resources);
+    mPrimaryColors = resources.obtainTypedArray(R.array.background_colors);
+    mSecondaryColors = resources.obtainTypedArray(R.array.background_colors_dark);
+    mResources = resources;
+  }
+
+  /**
+   * {@link Resources#getColor(int) used for compatibility
+   */
+  @SuppressWarnings("deprecation")
+  public static MaterialPalette getDefaultPrimaryAndSecondaryColors(Resources resources) {
+    final int primaryColor = resources.getColor(R.color.dialer_theme_color);
+    final int secondaryColor = resources.getColor(R.color.dialer_theme_color_dark);
+    return new MaterialPalette(primaryColor, secondaryColor);
+  }
+
+  /**
+   * Currently the InCallUI color will only vary by SIM color which is a list of colors defined in
+   * the background_colors array, so first search the list for the matching color and fall back to
+   * the closest matching color if an exact match does not exist.
+   */
+  @Override
+  public MaterialPalette calculatePrimaryAndSecondaryColor(int color) {
+    if (color == PhoneAccount.NO_HIGHLIGHT_COLOR) {
+      return getDefaultPrimaryAndSecondaryColors(mResources);
+    }
+
+    for (int i = 0; i < mPrimaryColors.length(); i++) {
+      if (mPrimaryColors.getColor(i, 0) == color) {
+        return new MaterialPalette(mPrimaryColors.getColor(i, 0), mSecondaryColors.getColor(i, 0));
+      }
+    }
+
+    // The color isn't in the list, so use the superclass to find an approximate color.
+    return super.calculatePrimaryAndSecondaryColor(color);
+  }
+}
diff --git a/java/com/android/incallui/Log.java b/java/com/android/incallui/Log.java
new file mode 100644
index 0000000..c63eccb
--- /dev/null
+++ b/java/com/android/incallui/Log.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.net.Uri;
+import android.telecom.PhoneAccount;
+import android.telephony.PhoneNumberUtils;
+import com.android.dialer.common.LogUtil;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/** Manages logging for the entire class. */
+public class Log {
+
+  public static void d(String tag, String msg) {
+    LogUtil.d(tag, msg);
+  }
+
+  public static void d(Object obj, String msg) {
+    LogUtil.d(getPrefix(obj), msg);
+  }
+
+  public static void d(Object obj, String str1, Object str2) {
+    LogUtil.d(getPrefix(obj), str1 + str2);
+  }
+
+  public static void v(Object obj, String msg) {
+    LogUtil.v(getPrefix(obj), msg);
+  }
+
+  public static void v(Object obj, String str1, Object str2) {
+    LogUtil.v(getPrefix(obj), str1 + str2);
+  }
+
+  public static void e(String tag, String msg, Exception e) {
+    LogUtil.e(tag, msg, e);
+  }
+
+  public static void e(String tag, String msg) {
+    LogUtil.e(tag, msg);
+  }
+
+  public static void e(Object obj, String msg, Exception e) {
+    LogUtil.e(getPrefix(obj), msg, e);
+  }
+
+  public static void e(Object obj, String msg) {
+    LogUtil.e(getPrefix(obj), msg);
+  }
+
+  public static void i(String tag, String msg) {
+    LogUtil.i(tag, msg);
+  }
+
+  public static void i(Object obj, String msg) {
+    LogUtil.i(getPrefix(obj), msg);
+  }
+
+  public static void w(Object obj, String msg) {
+    LogUtil.w(getPrefix(obj), msg);
+  }
+
+  public static String piiHandle(Object pii) {
+    if (pii == null || LogUtil.isVerboseEnabled()) {
+      return String.valueOf(pii);
+    }
+
+    if (pii instanceof Uri) {
+      Uri uri = (Uri) pii;
+
+      // All Uri's which are not "tel" go through normal pii() method.
+      if (!PhoneAccount.SCHEME_TEL.equals(uri.getScheme())) {
+        return pii(pii);
+      } else {
+        pii = uri.getSchemeSpecificPart();
+      }
+    }
+
+    String originalString = String.valueOf(pii);
+    StringBuilder stringBuilder = new StringBuilder(originalString.length());
+    for (char c : originalString.toCharArray()) {
+      if (PhoneNumberUtils.isDialable(c)) {
+        stringBuilder.append('*');
+      } else {
+        stringBuilder.append(c);
+      }
+    }
+    return stringBuilder.toString();
+  }
+
+  /**
+   * Redact personally identifiable information for production users. If we are running in verbose
+   * mode, return the original string, otherwise return a SHA-1 hash of the input string.
+   */
+  public static String pii(Object pii) {
+    if (pii == null || LogUtil.isVerboseEnabled()) {
+      return String.valueOf(pii);
+    }
+    return "[" + secureHash(String.valueOf(pii).getBytes()) + "]";
+  }
+
+  private static String secureHash(byte[] input) {
+    MessageDigest messageDigest;
+    try {
+      messageDigest = MessageDigest.getInstance("SHA-1");
+    } catch (NoSuchAlgorithmException e) {
+      return null;
+    }
+    messageDigest.update(input);
+    byte[] result = messageDigest.digest();
+    return encodeHex(result);
+  }
+
+  private static String encodeHex(byte[] bytes) {
+    StringBuffer hex = new StringBuffer(bytes.length * 2);
+
+    for (int i = 0; i < bytes.length; i++) {
+      int byteIntValue = bytes[i] & 0xff;
+      if (byteIntValue < 0x10) {
+        hex.append("0");
+      }
+      hex.append(Integer.toString(byteIntValue, 16));
+    }
+
+    return hex.toString();
+  }
+
+  private static String getPrefix(Object obj) {
+    return (obj == null ? "" : (obj.getClass().getSimpleName()));
+  }
+}
diff --git a/java/com/android/incallui/ManageConferenceActivity.java b/java/com/android/incallui/ManageConferenceActivity.java
new file mode 100644
index 0000000..6584e4f
--- /dev/null
+++ b/java/com/android/incallui/ManageConferenceActivity.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v7.app.AppCompatActivity;
+import android.view.MenuItem;
+
+/** Shows the {@link ConferenceManagerFragment} */
+public class ManageConferenceActivity extends AppCompatActivity {
+
+  private boolean isVisible;
+
+  public boolean isVisible() {
+    return isVisible;
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    InCallPresenter.getInstance().setManageConferenceActivity(this);
+
+    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+    setContentView(R.layout.activity_manage_conference);
+    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.manageConferencePanel);
+    if (fragment == null) {
+      fragment = new ConferenceManagerFragment();
+      getSupportFragmentManager()
+          .beginTransaction()
+          .replace(R.id.manageConferencePanel, fragment)
+          .commit();
+    }
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    if (isFinishing()) {
+      InCallPresenter.getInstance().setManageConferenceActivity(null);
+    }
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    final int itemId = item.getItemId();
+    if (itemId == android.R.id.home) {
+      onBackPressed();
+      return true;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  public void onBackPressed() {
+    InCallPresenter.getInstance().bringToForeground(false);
+    finish();
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    isVisible = true;
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    isVisible = false;
+  }
+}
diff --git a/java/com/android/incallui/NotificationBroadcastReceiver.java b/java/com/android/incallui/NotificationBroadcastReceiver.java
new file mode 100644
index 0000000..5c5d255
--- /dev/null
+++ b/java/com/android/incallui/NotificationBroadcastReceiver.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build.VERSION_CODES;
+import android.support.annotation.RequiresApi;
+import android.telecom.VideoProfile;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.VideoUtils;
+
+/**
+ * Accepts broadcast Intents which will be prepared by {@link StatusBarNotifier} and thus sent from
+ * the notification manager. This should be visible from outside, but shouldn't be exported.
+ */
+public class NotificationBroadcastReceiver extends BroadcastReceiver {
+
+  /**
+   * Intent Action used for hanging up the current call from Notification bar. This will choose
+   * first ringing call, first active call, or first background call (typically in STATE_HOLDING
+   * state).
+   */
+  public static final String ACTION_DECLINE_INCOMING_CALL =
+      "com.android.incallui.ACTION_DECLINE_INCOMING_CALL";
+
+  public static final String ACTION_HANG_UP_ONGOING_CALL =
+      "com.android.incallui.ACTION_HANG_UP_ONGOING_CALL";
+  public static final String ACTION_ANSWER_VIDEO_INCOMING_CALL =
+      "com.android.incallui.ACTION_ANSWER_VIDEO_INCOMING_CALL";
+  public static final String ACTION_ANSWER_VOICE_INCOMING_CALL =
+      "com.android.incallui.ACTION_ANSWER_VOICE_INCOMING_CALL";
+  public static final String ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST =
+      "com.android.incallui.ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST";
+  public static final String ACTION_DECLINE_VIDEO_UPGRADE_REQUEST =
+      "com.android.incallui.ACTION_DECLINE_VIDEO_UPGRADE_REQUEST";
+
+  @RequiresApi(VERSION_CODES.N_MR1)
+  public static final String ACTION_PULL_EXTERNAL_CALL =
+      "com.android.incallui.ACTION_PULL_EXTERNAL_CALL";
+
+  public static final String EXTRA_NOTIFICATION_ID =
+      "com.android.incallui.extra.EXTRA_NOTIFICATION_ID";
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    final String action = intent.getAction();
+    LogUtil.i("NotificationBroadcastReceiver.onReceive", "Broadcast from Notification: " + action);
+
+    // TODO: Commands of this nature should exist in the CallList.
+    if (action.equals(ACTION_ANSWER_VIDEO_INCOMING_CALL)) {
+      answerIncomingCall(context, VideoProfile.STATE_BIDIRECTIONAL);
+    } else if (action.equals(ACTION_ANSWER_VOICE_INCOMING_CALL)) {
+      answerIncomingCall(context, VideoProfile.STATE_AUDIO_ONLY);
+    } else if (action.equals(ACTION_DECLINE_INCOMING_CALL)) {
+      Logger.get(context)
+          .logImpression(DialerImpression.Type.REJECT_INCOMING_CALL_FROM_NOTIFICATION);
+      declineIncomingCall(context);
+    } else if (action.equals(ACTION_HANG_UP_ONGOING_CALL)) {
+      hangUpOngoingCall(context);
+    } else if (action.equals(ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST)) {
+      acceptUpgradeRequest(context);
+    } else if (action.equals(ACTION_DECLINE_VIDEO_UPGRADE_REQUEST)) {
+      declineUpgradeRequest(context);
+    } else if (action.equals(ACTION_PULL_EXTERNAL_CALL)) {
+      context.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+      int notificationId = intent.getIntExtra(EXTRA_NOTIFICATION_ID, -1);
+      InCallPresenter.getInstance().getExternalCallNotifier().pullExternalCall(notificationId);
+    }
+  }
+
+  private void acceptUpgradeRequest(Context context) {
+    CallList callList = InCallPresenter.getInstance().getCallList();
+    if (callList == null) {
+      StatusBarNotifier.clearAllCallNotifications(context);
+      LogUtil.e("NotificationBroadcastReceiver.acceptUpgradeRequest", "call list is empty");
+    } else {
+      DialerCall call = callList.getVideoUpgradeRequestCall();
+      if (call != null) {
+        call.acceptUpgradeRequest(call.getRequestedVideoState());
+      }
+    }
+  }
+
+  private void declineUpgradeRequest(Context context) {
+    CallList callList = InCallPresenter.getInstance().getCallList();
+    if (callList == null) {
+      StatusBarNotifier.clearAllCallNotifications(context);
+      LogUtil.e("NotificationBroadcastReceiver.declineUpgradeRequest", "call list is empty");
+    } else {
+      DialerCall call = callList.getVideoUpgradeRequestCall();
+      if (call != null) {
+        call.declineUpgradeRequest();
+      }
+    }
+  }
+
+  private void hangUpOngoingCall(Context context) {
+    CallList callList = InCallPresenter.getInstance().getCallList();
+    if (callList == null) {
+      StatusBarNotifier.clearAllCallNotifications(context);
+      LogUtil.e("NotificationBroadcastReceiver.hangUpOngoingCall", "call list is empty");
+    } else {
+      DialerCall call = callList.getOutgoingCall();
+      if (call == null) {
+        call = callList.getActiveOrBackgroundCall();
+      }
+      LogUtil.i(
+          "NotificationBroadcastReceiver.hangUpOngoingCall", "disconnecting call, call: " + call);
+      if (call != null) {
+        call.disconnect();
+      }
+    }
+  }
+
+  private void answerIncomingCall(Context context, int videoState) {
+    CallList callList = InCallPresenter.getInstance().getCallList();
+    if (callList == null) {
+      StatusBarNotifier.clearAllCallNotifications(context);
+      LogUtil.e("NotificationBroadcastReceiver.answerIncomingCall", "call list is empty");
+    } else {
+      DialerCall call = callList.getIncomingCall();
+      if (call != null) {
+        call.answer(videoState);
+        InCallPresenter.getInstance()
+            .showInCall(
+                false /* showDialpad */,
+                false /* newOutgoingCall */,
+                VideoUtils.isVideoCall(videoState));
+      }
+    }
+  }
+
+  private void declineIncomingCall(Context context) {
+    CallList callList = InCallPresenter.getInstance().getCallList();
+    if (callList == null) {
+      StatusBarNotifier.clearAllCallNotifications(context);
+      LogUtil.e("NotificationBroadcastReceiver.declineIncomingCall", "call list is empty");
+    } else {
+      DialerCall call = callList.getIncomingCall();
+      if (call != null) {
+        call.reject(false /* rejectWithMessage */, null);
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/PostCharDialogFragment.java b/java/com/android/incallui/PostCharDialogFragment.java
new file mode 100644
index 0000000..a852f76
--- /dev/null
+++ b/java/com/android/incallui/PostCharDialogFragment.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import com.android.incallui.call.TelecomAdapter;
+
+/**
+ * Pop up an alert dialog with OK and Cancel buttons to allow user to Accept or Reject the WAIT
+ * inserted as part of the Dial string.
+ */
+public class PostCharDialogFragment extends DialogFragment {
+
+  private static final String STATE_CALL_ID = "CALL_ID";
+  private static final String STATE_POST_CHARS = "POST_CHARS";
+
+  private String mCallId;
+  private String mPostDialStr;
+
+  public PostCharDialogFragment() {}
+
+  public PostCharDialogFragment(String callId, String postDialStr) {
+    mCallId = callId;
+    mPostDialStr = postDialStr;
+  }
+
+  @Override
+  public Dialog onCreateDialog(Bundle savedInstanceState) {
+    super.onCreateDialog(savedInstanceState);
+
+    if (mPostDialStr == null && savedInstanceState != null) {
+      mCallId = savedInstanceState.getString(STATE_CALL_ID);
+      mPostDialStr = savedInstanceState.getString(STATE_POST_CHARS);
+    }
+
+    final StringBuilder buf = new StringBuilder();
+    buf.append(getResources().getText(R.string.wait_prompt_str));
+    buf.append(mPostDialStr);
+
+    final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+    builder.setMessage(buf.toString());
+
+    builder.setPositiveButton(
+        R.string.pause_prompt_yes,
+        new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int whichButton) {
+            TelecomAdapter.getInstance().postDialContinue(mCallId, true);
+          }
+        });
+    builder.setNegativeButton(
+        R.string.pause_prompt_no,
+        new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int whichButton) {
+            dialog.cancel();
+          }
+        });
+
+    final AlertDialog dialog = builder.create();
+    return dialog;
+  }
+
+  @Override
+  public void onCancel(DialogInterface dialog) {
+    super.onCancel(dialog);
+
+    TelecomAdapter.getInstance().postDialContinue(mCallId, false);
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+
+    outState.putString(STATE_CALL_ID, mCallId);
+    outState.putString(STATE_POST_CHARS, mPostDialStr);
+  }
+}
diff --git a/java/com/android/incallui/ProximitySensor.java b/java/com/android/incallui/ProximitySensor.java
new file mode 100644
index 0000000..9122062
--- /dev/null
+++ b/java/com/android/incallui/ProximitySensor.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
+import android.os.PowerManager;
+import android.support.annotation.NonNull;
+import android.telecom.CallAudioState;
+import android.view.Display;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.AudioModeProvider.AudioModeListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.VideoUtils;
+
+/**
+ * Class manages the proximity sensor for the in-call UI. We enable the proximity sensor while the
+ * user in a phone call. The Proximity sensor turns off the touchscreen and display when the user is
+ * close to the screen to prevent user's cheek from causing touch events. The class requires special
+ * knowledge of the activity and device state to know when the proximity sensor should be enabled
+ * and disabled. Most of that state is fed into this class through public methods.
+ */
+public class ProximitySensor
+    implements AccelerometerListener.OrientationListener, InCallStateListener, AudioModeListener {
+
+  private static final String TAG = ProximitySensor.class.getSimpleName();
+
+  private final PowerManager mPowerManager;
+  private final PowerManager.WakeLock mProximityWakeLock;
+  private final AudioModeProvider mAudioModeProvider;
+  private final AccelerometerListener mAccelerometerListener;
+  private final ProximityDisplayListener mDisplayListener;
+  private int mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+  private boolean mUiShowing = false;
+  private boolean mIsPhoneOffhook = false;
+  private boolean mDialpadVisible;
+  private boolean mIsAttemptingVideoCall;
+  private boolean mIsVideoCall;
+
+  public ProximitySensor(
+      @NonNull Context context,
+      @NonNull AudioModeProvider audioModeProvider,
+      @NonNull AccelerometerListener accelerometerListener) {
+    mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+    if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+      mProximityWakeLock =
+          mPowerManager.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);
+    } else {
+      LogUtil.i("ProximitySensor.constructor", "Device does not support proximity wake lock.");
+      mProximityWakeLock = null;
+    }
+    mAccelerometerListener = accelerometerListener;
+    mAccelerometerListener.setListener(this);
+
+    mDisplayListener =
+        new ProximityDisplayListener(
+            (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE));
+    mDisplayListener.register();
+
+    mAudioModeProvider = audioModeProvider;
+    mAudioModeProvider.addListener(this);
+  }
+
+  public void tearDown() {
+    mAudioModeProvider.removeListener(this);
+
+    mAccelerometerListener.enable(false);
+    mDisplayListener.unregister();
+
+    turnOffProximitySensor(true);
+  }
+
+  /** Called to identify when the device is laid down flat. */
+  @Override
+  public void orientationChanged(int orientation) {
+    mOrientation = orientation;
+    updateProximitySensorMode();
+  }
+
+  /** Called to keep track of the overall UI state. */
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    // We ignore incoming state because we do not want to enable proximity
+    // sensor during incoming call screen. We check hasLiveCall() because a disconnected call
+    // can also put the in-call screen in the INCALL state.
+    boolean hasOngoingCall = InCallState.INCALL == newState && callList.hasLiveCall();
+    boolean isOffhook = (InCallState.OUTGOING == newState) || hasOngoingCall;
+
+    boolean isVideoCall = VideoUtils.isVideoCall(callList.getActiveCall());
+
+    if (isOffhook != mIsPhoneOffhook || mIsVideoCall != isVideoCall) {
+      mIsPhoneOffhook = isOffhook;
+      mIsVideoCall = isVideoCall;
+
+      mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+      mAccelerometerListener.enable(mIsPhoneOffhook);
+
+      updateProximitySensorMode();
+    }
+  }
+
+  @Override
+  public void onAudioStateChanged(CallAudioState audioState) {
+    updateProximitySensorMode();
+  }
+
+  public void onDialpadVisible(boolean visible) {
+    mDialpadVisible = visible;
+    updateProximitySensorMode();
+  }
+
+  public void setIsAttemptingVideoCall(boolean isAttemptingVideoCall) {
+    LogUtil.i(
+        "ProximitySensor.setIsAttemptingVideoCall",
+        "isAttemptingVideoCall: %b",
+        isAttemptingVideoCall);
+    mIsAttemptingVideoCall = isAttemptingVideoCall;
+    updateProximitySensorMode();
+  }
+  /** Used to save when the UI goes in and out of the foreground. */
+  public void onInCallShowing(boolean showing) {
+    if (showing) {
+      mUiShowing = true;
+
+      // We only consider the UI not showing for instances where another app took the foreground.
+      // If we stopped showing because the screen is off, we still consider that showing.
+    } else if (mPowerManager.isScreenOn()) {
+      mUiShowing = false;
+    }
+    updateProximitySensorMode();
+  }
+
+  void onDisplayStateChanged(boolean isDisplayOn) {
+    LogUtil.i("ProximitySensor.onDisplayStateChanged", "isDisplayOn: %b", isDisplayOn);
+    mAccelerometerListener.enable(isDisplayOn);
+  }
+
+  /**
+   * TODO: There is no way to determine if a screen is off due to proximity or if it is legitimately
+   * off, but if ever we can do that in the future, it would be useful here. Until then, this
+   * function will simply return true of the screen is off. TODO: Investigate whether this can be
+   * replaced with the ProximityDisplayListener.
+   */
+  public boolean isScreenReallyOff() {
+    return !mPowerManager.isScreenOn();
+  }
+
+  private void turnOnProximitySensor() {
+    if (mProximityWakeLock != null) {
+      if (!mProximityWakeLock.isHeld()) {
+        LogUtil.i("ProximitySensor.turnOnProximitySensor", "acquiring wake lock");
+        mProximityWakeLock.acquire();
+      } else {
+        LogUtil.i("ProximitySensor.turnOnProximitySensor", "wake lock already acquired");
+      }
+    }
+  }
+
+  private void turnOffProximitySensor(boolean screenOnImmediately) {
+    if (mProximityWakeLock != null) {
+      if (mProximityWakeLock.isHeld()) {
+        LogUtil.i("ProximitySensor.turnOffProximitySensor", "releasing wake lock");
+        int flags = (screenOnImmediately ? 0 : PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY);
+        mProximityWakeLock.release(flags);
+      } else {
+        LogUtil.i("ProximitySensor.turnOffProximitySensor", "wake lock already released");
+      }
+    }
+  }
+
+  /**
+   * Updates the wake lock used to control proximity sensor behavior, based on the current state of
+   * the phone.
+   *
+   * <p>On devices that have a proximity sensor, to avoid false touches during a call, we hold a
+   * PROXIMITY_SCREEN_OFF_WAKE_LOCK wake lock whenever the phone is off hook. (When held, that wake
+   * lock causes the screen to turn off automatically when the sensor detects an object close to the
+   * screen.)
+   *
+   * <p>This method is a no-op for devices that don't have a proximity sensor.
+   *
+   * <p>Proximity wake lock will be released if any of the following conditions are true: the audio
+   * is routed through bluetooth, a wired headset, or the speaker; the user requested, received a
+   * request for, or is in a video call; or the phone is horizontal while in a call.
+   */
+  private synchronized void updateProximitySensorMode() {
+    final int audioRoute = mAudioModeProvider.getAudioState().getRoute();
+
+    boolean screenOnImmediately =
+        (CallAudioState.ROUTE_WIRED_HEADSET == audioRoute
+            || CallAudioState.ROUTE_SPEAKER == audioRoute
+            || CallAudioState.ROUTE_BLUETOOTH == audioRoute
+            || mIsAttemptingVideoCall
+            || mIsVideoCall);
+
+    // We do not keep the screen off when the user is outside in-call screen and we are
+    // horizontal, but we do not force it on when we become horizontal until the
+    // proximity sensor goes negative.
+    final boolean horizontal = (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);
+    screenOnImmediately |= !mUiShowing && horizontal;
+
+    // We do not keep the screen off when dialpad is visible, we are horizontal, and
+    // the in-call screen is being shown.
+    // At that moment we're pretty sure users want to use it, instead of letting the
+    // proximity sensor turn off the screen by their hands.
+    screenOnImmediately |= mDialpadVisible && horizontal;
+
+    LogUtil.i(
+        "ProximitySensor.updateProximitySensorMode",
+        "screenOnImmediately: %b, dialPadVisible: %b, "
+            + "offHook: %b, horizontal: %b, uiShowing: %b, audioRoute: %s",
+        screenOnImmediately,
+        mDialpadVisible,
+        mIsPhoneOffhook,
+        mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL,
+        mUiShowing,
+        CallAudioState.audioRouteToString(audioRoute));
+
+    if (mIsPhoneOffhook && !screenOnImmediately) {
+      LogUtil.v("ProximitySensor.updateProximitySensorMode", "turning on proximity sensor");
+      // Phone is in use!  Arrange for the screen to turn off
+      // automatically when the sensor detects a close object.
+      turnOnProximitySensor();
+    } else {
+      LogUtil.v("ProximitySensor.updateProximitySensorMode", "turning off proximity sensor");
+      // Phone is either idle, or ringing.  We don't want any special proximity sensor
+      // behavior in either case.
+      turnOffProximitySensor(screenOnImmediately);
+    }
+  }
+
+  /**
+   * Implementation of a {@link DisplayListener} that maintains a binary state: Screen on vs screen
+   * off. Used by the proximity sensor manager to decide whether or not it needs to listen to
+   * accelerometer events.
+   */
+  public class ProximityDisplayListener implements DisplayListener {
+
+    private DisplayManager mDisplayManager;
+    private boolean mIsDisplayOn = true;
+
+    ProximityDisplayListener(DisplayManager displayManager) {
+      mDisplayManager = displayManager;
+    }
+
+    void register() {
+      mDisplayManager.registerDisplayListener(this, null);
+    }
+
+    void unregister() {
+      mDisplayManager.unregisterDisplayListener(this);
+    }
+
+    @Override
+    public void onDisplayRemoved(int displayId) {}
+
+    @Override
+    public void onDisplayChanged(int displayId) {
+      if (displayId == Display.DEFAULT_DISPLAY) {
+        final Display display = mDisplayManager.getDisplay(displayId);
+
+        final boolean isDisplayOn = display.getState() != Display.STATE_OFF;
+        // For call purposes, we assume that as long as the screen is not truly off, it is
+        // considered on, even if it is in an unknown or low power idle state.
+        if (isDisplayOn != mIsDisplayOn) {
+          mIsDisplayOn = isDisplayOn;
+          onDisplayStateChanged(mIsDisplayOn);
+        }
+      }
+    }
+
+    @Override
+    public void onDisplayAdded(int displayId) {}
+  }
+}
diff --git a/java/com/android/incallui/StatusBarNotifier.java b/java/com/android/incallui/StatusBarNotifier.java
new file mode 100644
index 0000000..c722675
--- /dev/null
+++ b/java/com/android/incallui/StatusBarNotifier.java
@@ -0,0 +1,842 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import static com.android.contacts.common.compat.CallCompat.Details.PROPERTY_ENTERPRISE_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ANSWER_VIDEO_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ANSWER_VOICE_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_DECLINE_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_DECLINE_VIDEO_UPGRADE_REQUEST;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_HANG_UP_ONGOING_CALL;
+
+import android.app.ActivityManager;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.support.annotation.ColorRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.StringRes;
+import android.support.annotation.VisibleForTesting;
+import android.telecom.Call.Details;
+import android.telecom.PhoneAccount;
+import android.telecom.TelecomManager;
+import android.text.BidiFormatter;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.text.style.ForegroundColorSpan;
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.ContactsUtils.UserType;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.BitmapUtil;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.util.DrawableConverter;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.async.PausableExecutorImpl;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCallListener;
+import com.android.incallui.ringtone.DialerRingtoneManager;
+import com.android.incallui.ringtone.InCallTonePlayer;
+import com.android.incallui.ringtone.ToneGeneratorFactory;
+import java.util.Objects;
+
+/** This class adds Notifications to the status bar for the in-call experience. */
+public class StatusBarNotifier implements InCallPresenter.InCallStateListener {
+
+  // Notification types
+  // Indicates that no notification is currently showing.
+  private static final int NOTIFICATION_NONE = 0;
+  // Notification for an active call. This is non-interruptive, but cannot be dismissed.
+  private static final int NOTIFICATION_IN_CALL = 1;
+  // Notification for incoming calls. This is interruptive and will show up as a HUN.
+  private static final int NOTIFICATION_INCOMING_CALL = 2;
+
+  private static final int PENDING_INTENT_REQUEST_CODE_NON_FULL_SCREEN = 0;
+  private static final int PENDING_INTENT_REQUEST_CODE_FULL_SCREEN = 1;
+
+  private static final long[] VIBRATE_PATTERN = new long[] {0, 1000, 1000};
+
+  private final Context mContext;
+  private final ContactInfoCache mContactInfoCache;
+  private final NotificationManager mNotificationManager;
+  private final DialerRingtoneManager mDialerRingtoneManager;
+  @Nullable private ContactsPreferences mContactsPreferences;
+  private int mCurrentNotification = NOTIFICATION_NONE;
+  private int mCallState = DialerCall.State.INVALID;
+  private int mSavedIcon = 0;
+  private String mSavedContent = null;
+  private Bitmap mSavedLargeIcon;
+  private String mSavedContentTitle;
+  private Uri mRingtone;
+  private StatusBarCallListener mStatusBarCallListener;
+
+  public StatusBarNotifier(@NonNull Context context, @NonNull ContactInfoCache contactInfoCache) {
+    Objects.requireNonNull(context);
+    mContext = context;
+    mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+    mContactInfoCache = contactInfoCache;
+    mNotificationManager = context.getSystemService(NotificationManager.class);
+    mDialerRingtoneManager =
+        new DialerRingtoneManager(
+            new InCallTonePlayer(new ToneGeneratorFactory(), new PausableExecutorImpl()),
+            CallList.getInstance());
+    mCurrentNotification = NOTIFICATION_NONE;
+  }
+
+  /**
+   * Should only be called from a irrecoverable state where it is necessary to dismiss all
+   * notifications.
+   */
+  static void clearAllCallNotifications(Context backupContext) {
+    Log.i(
+        StatusBarNotifier.class.getSimpleName(),
+        "Something terrible happened. Clear all InCall notifications");
+
+    NotificationManager notificationManager =
+        backupContext.getSystemService(NotificationManager.class);
+    notificationManager.cancel(NOTIFICATION_IN_CALL);
+    notificationManager.cancel(NOTIFICATION_INCOMING_CALL);
+  }
+
+  private static int getWorkStringFromPersonalString(int resId) {
+    if (resId == R.string.notification_ongoing_call) {
+      return R.string.notification_ongoing_work_call;
+    } else if (resId == R.string.notification_ongoing_call_wifi) {
+      return R.string.notification_ongoing_work_call_wifi;
+    } else if (resId == R.string.notification_incoming_call_wifi) {
+      return R.string.notification_incoming_work_call_wifi;
+    } else if (resId == R.string.notification_incoming_call) {
+      return R.string.notification_incoming_work_call;
+    } else {
+      return resId;
+    }
+  }
+
+  /**
+   * Returns PendingIntent for answering a phone call. This will typically be used from Notification
+   * context.
+   */
+  private static PendingIntent createNotificationPendingIntent(Context context, String action) {
+    final Intent intent = new Intent(action, null, context, NotificationBroadcastReceiver.class);
+    return PendingIntent.getBroadcast(context, 0, intent, 0);
+  }
+
+  /** Creates notifications according to the state we receive from {@link InCallPresenter}. */
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    Log.d(this, "onStateChange");
+    updateNotification(callList);
+  }
+
+  /**
+   * Updates the phone app's status bar notification *and* launches the incoming call UI in response
+   * to a new incoming call.
+   *
+   * <p>If an incoming call is ringing (or call-waiting), the notification will also include a
+   * "fullScreenIntent" that will cause the InCallScreen to be launched, unless the current
+   * foreground activity is marked as "immersive".
+   *
+   * <p>(This is the mechanism that actually brings up the incoming call UI when we receive a "new
+   * ringing connection" event from the telephony layer.)
+   *
+   * <p>Also note that this method is safe to call even if the phone isn't actually ringing (or,
+   * more likely, if an incoming call *was* ringing briefly but then disconnected). In that case,
+   * we'll simply update or cancel the in-call notification based on the current phone state.
+   *
+   * @see #updateInCallNotification(CallList)
+   */
+  public void updateNotification(CallList callList) {
+    updateInCallNotification(callList);
+  }
+
+  /**
+   * Take down the in-call notification.
+   *
+   * @see #updateInCallNotification(CallList)
+   */
+  private void cancelNotification() {
+    if (mStatusBarCallListener != null) {
+      setStatusBarCallListener(null);
+    }
+    if (mCurrentNotification != NOTIFICATION_NONE) {
+      Log.d(this, "cancelInCall()...");
+      mNotificationManager.cancel(mCurrentNotification);
+    }
+    mCurrentNotification = NOTIFICATION_NONE;
+  }
+
+  /**
+   * Helper method for updateInCallNotification() and updateNotification(): Update the phone app's
+   * status bar notification based on the current telephony state, or cancels the notification if
+   * the phone is totally idle.
+   */
+  private void updateInCallNotification(CallList callList) {
+    Log.d(this, "updateInCallNotification...");
+
+    final DialerCall call = getCallToShow(callList);
+
+    if (call != null) {
+      showNotification(callList, call);
+    } else {
+      cancelNotification();
+    }
+  }
+
+  private void showNotification(final CallList callList, final DialerCall call) {
+    final boolean isIncoming =
+        (call.getState() == DialerCall.State.INCOMING
+            || call.getState() == DialerCall.State.CALL_WAITING);
+    setStatusBarCallListener(new StatusBarCallListener(call));
+
+    // we make a call to the contact info cache to query for supplemental data to what the
+    // call provides.  This includes the contact name and photo.
+    // This callback will always get called immediately and synchronously with whatever data
+    // it has available, and may make a subsequent call later (same thread) if it had to
+    // call into the contacts provider for more data.
+    mContactInfoCache.findInfo(
+        call,
+        isIncoming,
+        new ContactInfoCacheCallback() {
+          @Override
+          public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+            DialerCall call = callList.getCallById(callId);
+            if (call != null) {
+              call.getLogState().contactLookupResult = entry.contactLookupResult;
+              buildAndSendNotification(callList, call, entry);
+            }
+          }
+
+          @Override
+          public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+            DialerCall call = callList.getCallById(callId);
+            if (call != null) {
+              buildAndSendNotification(callList, call, entry);
+            }
+          }
+        });
+  }
+
+  /** Sets up the main Ui for the notification */
+  private void buildAndSendNotification(
+      CallList callList, DialerCall originalCall, ContactCacheEntry contactInfo) {
+    // This can get called to update an existing notification after contact information has come
+    // back. However, it can happen much later. Before we continue, we need to make sure that
+    // the call being passed in is still the one we want to show in the notification.
+    final DialerCall call = getCallToShow(callList);
+    if (call == null || !call.getId().equals(originalCall.getId())) {
+      return;
+    }
+
+    final int callState = call.getState();
+
+    // Check if data has changed; if nothing is different, don't issue another notification.
+    final int iconResId = getIconToDisplay(call);
+    Bitmap largeIcon = getLargeIconToDisplay(contactInfo, call);
+    final String content = getContentString(call, contactInfo.userType);
+    final String contentTitle = getContentTitle(contactInfo, call);
+
+    final boolean isVideoUpgradeRequest =
+        call.getSessionModificationState()
+            == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+    final int notificationType;
+    if (callState == DialerCall.State.INCOMING
+        || callState == DialerCall.State.CALL_WAITING
+        || isVideoUpgradeRequest) {
+      notificationType = NOTIFICATION_INCOMING_CALL;
+    } else {
+      notificationType = NOTIFICATION_IN_CALL;
+    }
+
+    if (!checkForChangeAndSaveData(
+        iconResId,
+        content,
+        largeIcon,
+        contentTitle,
+        callState,
+        notificationType,
+        contactInfo.contactRingtoneUri)) {
+      return;
+    }
+
+    if (largeIcon != null) {
+      largeIcon = getRoundedIcon(largeIcon);
+    }
+
+    // This builder is used for the notification shown when the device is locked and the user
+    // has set their notification settings to 'hide sensitive content'
+    // {@see Notification.Builder#setPublicVersion}.
+    Notification.Builder publicBuilder = new Notification.Builder(mContext);
+    publicBuilder
+        .setSmallIcon(iconResId)
+        .setColor(mContext.getResources().getColor(R.color.dialer_theme_color))
+        // Hide work call state for the lock screen notification
+        .setContentTitle(getContentString(call, ContactsUtils.USER_TYPE_CURRENT));
+    setNotificationWhen(call, callState, publicBuilder);
+
+    // Builder for the notification shown when the device is unlocked or the user has set their
+    // notification settings to 'show all notification content'.
+    final Notification.Builder builder = getNotificationBuilder();
+    builder.setPublicVersion(publicBuilder.build());
+
+    // Set up the main intent to send the user to the in-call screen
+    builder.setContentIntent(
+        createLaunchPendingIntent(false /* isFullScreen */, call.isVideoCall()));
+
+    // Set the intent as a full screen intent as well if a call is incoming
+    if (notificationType == NOTIFICATION_INCOMING_CALL) {
+      if (!InCallPresenter.getInstance().isActivityStarted()) {
+        configureFullScreenIntent(
+            builder,
+            createLaunchPendingIntent(true /* isFullScreen */, call.isVideoCall()),
+            callList,
+            call);
+      } else {
+        // If the incall screen is already up, we don't want to show HUN but regular notification
+        // should still be shown. In order to do that the previous one with full screen intent
+        // needs to be cancelled.
+        LogUtil.d(
+            "StatusBarNotifier.buildAndSendNotification",
+            "cancel previous incoming call notification");
+        mNotificationManager.cancel(NOTIFICATION_INCOMING_CALL);
+      }
+      // Set the notification category for incoming calls
+      builder.setCategory(Notification.CATEGORY_CALL);
+    }
+
+    // Set the content
+    builder.setContentText(content);
+    builder.setSmallIcon(iconResId);
+    builder.setContentTitle(contentTitle);
+    builder.setLargeIcon(largeIcon);
+    builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
+
+    if (isVideoUpgradeRequest) {
+      builder.setUsesChronometer(false);
+      addDismissUpgradeRequestAction(builder);
+      addAcceptUpgradeRequestAction(builder);
+    } else {
+      createIncomingCallNotification(call, callState, builder);
+    }
+
+    addPersonReference(builder, contactInfo, call);
+
+    // Fire off the notification
+    Notification notification = builder.build();
+
+    if (mDialerRingtoneManager.shouldPlayRingtone(callState, contactInfo.contactRingtoneUri)) {
+      notification.flags |= Notification.FLAG_INSISTENT;
+      notification.sound = contactInfo.contactRingtoneUri;
+      AudioAttributes.Builder audioAttributes = new AudioAttributes.Builder();
+      audioAttributes.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC);
+      audioAttributes.setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE);
+      notification.audioAttributes = audioAttributes.build();
+      if (mDialerRingtoneManager.shouldVibrate(mContext.getContentResolver())) {
+        notification.vibrate = VIBRATE_PATTERN;
+      }
+    }
+    if (mDialerRingtoneManager.shouldPlayCallWaitingTone(callState)) {
+      Log.v(this, "Playing call waiting tone");
+      mDialerRingtoneManager.playCallWaitingTone();
+    }
+    if (mCurrentNotification != notificationType && mCurrentNotification != NOTIFICATION_NONE) {
+      Log.i(this, "Previous notification already showing - cancelling " + mCurrentNotification);
+      mNotificationManager.cancel(mCurrentNotification);
+    }
+
+    Log.i(this, "Displaying notification for " + notificationType);
+    try {
+      mNotificationManager.notify(notificationType, notification);
+    } catch (RuntimeException e) {
+      // TODO(b/34744003): Move the memory stats into silent feedback PSD.
+      ActivityManager activityManager = mContext.getSystemService(ActivityManager.class);
+      ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+      activityManager.getMemoryInfo(memoryInfo);
+      throw new RuntimeException(
+          String.format(
+              "Error displaying notification with photo type: %d (low memory? %b, availMem: %d)",
+              contactInfo.photoType, memoryInfo.lowMemory, memoryInfo.availMem),
+          e);
+    }
+    call.getLatencyReport().onNotificationShown();
+    mCurrentNotification = notificationType;
+  }
+
+  private void createIncomingCallNotification(
+      DialerCall call, int state, Notification.Builder builder) {
+    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)) {
+      addHangupAction(builder);
+    } else if (state == DialerCall.State.INCOMING || state == DialerCall.State.CALL_WAITING) {
+      addDismissAction(builder);
+      if (call.isVideoCall()) {
+        addVideoCallAction(builder);
+      } else {
+        addAnswerAction(builder);
+      }
+    }
+  }
+
+  /**
+   * Sets the notification's when section as needed. For active calls, this is explicitly set as the
+   * duration of the call. For all other states, the notification will automatically show the time
+   * at which the notification was created.
+   */
+  private void setNotificationWhen(DialerCall call, int state, Notification.Builder builder) {
+    if (state == DialerCall.State.ACTIVE) {
+      builder.setUsesChronometer(true);
+      builder.setWhen(call.getConnectTimeMillis());
+    } else {
+      builder.setUsesChronometer(false);
+    }
+  }
+
+  /**
+   * Checks the new notification data and compares it against any notification that we are already
+   * displaying. If the data is exactly the same, we return false so that we do not issue a new
+   * notification for the exact same data.
+   */
+  private boolean checkForChangeAndSaveData(
+      int icon,
+      String content,
+      Bitmap largeIcon,
+      String contentTitle,
+      int state,
+      int notificationType,
+      Uri ringtone) {
+
+    // The two are different:
+    // if new title is not null, it should be different from saved version OR
+    // if new title is null, the saved version should not be null
+    final boolean contentTitleChanged =
+        (contentTitle != null && !contentTitle.equals(mSavedContentTitle))
+            || (contentTitle == null && mSavedContentTitle != null);
+
+    // any change means we are definitely updating
+    boolean retval =
+        (mSavedIcon != icon)
+            || !Objects.equals(mSavedContent, content)
+            || (mCallState != state)
+            || (mSavedLargeIcon != largeIcon)
+            || contentTitleChanged
+            || !Objects.equals(mRingtone, ringtone);
+
+    // If we aren't showing a notification right now or the notification type is changing,
+    // definitely do an update.
+    if (mCurrentNotification != notificationType) {
+      if (mCurrentNotification == NOTIFICATION_NONE) {
+        Log.d(this, "Showing notification for first time.");
+      }
+      retval = true;
+    }
+
+    mSavedIcon = icon;
+    mSavedContent = content;
+    mCallState = state;
+    mSavedLargeIcon = largeIcon;
+    mSavedContentTitle = contentTitle;
+    mRingtone = ringtone;
+
+    if (retval) {
+      Log.d(this, "Data changed.  Showing notification");
+    }
+
+    return retval;
+  }
+
+  /** Returns the main string to use in the notification. */
+  @VisibleForTesting
+  @Nullable
+  String getContentTitle(ContactCacheEntry contactInfo, DialerCall call) {
+    if (call.isConferenceCall() && !call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE)) {
+      return mContext.getResources().getString(R.string.conference_call_name);
+    }
+
+    String preferredName =
+        ContactDisplayUtils.getPreferredDisplayName(
+            contactInfo.namePrimary, contactInfo.nameAlternative, mContactsPreferences);
+    if (TextUtils.isEmpty(preferredName)) {
+      return TextUtils.isEmpty(contactInfo.number)
+          ? null
+          : BidiFormatter.getInstance()
+              .unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR);
+    }
+    return preferredName;
+  }
+
+  private void addPersonReference(
+      Notification.Builder builder, ContactCacheEntry contactInfo, DialerCall call) {
+    // Query {@link Contacts#CONTENT_LOOKUP_URI} directly with work lookup key is not allowed.
+    // So, do not pass {@link Contacts#CONTENT_LOOKUP_URI} to NotificationManager to avoid
+    // NotificationManager using it.
+    if (contactInfo.lookupUri != null && contactInfo.userType != ContactsUtils.USER_TYPE_WORK) {
+      builder.addPerson(contactInfo.lookupUri.toString());
+    } else if (!TextUtils.isEmpty(call.getNumber())) {
+      builder.addPerson(Uri.fromParts(PhoneAccount.SCHEME_TEL, call.getNumber(), null).toString());
+    }
+  }
+
+  /** Gets a large icon from the contact info object to display in the notification. */
+  private Bitmap getLargeIconToDisplay(ContactCacheEntry contactInfo, DialerCall call) {
+    Bitmap largeIcon = null;
+    if (call.isConferenceCall() && !call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE)) {
+      largeIcon = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.img_conference);
+    }
+    if (contactInfo.photo != null && (contactInfo.photo instanceof BitmapDrawable)) {
+      largeIcon = ((BitmapDrawable) contactInfo.photo).getBitmap();
+    }
+    if (call.isSpam()) {
+      Drawable drawable = mContext.getResources().getDrawable(R.drawable.blocked_contact);
+      largeIcon = DrawableConverter.drawableToBitmap(drawable);
+    }
+    return largeIcon;
+  }
+
+  private Bitmap getRoundedIcon(Bitmap bitmap) {
+    if (bitmap == null) {
+      return null;
+    }
+    final int height =
+        (int) mContext.getResources().getDimension(android.R.dimen.notification_large_icon_height);
+    final int width =
+        (int) mContext.getResources().getDimension(android.R.dimen.notification_large_icon_width);
+    return BitmapUtil.getRoundedBitmap(bitmap, width, height);
+  }
+
+  /**
+   * Returns the appropriate icon res Id to display based on the call for which we want to display
+   * information.
+   */
+  private int getIconToDisplay(DialerCall call) {
+    // Even if both lines are in use, we only show a single item in
+    // the expanded Notifications UI.  It's labeled "Ongoing call"
+    // (or "On hold" if there's only one call, and it's on hold.)
+    // Also, we don't have room to display caller-id info from two
+    // 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) {
+      return R.drawable.ic_phone_paused_white_24dp;
+    } else if (call.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      return R.drawable.ic_videocam;
+    }
+    return R.anim.on_going_call;
+  }
+
+  /** Returns the message to use with the notification. */
+  private String getContentString(DialerCall call, @UserType long userType) {
+    boolean isIncomingOrWaiting =
+        call.getState() == DialerCall.State.INCOMING
+            || call.getState() == DialerCall.State.CALL_WAITING;
+
+    if (isIncomingOrWaiting
+        && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED) {
+
+      if (!TextUtils.isEmpty(call.getChildNumber())) {
+        return mContext.getString(R.string.child_number, call.getChildNumber());
+      } else if (!TextUtils.isEmpty(call.getCallSubject()) && call.isCallSubjectSupported()) {
+        return call.getCallSubject();
+      }
+    }
+
+    int resId = R.string.notification_ongoing_call;
+    if (call.hasProperty(Details.PROPERTY_WIFI)) {
+      resId = R.string.notification_ongoing_call_wifi;
+    }
+
+    if (isIncomingOrWaiting) {
+      if (call.hasProperty(Details.PROPERTY_WIFI)) {
+        resId = R.string.notification_incoming_call_wifi;
+      } else {
+        if (call.isSpam()) {
+          resId = R.string.notification_incoming_spam_call;
+        } else {
+          resId = R.string.notification_incoming_call;
+        }
+      }
+    } else if (call.getState() == DialerCall.State.ONHOLD) {
+      resId = R.string.notification_on_hold;
+    } else if (DialerCall.State.isDialing(call.getState())) {
+      resId = R.string.notification_dialing;
+    } else if (call.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      resId = R.string.notification_requesting_video_call;
+    }
+
+    // Is the call placed through work connection service.
+    boolean isWorkCall = call.hasProperty(PROPERTY_ENTERPRISE_CALL);
+    if (userType == ContactsUtils.USER_TYPE_WORK || isWorkCall) {
+      resId = getWorkStringFromPersonalString(resId);
+    }
+
+    return mContext.getString(resId);
+  }
+
+  /** Gets the most relevant call to display in the notification. */
+  private DialerCall getCallToShow(CallList callList) {
+    if (callList == null) {
+      return null;
+    }
+    DialerCall call = callList.getIncomingCall();
+    if (call == null) {
+      call = callList.getOutgoingCall();
+    }
+    if (call == null) {
+      call = callList.getVideoUpgradeRequestCall();
+    }
+    if (call == null) {
+      call = callList.getActiveOrBackgroundCall();
+    }
+    return call;
+  }
+
+  private Spannable getActionText(@StringRes int stringRes, @ColorRes int colorRes) {
+    Spannable spannable = new SpannableString(mContext.getText(stringRes));
+    if (VERSION.SDK_INT >= VERSION_CODES.N_MR1) {
+      // This will only work for cases where the Notification.Builder has a fullscreen intent set
+      // Notification.Builder that does not have a full screen intent will take the color of the
+      // app and the following leads to a no-op.
+      spannable.setSpan(
+          new ForegroundColorSpan(mContext.getColor(colorRes)), 0, spannable.length(), 0);
+    }
+    return spannable;
+  }
+
+  private void addAnswerAction(Notification.Builder builder) {
+    Log.d(this, "Will show \"answer\" action in the incoming call Notification");
+    PendingIntent answerVoicePendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_ANSWER_VOICE_INCOMING_CALL);
+    builder.addAction(
+        R.anim.on_going_call,
+        getActionText(R.string.notification_action_answer, R.color.notification_action_accept),
+        answerVoicePendingIntent);
+  }
+
+  private void addDismissAction(Notification.Builder builder) {
+    Log.d(this, "Will show \"decline\" action in the incoming call Notification");
+    PendingIntent declinePendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_DECLINE_INCOMING_CALL);
+    builder.addAction(
+        R.drawable.ic_close_dk,
+        getActionText(R.string.notification_action_dismiss, R.color.notification_action_dismiss),
+        declinePendingIntent);
+  }
+
+  private void addHangupAction(Notification.Builder builder) {
+    Log.d(this, "Will show \"hang-up\" action in the ongoing active call Notification");
+    PendingIntent hangupPendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_HANG_UP_ONGOING_CALL);
+    builder.addAction(
+        R.drawable.ic_call_end_white_24dp,
+        getActionText(R.string.notification_action_end_call, R.color.notification_action_end_call),
+        hangupPendingIntent);
+  }
+
+  private void addVideoCallAction(Notification.Builder builder) {
+    Log.i(this, "Will show \"video\" action in the incoming call Notification");
+    PendingIntent answerVideoPendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_ANSWER_VIDEO_INCOMING_CALL);
+    builder.addAction(
+        R.drawable.ic_videocam,
+        getActionText(
+            R.string.notification_action_answer_video, R.color.notification_action_answer_video),
+        answerVideoPendingIntent);
+  }
+
+  private void addAcceptUpgradeRequestAction(Notification.Builder builder) {
+    Log.i(this, "Will show \"accept upgrade\" action in the incoming call Notification");
+    PendingIntent acceptVideoPendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST);
+    builder.addAction(
+        R.drawable.ic_videocam,
+        getActionText(R.string.notification_action_accept, R.color.notification_action_accept),
+        acceptVideoPendingIntent);
+  }
+
+  private void addDismissUpgradeRequestAction(Notification.Builder builder) {
+    Log.i(this, "Will show \"dismiss upgrade\" action in the incoming call Notification");
+    PendingIntent declineVideoPendingIntent =
+        createNotificationPendingIntent(mContext, ACTION_DECLINE_VIDEO_UPGRADE_REQUEST);
+    builder.addAction(
+        R.drawable.ic_videocam,
+        getActionText(R.string.notification_action_dismiss, R.color.notification_action_dismiss),
+        declineVideoPendingIntent);
+  }
+
+  /** Adds fullscreen intent to the builder. */
+  private void configureFullScreenIntent(
+      Notification.Builder builder, PendingIntent intent, CallList callList, DialerCall call) {
+    // Ok, we actually want to launch the incoming call
+    // UI at this point (in addition to simply posting a notification
+    // to the status bar).  Setting fullScreenIntent will cause
+    // the InCallScreen to be launched immediately *unless* the
+    // current foreground activity is marked as "immersive".
+    Log.d(this, "- Setting fullScreenIntent: " + intent);
+    builder.setFullScreenIntent(intent, true);
+
+    // Ugly hack alert:
+    //
+    // The NotificationManager has the (undocumented) behavior
+    // that it will *ignore* the fullScreenIntent field if you
+    // post a new Notification that matches the ID of one that's
+    // already active.  Unfortunately this is exactly what happens
+    // when you get an incoming call-waiting call:  the
+    // "ongoing call" notification is already visible, so the
+    // InCallScreen won't get launched in this case!
+    // (The result: if you bail out of the in-call UI while on a
+    // call and then get a call-waiting call, the incoming call UI
+    // won't come up automatically.)
+    //
+    // The workaround is to just notice this exact case (this is a
+    // call-waiting call *and* the InCallScreen is not in the
+    // foreground) and manually cancel the in-call notification
+    // before (re)posting it.
+    //
+    // TODO: there should be a cleaner way of avoiding this
+    // problem (see discussion in bug 3184149.)
+
+    // If a call is onhold during an incoming call, the call actually comes in as
+    // INCOMING.  For that case *and* traditional call-waiting, we want to
+    // cancel the notification.
+    boolean isCallWaiting =
+        (call.getState() == DialerCall.State.CALL_WAITING
+            || (call.getState() == DialerCall.State.INCOMING
+                && callList.getBackgroundCall() != null));
+
+    if (isCallWaiting) {
+      Log.i(this, "updateInCallNotification: call-waiting! force relaunch...");
+      // Cancel the IN_CALL_NOTIFICATION immediately before
+      // (re)posting it; this seems to force the
+      // NotificationManager to launch the fullScreenIntent.
+      mNotificationManager.cancel(NOTIFICATION_IN_CALL);
+    }
+  }
+
+  private Notification.Builder getNotificationBuilder() {
+    final Notification.Builder builder = new Notification.Builder(mContext);
+    builder.setOngoing(true);
+
+    // Make the notification prioritized over the other normal notifications.
+    builder.setPriority(Notification.PRIORITY_HIGH);
+
+    return builder;
+  }
+
+  private PendingIntent createLaunchPendingIntent(boolean isFullScreen, boolean isVideoCall) {
+    Intent intent =
+        InCallActivity.getIntent(
+            mContext,
+            false /* showDialpad */,
+            false /* newOutgoingCall */,
+            isVideoCall,
+            isFullScreen);
+
+    int requestCode = PENDING_INTENT_REQUEST_CODE_NON_FULL_SCREEN;
+    if (isFullScreen) {
+      // Use a unique request code so that the pending intent isn't clobbered by the
+      // non-full screen pending intent.
+      requestCode = PENDING_INTENT_REQUEST_CODE_FULL_SCREEN;
+    }
+
+    // PendingIntent that can be used to launch the InCallActivity.  The
+    // system fires off this intent if the user pulls down the windowshade
+    // and clicks the notification's expanded view.  It's also used to
+    // launch the InCallActivity immediately when when there's an incoming
+    // call (see the "fullScreenIntent" field below).
+    return PendingIntent.getActivity(mContext, requestCode, intent, 0);
+  }
+
+  private void setStatusBarCallListener(StatusBarCallListener listener) {
+    if (mStatusBarCallListener != null) {
+      mStatusBarCallListener.cleanup();
+    }
+    mStatusBarCallListener = listener;
+  }
+
+  private class StatusBarCallListener implements DialerCallListener {
+
+    private DialerCall mDialerCall;
+
+    StatusBarCallListener(DialerCall dialerCall) {
+      mDialerCall = dialerCall;
+      mDialerCall.addListener(this);
+    }
+
+    void cleanup() {
+      mDialerCall.removeListener(this);
+    }
+
+    @Override
+    public void onDialerCallDisconnect() {}
+
+    @Override
+    public void onDialerCallUpdate() {
+      if (CallList.getInstance().getIncomingCall() == null) {
+        mDialerRingtoneManager.stopCallWaitingTone();
+      }
+    }
+
+    @Override
+    public void onDialerCallChildNumberChange() {}
+
+    @Override
+    public void onDialerCallLastForwardedNumberChange() {}
+
+    @Override
+    public void onDialerCallUpgradeToVideo() {}
+
+    @Override
+    public void onWiFiToLteHandover() {}
+
+    @Override
+    public void onHandoverToWifiFailure() {}
+
+    /**
+     * Responds to changes in the session modification state for the call by dismissing the status
+     * bar notification as required.
+     */
+    @Override
+    public void onDialerCallSessionModificationStateChange(@SessionModificationState int state) {
+      if (state == DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST) {
+        cleanup();
+        updateNotification(CallList.getInstance());
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/ThemeColorManager.java b/java/com/android/incallui/ThemeColorManager.java
new file mode 100644
index 0000000..a88ae33
--- /dev/null
+++ b/java/com/android/incallui/ThemeColorManager.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.support.annotation.ColorInt;
+import android.support.annotation.Nullable;
+import android.support.v4.graphics.ColorUtils;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import com.android.contacts.common.util.MaterialColorMapUtils;
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+import com.android.incallui.call.DialerCall;
+
+/**
+ * Calculates the background color for the in call window. The background color is based on the SIM
+ * and spam status.
+ */
+public class ThemeColorManager {
+  private final MaterialColorMapUtils colorMap;
+  @ColorInt private int primaryColor;
+  @ColorInt private int secondaryColor;
+  @ColorInt private int backgroundColorTop;
+  @ColorInt private int backgroundColorMiddle;
+  @ColorInt private int backgroundColorBottom;
+  @ColorInt private int backgroundColorSolid;
+
+  /**
+   * If there is no actual call currently in the call list, this will be used as a fallback to
+   * determine the theme color for InCallUI.
+   */
+  @Nullable private PhoneAccountHandle pendingPhoneAccountHandle;
+
+  public ThemeColorManager(MaterialColorMapUtils colorMap) {
+    this.colorMap = colorMap;
+  }
+
+  public void setPendingPhoneAccountHandle(@Nullable PhoneAccountHandle pendingPhoneAccountHandle) {
+    this.pendingPhoneAccountHandle = pendingPhoneAccountHandle;
+  }
+
+  public void onForegroundCallChanged(Context context, @Nullable DialerCall newForegroundCall) {
+    if (newForegroundCall == null) {
+      updateThemeColors(context, pendingPhoneAccountHandle, false);
+    } else {
+      updateThemeColors(context, newForegroundCall.getAccountHandle(), newForegroundCall.isSpam());
+    }
+  }
+
+  private void updateThemeColors(
+      Context context, @Nullable PhoneAccountHandle handle, boolean isSpam) {
+    MaterialPalette palette;
+    if (isSpam) {
+      palette =
+          colorMap.calculatePrimaryAndSecondaryColor(R.color.incall_call_spam_background_color);
+      backgroundColorTop = context.getColor(R.color.incall_background_gradient_spam_top);
+      backgroundColorMiddle = context.getColor(R.color.incall_background_gradient_spam_middle);
+      backgroundColorBottom = context.getColor(R.color.incall_background_gradient_spam_bottom);
+      backgroundColorSolid = context.getColor(R.color.incall_background_multiwindow_spam);
+    } else {
+      @ColorInt int highlightColor = getHighlightColor(context, handle);
+      palette = colorMap.calculatePrimaryAndSecondaryColor(highlightColor);
+      backgroundColorTop = context.getColor(R.color.incall_background_gradient_top);
+      backgroundColorMiddle = context.getColor(R.color.incall_background_gradient_middle);
+      backgroundColorBottom = context.getColor(R.color.incall_background_gradient_bottom);
+      backgroundColorSolid = context.getColor(R.color.incall_background_multiwindow);
+      if (highlightColor != PhoneAccount.NO_HIGHLIGHT_COLOR) {
+        // The default background gradient has a subtle alpha. We grab that alpha and apply it to
+        // the phone account color.
+        backgroundColorTop = applyAlpha(palette.mPrimaryColor, backgroundColorTop);
+        backgroundColorMiddle = applyAlpha(palette.mPrimaryColor, backgroundColorMiddle);
+        backgroundColorBottom = applyAlpha(palette.mPrimaryColor, backgroundColorBottom);
+        backgroundColorSolid = applyAlpha(palette.mPrimaryColor, backgroundColorSolid);
+      }
+    }
+
+    primaryColor = palette.mPrimaryColor;
+    secondaryColor = palette.mSecondaryColor;
+  }
+
+  @ColorInt
+  private static int getHighlightColor(Context context, @Nullable PhoneAccountHandle handle) {
+    if (handle != null) {
+      PhoneAccount account = context.getSystemService(TelecomManager.class).getPhoneAccount(handle);
+      if (account != null) {
+        return account.getHighlightColor();
+      }
+    }
+    return PhoneAccount.NO_HIGHLIGHT_COLOR;
+  }
+
+  @ColorInt
+  public int getPrimaryColor() {
+    return primaryColor;
+  }
+
+  @ColorInt
+  public int getSecondaryColor() {
+    return secondaryColor;
+  }
+
+  @ColorInt
+  public int getBackgroundColorTop() {
+    return backgroundColorTop;
+  }
+
+  @ColorInt
+  public int getBackgroundColorMiddle() {
+    return backgroundColorMiddle;
+  }
+
+  @ColorInt
+  public int getBackgroundColorBottom() {
+    return backgroundColorBottom;
+  }
+
+  @ColorInt
+  public int getBackgroundColorSolid() {
+    return backgroundColorSolid;
+  }
+
+  @ColorInt
+  private static int applyAlpha(@ColorInt int color, @ColorInt int sourceColorWithAlpha) {
+    return ColorUtils.setAlphaComponent(color, Color.alpha(sourceColorWithAlpha));
+  }
+}
diff --git a/java/com/android/incallui/TransactionSafeFragmentActivity.java b/java/com/android/incallui/TransactionSafeFragmentActivity.java
new file mode 100644
index 0000000..a6b078c
--- /dev/null
+++ b/java/com/android/incallui/TransactionSafeFragmentActivity.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.support.v4.app.FragmentActivity;
+
+/**
+ * A common superclass that keeps track of whether an {@link Activity} has saved its state yet or
+ * not.
+ */
+public abstract class TransactionSafeFragmentActivity extends FragmentActivity {
+
+  private boolean mIsSafeToCommitTransactions;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    mIsSafeToCommitTransactions = true;
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    mIsSafeToCommitTransactions = true;
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    mIsSafeToCommitTransactions = true;
+  }
+
+  @Override
+  protected void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    mIsSafeToCommitTransactions = false;
+  }
+
+  /**
+   * Returns true if it is safe to commit {@link FragmentTransaction}s at this time, based on
+   * whether {@link Activity#onSaveInstanceState} has been called or not.
+   *
+   * <p>Make sure that the current activity calls into {@link super.onSaveInstanceState(Bundle
+   * outState)} (if that method is overridden), so the flag is properly set.
+   */
+  public boolean isSafeToCommitTransactions() {
+    return mIsSafeToCommitTransactions;
+  }
+}
diff --git a/java/com/android/incallui/VideoCallPresenter.java b/java/com/android/incallui/VideoCallPresenter.java
new file mode 100644
index 0000000..971b695
--- /dev/null
+++ b/java/com/android/incallui/VideoCallPresenter.java
@@ -0,0 +1,1289 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Point;
+import android.os.Handler;
+import android.support.annotation.Nullable;
+import android.telecom.Connection;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+import android.view.Surface;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.CompatUtils;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallOrientationListener;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.InCallVideoCallCallbackNotifier;
+import com.android.incallui.call.InCallVideoCallCallbackNotifier.SurfaceChangeListener;
+import com.android.incallui.call.InCallVideoCallCallbackNotifier.VideoEventListener;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.util.AccessibilityUtil;
+import com.android.incallui.video.protocol.VideoCallScreen;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+import com.android.incallui.videosurface.protocol.VideoSurfaceDelegate;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+import java.util.Objects;
+
+/**
+ * Logic related to the {@link VideoCallScreen} and for managing changes to the video calling
+ * surfaces based on other user interface events and incoming events from the {@class
+ * VideoCallListener}.
+ *
+ * <p>When a call's video state changes to bi-directional video, the {@link
+ * com.android.incallui.VideoCallPresenter} performs the following negotiation with the telephony
+ * layer:
+ *
+ * <ul>
+ * <li>{@code VideoCallPresenter} creates and informs telephony of the display surface.
+ * <li>{@code VideoCallPresenter} creates the preview surface.
+ * <li>{@code VideoCallPresenter} informs telephony of the currently selected camera.
+ * <li>Telephony layer sends {@link CameraCapabilities}, including the dimensions of the video for
+ *     the current camera.
+ * <li>{@code VideoCallPresenter} adjusts size of the preview surface to match the aspect ratio of
+ *     the camera.
+ * <li>{@code VideoCallPresenter} informs telephony of the new preview surface.
+ * </ul>
+ *
+ * <p>When downgrading to an audio-only video state, the {@code VideoCallPresenter} nulls both
+ * surfaces.
+ */
+public class VideoCallPresenter
+    implements IncomingCallListener,
+        InCallOrientationListener,
+        InCallStateListener,
+        InCallDetailsListener,
+        SurfaceChangeListener,
+        VideoEventListener,
+        InCallPresenter.InCallEventListener,
+        VideoCallScreenDelegate {
+
+  private static boolean mIsVideoMode = false;
+
+  private final Handler mHandler = new Handler();
+  private VideoCallScreen mVideoCallScreen;
+
+  /** The current context. */
+  private Context mContext;
+
+  @Override
+  public boolean shouldShowCameraPermissionDialog() {
+    if (mPrimaryCall == null) {
+      LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionDialog", "null call");
+      return false;
+    }
+    if (mPrimaryCall.didShowCameraPermission()) {
+      LogUtil.i(
+          "VideoCallPresenter.shouldShowCameraPermissionDialog", "already shown for this call");
+      return false;
+    }
+    if (!ConfigProviderBindings.get(mContext)
+        .getBoolean("camera_permission_dialog_allowed", true)) {
+      LogUtil.i("VideoCallPresenter.shouldShowCameraPermissionDialog", "disabled by config");
+      return false;
+    }
+    return !VideoUtils.hasCameraPermission(mContext) || !VideoUtils.isCameraAllowedByUser(mContext);
+  }
+
+  @Override
+  public void onCameraPermissionDialogShown() {
+    if (mPrimaryCall != null) {
+      mPrimaryCall.setDidShowCameraPermission(true);
+    }
+  }
+
+  /** The call the video surfaces are currently related to */
+  private DialerCall mPrimaryCall;
+  /**
+   * The {@link VideoCall} used to inform the video telephony layer of changes to the video
+   * surfaces.
+   */
+  private VideoCall mVideoCall;
+  /** Determines if the current UI state represents a video call. */
+  private int mCurrentVideoState;
+  /** DialerCall's current state */
+  private int mCurrentCallState = DialerCall.State.INVALID;
+  /** Determines the device orientation (portrait/lanscape). */
+  private int mDeviceOrientation = InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN;
+  /** Tracks the state of the preview surface negotiation with the telephony layer. */
+  private int mPreviewSurfaceState = PreviewSurfaceState.NONE;
+  /**
+   * Determines whether video calls should automatically enter full screen mode after {@link
+   * #mAutoFullscreenTimeoutMillis} milliseconds.
+   */
+  private boolean mIsAutoFullscreenEnabled = false;
+  /**
+   * Determines the number of milliseconds after which a video call will automatically enter
+   * fullscreen mode. Requires {@link #mIsAutoFullscreenEnabled} to be {@code true}.
+   */
+  private int mAutoFullscreenTimeoutMillis = 0;
+  /**
+   * Determines if the countdown is currently running to automatically enter full screen video mode.
+   */
+  private boolean mAutoFullScreenPending = false;
+  /** Whether if the call is remotely held. */
+  private boolean mIsRemotelyHeld = false;
+  /**
+   * Runnable which is posted to schedule automatically entering fullscreen mode. Will not auto
+   * enter fullscreen mode if the dialpad is visible (doing so would make it impossible to exit the
+   * dialpad).
+   */
+  private Runnable mAutoFullscreenRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          if (mAutoFullScreenPending
+              && !InCallPresenter.getInstance().isDialpadVisible()
+              && mIsVideoMode) {
+
+            LogUtil.v("VideoCallPresenter.mAutoFullScreenRunnable", "entering fullscreen mode");
+            InCallPresenter.getInstance().setFullScreen(true);
+            mAutoFullScreenPending = false;
+          } else {
+            LogUtil.v(
+                "VideoCallPresenter.mAutoFullScreenRunnable",
+                "skipping scheduled fullscreen mode.");
+          }
+        }
+      };
+
+  private boolean isVideoCallScreenUiReady;
+
+  private static boolean isCameraRequired(int videoState, int sessionModificationState) {
+    return VideoProfile.isBidirectional(videoState)
+        || VideoProfile.isTransmissionEnabled(videoState)
+        || isVideoUpgrade(sessionModificationState);
+  }
+
+  /**
+   * Determines if the incoming video surface should be shown based on the current videoState and
+   * callState. The video surface is shown when incoming video is not paused, the call is active,
+   * and video reception is enabled.
+   *
+   * @param videoState The current video state.
+   * @param callState The current call state.
+   * @return {@code true} if the incoming video surface should be shown, {@code false} otherwise.
+   */
+  public static boolean showIncomingVideo(int videoState, int callState) {
+    if (!CompatUtils.isVideoCompatible()) {
+      return false;
+    }
+
+    boolean isPaused = VideoProfile.isPaused(videoState);
+    boolean isCallActive = callState == DialerCall.State.ACTIVE;
+
+    return !isPaused && isCallActive && VideoProfile.isReceptionEnabled(videoState);
+  }
+
+  /**
+   * Determines if the outgoing video surface should be shown based on the current videoState. The
+   * video surface is shown if video transmission is enabled.
+   *
+   * @return {@code true} if the the outgoing video surface should be shown, {@code false}
+   *     otherwise.
+   */
+  public static boolean showOutgoingVideo(
+      Context context, int videoState, int sessionModificationState) {
+    if (!VideoUtils.hasCameraPermissionAndAllowedByUser(context)) {
+      LogUtil.i("VideoCallPresenter.showOutgoingVideo", "Camera permission is disabled by user.");
+      return false;
+    }
+
+    if (!CompatUtils.isVideoCompatible()) {
+      return false;
+    }
+
+    return VideoProfile.isTransmissionEnabled(videoState)
+        || isVideoUpgrade(sessionModificationState);
+  }
+
+  private static void updateCameraSelection(DialerCall call) {
+    LogUtil.v("VideoCallPresenter.updateCameraSelection", "call=" + call);
+    LogUtil.v("VideoCallPresenter.updateCameraSelection", "call=" + toSimpleString(call));
+
+    final DialerCall activeCall = CallList.getInstance().getActiveCall();
+    int cameraDir;
+
+    // this function should never be called with null call object, however if it happens we
+    // should handle it gracefully.
+    if (call == null) {
+      cameraDir = DialerCall.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+      LogUtil.e(
+          "VideoCallPresenter.updateCameraSelection",
+          "call is null. Setting camera direction to default value (CAMERA_DIRECTION_UNKNOWN)");
+    }
+
+    // Clear camera direction if this is not a video call.
+    else if (VideoUtils.isAudioCall(call) && !isVideoUpgrade(call)) {
+      cameraDir = DialerCall.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+      call.getVideoSettings().setCameraDir(cameraDir);
+    }
+
+    // If this is a waiting video call, default to active call's camera,
+    // since we don't want to change the current camera for waiting call
+    // without user's permission.
+    else if (VideoUtils.isVideoCall(activeCall) && VideoUtils.isIncomingVideoCall(call)) {
+      cameraDir = activeCall.getVideoSettings().getCameraDir();
+    }
+
+    // Infer the camera direction from the video state and store it,
+    // if this is an outgoing video call.
+    else if (VideoUtils.isOutgoingVideoCall(call) && !isCameraDirectionSet(call)) {
+      cameraDir = toCameraDirection(call.getVideoState());
+      call.getVideoSettings().setCameraDir(cameraDir);
+    }
+
+    // Use the stored camera dir if this is an outgoing video call for which camera direction
+    // is set.
+    else if (VideoUtils.isOutgoingVideoCall(call)) {
+      cameraDir = call.getVideoSettings().getCameraDir();
+    }
+
+    // Infer the camera direction from the video state and store it,
+    // if this is an active video call and camera direction is not set.
+    else if (VideoUtils.isActiveVideoCall(call) && !isCameraDirectionSet(call)) {
+      cameraDir = toCameraDirection(call.getVideoState());
+      call.getVideoSettings().setCameraDir(cameraDir);
+    }
+
+    // Use the stored camera dir if this is an active video call for which camera direction
+    // is set.
+    else if (VideoUtils.isActiveVideoCall(call)) {
+      cameraDir = call.getVideoSettings().getCameraDir();
+    }
+
+    // For all other cases infer the camera direction but don't store it in the call object.
+    else {
+      cameraDir = toCameraDirection(call.getVideoState());
+    }
+
+    LogUtil.i(
+        "VideoCallPresenter.updateCameraSelection",
+        "setting camera direction to %d, call: %s",
+        cameraDir,
+        call);
+    final InCallCameraManager cameraManager =
+        InCallPresenter.getInstance().getInCallCameraManager();
+    cameraManager.setUseFrontFacingCamera(
+        cameraDir == DialerCall.VideoSettings.CAMERA_DIRECTION_FRONT_FACING);
+  }
+
+  private static int toCameraDirection(int videoState) {
+    return VideoProfile.isTransmissionEnabled(videoState)
+            && !VideoProfile.isBidirectional(videoState)
+        ? DialerCall.VideoSettings.CAMERA_DIRECTION_BACK_FACING
+        : DialerCall.VideoSettings.CAMERA_DIRECTION_FRONT_FACING;
+  }
+
+  private static boolean isCameraDirectionSet(DialerCall call) {
+    return VideoUtils.isVideoCall(call)
+        && call.getVideoSettings().getCameraDir()
+            != DialerCall.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+  }
+
+  private static String toSimpleString(DialerCall call) {
+    return call == null ? null : call.toSimpleString();
+  }
+
+  /**
+   * Initializes the presenter.
+   *
+   * @param context The current context.
+   */
+  @Override
+  public void initVideoCallScreenDelegate(Context context, VideoCallScreen videoCallScreen) {
+    mContext = context;
+    mVideoCallScreen = videoCallScreen;
+    mIsAutoFullscreenEnabled =
+        mContext.getResources().getBoolean(R.bool.video_call_auto_fullscreen);
+    mAutoFullscreenTimeoutMillis =
+        mContext.getResources().getInteger(R.integer.video_call_auto_fullscreen_timeout);
+  }
+
+  /** Called when the user interface is ready to be used. */
+  @Override
+  public void onVideoCallScreenUiReady() {
+    LogUtil.v("VideoCallPresenter.onVideoCallScreenUiReady", "");
+    Assert.checkState(!isVideoCallScreenUiReady);
+
+    // Do not register any listeners if video calling is not compatible to safeguard against
+    // any accidental calls of video calling code.
+    if (!CompatUtils.isVideoCompatible()) {
+      return;
+    }
+
+    mDeviceOrientation = InCallOrientationEventListener.getCurrentOrientation();
+
+    // Register for call state changes last
+    InCallPresenter.getInstance().addListener(this);
+    InCallPresenter.getInstance().addDetailsListener(this);
+    InCallPresenter.getInstance().addIncomingCallListener(this);
+    InCallPresenter.getInstance().addOrientationListener(this);
+    // To get updates of video call details changes
+    InCallPresenter.getInstance().addInCallEventListener(this);
+    InCallPresenter.getInstance().getLocalVideoSurfaceTexture().setDelegate(new LocalDelegate());
+    InCallPresenter.getInstance().getRemoteVideoSurfaceTexture().setDelegate(new RemoteDelegate());
+
+    // Register for surface and video events from {@link InCallVideoCallListener}s.
+    InCallVideoCallCallbackNotifier.getInstance().addSurfaceChangeListener(this);
+    InCallVideoCallCallbackNotifier.getInstance().addVideoEventListener(this);
+    mCurrentVideoState = VideoProfile.STATE_AUDIO_ONLY;
+    mCurrentCallState = DialerCall.State.INVALID;
+
+    InCallPresenter.InCallState inCallState = InCallPresenter.getInstance().getInCallState();
+    onStateChange(inCallState, inCallState, CallList.getInstance());
+    isVideoCallScreenUiReady = true;
+  }
+
+  /** Called when the user interface is no longer ready to be used. */
+  @Override
+  public void onVideoCallScreenUiUnready() {
+    LogUtil.v("VideoCallPresenter.onVideoCallScreenUiUnready", "");
+    Assert.checkState(isVideoCallScreenUiReady);
+
+    if (!CompatUtils.isVideoCompatible()) {
+      return;
+    }
+
+    cancelAutoFullScreen();
+
+    InCallPresenter.getInstance().removeListener(this);
+    InCallPresenter.getInstance().removeDetailsListener(this);
+    InCallPresenter.getInstance().removeIncomingCallListener(this);
+    InCallPresenter.getInstance().removeOrientationListener(this);
+    InCallPresenter.getInstance().removeInCallEventListener(this);
+    InCallPresenter.getInstance().getLocalVideoSurfaceTexture().setDelegate(null);
+
+    InCallVideoCallCallbackNotifier.getInstance().removeSurfaceChangeListener(this);
+    InCallVideoCallCallbackNotifier.getInstance().removeVideoEventListener(this);
+
+    // Ensure that the call's camera direction is updated (most likely to UNKNOWN). Normally this
+    // happens after any call state changes but we're unregistering from InCallPresenter above so
+    // we won't get any more call state changes. See b/32957114.
+    if (mPrimaryCall != null) {
+      updateCameraSelection(mPrimaryCall);
+    }
+
+    isVideoCallScreenUiReady = false;
+  }
+
+  /**
+   * Handles clicks on the video surfaces. If not currently in fullscreen mode, will set fullscreen.
+   */
+  private void onSurfaceClick() {
+    LogUtil.i("VideoCallPresenter.onSurfaceClick", "");
+    cancelAutoFullScreen();
+    if (!InCallPresenter.getInstance().isFullscreen()) {
+      InCallPresenter.getInstance().setFullScreen(true);
+    } else {
+      InCallPresenter.getInstance().setFullScreen(false);
+      maybeAutoEnterFullscreen(mPrimaryCall);
+      // If Activity is not multiwindow, fullscreen will be driven by SystemUI visibility changes
+      // instead. See #onSystemUiVisibilityChange(boolean)
+
+      // TODO (keyboardr): onSystemUiVisibilityChange isn't being called the first time
+      // visibility changes after orientation change, so this is currently always done as a backup.
+    }
+  }
+
+  @Override
+  public void onSystemUiVisibilityChange(boolean visible) {
+    // If the SystemUI has changed to be visible, take us out of fullscreen mode
+    LogUtil.i("VideoCallPresenter.onSystemUiVisibilityChange", "visible: " + visible);
+    if (visible) {
+      InCallPresenter.getInstance().setFullScreen(false);
+      maybeAutoEnterFullscreen(mPrimaryCall);
+    }
+  }
+
+  @Override
+  public VideoSurfaceTexture getLocalVideoSurfaceTexture() {
+    return InCallPresenter.getInstance().getLocalVideoSurfaceTexture();
+  }
+
+  @Override
+  public VideoSurfaceTexture getRemoteVideoSurfaceTexture() {
+    return InCallPresenter.getInstance().getRemoteVideoSurfaceTexture();
+  }
+
+  @Override
+  public int getDeviceOrientation() {
+    return mDeviceOrientation;
+  }
+
+  /**
+   * This should only be called when user approved the camera permission, which is local action and
+   * does NOT change any call states.
+   */
+  @Override
+  public void onCameraPermissionGranted() {
+    LogUtil.i("VideoCallPresenter.onCameraPermissionGranted", "");
+    VideoUtils.setCameraAllowedByUser(mContext);
+    enableCamera(mPrimaryCall.getVideoCall(), isCameraRequired());
+    showVideoUi(
+        mPrimaryCall.getVideoState(),
+        mPrimaryCall.getState(),
+        mPrimaryCall.getSessionModificationState(),
+        mPrimaryCall.isRemotelyHeld());
+    InCallPresenter.getInstance().getInCallCameraManager().onCameraPermissionGranted();
+  }
+
+  /**
+   * Called when the user interacts with the UI. If a fullscreen timer is pending then we start the
+   * timer from scratch to avoid having the UI disappear while the user is interacting with it.
+   */
+  @Override
+  public void resetAutoFullscreenTimer() {
+    if (mAutoFullScreenPending) {
+      LogUtil.i("VideoCallPresenter.resetAutoFullscreenTimer", "resetting");
+      mHandler.removeCallbacks(mAutoFullscreenRunnable);
+      mHandler.postDelayed(mAutoFullscreenRunnable, mAutoFullscreenTimeoutMillis);
+    }
+  }
+
+  /**
+   * Handles incoming calls.
+   *
+   * @param oldState The old in call state.
+   * @param newState The new in call state.
+   * @param call The call.
+   */
+  @Override
+  public void onIncomingCall(
+      InCallPresenter.InCallState oldState, InCallPresenter.InCallState newState, DialerCall call) {
+    // same logic should happen as with onStateChange()
+    onStateChange(oldState, newState, CallList.getInstance());
+  }
+
+  /**
+   * Handles state changes (including incoming calls)
+   *
+   * @param newState The in call state.
+   * @param callList The call list.
+   */
+  @Override
+  public void onStateChange(
+      InCallPresenter.InCallState oldState,
+      InCallPresenter.InCallState newState,
+      CallList callList) {
+    LogUtil.v(
+        "VideoCallPresenter.onStateChange",
+        "oldState: %s, newState: %s, isVideoMode: %b",
+        oldState,
+        newState,
+        isVideoMode());
+
+    if (newState == InCallPresenter.InCallState.NO_CALLS) {
+      if (isVideoMode()) {
+        exitVideoMode();
+      }
+
+      InCallPresenter.getInstance().cleanupSurfaces();
+    }
+
+    // Determine the primary active call).
+    DialerCall primary = null;
+
+    // Determine the call which is the focus of the user's attention.  In the case of an
+    // incoming call waiting call, the primary call is still the active video call, however
+    // the determination of whether we should be in fullscreen mode is based on the type of the
+    // incoming call, not the active video call.
+    DialerCall currentCall = null;
+
+    if (newState == InCallPresenter.InCallState.INCOMING) {
+      // We don't want to replace active video call (primary call)
+      // with a waiting call, since user may choose to ignore/decline the waiting call and
+      // this should have no impact on current active video call, that is, we should not
+      // change the camera or UI unless the waiting VT call becomes active.
+      primary = callList.getActiveCall();
+      currentCall = callList.getIncomingCall();
+      if (!VideoUtils.isActiveVideoCall(primary)) {
+        primary = callList.getIncomingCall();
+      }
+    } else if (newState == InCallPresenter.InCallState.OUTGOING) {
+      currentCall = primary = callList.getOutgoingCall();
+    } else if (newState == InCallPresenter.InCallState.PENDING_OUTGOING) {
+      currentCall = primary = callList.getPendingOutgoingCall();
+    } else if (newState == InCallPresenter.InCallState.INCALL) {
+      currentCall = primary = callList.getActiveCall();
+    }
+
+    final boolean primaryChanged = !Objects.equals(mPrimaryCall, primary);
+    LogUtil.i(
+        "VideoCallPresenter.onStateChange",
+        "primaryChanged: %b, primary: %s, mPrimaryCall: %s",
+        primaryChanged,
+        primary,
+        mPrimaryCall);
+    if (primaryChanged) {
+      onPrimaryCallChanged(primary);
+    } else if (mPrimaryCall != null) {
+      updateVideoCall(primary);
+    }
+    updateCallCache(primary);
+
+    // If the call context changed, potentially exit fullscreen or schedule auto enter of
+    // fullscreen mode.
+    // If the current call context is no longer a video call, exit fullscreen mode.
+    maybeExitFullscreen(currentCall);
+    // Schedule auto-enter of fullscreen mode if the current call context is a video call
+    maybeAutoEnterFullscreen(currentCall);
+  }
+
+  /**
+   * Handles a change to the fullscreen mode of the app.
+   *
+   * @param isFullscreenMode {@code true} if the app is now fullscreen, {@code false} otherwise.
+   */
+  @Override
+  public void onFullscreenModeChanged(boolean isFullscreenMode) {
+    cancelAutoFullScreen();
+    if (mPrimaryCall != null) {
+      updateFullscreenAndGreenScreenMode(
+          mPrimaryCall.getState(), mPrimaryCall.getSessionModificationState());
+    } else {
+      updateFullscreenAndGreenScreenMode(
+          State.INVALID, DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    }
+  }
+
+  private void checkForVideoStateChange(DialerCall call) {
+    final boolean shouldShowVideoUi = shouldShowVideoUiForCall(call);
+    final boolean hasVideoStateChanged = mCurrentVideoState != call.getVideoState();
+
+    LogUtil.v(
+        "VideoCallPresenter.checkForVideoStateChange",
+        "shouldShowVideoUi: %b, hasVideoStateChanged: %b, isVideoMode: %b, previousVideoState: %s,"
+            + " newVideoState: %s",
+        shouldShowVideoUi,
+        hasVideoStateChanged,
+        isVideoMode(),
+        VideoProfile.videoStateToString(mCurrentVideoState),
+        VideoProfile.videoStateToString(call.getVideoState()));
+    if (!hasVideoStateChanged) {
+      return;
+    }
+
+    updateCameraSelection(call);
+
+    if (shouldShowVideoUi) {
+      adjustVideoMode(call);
+    } else if (isVideoMode()) {
+      exitVideoMode();
+    }
+  }
+
+  private void checkForCallStateChange(DialerCall call) {
+    final boolean shouldShowVideoUi = shouldShowVideoUiForCall(call);
+    final boolean hasCallStateChanged =
+        mCurrentCallState != call.getState() || mIsRemotelyHeld != call.isRemotelyHeld();
+    mIsRemotelyHeld = call.isRemotelyHeld();
+
+    LogUtil.v(
+        "VideoCallPresenter.checkForCallStateChange",
+        "shouldShowVideoUi: %b, hasCallStateChanged: %b, isVideoMode: %b",
+        shouldShowVideoUi,
+        hasCallStateChanged,
+        isVideoMode());
+
+    if (!hasCallStateChanged) {
+      return;
+    }
+
+    if (shouldShowVideoUi) {
+      final InCallCameraManager cameraManager =
+          InCallPresenter.getInstance().getInCallCameraManager();
+
+      String prevCameraId = cameraManager.getActiveCameraId();
+      updateCameraSelection(call);
+      String newCameraId = cameraManager.getActiveCameraId();
+
+      if (!Objects.equals(prevCameraId, newCameraId) && VideoUtils.isActiveVideoCall(call)) {
+        enableCamera(call.getVideoCall(), true);
+      }
+    }
+
+    // Make sure we hide or show the video UI if needed.
+    showVideoUi(
+        call.getVideoState(),
+        call.getState(),
+        call.getSessionModificationState(),
+        call.isRemotelyHeld());
+  }
+
+  private void onPrimaryCallChanged(DialerCall newPrimaryCall) {
+    final boolean shouldShowVideoUi = shouldShowVideoUiForCall(newPrimaryCall);
+    final boolean isVideoMode = isVideoMode();
+
+    LogUtil.v(
+        "VideoCallPresenter.onPrimaryCallChanged",
+        "shouldShowVideoUi: %b, isVideoMode: %b",
+        shouldShowVideoUi,
+        isVideoMode);
+
+    if (!shouldShowVideoUi && isVideoMode) {
+      // Terminate video mode if new primary call is not a video call
+      // and we are currently in video mode.
+      LogUtil.i("VideoCallPresenter.onPrimaryCallChanged", "exiting video mode...");
+      exitVideoMode();
+    } else if (shouldShowVideoUi) {
+      LogUtil.i("VideoCallPresenter.onPrimaryCallChanged", "entering video mode...");
+
+      updateCameraSelection(newPrimaryCall);
+      adjustVideoMode(newPrimaryCall);
+    }
+    checkForOrientationAllowedChange(newPrimaryCall);
+  }
+
+  private boolean isVideoMode() {
+    return mIsVideoMode;
+  }
+
+  private void updateCallCache(DialerCall call) {
+    if (call == null) {
+      mCurrentVideoState = VideoProfile.STATE_AUDIO_ONLY;
+      mCurrentCallState = DialerCall.State.INVALID;
+      mVideoCall = null;
+      mPrimaryCall = null;
+    } else {
+      mCurrentVideoState = call.getVideoState();
+      mVideoCall = call.getVideoCall();
+      mCurrentCallState = call.getState();
+      mPrimaryCall = call;
+    }
+  }
+
+  /**
+   * Handles changes to the details of the call. The {@link VideoCallPresenter} is interested in
+   * changes to the video state.
+   *
+   * @param call The call for which the details changed.
+   * @param details The new call details.
+   */
+  @Override
+  public void onDetailsChanged(DialerCall call, android.telecom.Call.Details details) {
+    LogUtil.v(
+        "VideoCallPresenter.onDetailsChanged",
+        "call: %s, details: %s, mPrimaryCall: %s",
+        call,
+        details,
+        mPrimaryCall);
+    if (call == null) {
+      return;
+    }
+    // If the details change is not for the currently active call no update is required.
+    if (!call.equals(mPrimaryCall)) {
+      LogUtil.v("VideoCallPresenter.onDetailsChanged", "details not for current active call");
+      return;
+    }
+
+    updateVideoCall(call);
+
+    updateCallCache(call);
+  }
+
+  private void updateVideoCall(DialerCall call) {
+    checkForVideoCallChange(call);
+    checkForVideoStateChange(call);
+    checkForCallStateChange(call);
+    checkForOrientationAllowedChange(call);
+    updateFullscreenAndGreenScreenMode(call.getState(), call.getSessionModificationState());
+  }
+
+  private void checkForOrientationAllowedChange(@Nullable DialerCall call) {
+    InCallPresenter.getInstance()
+        .setInCallAllowsOrientationChange(VideoUtils.isVideoCall(call) || isVideoUpgrade(call));
+  }
+
+  private void updateFullscreenAndGreenScreenMode(
+      int callState, @SessionModificationState int sessionModificationState) {
+    if (mVideoCallScreen != null) {
+      boolean shouldShowFullscreen = InCallPresenter.getInstance().isFullscreen();
+      boolean shouldShowGreenScreen =
+          callState == State.DIALING
+              || callState == State.CONNECTING
+              || callState == State.INCOMING
+              || isVideoUpgrade(sessionModificationState);
+      mVideoCallScreen.updateFullscreenAndGreenScreenMode(
+          shouldShowFullscreen, shouldShowGreenScreen);
+    }
+  }
+
+  /** Checks for a change to the video call and changes it if required. */
+  private void checkForVideoCallChange(DialerCall call) {
+    final VideoCall videoCall = call.getVideoCall();
+    LogUtil.v(
+        "VideoCallPresenter.checkForVideoCallChange",
+        "videoCall: %s, mVideoCall: %s",
+        videoCall,
+        mVideoCall);
+    if (!Objects.equals(videoCall, mVideoCall)) {
+      changeVideoCall(call);
+    }
+  }
+
+  /**
+   * Handles a change to the video call. Sets the surfaces on the previous call to null and sets the
+   * surfaces on the new video call accordingly.
+   *
+   * @param call The new video call.
+   */
+  private void changeVideoCall(DialerCall call) {
+    final VideoCall videoCall = call == null ? null : call.getVideoCall();
+    LogUtil.i(
+        "VideoCallPresenter.changeVideoCall",
+        "videoCall: %s, mVideoCall: %s",
+        videoCall,
+        mVideoCall);
+    final boolean hasChanged = mVideoCall == null && videoCall != null;
+
+    mVideoCall = videoCall;
+    if (mVideoCall == null) {
+      LogUtil.v("VideoCallPresenter.changeVideoCall", "video call or primary call is null. Return");
+      return;
+    }
+
+    if (shouldShowVideoUiForCall(call) && hasChanged) {
+      adjustVideoMode(call);
+    }
+  }
+
+  private boolean isCameraRequired() {
+    return mPrimaryCall != null
+        && isCameraRequired(
+            mPrimaryCall.getVideoState(), mPrimaryCall.getSessionModificationState());
+  }
+
+  /**
+   * Adjusts the current video mode by setting up the preview and display surfaces as necessary.
+   * Expected to be called whenever the video state associated with a call changes (e.g. a user
+   * turns their camera on or off) to ensure the correct surfaces are shown/hidden. TODO: Need
+   * to adjust size and orientation of preview surface here.
+   */
+  private void adjustVideoMode(DialerCall call) {
+    VideoCall videoCall = call.getVideoCall();
+    int newVideoState = call.getVideoState();
+
+    LogUtil.i(
+        "VideoCallPresenter.adjustVideoMode",
+        "videoCall: %s, videoState: %d",
+        videoCall,
+        newVideoState);
+    if (mVideoCallScreen == null) {
+      LogUtil.e("VideoCallPresenter.adjustVideoMode", "error VideoCallScreen is null so returning");
+      return;
+    }
+
+    showVideoUi(
+        newVideoState, call.getState(), call.getSessionModificationState(), call.isRemotelyHeld());
+
+    // Communicate the current camera to telephony and make a request for the camera
+    // capabilities.
+    if (videoCall != null) {
+      Surface surface = getRemoteVideoSurfaceTexture().getSavedSurface();
+      if (surface != null) {
+        LogUtil.v(
+            "VideoCallPresenter.adjustVideoMode", "calling setDisplaySurface with: " + surface);
+        videoCall.setDisplaySurface(surface);
+      }
+
+      Assert.checkState(
+          mDeviceOrientation != InCallOrientationEventListener.SCREEN_ORIENTATION_UNKNOWN);
+      videoCall.setDeviceOrientation(mDeviceOrientation);
+      enableCamera(videoCall, isCameraRequired(newVideoState, call.getSessionModificationState()));
+    }
+    int previousVideoState = mCurrentVideoState;
+    mCurrentVideoState = newVideoState;
+    mIsVideoMode = true;
+
+    // adjustVideoMode may be called if we are already in a 1-way video state.  In this case
+    // we do not want to trigger auto-fullscreen mode.
+    if (!VideoUtils.isVideoCall(previousVideoState) && VideoUtils.isVideoCall(newVideoState)) {
+      maybeAutoEnterFullscreen(call);
+    }
+  }
+
+  private static boolean shouldShowVideoUiForCall(@Nullable DialerCall call) {
+    if (call == null) {
+      return false;
+    }
+
+    if (VideoUtils.isVideoCall(call)) {
+      return true;
+    }
+
+    if (isVideoUpgrade(call)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  private void enableCamera(VideoCall videoCall, boolean isCameraRequired) {
+    LogUtil.v(
+        "VideoCallPresenter.enableCamera",
+        "videoCall: %s, enabling: %b",
+        videoCall,
+        isCameraRequired);
+    if (videoCall == null) {
+      LogUtil.i("VideoCallPresenter.enableCamera", "videoCall is null.");
+      return;
+    }
+
+    boolean hasCameraPermission = VideoUtils.hasCameraPermissionAndAllowedByUser(mContext);
+    if (!hasCameraPermission) {
+      videoCall.setCamera(null);
+      mPreviewSurfaceState = PreviewSurfaceState.NONE;
+      // TODO: Inform remote party that the video is off. This is similar to b/30256571.
+    } else if (isCameraRequired) {
+      InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager();
+      videoCall.setCamera(cameraManager.getActiveCameraId());
+      mPreviewSurfaceState = PreviewSurfaceState.CAMERA_SET;
+      videoCall.requestCameraCapabilities();
+    } else {
+      mPreviewSurfaceState = PreviewSurfaceState.NONE;
+      videoCall.setCamera(null);
+    }
+  }
+
+  /** Exits video mode by hiding the video surfaces and making other adjustments (eg. audio). */
+  private void exitVideoMode() {
+    LogUtil.i("VideoCallPresenter.exitVideoMode", "");
+
+    showVideoUi(
+        VideoProfile.STATE_AUDIO_ONLY,
+        DialerCall.State.ACTIVE,
+        DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST,
+        false /* isRemotelyHeld */);
+    enableCamera(mVideoCall, false);
+    InCallPresenter.getInstance().setFullScreen(false);
+
+    mIsVideoMode = false;
+  }
+
+  /**
+   * Based on the current video state and call state, show or hide the incoming and outgoing video
+   * surfaces. The outgoing video surface is shown any time video is transmitting. The incoming
+   * video surface is shown whenever the video is un-paused and active.
+   *
+   * @param videoState The video state.
+   * @param callState The call state.
+   */
+  private void showVideoUi(
+      int videoState,
+      int callState,
+      @SessionModificationState int sessionModificationState,
+      boolean isRemotelyHeld) {
+    if (mVideoCallScreen == null) {
+      LogUtil.e("VideoCallPresenter.showVideoUi", "videoCallScreen is null returning");
+      return;
+    }
+    boolean showIncomingVideo = showIncomingVideo(videoState, callState);
+    boolean showOutgoingVideo = showOutgoingVideo(mContext, videoState, sessionModificationState);
+    LogUtil.i(
+        "VideoCallPresenter.showVideoUi",
+        "showIncoming: %b, showOutgoing: %b, isRemotelyHeld: %b",
+        showIncomingVideo,
+        showOutgoingVideo,
+        isRemotelyHeld);
+    updateRemoteVideoSurfaceDimensions();
+    mVideoCallScreen.showVideoViews(showOutgoingVideo, showIncomingVideo, isRemotelyHeld);
+
+    InCallPresenter.getInstance().enableScreenTimeout(VideoProfile.isAudioOnly(videoState));
+    updateFullscreenAndGreenScreenMode(callState, sessionModificationState);
+  }
+
+  /**
+   * Handles peer video pause state changes.
+   *
+   * @param call The call which paused or un-pausedvideo transmission.
+   * @param paused {@code True} when the video transmission is paused, {@code false} when video
+   *     transmission resumes.
+   */
+  @Override
+  public void onPeerPauseStateChanged(DialerCall call, boolean paused) {
+    if (!call.equals(mPrimaryCall)) {
+      return;
+    }
+  }
+
+  /**
+   * Handles peer video dimension changes.
+   *
+   * @param call The call which experienced a peer video dimension change.
+   * @param width The new peer video width .
+   * @param height The new peer video height.
+   */
+  @Override
+  public void onUpdatePeerDimensions(DialerCall call, int width, int height) {
+    LogUtil.i("VideoCallPresenter.onUpdatePeerDimensions", "width: %d, height: %d", width, height);
+    if (mVideoCallScreen == null) {
+      LogUtil.e("VideoCallPresenter.onUpdatePeerDimensions", "videoCallScreen is null");
+      return;
+    }
+    if (!call.equals(mPrimaryCall)) {
+      LogUtil.e(
+          "VideoCallPresenter.onUpdatePeerDimensions", "current call is not equal to primary");
+      return;
+    }
+
+    // Change size of display surface to match the peer aspect ratio
+    if (width > 0 && height > 0 && mVideoCallScreen != null) {
+      getRemoteVideoSurfaceTexture().setSourceVideoDimensions(new Point(width, height));
+      mVideoCallScreen.onRemoteVideoDimensionsChanged();
+    }
+  }
+
+  /**
+   * Handles any video quality changes in the call.
+   *
+   * @param call The call which experienced a video quality change.
+   * @param videoQuality The new video call quality.
+   */
+  @Override
+  public void onVideoQualityChanged(DialerCall call, int videoQuality) {
+    // No-op
+  }
+
+  /**
+   * Handles a change to the dimensions of the local camera. Receiving the camera capabilities
+   * triggers the creation of the video
+   *
+   * @param call The call which experienced the camera dimension change.
+   * @param width The new camera video width.
+   * @param height The new camera video height.
+   */
+  @Override
+  public void onCameraDimensionsChange(DialerCall call, int width, int height) {
+    LogUtil.i(
+        "VideoCallPresenter.onCameraDimensionsChange",
+        "call: %s, width: %d, height: %d",
+        call,
+        width,
+        height);
+    if (mVideoCallScreen == null) {
+      LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "ui is null");
+      return;
+    }
+
+    if (!call.equals(mPrimaryCall)) {
+      LogUtil.e("VideoCallPresenter.onCameraDimensionsChange", "not the primary call");
+      return;
+    }
+
+    mPreviewSurfaceState = PreviewSurfaceState.CAPABILITIES_RECEIVED;
+    changePreviewDimensions(width, height);
+
+    // Check if the preview surface is ready yet; if it is, set it on the {@code VideoCall}.
+    // If it not yet ready, it will be set when when creation completes.
+    Surface surface = getLocalVideoSurfaceTexture().getSavedSurface();
+    if (surface != null) {
+      mPreviewSurfaceState = PreviewSurfaceState.SURFACE_SET;
+      mVideoCall.setPreviewSurface(surface);
+    }
+  }
+
+  /**
+   * Changes the dimensions of the preview surface.
+   *
+   * @param width The new width.
+   * @param height The new height.
+   */
+  private void changePreviewDimensions(int width, int height) {
+    if (mVideoCallScreen == null) {
+      return;
+    }
+
+    // Resize the surface used to display the preview video
+    getLocalVideoSurfaceTexture().setSurfaceDimensions(new Point(width, height));
+    mVideoCallScreen.onLocalVideoDimensionsChanged();
+  }
+
+  /**
+   * Called when call session event is raised.
+   *
+   * @param event The call session event.
+   */
+  @Override
+  public void onCallSessionEvent(int event) {
+    switch (event) {
+      case Connection.VideoProvider.SESSION_EVENT_RX_PAUSE:
+        LogUtil.v("VideoCallPresenter.onCallSessionEvent", "rx_pause");
+        break;
+      case Connection.VideoProvider.SESSION_EVENT_RX_RESUME:
+        LogUtil.v("VideoCallPresenter.onCallSessionEvent", "rx_resume");
+        break;
+      case Connection.VideoProvider.SESSION_EVENT_CAMERA_FAILURE:
+        LogUtil.v("VideoCallPresenter.onCallSessionEvent", "camera_failure");
+        break;
+      case Connection.VideoProvider.SESSION_EVENT_CAMERA_READY:
+        LogUtil.v("VideoCallPresenter.onCallSessionEvent", "camera_ready");
+        break;
+      default:
+        LogUtil.v("VideoCallPresenter.onCallSessionEvent", "unknown event = : " + event);
+        break;
+    }
+  }
+
+  /**
+   * Handles a change to the call data usage
+   *
+   * @param dataUsage call data usage value
+   */
+  @Override
+  public void onCallDataUsageChange(long dataUsage) {
+    LogUtil.v("VideoCallPresenter.onCallDataUsageChange", "dataUsage=" + dataUsage);
+  }
+
+  /**
+   * Handles changes to the device orientation.
+   *
+   * @param orientation The screen orientation of the device (one of: {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_0}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_90}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_180}, {@link
+   *     InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+   */
+  @Override
+  public void onDeviceOrientationChanged(int orientation) {
+    LogUtil.i(
+        "VideoCallPresenter.onDeviceOrientationChanged",
+        "orientation: %d -> %d",
+        mDeviceOrientation,
+        orientation);
+    mDeviceOrientation = orientation;
+
+    if (mVideoCallScreen == null) {
+      LogUtil.e("VideoCallPresenter.onDeviceOrientationChanged", "videoCallScreen is null");
+      return;
+    }
+
+    Point previewDimensions = getLocalVideoSurfaceTexture().getSurfaceDimensions();
+    if (previewDimensions == null) {
+      return;
+    }
+    LogUtil.v(
+        "VideoCallPresenter.onDeviceOrientationChanged",
+        "orientation: %d, size: %s",
+        orientation,
+        previewDimensions);
+    changePreviewDimensions(previewDimensions.x, previewDimensions.y);
+
+    mVideoCallScreen.onLocalVideoOrientationChanged();
+  }
+
+  /**
+   * Exits fullscreen mode if the current call context has changed to a non-video call.
+   *
+   * @param call The call.
+   */
+  protected void maybeExitFullscreen(DialerCall call) {
+    if (call == null) {
+      return;
+    }
+
+    if (!VideoUtils.isVideoCall(call) || call.getState() == DialerCall.State.INCOMING) {
+      LogUtil.i("VideoCallPresenter.maybeExitFullscreen", "exiting fullscreen");
+      InCallPresenter.getInstance().setFullScreen(false);
+    }
+  }
+
+  /**
+   * Schedules auto-entering of fullscreen mode. Will not enter full screen mode if any of the
+   * following conditions are met: 1. No call 2. DialerCall is not active 3. The current video state
+   * is not bi-directional. 4. Already in fullscreen mode 5. In accessibility mode
+   *
+   * @param call The current call.
+   */
+  protected void maybeAutoEnterFullscreen(DialerCall call) {
+    if (!mIsAutoFullscreenEnabled) {
+      return;
+    }
+
+    if (call == null
+        || call.getState() != DialerCall.State.ACTIVE
+        || !VideoUtils.isBidirectionalVideoCall(call)
+        || InCallPresenter.getInstance().isFullscreen()
+        || (mContext != null && AccessibilityUtil.isTouchExplorationEnabled(mContext))) {
+      // Ensure any previously scheduled attempt to enter fullscreen is cancelled.
+      cancelAutoFullScreen();
+      return;
+    }
+
+    if (mAutoFullScreenPending) {
+      LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "already pending.");
+      return;
+    }
+    LogUtil.v("VideoCallPresenter.maybeAutoEnterFullscreen", "scheduled");
+    mAutoFullScreenPending = true;
+    mHandler.removeCallbacks(mAutoFullscreenRunnable);
+    mHandler.postDelayed(mAutoFullscreenRunnable, mAutoFullscreenTimeoutMillis);
+  }
+
+  /** Cancels pending auto fullscreen mode. */
+  @Override
+  public void cancelAutoFullScreen() {
+    if (!mAutoFullScreenPending) {
+      LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "none pending.");
+      return;
+    }
+    LogUtil.v("VideoCallPresenter.cancelAutoFullScreen", "cancelling pending");
+    mAutoFullScreenPending = false;
+    mHandler.removeCallbacks(mAutoFullscreenRunnable);
+  }
+
+  private void updateRemoteVideoSurfaceDimensions() {
+    Activity activity = mVideoCallScreen.getVideoCallScreenFragment().getActivity();
+    if (activity != null) {
+      Point screenSize = new Point();
+      activity.getWindowManager().getDefaultDisplay().getSize(screenSize);
+      getRemoteVideoSurfaceTexture().setSurfaceDimensions(screenSize);
+    }
+  }
+
+  private static boolean isVideoUpgrade(DialerCall call) {
+    return VideoUtils.hasSentVideoUpgradeRequest(call)
+        || VideoUtils.hasReceivedVideoUpgradeRequest(call);
+  }
+
+  private static boolean isVideoUpgrade(@SessionModificationState int state) {
+    return VideoUtils.hasSentVideoUpgradeRequest(state)
+        || VideoUtils.hasReceivedVideoUpgradeRequest(state);
+  }
+
+  private class LocalDelegate implements VideoSurfaceDelegate {
+    @Override
+    public void onSurfaceCreated(VideoSurfaceTexture videoCallSurface) {
+      if (mVideoCallScreen == null) {
+        LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceCreated", "no UI");
+        return;
+      }
+      if (mVideoCall == null) {
+        LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceCreated", "no video call");
+        return;
+      }
+
+      // If the preview surface has just been created and we have already received camera
+      // capabilities, but not yet set the surface, we will set the surface now.
+      if (mPreviewSurfaceState == PreviewSurfaceState.CAPABILITIES_RECEIVED) {
+        mPreviewSurfaceState = PreviewSurfaceState.SURFACE_SET;
+        mVideoCall.setPreviewSurface(videoCallSurface.getSavedSurface());
+      } else if (mPreviewSurfaceState == PreviewSurfaceState.NONE && isCameraRequired()) {
+        enableCamera(mVideoCall, true);
+      }
+    }
+
+    @Override
+    public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) {
+      if (mVideoCall == null) {
+        LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceReleased", "no video call");
+        return;
+      }
+
+      mVideoCall.setPreviewSurface(null);
+      enableCamera(mVideoCall, false);
+    }
+
+    @Override
+    public void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface) {
+      if (mVideoCall == null) {
+        LogUtil.e("VideoCallPresenter.LocalDelegate.onSurfaceDestroyed", "no video call");
+        return;
+      }
+
+      boolean isChangingConfigurations = InCallPresenter.getInstance().isChangingConfigurations();
+      if (!isChangingConfigurations) {
+        enableCamera(mVideoCall, false);
+      } else {
+        LogUtil.i(
+            "VideoCallPresenter.LocalDelegate.onSurfaceDestroyed",
+            "activity is being destroyed due to configuration changes. Not closing the camera.");
+      }
+    }
+
+    @Override
+    public void onSurfaceClick(VideoSurfaceTexture videoCallSurface) {
+      VideoCallPresenter.this.onSurfaceClick();
+    }
+  }
+
+  private class RemoteDelegate implements VideoSurfaceDelegate {
+    @Override
+    public void onSurfaceCreated(VideoSurfaceTexture videoCallSurface) {
+      if (mVideoCallScreen == null) {
+        LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no UI");
+        return;
+      }
+      if (mVideoCall == null) {
+        LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceCreated", "no video call");
+        return;
+      }
+      mVideoCall.setDisplaySurface(videoCallSurface.getSavedSurface());
+    }
+
+    @Override
+    public void onSurfaceReleased(VideoSurfaceTexture videoCallSurface) {
+      if (mVideoCall == null) {
+        LogUtil.e("VideoCallPresenter.RemoteDelegate.onSurfaceReleased", "no video call");
+        return;
+      }
+      mVideoCall.setDisplaySurface(null);
+    }
+
+    @Override
+    public void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface) {}
+
+    @Override
+    public void onSurfaceClick(VideoSurfaceTexture videoCallSurface) {
+      VideoCallPresenter.this.onSurfaceClick();
+    }
+  }
+
+  /** Defines the state of the preview surface negotiation with the telephony layer. */
+  private static class PreviewSurfaceState {
+
+    /**
+     * The camera has not yet been set on the {@link VideoCall}; negotiation has not yet started.
+     */
+    private static final int NONE = 0;
+
+    /**
+     * The camera has been set on the {@link VideoCall}, but camera capabilities have not yet been
+     * received.
+     */
+    private static final int CAMERA_SET = 1;
+
+    /**
+     * The camera capabilties have been received from telephony, but the surface has not yet been
+     * set on the {@link VideoCall}.
+     */
+    private static final int CAPABILITIES_RECEIVED = 2;
+
+    /** The surface has been set on the {@link VideoCall}. */
+    private static final int SURFACE_SET = 3;
+  }
+}
diff --git a/java/com/android/incallui/VideoPauseController.java b/java/com/android/incallui/VideoPauseController.java
new file mode 100644
index 0000000..2b43577
--- /dev/null
+++ b/java/com/android/incallui/VideoPauseController.java
@@ -0,0 +1,416 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.support.annotation.NonNull;
+import android.telecom.VideoProfile;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.VideoUtils;
+import java.util.Objects;
+
+/**
+ * This class is responsible for generating video pause/resume requests when the InCall UI is sent
+ * to the background and subsequently brought back to the foreground.
+ */
+class VideoPauseController implements InCallStateListener, IncomingCallListener {
+
+  private static final String TAG = "VideoPauseController";
+  private static VideoPauseController sVideoPauseController;
+  private InCallPresenter mInCallPresenter;
+  /** The current call context, if applicable. */
+  private CallContext mPrimaryCallContext = null;
+  /**
+   * Tracks whether the application is in the background. {@code True} if the application is in the
+   * background, {@code false} otherwise.
+   */
+  private boolean mIsInBackground = false;
+
+  /**
+   * Singleton accessor for the {@link VideoPauseController}.
+   *
+   * @return Singleton instance of the {@link VideoPauseController}.
+   */
+  /*package*/
+  static synchronized VideoPauseController getInstance() {
+    if (sVideoPauseController == null) {
+      sVideoPauseController = new VideoPauseController();
+    }
+    return sVideoPauseController;
+  }
+
+  /**
+   * Determines if a given call is the same one stored in a {@link CallContext}.
+   *
+   * @param call The call.
+   * @param callContext The call context.
+   * @return {@code true} if the {@link DialerCall} is the same as the one referenced in the {@link
+   *     CallContext}.
+   */
+  private static boolean areSame(DialerCall call, CallContext callContext) {
+    if (call == null && callContext == null) {
+      return true;
+    } else if (call == null || callContext == null) {
+      return false;
+    }
+    return call.equals(callContext.getCall());
+  }
+
+  /**
+   * Determines if a video call can be paused. Only a video call which is active can be paused.
+   *
+   * @param callContext The call context to check.
+   * @return {@code true} if the call is an active video call.
+   */
+  private static boolean canVideoPause(CallContext callContext) {
+    return isVideoCall(callContext) && callContext.getState() == DialerCall.State.ACTIVE;
+  }
+
+  /**
+   * Determines if a call referenced by a {@link CallContext} is a video call.
+   *
+   * @param callContext The call context.
+   * @return {@code true} if the call is a video call, {@code false} otherwise.
+   */
+  private static boolean isVideoCall(CallContext callContext) {
+    return callContext != null && VideoUtils.isVideoCall(callContext.getVideoState());
+  }
+
+  /**
+   * Determines if call is in incoming/waiting state.
+   *
+   * @param call The call context.
+   * @return {@code true} if the call is in incoming or waiting state, {@code false} otherwise.
+   */
+  private static boolean isIncomingCall(CallContext call) {
+    return call != null && isIncomingCall(call.getCall());
+  }
+
+  /**
+   * Determines if a call is in incoming/waiting state.
+   *
+   * @param call The call.
+   * @return {@code true} if the call is in incoming or waiting state, {@code false} otherwise.
+   */
+  private static boolean isIncomingCall(DialerCall call) {
+    return call != null
+        && (call.getState() == DialerCall.State.CALL_WAITING
+            || call.getState() == DialerCall.State.INCOMING);
+  }
+
+  /**
+   * Determines if a call is dialing.
+   *
+   * @param call The call context.
+   * @return {@code true} if the call is dialing, {@code false} otherwise.
+   */
+  private static boolean isDialing(CallContext call) {
+    return call != null && DialerCall.State.isDialing(call.getState());
+  }
+
+  /**
+   * Configures the {@link VideoPauseController} to listen to call events. Configured via the {@link
+   * com.android.incallui.InCallPresenter}.
+   *
+   * @param inCallPresenter The {@link com.android.incallui.InCallPresenter}.
+   */
+  public void setUp(@NonNull InCallPresenter inCallPresenter) {
+    log("setUp");
+    mInCallPresenter = Objects.requireNonNull(inCallPresenter);
+    mInCallPresenter.addListener(this);
+    mInCallPresenter.addIncomingCallListener(this);
+  }
+
+  /**
+   * Cleans up the {@link VideoPauseController} by removing all listeners and clearing its internal
+   * state. Called from {@link com.android.incallui.InCallPresenter}.
+   */
+  public void tearDown() {
+    log("tearDown...");
+    mInCallPresenter.removeListener(this);
+    mInCallPresenter.removeIncomingCallListener(this);
+    clear();
+  }
+
+  /** Clears the internal state for the {@link VideoPauseController}. */
+  private void clear() {
+    mInCallPresenter = null;
+    mPrimaryCallContext = null;
+    mIsInBackground = false;
+  }
+
+  /**
+   * Handles changes in the {@link InCallState}. Triggers pause and resumption of video for the
+   * current foreground call.
+   *
+   * @param oldState The previous {@link InCallState}.
+   * @param newState The current {@link InCallState}.
+   * @param callList List of current call.
+   */
+  @Override
+  public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+    log("onStateChange, OldState=" + oldState + " NewState=" + newState);
+
+    DialerCall call;
+    if (newState == InCallState.INCOMING) {
+      call = callList.getIncomingCall();
+    } else if (newState == InCallState.WAITING_FOR_ACCOUNT) {
+      call = callList.getWaitingForAccountCall();
+    } else if (newState == InCallState.PENDING_OUTGOING) {
+      call = callList.getPendingOutgoingCall();
+    } else if (newState == InCallState.OUTGOING) {
+      call = callList.getOutgoingCall();
+    } else {
+      call = callList.getActiveCall();
+    }
+
+    boolean hasPrimaryCallChanged = !areSame(call, mPrimaryCallContext);
+    boolean canVideoPause = VideoUtils.canVideoPause(call);
+    log("onStateChange, hasPrimaryCallChanged=" + hasPrimaryCallChanged);
+    log("onStateChange, canVideoPause=" + canVideoPause);
+    log("onStateChange, IsInBackground=" + mIsInBackground);
+
+    if (hasPrimaryCallChanged) {
+      onPrimaryCallChanged(call);
+      return;
+    }
+
+    if (isDialing(mPrimaryCallContext) && canVideoPause && mIsInBackground) {
+      // Bring UI to foreground if outgoing request becomes active while UI is in
+      // background.
+      bringToForeground();
+    } else if (!isVideoCall(mPrimaryCallContext) && canVideoPause && mIsInBackground) {
+      // Bring UI to foreground if VoLTE call becomes active while UI is in
+      // background.
+      bringToForeground();
+    }
+
+    updatePrimaryCallContext(call);
+  }
+
+  /**
+   * Handles a change to the primary call.
+   *
+   * <p>Reject incoming or hangup dialing call: Where the previous call was an incoming call or a
+   * call in dialing state, resume the new primary call. DialerCall swap: Where the new primary call
+   * is incoming, pause video on the previous primary call.
+   *
+   * @param call The new primary call.
+   */
+  private void onPrimaryCallChanged(DialerCall call) {
+    log("onPrimaryCallChanged: New call = " + call);
+    log("onPrimaryCallChanged: Old call = " + mPrimaryCallContext);
+    log("onPrimaryCallChanged, IsInBackground=" + mIsInBackground);
+
+    if (areSame(call, mPrimaryCallContext)) {
+      throw new IllegalStateException();
+    }
+    final boolean canVideoPause = VideoUtils.canVideoPause(call);
+
+    if ((isIncomingCall(mPrimaryCallContext)
+            || isDialing(mPrimaryCallContext)
+            || (call != null && VideoProfile.isPaused(call.getVideoState())))
+        && canVideoPause
+        && !mIsInBackground) {
+      // Send resume request for the active call, if user rejects incoming call, ends dialing
+      // call, or the call was previously in a paused state and UI is in the foreground.
+      sendRequest(call, true);
+    } else if (isIncomingCall(call) && canVideoPause(mPrimaryCallContext)) {
+      // Send pause request if there is an active video call, and we just received a new
+      // incoming call.
+      sendRequest(mPrimaryCallContext.getCall(), false);
+    }
+
+    updatePrimaryCallContext(call);
+  }
+
+  /**
+   * Handles new incoming calls by triggering a change in the primary call.
+   *
+   * @param oldState the old {@link InCallState}.
+   * @param newState the new {@link InCallState}.
+   * @param call the incoming call.
+   */
+  @Override
+  public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) {
+    log("onIncomingCall, OldState=" + oldState + " NewState=" + newState + " DialerCall=" + call);
+
+    if (areSame(call, mPrimaryCallContext)) {
+      return;
+    }
+
+    onPrimaryCallChanged(call);
+  }
+
+  /**
+   * Caches a reference to the primary call and stores its previous state.
+   *
+   * @param call The new primary call.
+   */
+  private void updatePrimaryCallContext(DialerCall call) {
+    if (call == null) {
+      mPrimaryCallContext = null;
+    } else if (mPrimaryCallContext != null) {
+      mPrimaryCallContext.update(call);
+    } else {
+      mPrimaryCallContext = new CallContext(call);
+    }
+  }
+
+  /**
+   * Called when UI goes in/out of the foreground.
+   *
+   * @param showing true if UI is in the foreground, false otherwise.
+   */
+  public void onUiShowing(boolean showing) {
+    if (mInCallPresenter == null) {
+      return;
+    }
+
+    final boolean isInCall = mInCallPresenter.getInCallState() == InCallState.INCALL;
+    if (showing) {
+      onResume(isInCall);
+    } else {
+      onPause(isInCall);
+    }
+  }
+
+  /**
+   * Called when UI is brought to the foreground. Sends a session modification request to resume the
+   * outgoing video.
+   *
+   * @param isInCall {@code true} if we are in an active call. A resume request is only sent to the
+   *     video provider if we are in a call.
+   */
+  private void onResume(boolean isInCall) {
+    log("onResume");
+
+    mIsInBackground = false;
+    if (canVideoPause(mPrimaryCallContext) && isInCall) {
+      sendRequest(mPrimaryCallContext.getCall(), true);
+    } else {
+      log("onResume. Ignoring...");
+    }
+  }
+
+  /**
+   * Called when UI is sent to the background. Sends a session modification request to pause the
+   * outgoing video.
+   *
+   * @param isInCall {@code true} if we are in an active call. A pause request is only sent to the
+   *     video provider if we are in a call.
+   */
+  private void onPause(boolean isInCall) {
+    log("onPause");
+
+    mIsInBackground = true;
+    if (canVideoPause(mPrimaryCallContext) && isInCall) {
+      sendRequest(mPrimaryCallContext.getCall(), false);
+    } else {
+      log("onPause, Ignoring...");
+    }
+  }
+
+  private void bringToForeground() {
+    if (mInCallPresenter != null) {
+      log("Bringing UI to foreground");
+      mInCallPresenter.bringToForeground(false);
+    } else {
+      loge("InCallPresenter is null. Cannot bring UI to foreground");
+    }
+  }
+
+  /**
+   * Sends Pause/Resume request.
+   *
+   * @param call DialerCall to be paused/resumed.
+   * @param resume If true resume request will be sent, otherwise pause request.
+   */
+  private void sendRequest(DialerCall call, boolean resume) {
+    // Check if this call supports pause/un-pause.
+    if (!call.can(android.telecom.Call.Details.CAPABILITY_CAN_PAUSE_VIDEO)) {
+      return;
+    }
+
+    if (resume) {
+      log("sending resume request, call=" + call);
+      call.getVideoCall().sendSessionModifyRequest(VideoUtils.makeVideoUnPauseProfile(call));
+    } else {
+      log("sending pause request, call=" + call);
+      call.getVideoCall().sendSessionModifyRequest(VideoUtils.makeVideoPauseProfile(call));
+    }
+  }
+
+  /**
+   * Logs a debug message.
+   *
+   * @param msg The message.
+   */
+  private void log(String msg) {
+    Log.d(this, TAG + msg);
+  }
+
+  /**
+   * Logs an error message.
+   *
+   * @param msg The message.
+   */
+  private void loge(String msg) {
+    Log.e(this, TAG + msg);
+  }
+
+  /** Keeps track of the current active/foreground call. */
+  private static class CallContext {
+
+    private int mState = State.INVALID;
+    private int mVideoState;
+    private DialerCall mCall;
+
+    public CallContext(@NonNull DialerCall call) {
+      Objects.requireNonNull(call);
+      update(call);
+    }
+
+    public void update(@NonNull DialerCall call) {
+      mCall = Objects.requireNonNull(call);
+      mState = call.getState();
+      mVideoState = call.getVideoState();
+    }
+
+    public int getState() {
+      return mState;
+    }
+
+    public int getVideoState() {
+      return mVideoState;
+    }
+
+    @Override
+    public String toString() {
+      return String.format(
+          "CallContext {CallId=%s, State=%s, VideoState=%d}", mCall.getId(), mState, mVideoState);
+    }
+
+    public DialerCall getCall() {
+      return mCall;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/bindings/AnswerBindings.java b/java/com/android/incallui/answer/bindings/AnswerBindings.java
new file mode 100644
index 0000000..f7a7a0a
--- /dev/null
+++ b/java/com/android/incallui/answer/bindings/AnswerBindings.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 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.answer.bindings;
+
+import com.android.incallui.answer.impl.AnswerFragment;
+import com.android.incallui.answer.protocol.AnswerScreen;
+
+/** Bindings for answer module. */
+public class AnswerBindings {
+
+  public static AnswerScreen createAnswerScreen(
+      String callId, int videoState, boolean isVideoUpgradeRequest) {
+    return AnswerFragment.newInstance(callId, videoState, isVideoUpgradeRequest);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/AffordanceHolderLayout.java b/java/com/android/incallui/answer/impl/AffordanceHolderLayout.java
new file mode 100644
index 0000000..0f93abe
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/AffordanceHolderLayout.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.support.annotation.Nullable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+import com.android.incallui.answer.impl.affordance.SwipeButtonHelper;
+import com.android.incallui.answer.impl.affordance.SwipeButtonHelper.Callback;
+import com.android.incallui.answer.impl.affordance.SwipeButtonView;
+import com.android.incallui.util.AccessibilityUtil;
+
+/** Layout that delegates touches to its SwipeButtonHelper */
+public class AffordanceHolderLayout extends FrameLayout {
+
+  private SwipeButtonHelper affordanceHelper;
+
+  private Callback affordanceCallback;
+
+  public AffordanceHolderLayout(Context context) {
+    this(context, null);
+  }
+
+  public AffordanceHolderLayout(Context context, AttributeSet attrs) {
+    this(context, attrs, 0);
+  }
+
+  public AffordanceHolderLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+    super(context, attrs, defStyleAttr);
+
+    affordanceHelper =
+        new SwipeButtonHelper(
+            new Callback() {
+              @Override
+              public void onAnimationToSideStarted(
+                  boolean rightPage, float translation, float vel) {
+                if (affordanceCallback != null) {
+                  affordanceCallback.onAnimationToSideStarted(rightPage, translation, vel);
+                }
+              }
+
+              @Override
+              public void onAnimationToSideEnded() {
+                if (affordanceCallback != null) {
+                  affordanceCallback.onAnimationToSideEnded();
+                }
+              }
+
+              @Override
+              public float getMaxTranslationDistance() {
+                if (affordanceCallback != null) {
+                  return affordanceCallback.getMaxTranslationDistance();
+                }
+                return 0;
+              }
+
+              @Override
+              public void onSwipingStarted(boolean rightIcon) {
+                if (affordanceCallback != null) {
+                  affordanceCallback.onSwipingStarted(rightIcon);
+                }
+              }
+
+              @Override
+              public void onSwipingAborted() {
+                if (affordanceCallback != null) {
+                  affordanceCallback.onSwipingAborted();
+                }
+              }
+
+              @Override
+              public void onIconClicked(boolean rightIcon) {
+                if (affordanceCallback != null) {
+                  affordanceCallback.onIconClicked(rightIcon);
+                }
+              }
+
+              @Nullable
+              @Override
+              public SwipeButtonView getLeftIcon() {
+                if (affordanceCallback != null) {
+                  return affordanceCallback.getLeftIcon();
+                }
+                return null;
+              }
+
+              @Nullable
+              @Override
+              public SwipeButtonView getRightIcon() {
+                if (affordanceCallback != null) {
+                  return affordanceCallback.getRightIcon();
+                }
+                return null;
+              }
+
+              @Nullable
+              @Override
+              public View getLeftPreview() {
+                if (affordanceCallback != null) {
+                  return affordanceCallback.getLeftPreview();
+                }
+                return null;
+              }
+
+              @Nullable
+              @Override
+              public View getRightPreview() {
+                if (affordanceCallback != null) {
+                  affordanceCallback.getRightPreview();
+                }
+                return null;
+              }
+
+              @Override
+              public float getAffordanceFalsingFactor() {
+                if (affordanceCallback != null) {
+                  return affordanceCallback.getAffordanceFalsingFactor();
+                }
+                return 1.0f;
+              }
+            },
+            context);
+  }
+
+  public void setAffordanceCallback(@Nullable Callback callback) {
+    affordanceCallback = callback;
+    affordanceHelper.init();
+  }
+
+  public void startHintAnimation(boolean rightIcon, @Nullable Runnable onFinishListener) {
+    affordanceHelper.startHintAnimation(rightIcon, onFinishListener);
+  }
+
+  public void animateHideLeftRightIcon() {
+    affordanceHelper.animateHideLeftRightIcon();
+  }
+
+  public void reset(boolean animate) {
+    affordanceHelper.reset(animate);
+  }
+
+  @Override
+  public boolean onInterceptTouchEvent(MotionEvent event) {
+    if (AccessibilityUtil.isTouchExplorationEnabled(getContext())) {
+      return false;
+    }
+    return affordanceHelper.onTouchEvent(event) || super.onInterceptTouchEvent(event);
+  }
+
+  @Override
+  public boolean onTouchEvent(MotionEvent event) {
+    return affordanceHelper.onTouchEvent(event) || super.onTouchEvent(event);
+  }
+
+  @Override
+  protected void onConfigurationChanged(Configuration newConfig) {
+    super.onConfigurationChanged(newConfig);
+    affordanceHelper.onConfigurationChanged();
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/AndroidManifest.xml b/java/com/android/incallui/answer/impl/AndroidManifest.xml
new file mode 100644
index 0000000..482c716
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.answer.impl">
+</manifest>
diff --git a/java/com/android/incallui/answer/impl/AnswerFragment.java b/java/com/android/incallui/answer/impl/AnswerFragment.java
new file mode 100644
index 0000000..98439ee
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/AnswerFragment.java
@@ -0,0 +1,981 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.Manifest.permission;
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.FloatRange;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.StringRes;
+import android.support.annotation.VisibleForTesting;
+import android.support.transition.TransitionManager;
+import android.support.v4.app.Fragment;
+import android.telecom.VideoProfile;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.AccessibilityDelegate;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver.OnGlobalLayoutListener;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
+import android.widget.ImageView;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.MathUtil;
+import com.android.dialer.compat.ActivityCompat;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.dialer.util.ViewUtil;
+import com.android.incallui.answer.impl.CreateCustomSmsDialogFragment.CreateCustomSmsHolder;
+import com.android.incallui.answer.impl.SmsBottomSheetFragment.SmsSheetHolder;
+import com.android.incallui.answer.impl.affordance.SwipeButtonHelper.Callback;
+import com.android.incallui.answer.impl.affordance.SwipeButtonView;
+import com.android.incallui.answer.impl.answermethod.AnswerMethod;
+import com.android.incallui.answer.impl.answermethod.AnswerMethodFactory;
+import com.android.incallui.answer.impl.answermethod.AnswerMethodHolder;
+import com.android.incallui.answer.impl.utils.Interpolators;
+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.VideoUtils;
+import com.android.incallui.contactgrid.ContactGridManager;
+import com.android.incallui.incall.protocol.ContactPhotoType;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.InCallScreenDelegateFactory;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import com.android.incallui.maps.StaticMapBinding;
+import com.android.incallui.sessiondata.AvatarPresenter;
+import com.android.incallui.sessiondata.MultimediaFragment;
+import com.android.incallui.util.AccessibilityUtil;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/** The new version of the incoming call screen. */
+@SuppressLint("ClickableViewAccessibility")
+public class AnswerFragment extends Fragment
+    implements AnswerScreen,
+        InCallScreen,
+        SmsSheetHolder,
+        CreateCustomSmsHolder,
+        AnswerMethodHolder,
+        MultimediaFragment.Holder {
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String ARG_CALL_ID = "call_id";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String ARG_VIDEO_STATE = "video_state";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String ARG_IS_VIDEO_UPGRADE_REQUEST = "is_video_upgrade_request";
+
+  private static final String STATE_HAS_ANIMATED_ENTRY = "hasAnimated";
+
+  private static final int HINT_SECONDARY_SHOW_DURATION_MILLIS = 5000;
+  private static final float ANIMATE_LERP_PROGRESS = 0.5f;
+  private static final int STATUS_BAR_DISABLE_RECENT = 0x01000000;
+  private static final int STATUS_BAR_DISABLE_HOME = 0x00200000;
+  private static final int STATUS_BAR_DISABLE_BACK = 0x00400000;
+
+  private static void fadeToward(View view, float newAlpha) {
+    view.setAlpha(MathUtil.lerp(view.getAlpha(), newAlpha, ANIMATE_LERP_PROGRESS));
+  }
+
+  private static void scaleToward(View view, float newScale) {
+    view.setScaleX(MathUtil.lerp(view.getScaleX(), newScale, ANIMATE_LERP_PROGRESS));
+    view.setScaleY(MathUtil.lerp(view.getScaleY(), newScale, ANIMATE_LERP_PROGRESS));
+  }
+
+  private AnswerScreenDelegate answerScreenDelegate;
+  private InCallScreenDelegate inCallScreenDelegate;
+
+  private View importanceBadge;
+  private SwipeButtonView secondaryButton;
+  private AffordanceHolderLayout affordanceHolderLayout;
+  // Use these flags to prevent user from clicking accept/reject buttons multiple times.
+  // We use separate flags because in some rare cases accepting a call may fail to join the room,
+  // and then user is stuck in the incoming call view until it times out. Two flags at least give
+  // the user a chance to get out of the CallActivity.
+  private boolean buttonAcceptClicked;
+  private boolean buttonRejectClicked;
+  private boolean hasAnimatedEntry;
+  private PrimaryInfo primaryInfo = PrimaryInfo.createEmptyPrimaryInfo();
+  private PrimaryCallState primaryCallState;
+  private ArrayList<CharSequence> textResponses;
+  private SmsBottomSheetFragment textResponsesFragment;
+  private CreateCustomSmsDialogFragment createCustomSmsDialogFragment;
+  private SecondaryBehavior secondaryBehavior = SecondaryBehavior.REJECT_WITH_SMS;
+  private ContactGridManager contactGridManager;
+  private AnswerVideoCallScreen answerVideoCallScreen;
+  private Handler handler = new Handler(Looper.getMainLooper());
+
+  private enum SecondaryBehavior {
+    REJECT_WITH_SMS(
+        R.drawable.quantum_ic_message_white_24,
+        R.string.a11y_description_incoming_call_reject_with_sms,
+        R.string.a11y_incoming_call_reject_with_sms,
+        R.string.call_incoming_swipe_to_decline_with_message) {
+      @Override
+      public void performAction(AnswerFragment fragment) {
+        fragment.showMessageMenu();
+      }
+    },
+
+    ANSWER_VIDEO_AS_AUDIO(
+        R.drawable.quantum_ic_videocam_off_white_24,
+        R.string.a11y_description_incoming_call_answer_video_as_audio,
+        R.string.a11y_incoming_call_answer_video_as_audio,
+        R.string.call_incoming_swipe_to_answer_video_as_audio) {
+      @Override
+      public void performAction(AnswerFragment fragment) {
+        fragment.acceptCallByUser(true /* answerVideoAsAudio */);
+      }
+    };
+
+    @DrawableRes public final int icon;
+    @StringRes public final int contentDescription;
+    @StringRes public final int accessibilityLabel;
+    @StringRes public final int hintText;
+
+    SecondaryBehavior(
+        @DrawableRes int icon,
+        @StringRes int contentDescription,
+        @StringRes int accessibilityLabel,
+        @StringRes int hintText) {
+      this.icon = icon;
+      this.contentDescription = contentDescription;
+      this.accessibilityLabel = accessibilityLabel;
+      this.hintText = hintText;
+    }
+
+    public abstract void performAction(AnswerFragment fragment);
+
+    public void applyToView(ImageView view) {
+      view.setImageResource(icon);
+      view.setContentDescription(view.getContext().getText(contentDescription));
+    }
+  }
+
+  private AccessibilityDelegate accessibilityDelegate =
+      new AccessibilityDelegate() {
+        @Override
+        public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
+          super.onInitializeAccessibilityNodeInfo(host, info);
+          if (host == secondaryButton) {
+            CharSequence label = getText(secondaryBehavior.accessibilityLabel);
+            info.addAction(new AccessibilityAction(AccessibilityNodeInfo.ACTION_CLICK, label));
+          }
+        }
+
+        @Override
+        public boolean performAccessibilityAction(View host, int action, Bundle args) {
+          if (action == AccessibilityNodeInfo.ACTION_CLICK) {
+            if (host == secondaryButton) {
+              performSecondaryButtonAction();
+              return true;
+            }
+          }
+          return super.performAccessibilityAction(host, action, args);
+        }
+      };
+
+  private Callback affordanceCallback =
+      new Callback() {
+        @Override
+        public void onAnimationToSideStarted(boolean rightPage, float translation, float vel) {}
+
+        @Override
+        public void onAnimationToSideEnded() {
+          performSecondaryButtonAction();
+        }
+
+        @Override
+        public float getMaxTranslationDistance() {
+          View view = getView();
+          if (view == null) {
+            return 0;
+          }
+          return (float) Math.hypot(view.getWidth(), view.getHeight());
+        }
+
+        @Override
+        public void onSwipingStarted(boolean rightIcon) {}
+
+        @Override
+        public void onSwipingAborted() {}
+
+        @Override
+        public void onIconClicked(boolean rightIcon) {
+          affordanceHolderLayout.startHintAnimation(rightIcon, null);
+          getAnswerMethod().setHintText(getText(secondaryBehavior.hintText));
+          handler.removeCallbacks(swipeHintRestoreTimer);
+          handler.postDelayed(swipeHintRestoreTimer, HINT_SECONDARY_SHOW_DURATION_MILLIS);
+        }
+
+        @Override
+        public SwipeButtonView getLeftIcon() {
+          return secondaryButton;
+        }
+
+        @Override
+        public SwipeButtonView getRightIcon() {
+          return null;
+        }
+
+        @Override
+        public View getLeftPreview() {
+          return null;
+        }
+
+        @Override
+        public View getRightPreview() {
+          return null;
+        }
+
+        @Override
+        public float getAffordanceFalsingFactor() {
+          return 1.0f;
+        }
+      };
+
+  private Runnable swipeHintRestoreTimer =
+      new Runnable() {
+        @Override
+        public void run() {
+          restoreSwipeHintTexts();
+        }
+      };
+
+  private void performSecondaryButtonAction() {
+    secondaryBehavior.performAction(this);
+  }
+
+  public static AnswerFragment newInstance(
+      String callId, int videoState, boolean isVideoUpgradeRequest) {
+    Bundle bundle = new Bundle();
+    bundle.putString(ARG_CALL_ID, Assert.isNotNull(callId));
+    bundle.putInt(ARG_VIDEO_STATE, videoState);
+    bundle.putBoolean(ARG_IS_VIDEO_UPGRADE_REQUEST, isVideoUpgradeRequest);
+
+    AnswerFragment instance = new AnswerFragment();
+    instance.setArguments(bundle);
+    return instance;
+  }
+
+  @Override
+  @NonNull
+  public String getCallId() {
+    return Assert.isNotNull(getArguments().getString(ARG_CALL_ID));
+  }
+
+  @Override
+  public int getVideoState() {
+    return getArguments().getInt(ARG_VIDEO_STATE);
+  }
+
+  @Override
+  public boolean isVideoUpgradeRequest() {
+    return getArguments().getBoolean(ARG_IS_VIDEO_UPGRADE_REQUEST);
+  }
+
+  @Override
+  public void setTextResponses(List<String> textResponses) {
+    if (isVideoCall()) {
+      LogUtil.i("AnswerFragment.setTextResponses", "no-op for video calls");
+    } else if (textResponses == null) {
+      LogUtil.i("AnswerFragment.setTextResponses", "no text responses, hiding secondary button");
+      this.textResponses = null;
+      secondaryButton.setVisibility(View.INVISIBLE);
+    } else if (ActivityCompat.isInMultiWindowMode(getActivity())) {
+      LogUtil.i("AnswerFragment.setTextResponses", "in multiwindow, hiding secondary button");
+      this.textResponses = null;
+      secondaryButton.setVisibility(View.INVISIBLE);
+    } else {
+      LogUtil.i("AnswerFragment.setTextResponses", "textResponses.size: " + textResponses.size());
+      this.textResponses = new ArrayList<CharSequence>(textResponses);
+      secondaryButton.setVisibility(View.VISIBLE);
+    }
+  }
+
+  private void initSecondaryButton() {
+    secondaryBehavior =
+        isVideoCall() ? SecondaryBehavior.ANSWER_VIDEO_AS_AUDIO : SecondaryBehavior.REJECT_WITH_SMS;
+    secondaryBehavior.applyToView(secondaryButton);
+
+    secondaryButton.setOnClickListener(
+        new OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            performSecondaryButtonAction();
+          }
+        });
+    secondaryButton.setClickable(AccessibilityUtil.isAccessibilityEnabled(getContext()));
+    secondaryButton.setFocusable(AccessibilityUtil.isAccessibilityEnabled(getContext()));
+    secondaryButton.setAccessibilityDelegate(accessibilityDelegate);
+
+    if (isVideoCall()) {
+      //noinspection WrongConstant
+      if (!isVideoUpgradeRequest() && VideoProfile.isTransmissionEnabled(getVideoState())) {
+        secondaryButton.setVisibility(View.VISIBLE);
+      } else {
+        secondaryButton.setVisibility(View.INVISIBLE);
+      }
+    }
+  }
+
+  @Override
+  public boolean hasPendingDialogs() {
+    boolean hasPendingDialogs =
+        textResponsesFragment != null || createCustomSmsDialogFragment != null;
+    LogUtil.i("AnswerFragment.hasPendingDialogs", "" + hasPendingDialogs);
+    return hasPendingDialogs;
+  }
+
+  @Override
+  public void dismissPendingDialogs() {
+    LogUtil.i("AnswerFragment.dismissPendingDialogs", null);
+    if (textResponsesFragment != null) {
+      textResponsesFragment.dismiss();
+      textResponsesFragment = null;
+    }
+
+    if (createCustomSmsDialogFragment != null) {
+      createCustomSmsDialogFragment.dismiss();
+      createCustomSmsDialogFragment = null;
+    }
+  }
+
+  @Override
+  public boolean isShowingLocationUi() {
+    Fragment fragment = getChildFragmentManager().findFragmentById(R.id.incall_location_holder);
+    return fragment != null && fragment.isVisible();
+  }
+
+  @Override
+  public void showLocationUi(@Nullable Fragment locationUi) {
+    boolean isShowing = isShowingLocationUi();
+    if (!isShowing && locationUi != null) {
+      // Show the location fragment.
+      getChildFragmentManager()
+          .beginTransaction()
+          .replace(R.id.incall_location_holder, locationUi)
+          .commitAllowingStateLoss();
+    } else if (isShowing && locationUi == null) {
+      // Hide the location fragment
+      Fragment fragment = getChildFragmentManager().findFragmentById(R.id.incall_location_holder);
+      getChildFragmentManager().beginTransaction().remove(fragment).commitAllowingStateLoss();
+    }
+  }
+
+  @Override
+  public Fragment getAnswerScreenFragment() {
+    return this;
+  }
+
+  private AnswerMethod getAnswerMethod() {
+    return ((AnswerMethod)
+        getChildFragmentManager().findFragmentById(R.id.answer_method_container));
+  }
+
+  @Override
+  public void setPrimary(PrimaryInfo primaryInfo) {
+    LogUtil.i("AnswerFragment.setPrimary", primaryInfo.toString());
+    this.primaryInfo = primaryInfo;
+    updatePrimaryUI();
+    updateImportanceBadgeVisibility();
+  }
+
+  private void updatePrimaryUI() {
+    if (getView() == null) {
+      return;
+    }
+    contactGridManager.setPrimary(primaryInfo);
+    getAnswerMethod().setShowIncomingWillDisconnect(primaryInfo.answeringDisconnectsOngoingCall);
+    getAnswerMethod()
+        .setContactPhoto(
+            primaryInfo.photoType == ContactPhotoType.CONTACT ? primaryInfo.photo : null);
+    updateDataFragment();
+
+    if (primaryInfo.shouldShowLocation) {
+      // Hide the avatar to make room for location
+      contactGridManager.setAvatarHidden(true);
+    }
+  }
+
+  private void updateDataFragment() {
+    if (!isAdded()) {
+      return;
+    }
+    Fragment current = getChildFragmentManager().findFragmentById(R.id.incall_data_container);
+    Fragment newFragment = null;
+
+    MultimediaData multimediaData = getSessionData();
+    if (multimediaData != null
+        && (!TextUtils.isEmpty(multimediaData.getSubject())
+            || (multimediaData.getImageUri() != null)
+            || (multimediaData.getLocation() != null && canShowMap()))) {
+      // Need message fragment
+      String subject = multimediaData.getSubject();
+      Uri imageUri = multimediaData.getImageUri();
+      Location location = multimediaData.getLocation();
+      if (!(current instanceof MultimediaFragment)
+          || !Objects.equals(((MultimediaFragment) current).getSubject(), subject)
+          || !Objects.equals(((MultimediaFragment) current).getImageUri(), imageUri)
+          || !Objects.equals(((MultimediaFragment) current).getLocation(), location)) {
+        // Needs replacement
+        newFragment =
+            MultimediaFragment.newInstance(
+                multimediaData, false /* isInteractive */, true /* showAvatar */);
+      }
+    } else if (shouldShowAvatar()) {
+      // Needs Avatar
+      if (!(current instanceof AvatarFragment)) {
+        // Needs replacement
+        newFragment = new AvatarFragment();
+      }
+    } else {
+      // Needs empty
+      if (current != null) {
+        getChildFragmentManager().beginTransaction().remove(current).commitNow();
+      }
+      contactGridManager.setAvatarImageView(null, 0, false);
+    }
+
+    if (newFragment != null) {
+      getChildFragmentManager()
+          .beginTransaction()
+          .replace(R.id.incall_data_container, newFragment)
+          .commitNow();
+    }
+  }
+
+  private boolean shouldShowAvatar() {
+    return !isVideoCall();
+  }
+
+  private boolean canShowMap() {
+    return StaticMapBinding.get(getActivity().getApplication()) != null;
+  }
+
+  @Override
+  public void updateAvatar(AvatarPresenter avatarContainer) {
+    contactGridManager.setAvatarImageView(
+        avatarContainer.getAvatarImageView(),
+        avatarContainer.getAvatarSize(),
+        avatarContainer.shouldShowAnonymousAvatar());
+  }
+
+  @Override
+  public void setSecondary(@NonNull SecondaryInfo secondaryInfo) {}
+
+  @Override
+  public void setCallState(@NonNull PrimaryCallState primaryCallState) {
+    LogUtil.i("AnswerFragment.setCallState", primaryCallState.toString());
+    this.primaryCallState = primaryCallState;
+    contactGridManager.setCallState(primaryCallState);
+  }
+
+  @Override
+  public void setEndCallButtonEnabled(boolean enabled, boolean animate) {}
+
+  @Override
+  public void showManageConferenceCallButton(boolean visible) {}
+
+  @Override
+  public boolean isManageConferenceVisible() {
+    return false;
+  }
+
+  @Override
+  public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+    contactGridManager.dispatchPopulateAccessibilityEvent(event);
+    // Add prompt of how to accept/decline call with swipe gesture.
+    if (AccessibilityUtil.isTouchExplorationEnabled(getContext())) {
+      event
+          .getText()
+          .add(getResources().getString(R.string.a11y_incoming_call_swipe_gesture_prompt));
+    }
+  }
+
+  @Override
+  public void showNoteSentToast() {}
+
+  @Override
+  public void updateInCallScreenColors() {}
+
+  @Override
+  public void onInCallScreenDialpadVisibilityChange(boolean isShowing) {}
+
+  @Override
+  public int getAnswerAndDialpadContainerResourceId() {
+    Assert.fail();
+    return 0;
+  }
+
+  @Override
+  public Fragment getInCallScreenFragment() {
+    return this;
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+  }
+
+  @Override
+  public View onCreateView(
+      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    Bundle arguments = getArguments();
+    Assert.checkState(arguments.containsKey(ARG_CALL_ID));
+    Assert.checkState(arguments.containsKey(ARG_VIDEO_STATE));
+    Assert.checkState(arguments.containsKey(ARG_IS_VIDEO_UPGRADE_REQUEST));
+
+    buttonAcceptClicked = false;
+    buttonRejectClicked = false;
+
+    View view = inflater.inflate(R.layout.fragment_incoming_call, container, false);
+    secondaryButton = (SwipeButtonView) view.findViewById(R.id.incoming_secondary_button);
+
+    affordanceHolderLayout = (AffordanceHolderLayout) view.findViewById(R.id.incoming_container);
+    affordanceHolderLayout.setAffordanceCallback(affordanceCallback);
+
+    importanceBadge = view.findViewById(R.id.incall_important_call_badge);
+    PillDrawable importanceBackground = new PillDrawable();
+    importanceBackground.setColor(getContext().getColor(android.R.color.white));
+    importanceBadge.setBackground(importanceBackground);
+    importanceBadge
+        .getViewTreeObserver()
+        .addOnGlobalLayoutListener(
+            new OnGlobalLayoutListener() {
+              @Override
+              public void onGlobalLayout() {
+                int leftRightPadding = importanceBadge.getHeight() / 2;
+                importanceBadge.setPadding(
+                    leftRightPadding,
+                    importanceBadge.getPaddingTop(),
+                    leftRightPadding,
+                    importanceBadge.getPaddingBottom());
+              }
+            });
+    updateImportanceBadgeVisibility();
+
+    boolean isVideoCall = isVideoCall();
+    contactGridManager = new ContactGridManager(view, null, 0, false /* showAnonymousAvatar */);
+
+    Fragment answerMethod =
+        getChildFragmentManager().findFragmentById(R.id.answer_method_container);
+    if (AnswerMethodFactory.needsReplacement(answerMethod)) {
+      getChildFragmentManager()
+          .beginTransaction()
+          .replace(
+              R.id.answer_method_container, AnswerMethodFactory.createAnswerMethod(getActivity()))
+          .commitNow();
+    }
+
+    answerScreenDelegate =
+        FragmentUtils.getParentUnsafe(this, AnswerScreenDelegateFactory.class)
+            .newAnswerScreenDelegate(this);
+
+    initSecondaryButton();
+
+    int flags = View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
+    if (!ActivityCompat.isInMultiWindowMode(getActivity())
+        && (getActivity().checkSelfPermission(permission.STATUS_BAR)
+            == PackageManager.PERMISSION_GRANTED)) {
+      LogUtil.i("AnswerFragment.onCreateView", "STATUS_BAR permission granted, disabling nav bar");
+      // These flags will suppress the alert that the activity is in full view mode
+      // during an incoming call on a fresh system/factory reset of the app
+      flags |= STATUS_BAR_DISABLE_BACK | STATUS_BAR_DISABLE_HOME | STATUS_BAR_DISABLE_RECENT;
+    }
+    view.setSystemUiVisibility(flags);
+    if (isVideoCall) {
+      if (VideoUtils.hasCameraPermissionAndAllowedByUser(getContext())) {
+        answerVideoCallScreen = new AnswerVideoCallScreen(this, view);
+      } else {
+        view.findViewById(R.id.videocall_video_off).setVisibility(View.VISIBLE);
+      }
+    }
+
+    return view;
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    FragmentUtils.checkParent(this, InCallScreenDelegateFactory.class);
+  }
+
+  @Override
+  public void onViewCreated(final View view, @Nullable Bundle savedInstanceState) {
+    super.onViewCreated(view, savedInstanceState);
+    createInCallScreenDelegate();
+    updateUI();
+
+    if (savedInstanceState == null || !savedInstanceState.getBoolean(STATE_HAS_ANIMATED_ENTRY)) {
+      ViewUtil.doOnPreDraw(view, false, this::animateEntry);
+    }
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    LogUtil.i("AnswerFragment.onResume", null);
+    inCallScreenDelegate.onInCallScreenResumed();
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    LogUtil.i("AnswerFragment.onStart", null);
+
+    updateUI();
+    if (answerVideoCallScreen != null) {
+      answerVideoCallScreen.onStart();
+    }
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    LogUtil.i("AnswerFragment.onStop", null);
+
+    handler.removeCallbacks(swipeHintRestoreTimer);
+    if (answerVideoCallScreen != null) {
+      answerVideoCallScreen.onStop();
+    }
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    LogUtil.i("AnswerFragment.onPause", null);
+  }
+
+  @Override
+  public void onDestroyView() {
+    LogUtil.i("AnswerFragment.onDestroyView", null);
+    if (answerVideoCallScreen != null) {
+      answerVideoCallScreen = null;
+    }
+    super.onDestroyView();
+    inCallScreenDelegate.onInCallScreenUnready();
+    answerScreenDelegate.onAnswerScreenUnready();
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle bundle) {
+    super.onSaveInstanceState(bundle);
+    bundle.putBoolean(STATE_HAS_ANIMATED_ENTRY, hasAnimatedEntry);
+  }
+
+  private void updateUI() {
+    if (getView() == null) {
+      return;
+    }
+
+    if (primaryInfo != null) {
+      updatePrimaryUI();
+    }
+    if (primaryCallState != null) {
+      contactGridManager.setCallState(primaryCallState);
+    }
+
+    restoreBackgroundMaskColor();
+  }
+
+  @Override
+  public boolean isVideoCall() {
+    return VideoUtils.isVideoCall(getVideoState());
+  }
+
+  @Override
+  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()) {
+      answerScreenDelegate.updateWindowBackgroundColor(answerProgress);
+    }
+
+    // Fade and scale contact name and video call text
+    float startDelay = .25f;
+    // Header progress is zero over positiveAdjustedProgress = [0, startDelay],
+    // linearly increases over (startDelay, 1] until reaching 1 when positiveAdjustedProgress = 1
+    float headerProgress = Math.max(0, (Math.abs(answerProgress) - 1) / (1 - startDelay) + 1);
+    fadeToward(contactGridManager.getContainerView(), 1 - headerProgress);
+    scaleToward(contactGridManager.getContainerView(), MathUtil.lerp(1f, .75f, headerProgress));
+
+    if (Math.abs(answerProgress) >= .0001) {
+      affordanceHolderLayout.animateHideLeftRightIcon();
+      handler.removeCallbacks(swipeHintRestoreTimer);
+      restoreSwipeHintTexts();
+    }
+  }
+
+  @Override
+  public void answerFromMethod() {
+    acceptCallByUser(false /* answerVideoAsAudio */);
+  }
+
+  @Override
+  public void rejectFromMethod() {
+    rejectCall();
+  }
+
+  @Override
+  public void resetAnswerProgress() {
+    affordanceHolderLayout.reset(true);
+    restoreBackgroundMaskColor();
+  }
+
+  private void animateEntry(@NonNull View rootView) {
+    contactGridManager.getContainerView().setAlpha(0f);
+    Animator alpha =
+        ObjectAnimator.ofFloat(contactGridManager.getContainerView(), View.ALPHA, 0, 1);
+    Animator topRow = createTranslation(rootView.findViewById(R.id.contactgrid_top_row));
+    Animator contactName = createTranslation(rootView.findViewById(R.id.contactgrid_contact_name));
+    Animator bottomRow = createTranslation(rootView.findViewById(R.id.contactgrid_bottom_row));
+    Animator important = createTranslation(importanceBadge);
+    Animator dataContainer = createTranslation(rootView.findViewById(R.id.incall_data_container));
+
+    AnimatorSet animatorSet = new AnimatorSet();
+    animatorSet
+        .play(alpha)
+        .with(topRow)
+        .with(contactName)
+        .with(bottomRow)
+        .with(important)
+        .with(dataContainer);
+    animatorSet.setDuration(getResources().getInteger(android.R.integer.config_longAnimTime));
+    animatorSet.addListener(
+        new AnimatorListenerAdapter() {
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            hasAnimatedEntry = true;
+          }
+        });
+    animatorSet.start();
+  }
+
+  private ObjectAnimator createTranslation(View view) {
+    float translationY = view.getTop() * 0.5f;
+    ObjectAnimator animator = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, translationY, 0);
+    animator.setInterpolator(Interpolators.LINEAR_OUT_SLOW_IN);
+    return animator;
+  }
+
+  private void acceptCallByUser(boolean answerVideoAsAudio) {
+    LogUtil.i("AnswerFragment.acceptCallByUser", answerVideoAsAudio ? " answerVideoAsAudio" : "");
+    if (!buttonAcceptClicked) {
+      int desiredVideoState = getVideoState();
+      if (answerVideoAsAudio) {
+        desiredVideoState = VideoProfile.STATE_AUDIO_ONLY;
+      }
+
+      // Notify the lower layer first to start signaling ASAP.
+      answerScreenDelegate.onAnswer(desiredVideoState);
+
+      buttonAcceptClicked = true;
+    }
+  }
+
+  private void rejectCall() {
+    LogUtil.i("AnswerFragment.rejectCall", null);
+    if (!buttonRejectClicked) {
+      Context context = getContext();
+      if (context == null) {
+        LogUtil.w(
+            "AnswerFragment.rejectCall",
+            "Null context when rejecting call. Logger call was skipped");
+      } else {
+        Logger.get(context)
+            .logImpression(DialerImpression.Type.REJECT_INCOMING_CALL_FROM_ANSWER_SCREEN);
+      }
+      buttonRejectClicked = true;
+      answerScreenDelegate.onReject();
+    }
+  }
+
+  private void restoreBackgroundMaskColor() {
+    answerScreenDelegate.updateWindowBackgroundColor(0);
+  }
+
+  private void restoreSwipeHintTexts() {
+    if (getAnswerMethod() != null) {
+      getAnswerMethod().setHintText(null);
+    }
+  }
+
+  private void showMessageMenu() {
+    LogUtil.i("AnswerFragment.showMessageMenu", "Show sms menu.");
+
+    textResponsesFragment = SmsBottomSheetFragment.newInstance(textResponses);
+    textResponsesFragment.show(getChildFragmentManager(), null);
+    secondaryButton
+        .animate()
+        .alpha(0)
+        .withEndAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                affordanceHolderLayout.reset(false);
+                secondaryButton.animate().alpha(1);
+              }
+            });
+  }
+
+  @Override
+  public void smsSelected(@Nullable CharSequence text) {
+    LogUtil.i("AnswerFragment.smsSelected", null);
+    textResponsesFragment = null;
+
+    if (text == null) {
+      createCustomSmsDialogFragment = CreateCustomSmsDialogFragment.newInstance();
+      createCustomSmsDialogFragment.show(getChildFragmentManager(), null);
+      return;
+    }
+
+    if (primaryCallState != null && canRejectCallWithSms()) {
+      rejectCall();
+      answerScreenDelegate.onRejectCallWithMessage(text.toString());
+    }
+  }
+
+  @Override
+  public void smsDismissed() {
+    LogUtil.i("AnswerFragment.smsDismissed", null);
+    textResponsesFragment = null;
+    answerScreenDelegate.onDismissDialog();
+  }
+
+  @Override
+  public void customSmsCreated(@NonNull CharSequence text) {
+    LogUtil.i("AnswerFragment.customSmsCreated", null);
+    createCustomSmsDialogFragment = null;
+    if (primaryCallState != null && canRejectCallWithSms()) {
+      rejectCall();
+      answerScreenDelegate.onRejectCallWithMessage(text.toString());
+    }
+  }
+
+  @Override
+  public void customSmsDismissed() {
+    LogUtil.i("AnswerFragment.customSmsDismissed", null);
+    createCustomSmsDialogFragment = null;
+    answerScreenDelegate.onDismissDialog();
+  }
+
+  private boolean canRejectCallWithSms() {
+    return primaryCallState != null
+        && !(primaryCallState.state == State.DISCONNECTED
+            || primaryCallState.state == State.DISCONNECTING
+            || primaryCallState.state == State.IDLE);
+  }
+
+  private void createInCallScreenDelegate() {
+    inCallScreenDelegate =
+        FragmentUtils.getParentUnsafe(this, InCallScreenDelegateFactory.class)
+            .newInCallScreenDelegate();
+    Assert.isNotNull(inCallScreenDelegate);
+    inCallScreenDelegate.onInCallScreenDelegateInit(this);
+    inCallScreenDelegate.onInCallScreenReady();
+  }
+
+  private void updateImportanceBadgeVisibility() {
+    if (!isAdded()) {
+      return;
+    }
+
+    if (!getResources().getBoolean(R.bool.answer_important_call_allowed)) {
+      importanceBadge.setVisibility(View.GONE);
+      return;
+    }
+
+    MultimediaData multimediaData = getSessionData();
+    boolean showImportant = multimediaData != null && multimediaData.isImportant();
+    TransitionManager.beginDelayedTransition((ViewGroup) importanceBadge.getParent());
+    // TODO (keyboardr): Change this back to being View.INVISIBLE once mocks are available to
+    // properly handle smaller screens
+    importanceBadge.setVisibility(showImportant ? View.VISIBLE : View.GONE);
+  }
+
+  @Nullable
+  private MultimediaData getSessionData() {
+    if (primaryInfo == null) {
+      return null;
+    }
+    return primaryInfo.multimediaData;
+  }
+
+  /** Shows the Avatar image if available. */
+  public static class AvatarFragment extends Fragment implements AvatarPresenter {
+
+    private ImageView avatarImageView;
+
+    @Nullable
+    @Override
+    public View onCreateView(
+        LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+      return layoutInflater.inflate(R.layout.fragment_avatar, viewGroup, false);
+    }
+
+    @Override
+    public void onViewCreated(View view, @Nullable Bundle bundle) {
+      super.onViewCreated(view, bundle);
+      avatarImageView = ((ImageView) view.findViewById(R.id.contactgrid_avatar));
+      FragmentUtils.getParentUnsafe(this, MultimediaFragment.Holder.class).updateAvatar(this);
+    }
+
+    @NonNull
+    @Override
+    public ImageView getAvatarImageView() {
+      return avatarImageView;
+    }
+
+    @Override
+    public int getAvatarSize() {
+      return getResources().getDimensionPixelSize(R.dimen.answer_avatar_size);
+    }
+
+    @Override
+    public boolean shouldShowAnonymousAvatar() {
+      return false;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/AnswerVideoCallScreen.java b/java/com/android/incallui/answer/impl/AnswerVideoCallScreen.java
new file mode 100644
index 0000000..0316a5f
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/AnswerVideoCallScreen.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.content.res.Configuration;
+import android.graphics.Point;
+import android.support.annotation.NonNull;
+import android.support.v4.app.Fragment;
+import android.view.TextureView;
+import android.view.View;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.video.protocol.VideoCallScreen;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+import com.android.incallui.video.protocol.VideoCallScreenDelegateFactory;
+import com.android.incallui.videosurface.bindings.VideoSurfaceBindings;
+
+/** Shows a video preview for an incoming call. */
+public class AnswerVideoCallScreen implements VideoCallScreen {
+  @NonNull private final Fragment fragment;
+  @NonNull private final TextureView textureView;
+  @NonNull private final VideoCallScreenDelegate delegate;
+
+  public AnswerVideoCallScreen(@NonNull Fragment fragment, @NonNull View view) {
+    this.fragment = fragment;
+
+    textureView =
+        Assert.isNotNull((TextureView) view.findViewById(R.id.incoming_preview_texture_view));
+    View overlayView =
+        Assert.isNotNull(view.findViewById(R.id.incoming_preview_texture_view_overlay));
+    view.setBackgroundColor(0xff000000);
+    delegate =
+        FragmentUtils.getParentUnsafe(fragment, VideoCallScreenDelegateFactory.class)
+            .newVideoCallScreenDelegate();
+    delegate.initVideoCallScreenDelegate(fragment.getContext(), this);
+
+    textureView.setVisibility(View.VISIBLE);
+    overlayView.setVisibility(View.VISIBLE);
+  }
+
+  public void onStart() {
+    LogUtil.i("AnswerVideoCallScreen.onStart", null);
+    delegate.onVideoCallScreenUiReady();
+    delegate.getLocalVideoSurfaceTexture().attachToTextureView(textureView);
+  }
+
+  public void onStop() {
+    LogUtil.i("AnswerVideoCallScreen.onStop", null);
+    delegate.onVideoCallScreenUiUnready();
+  }
+
+  @Override
+  public void showVideoViews(
+      boolean shouldShowPreview, boolean shouldShowRemote, boolean isRemotelyHeld) {
+    LogUtil.i(
+        "AnswerVideoCallScreen.showVideoViews",
+        "showPreview: %b, shouldShowRemote: %b",
+        shouldShowPreview,
+        shouldShowRemote);
+  }
+
+  @Override
+  public void onLocalVideoDimensionsChanged() {
+    LogUtil.i("AnswerVideoCallScreen.onLocalVideoDimensionsChanged", null);
+    updatePreviewVideoScaling();
+  }
+
+  @Override
+  public void onRemoteVideoDimensionsChanged() {}
+
+  @Override
+  public void onLocalVideoOrientationChanged() {
+    LogUtil.i("AnswerVideoCallScreen.onLocalVideoOrientationChanged", null);
+    updatePreviewVideoScaling();
+  }
+
+  @Override
+  public void updateFullscreenAndGreenScreenMode(
+      boolean shouldShowFullscreen, boolean shouldShowGreenScreen) {}
+
+  @Override
+  public Fragment getVideoCallScreenFragment() {
+    return fragment;
+  }
+
+  private void updatePreviewVideoScaling() {
+    if (textureView.getWidth() == 0 || textureView.getHeight() == 0) {
+      LogUtil.i(
+          "AnswerVideoCallScreen.updatePreviewVideoScaling", "view layout hasn't finished yet");
+      return;
+    }
+    Point cameraDimensions = delegate.getLocalVideoSurfaceTexture().getSurfaceDimensions();
+    if (cameraDimensions == null) {
+      LogUtil.i("AnswerVideoCallScreen.updatePreviewVideoScaling", "camera dimensions not set");
+      return;
+    }
+    if (isLandscape()) {
+      VideoSurfaceBindings.scaleVideoAndFillView(
+          textureView, cameraDimensions.x, cameraDimensions.y, delegate.getDeviceOrientation());
+    } else {
+      // Landscape, so dimensions are swapped
+      //noinspection SuspiciousNameCombination
+      VideoSurfaceBindings.scaleVideoAndFillView(
+          textureView, cameraDimensions.y, cameraDimensions.x, delegate.getDeviceOrientation());
+    }
+  }
+
+  private boolean isLandscape() {
+    return fragment.getResources().getConfiguration().orientation
+        == Configuration.ORIENTATION_LANDSCAPE;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/CreateCustomSmsDialogFragment.java b/java/com/android/incallui/answer/impl/CreateCustomSmsDialogFragment.java
new file mode 100644
index 0000000..b494092
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/CreateCustomSmsDialogFragment.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.DialogInterface.OnShowListener;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v7.app.AppCompatDialogFragment;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.View;
+import android.view.WindowManager.LayoutParams;
+import android.widget.Button;
+import android.widget.EditText;
+import com.android.dialer.common.FragmentUtils;
+
+/**
+ * Shows the dialog for users to enter a custom message when rejecting a call with an SMS message.
+ */
+public class CreateCustomSmsDialogFragment extends AppCompatDialogFragment {
+
+  private static final String ARG_ENTERED_TEXT = "enteredText";
+
+  private EditText editText;
+
+  public static CreateCustomSmsDialogFragment newInstance() {
+    return new CreateCustomSmsDialogFragment();
+  }
+
+  @NonNull
+  @Override
+  public Dialog onCreateDialog(Bundle savedInstanceState) {
+    super.onCreateDialog(savedInstanceState);
+    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+    View view = View.inflate(builder.getContext(), R.layout.fragment_custom_sms_dialog, null);
+    editText = (EditText) view.findViewById(R.id.custom_sms_input);
+    if (savedInstanceState != null) {
+      editText.setText(savedInstanceState.getCharSequence(ARG_ENTERED_TEXT));
+    }
+    builder
+        .setCancelable(true)
+        .setView(view)
+        .setPositiveButton(
+            R.string.call_incoming_custom_message_send,
+            new DialogInterface.OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialogInterface, int i) {
+                FragmentUtils.getParentUnsafe(
+                        CreateCustomSmsDialogFragment.this, CreateCustomSmsHolder.class)
+                    .customSmsCreated(editText.getText().toString().trim());
+                dismiss();
+              }
+            })
+        .setNegativeButton(
+            R.string.call_incoming_custom_message_cancel,
+            new DialogInterface.OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialogInterface, int i) {
+                dismiss();
+              }
+            })
+        .setOnCancelListener(
+            new OnCancelListener() {
+              @Override
+              public void onCancel(DialogInterface dialogInterface) {
+                dismiss();
+              }
+            })
+        .setTitle(R.string.call_incoming_respond_via_sms_custom_message);
+    final AlertDialog customMessagePopup = builder.create();
+    customMessagePopup.setOnShowListener(
+        new OnShowListener() {
+          @Override
+          public void onShow(DialogInterface dialogInterface) {
+            ((AlertDialog) dialogInterface)
+                .getButton(AlertDialog.BUTTON_POSITIVE)
+                .setEnabled(false);
+          }
+        });
+
+    editText.addTextChangedListener(
+        new TextWatcher() {
+          @Override
+          public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
+
+          @Override
+          public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
+
+          @Override
+          public void afterTextChanged(Editable editable) {
+            Button sendButton = customMessagePopup.getButton(DialogInterface.BUTTON_POSITIVE);
+            sendButton.setEnabled(editable != null && editable.toString().trim().length() != 0);
+          }
+        });
+    customMessagePopup.getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
+    customMessagePopup.getWindow().addFlags(LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+    return customMessagePopup;
+  }
+
+  @Override
+  public void onSaveInstanceState(@NonNull Bundle outState) {
+    super.onSaveInstanceState(outState);
+    outState.putCharSequence(ARG_ENTERED_TEXT, editText.getText());
+  }
+
+  @Override
+  public void onDismiss(DialogInterface dialogInterface) {
+    super.onDismiss(dialogInterface);
+    FragmentUtils.getParentUnsafe(this, CreateCustomSmsHolder.class).customSmsDismissed();
+  }
+
+  /** Call back for {@link CreateCustomSmsDialogFragment} */
+  public interface CreateCustomSmsHolder {
+
+    void customSmsCreated(@NonNull CharSequence text);
+
+    void customSmsDismissed();
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/PillDrawable.java b/java/com/android/incallui/answer/impl/PillDrawable.java
new file mode 100644
index 0000000..57d84c4
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/PillDrawable.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.graphics.Rect;
+import android.graphics.drawable.GradientDrawable;
+
+/** Draws a pill-shaped background */
+public class PillDrawable extends GradientDrawable {
+
+  public PillDrawable() {
+    super();
+    setShape(RECTANGLE);
+  }
+
+  @Override
+  protected void onBoundsChange(Rect r) {
+    super.onBoundsChange(r);
+    setCornerRadius(r.height() / 2);
+  }
+
+  @Override
+  public void setShape(int shape) {
+    if (shape != GradientDrawable.RECTANGLE) {
+      throw new UnsupportedOperationException("PillDrawable must be a rectangle");
+    }
+    super.setShape(shape);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/SmsBottomSheetFragment.java b/java/com/android/incallui/answer/impl/SmsBottomSheetFragment.java
new file mode 100644
index 0000000..085430e
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/SmsBottomSheetFragment.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2016 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.answer.impl;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.design.widget.BottomSheetDialogFragment;
+import android.view.ContextThemeWrapper;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.view.WindowManager;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import com.android.dialer.common.DpUtil;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Shows options for rejecting call with SMS */
+public class SmsBottomSheetFragment extends BottomSheetDialogFragment {
+
+  private static final String ARG_OPTIONS = "options";
+
+  public static SmsBottomSheetFragment newInstance(@Nullable ArrayList<CharSequence> options) {
+    SmsBottomSheetFragment fragment = new SmsBottomSheetFragment();
+    Bundle args = new Bundle();
+    args.putCharSequenceArrayList(ARG_OPTIONS, options);
+    fragment.setArguments(args);
+    return fragment;
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    LinearLayout layout = new LinearLayout(getContext());
+    layout.setOrientation(LinearLayout.VERTICAL);
+    List<CharSequence> items = getArguments().getCharSequenceArrayList(ARG_OPTIONS);
+    if (items != null) {
+      for (CharSequence item : items) {
+        layout.addView(newTextViewItem(item));
+      }
+    }
+    layout.addView(newTextViewItem(null));
+    layout.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
+    return layout;
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    FragmentUtils.checkParent(this, SmsSheetHolder.class);
+  }
+
+  @Override
+  public Dialog onCreateDialog(final Bundle savedInstanceState) {
+    LogUtil.i("SmsBottomSheetFragment.onCreateDialog", null);
+    Dialog dialog = super.onCreateDialog(savedInstanceState);
+    dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+    return dialog;
+  }
+
+  private TextView newTextViewItem(@Nullable final CharSequence text) {
+    int[] attrs = new int[] {android.R.attr.selectableItemBackground};
+    Context context = new ContextThemeWrapper(getContext(), getTheme());
+    TypedArray typedArray = context.obtainStyledAttributes(attrs);
+    Drawable background = typedArray.getDrawable(0);
+    //noinspection ResourceType
+    typedArray.recycle();
+
+    TextView textView = new TextView(context);
+    textView.setText(text == null ? getString(R.string.call_incoming_message_custom) : text);
+    int padding = (int) DpUtil.dpToPx(context, 16);
+    textView.setPadding(padding, padding, padding, padding);
+    textView.setBackground(background);
+    textView.setTextColor(context.getColor(R.color.blue_grey_100));
+    textView.setTextAppearance(R.style.TextAppearance_AppCompat_Widget_PopupMenu_Large);
+
+    LayoutParams params =
+        new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+    textView.setLayoutParams(params);
+
+    textView.setOnClickListener(
+        new OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            FragmentUtils.getParentUnsafe(SmsBottomSheetFragment.this, SmsSheetHolder.class)
+                .smsSelected(text);
+            dismiss();
+          }
+        });
+    return textView;
+  }
+
+  @Override
+  public int getTheme() {
+    return R.style.Theme_Design_Light_BottomSheetDialog;
+  }
+
+  @Override
+  public void onDismiss(DialogInterface dialogInterface) {
+    super.onDismiss(dialogInterface);
+    FragmentUtils.getParentUnsafe(this, SmsSheetHolder.class).smsDismissed();
+  }
+
+  /** Callback interface for {@link SmsBottomSheetFragment} */
+  public interface SmsSheetHolder {
+
+    void smsSelected(@Nullable CharSequence text);
+
+    void smsDismissed();
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/affordance/AndroidManifest.xml b/java/com/android/incallui/answer/impl/affordance/AndroidManifest.xml
new file mode 100644
index 0000000..960fd71
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/affordance/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.answer.impl.affordance">
+</manifest>
diff --git a/java/com/android/incallui/answer/impl/affordance/SwipeButtonHelper.java b/java/com/android/incallui/answer/impl/affordance/SwipeButtonHelper.java
new file mode 100644
index 0000000..62845b7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/affordance/SwipeButtonHelper.java
@@ -0,0 +1,642 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.affordance;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import com.android.incallui.answer.impl.utils.FlingAnimationUtils;
+import com.android.incallui.answer.impl.utils.Interpolators;
+
+/** A touch handler of the swipe buttons */
+public class SwipeButtonHelper {
+
+  public static final float SWIPE_RESTING_ALPHA_AMOUNT = 0.87f;
+  public static final long HINT_PHASE1_DURATION = 200;
+  private static final long HINT_PHASE2_DURATION = 350;
+  private static final float BACKGROUND_RADIUS_SCALE_FACTOR = 0.25f;
+  private static final int HINT_CIRCLE_OPEN_DURATION = 500;
+
+  private final Context context;
+  private final Callback callback;
+
+  private FlingAnimationUtils flingAnimationUtils;
+  private VelocityTracker velocityTracker;
+  private boolean swipingInProgress;
+  private float initialTouchX;
+  private float initialTouchY;
+  private float translation;
+  private float translationOnDown;
+  private int touchSlop;
+  private int minTranslationAmount;
+  private int minFlingVelocity;
+  private int hintGrowAmount;
+  @Nullable private SwipeButtonView leftIcon;
+  @Nullable private SwipeButtonView rightIcon;
+  private Animator swipeAnimator;
+  private int minBackgroundRadius;
+  private boolean motionCancelled;
+  private int touchTargetSize;
+  private View targetedView;
+  private boolean touchSlopExeeded;
+  private AnimatorListenerAdapter flingEndListener =
+      new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+          swipeAnimator = null;
+          swipingInProgress = false;
+          targetedView = null;
+        }
+      };
+  private Runnable animationEndRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          callback.onAnimationToSideEnded();
+        }
+      };
+
+  public SwipeButtonHelper(Callback callback, Context context) {
+    this.context = context;
+    this.callback = callback;
+    init();
+  }
+
+  public void init() {
+    initIcons();
+    updateIcon(
+        leftIcon,
+        0.0f,
+        leftIcon != null ? leftIcon.getRestingAlpha() : 0,
+        false,
+        false,
+        true,
+        false);
+    updateIcon(
+        rightIcon,
+        0.0f,
+        rightIcon != null ? rightIcon.getRestingAlpha() : 0,
+        false,
+        false,
+        true,
+        false);
+    initDimens();
+  }
+
+  private void initDimens() {
+    final ViewConfiguration configuration = ViewConfiguration.get(context);
+    touchSlop = configuration.getScaledPagingTouchSlop();
+    minFlingVelocity = configuration.getScaledMinimumFlingVelocity();
+    minTranslationAmount =
+        context.getResources().getDimensionPixelSize(R.dimen.answer_min_swipe_amount);
+    minBackgroundRadius =
+        context
+            .getResources()
+            .getDimensionPixelSize(R.dimen.answer_affordance_min_background_radius);
+    touchTargetSize =
+        context.getResources().getDimensionPixelSize(R.dimen.answer_affordance_touch_target_size);
+    hintGrowAmount =
+        context.getResources().getDimensionPixelSize(R.dimen.hint_grow_amount_sideways);
+    flingAnimationUtils = new FlingAnimationUtils(context, 0.4f);
+  }
+
+  private void initIcons() {
+    leftIcon = callback.getLeftIcon();
+    rightIcon = callback.getRightIcon();
+    updatePreviews();
+  }
+
+  public void updatePreviews() {
+    if (leftIcon != null) {
+      leftIcon.setPreviewView(callback.getLeftPreview());
+    }
+    if (rightIcon != null) {
+      rightIcon.setPreviewView(callback.getRightPreview());
+    }
+  }
+
+  public boolean onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+    if (motionCancelled && action != MotionEvent.ACTION_DOWN) {
+      return false;
+    }
+    final float y = event.getY();
+    final float x = event.getX();
+
+    boolean isUp = false;
+    switch (action) {
+      case MotionEvent.ACTION_DOWN:
+        View targetView = getIconAtPosition(x, y);
+        if (targetView == null || (targetedView != null && targetedView != targetView)) {
+          motionCancelled = true;
+          return false;
+        }
+        if (targetedView != null) {
+          cancelAnimation();
+        } else {
+          touchSlopExeeded = false;
+        }
+        startSwiping(targetView);
+        initialTouchX = x;
+        initialTouchY = y;
+        translationOnDown = translation;
+        initVelocityTracker();
+        trackMovement(event);
+        motionCancelled = false;
+        break;
+      case MotionEvent.ACTION_POINTER_DOWN:
+        motionCancelled = true;
+        endMotion(true /* forceSnapBack */, x, y);
+        break;
+      case MotionEvent.ACTION_MOVE:
+        trackMovement(event);
+        float xDist = x - initialTouchX;
+        float yDist = y - initialTouchY;
+        float distance = (float) Math.hypot(xDist, yDist);
+        if (!touchSlopExeeded && distance > touchSlop) {
+          touchSlopExeeded = true;
+        }
+        if (swipingInProgress) {
+          if (targetedView == rightIcon) {
+            distance = translationOnDown - distance;
+            distance = Math.min(0, distance);
+          } else {
+            distance = translationOnDown + distance;
+            distance = Math.max(0, distance);
+          }
+          setTranslation(distance, false /* isReset */, false /* animateReset */);
+        }
+        break;
+
+      case MotionEvent.ACTION_UP:
+        isUp = true;
+        //fallthrough_intended
+      case MotionEvent.ACTION_CANCEL:
+        boolean hintOnTheRight = targetedView == rightIcon;
+        trackMovement(event);
+        endMotion(!isUp, x, y);
+        if (!touchSlopExeeded && isUp) {
+          callback.onIconClicked(hintOnTheRight);
+        }
+        break;
+    }
+    return true;
+  }
+
+  private void startSwiping(View targetView) {
+    callback.onSwipingStarted(targetView == rightIcon);
+    swipingInProgress = true;
+    targetedView = targetView;
+  }
+
+  private View getIconAtPosition(float x, float y) {
+    if (leftSwipePossible() && isOnIcon(leftIcon, x, y)) {
+      return leftIcon;
+    }
+    if (rightSwipePossible() && isOnIcon(rightIcon, x, y)) {
+      return rightIcon;
+    }
+    return null;
+  }
+
+  public boolean isOnAffordanceIcon(float x, float y) {
+    return isOnIcon(leftIcon, x, y) || isOnIcon(rightIcon, x, y);
+  }
+
+  private boolean isOnIcon(View icon, float x, float y) {
+    float iconX = icon.getX() + icon.getWidth() / 2.0f;
+    float iconY = icon.getY() + icon.getHeight() / 2.0f;
+    double distance = Math.hypot(x - iconX, y - iconY);
+    return distance <= touchTargetSize / 2;
+  }
+
+  private void endMotion(boolean forceSnapBack, float lastX, float lastY) {
+    if (swipingInProgress) {
+      flingWithCurrentVelocity(forceSnapBack, lastX, lastY);
+    } else {
+      targetedView = null;
+    }
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+      velocityTracker = null;
+    }
+  }
+
+  private boolean rightSwipePossible() {
+    return rightIcon != null && rightIcon.getVisibility() == View.VISIBLE;
+  }
+
+  private boolean leftSwipePossible() {
+    return leftIcon != null && leftIcon.getVisibility() == View.VISIBLE;
+  }
+
+  public void startHintAnimation(boolean right, @Nullable Runnable onFinishedListener) {
+    cancelAnimation();
+    startHintAnimationPhase1(right, onFinishedListener);
+  }
+
+  private void startHintAnimationPhase1(
+      final boolean right, @Nullable final Runnable onFinishedListener) {
+    final SwipeButtonView targetView = right ? rightIcon : leftIcon;
+    ValueAnimator animator = getAnimatorToRadius(right, hintGrowAmount);
+    if (animator == null) {
+      if (onFinishedListener != null) {
+        onFinishedListener.run();
+      }
+      return;
+    }
+    animator.addListener(
+        new AnimatorListenerAdapter() {
+          private boolean mCancelled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            mCancelled = true;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            if (mCancelled) {
+              swipeAnimator = null;
+              targetedView = null;
+              if (onFinishedListener != null) {
+                onFinishedListener.run();
+              }
+            } else {
+              startUnlockHintAnimationPhase2(right, onFinishedListener);
+            }
+          }
+        });
+    animator.setInterpolator(Interpolators.LINEAR_OUT_SLOW_IN);
+    animator.setDuration(HINT_PHASE1_DURATION);
+    animator.start();
+    swipeAnimator = animator;
+    targetedView = targetView;
+  }
+
+  /** Phase 2: Move back. */
+  private void startUnlockHintAnimationPhase2(
+      boolean right, @Nullable final Runnable onFinishedListener) {
+    ValueAnimator animator = getAnimatorToRadius(right, 0);
+    if (animator == null) {
+      if (onFinishedListener != null) {
+        onFinishedListener.run();
+      }
+      return;
+    }
+    animator.addListener(
+        new AnimatorListenerAdapter() {
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            swipeAnimator = null;
+            targetedView = null;
+            if (onFinishedListener != null) {
+              onFinishedListener.run();
+            }
+          }
+        });
+    animator.setInterpolator(Interpolators.FAST_OUT_LINEAR_IN);
+    animator.setDuration(HINT_PHASE2_DURATION);
+    animator.setStartDelay(HINT_CIRCLE_OPEN_DURATION);
+    animator.start();
+    swipeAnimator = animator;
+  }
+
+  private ValueAnimator getAnimatorToRadius(final boolean right, int radius) {
+    final SwipeButtonView targetView = right ? rightIcon : leftIcon;
+    if (targetView == null) {
+      return null;
+    }
+    ValueAnimator animator = ValueAnimator.ofFloat(targetView.getCircleRadius(), radius);
+    animator.addUpdateListener(
+        new ValueAnimator.AnimatorUpdateListener() {
+          @Override
+          public void onAnimationUpdate(ValueAnimator animation) {
+            float newRadius = (float) animation.getAnimatedValue();
+            targetView.setCircleRadiusWithoutAnimation(newRadius);
+            float translation = getTranslationFromRadius(newRadius);
+            SwipeButtonHelper.this.translation = right ? -translation : translation;
+            updateIconsFromTranslation(targetView);
+          }
+        });
+    return animator;
+  }
+
+  private void cancelAnimation() {
+    if (swipeAnimator != null) {
+      swipeAnimator.cancel();
+    }
+  }
+
+  private void flingWithCurrentVelocity(boolean forceSnapBack, float lastX, float lastY) {
+    float vel = getCurrentVelocity(lastX, lastY);
+
+    // We snap back if the current translation is not far enough
+    boolean snapBack = isBelowFalsingThreshold();
+
+    // or if the velocity is in the opposite direction.
+    boolean velIsInWrongDirection = vel * translation < 0;
+    snapBack |= Math.abs(vel) > minFlingVelocity && velIsInWrongDirection;
+    vel = snapBack ^ velIsInWrongDirection ? 0 : vel;
+    fling(vel, snapBack || forceSnapBack, translation < 0);
+  }
+
+  private boolean isBelowFalsingThreshold() {
+    return Math.abs(translation) < Math.abs(translationOnDown) + getMinTranslationAmount();
+  }
+
+  private int getMinTranslationAmount() {
+    float factor = callback.getAffordanceFalsingFactor();
+    return (int) (minTranslationAmount * factor);
+  }
+
+  private void fling(float vel, final boolean snapBack, boolean right) {
+    float target =
+        right ? -callback.getMaxTranslationDistance() : callback.getMaxTranslationDistance();
+    target = snapBack ? 0 : target;
+
+    ValueAnimator animator = ValueAnimator.ofFloat(translation, target);
+    flingAnimationUtils.apply(animator, translation, target, vel);
+    animator.addUpdateListener(
+        new ValueAnimator.AnimatorUpdateListener() {
+          @Override
+          public void onAnimationUpdate(ValueAnimator animation) {
+            translation = (float) animation.getAnimatedValue();
+          }
+        });
+    animator.addListener(flingEndListener);
+    if (!snapBack) {
+      startFinishingCircleAnimation(vel * 0.375f, animationEndRunnable, right);
+      callback.onAnimationToSideStarted(right, translation, vel);
+    } else {
+      reset(true);
+    }
+    animator.start();
+    swipeAnimator = animator;
+    if (snapBack) {
+      callback.onSwipingAborted();
+    }
+  }
+
+  private void startFinishingCircleAnimation(
+      float velocity, Runnable mAnimationEndRunnable, boolean right) {
+    SwipeButtonView targetView = right ? rightIcon : leftIcon;
+    if (targetView != null) {
+      targetView.finishAnimation(velocity, mAnimationEndRunnable);
+    }
+  }
+
+  private void setTranslation(float translation, boolean isReset, boolean animateReset) {
+    translation = rightSwipePossible() ? translation : Math.max(0, translation);
+    translation = leftSwipePossible() ? translation : Math.min(0, translation);
+    float absTranslation = Math.abs(translation);
+    if (translation != this.translation || isReset) {
+      SwipeButtonView targetView = translation > 0 ? leftIcon : rightIcon;
+      SwipeButtonView otherView = translation > 0 ? rightIcon : leftIcon;
+      float alpha = absTranslation / getMinTranslationAmount();
+
+      // We interpolate the alpha of the other icons to 0
+      float fadeOutAlpha = 1.0f - alpha;
+      fadeOutAlpha = Math.max(fadeOutAlpha, 0.0f);
+
+      boolean animateIcons = isReset && animateReset;
+      boolean forceNoCircleAnimation = isReset && !animateReset;
+      float radius = getRadiusFromTranslation(absTranslation);
+      boolean slowAnimation = isReset && isBelowFalsingThreshold();
+      if (targetView != null) {
+        if (!isReset) {
+          updateIcon(
+              targetView,
+              radius,
+              alpha + fadeOutAlpha * targetView.getRestingAlpha(),
+              false,
+              false,
+              false,
+              false);
+        } else {
+          updateIcon(
+              targetView,
+              0.0f,
+              fadeOutAlpha * targetView.getRestingAlpha(),
+              animateIcons,
+              slowAnimation,
+              false,
+              forceNoCircleAnimation);
+        }
+      }
+      if (otherView != null) {
+        updateIcon(
+            otherView,
+            0.0f,
+            fadeOutAlpha * otherView.getRestingAlpha(),
+            animateIcons,
+            slowAnimation,
+            false,
+            forceNoCircleAnimation);
+      }
+
+      this.translation = translation;
+    }
+  }
+
+  private void updateIconsFromTranslation(SwipeButtonView targetView) {
+    float absTranslation = Math.abs(translation);
+    float alpha = absTranslation / getMinTranslationAmount();
+
+    // We interpolate the alpha of the other icons to 0
+    float fadeOutAlpha = 1.0f - alpha;
+    fadeOutAlpha = Math.max(0.0f, fadeOutAlpha);
+
+    // We interpolate the alpha of the targetView to 1
+    SwipeButtonView otherView = targetView == rightIcon ? leftIcon : rightIcon;
+    updateIconAlpha(targetView, alpha + fadeOutAlpha * targetView.getRestingAlpha(), false);
+    if (otherView != null) {
+      updateIconAlpha(otherView, fadeOutAlpha * otherView.getRestingAlpha(), false);
+    }
+  }
+
+  private float getTranslationFromRadius(float circleSize) {
+    float translation = (circleSize - minBackgroundRadius) / BACKGROUND_RADIUS_SCALE_FACTOR;
+    return translation > 0.0f ? translation + touchSlop : 0.0f;
+  }
+
+  private float getRadiusFromTranslation(float translation) {
+    if (translation <= touchSlop) {
+      return 0.0f;
+    }
+    return (translation - touchSlop) * BACKGROUND_RADIUS_SCALE_FACTOR + minBackgroundRadius;
+  }
+
+  public void animateHideLeftRightIcon() {
+    cancelAnimation();
+    updateIcon(rightIcon, 0f, 0f, true, false, false, false);
+    updateIcon(leftIcon, 0f, 0f, true, false, false, false);
+  }
+
+  private void updateIcon(
+      @Nullable SwipeButtonView view,
+      float circleRadius,
+      float alpha,
+      boolean animate,
+      boolean slowRadiusAnimation,
+      boolean force,
+      boolean forceNoCircleAnimation) {
+    if (view == null) {
+      return;
+    }
+    if (view.getVisibility() != View.VISIBLE && !force) {
+      return;
+    }
+    if (forceNoCircleAnimation) {
+      view.setCircleRadiusWithoutAnimation(circleRadius);
+    } else {
+      view.setCircleRadius(circleRadius, slowRadiusAnimation);
+    }
+    updateIconAlpha(view, alpha, animate);
+  }
+
+  private void updateIconAlpha(SwipeButtonView view, float alpha, boolean animate) {
+    float scale = getScale(alpha, view);
+    alpha = Math.min(1.0f, alpha);
+    view.setImageAlpha(alpha, animate);
+    view.setImageScale(scale, animate);
+  }
+
+  private float getScale(float alpha, SwipeButtonView icon) {
+    float scale = alpha / icon.getRestingAlpha() * 0.2f + SwipeButtonView.MIN_ICON_SCALE_AMOUNT;
+    return Math.min(scale, SwipeButtonView.MAX_ICON_SCALE_AMOUNT);
+  }
+
+  private void trackMovement(MotionEvent event) {
+    if (velocityTracker != null) {
+      velocityTracker.addMovement(event);
+    }
+  }
+
+  private void initVelocityTracker() {
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+    }
+    velocityTracker = VelocityTracker.obtain();
+  }
+
+  private float getCurrentVelocity(float lastX, float lastY) {
+    if (velocityTracker == null) {
+      return 0;
+    }
+    velocityTracker.computeCurrentVelocity(1000);
+    float aX = velocityTracker.getXVelocity();
+    float aY = velocityTracker.getYVelocity();
+    float bX = lastX - initialTouchX;
+    float bY = lastY - initialTouchY;
+    float bLen = (float) Math.hypot(bX, bY);
+    // Project the velocity onto the distance vector: a * b / |b|
+    float projectedVelocity = (aX * bX + aY * bY) / bLen;
+    if (targetedView == rightIcon) {
+      projectedVelocity = -projectedVelocity;
+    }
+    return projectedVelocity;
+  }
+
+  public void onConfigurationChanged() {
+    initDimens();
+    initIcons();
+  }
+
+  public void onRtlPropertiesChanged() {
+    initIcons();
+  }
+
+  public void reset(boolean animate) {
+    cancelAnimation();
+    setTranslation(0.0f, true, animate);
+    motionCancelled = true;
+    if (swipingInProgress) {
+      callback.onSwipingAborted();
+      swipingInProgress = false;
+    }
+  }
+
+  public boolean isSwipingInProgress() {
+    return swipingInProgress;
+  }
+
+  public void launchAffordance(boolean animate, boolean left) {
+    SwipeButtonView targetView = left ? leftIcon : rightIcon;
+    if (swipingInProgress || targetView == null) {
+      // We don't want to mess with the state if the user is actually swiping already.
+      return;
+    }
+    SwipeButtonView otherView = left ? rightIcon : leftIcon;
+    startSwiping(targetView);
+    if (animate) {
+      fling(0, false, !left);
+      updateIcon(otherView, 0.0f, 0, true, false, true, false);
+    } else {
+      callback.onAnimationToSideStarted(!left, translation, 0);
+      translation =
+          left ? callback.getMaxTranslationDistance() : callback.getMaxTranslationDistance();
+      updateIcon(otherView, 0.0f, 0.0f, false, false, true, false);
+      targetView.instantFinishAnimation();
+      flingEndListener.onAnimationEnd(null);
+      animationEndRunnable.run();
+    }
+  }
+
+  /** Callback interface for various actions */
+  public interface Callback {
+
+    /**
+     * Notifies the callback when an animation to a side page was started.
+     *
+     * @param rightPage Is the page animated to the right page?
+     */
+    void onAnimationToSideStarted(boolean rightPage, float translation, float vel);
+
+    /** Notifies the callback the animation to a side page has ended. */
+    void onAnimationToSideEnded();
+
+    float getMaxTranslationDistance();
+
+    void onSwipingStarted(boolean rightIcon);
+
+    void onSwipingAborted();
+
+    void onIconClicked(boolean rightIcon);
+
+    @Nullable
+    SwipeButtonView getLeftIcon();
+
+    @Nullable
+    SwipeButtonView getRightIcon();
+
+    @Nullable
+    View getLeftPreview();
+
+    @Nullable
+    View getRightPreview();
+
+    /** @return The factor the minimum swipe amount should be multiplied with. */
+    float getAffordanceFalsingFactor();
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/affordance/SwipeButtonView.java b/java/com/android/incallui/answer/impl/affordance/SwipeButtonView.java
new file mode 100644
index 0000000..46879ea
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/affordance/SwipeButtonView.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.affordance;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ArgbEvaluator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.Nullable;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewAnimationUtils;
+import android.view.animation.Interpolator;
+import android.widget.ImageView;
+import com.android.incallui.answer.impl.utils.FlingAnimationUtils;
+import com.android.incallui.answer.impl.utils.Interpolators;
+
+/** Button that allows swiping to trigger */
+public class SwipeButtonView extends ImageView {
+
+  private static final long CIRCLE_APPEAR_DURATION = 80;
+  private static final long CIRCLE_DISAPPEAR_MAX_DURATION = 200;
+  private static final long NORMAL_ANIMATION_DURATION = 200;
+  public static final float MAX_ICON_SCALE_AMOUNT = 1.5f;
+  public static final float MIN_ICON_SCALE_AMOUNT = 0.8f;
+
+  private final int minBackgroundRadius;
+  private final Paint circlePaint;
+  private final int inverseColor;
+  private final int normalColor;
+  private final ArgbEvaluator colorInterpolator;
+  private final FlingAnimationUtils flingAnimationUtils;
+  private float circleRadius;
+  private int centerX;
+  private int centerY;
+  private ValueAnimator circleAnimator;
+  private ValueAnimator alphaAnimator;
+  private ValueAnimator scaleAnimator;
+  private float circleStartValue;
+  private boolean circleWillBeHidden;
+  private int[] tempPoint = new int[2];
+  private float tmageScale = 1f;
+  private int circleColor;
+  private View previewView;
+  private float circleStartRadius;
+  private float maxCircleSize;
+  private Animator previewClipper;
+  private float restingAlpha = SwipeButtonHelper.SWIPE_RESTING_ALPHA_AMOUNT;
+  private boolean finishing;
+  private boolean launchingAffordance;
+
+  private AnimatorListenerAdapter clipEndListener =
+      new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+          previewClipper = null;
+        }
+      };
+  private AnimatorListenerAdapter circleEndListener =
+      new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+          circleAnimator = null;
+        }
+      };
+  private AnimatorListenerAdapter scaleEndListener =
+      new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+          scaleAnimator = null;
+        }
+      };
+  private AnimatorListenerAdapter alphaEndListener =
+      new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+          alphaAnimator = null;
+        }
+      };
+
+  public SwipeButtonView(Context context) {
+    this(context, null);
+  }
+
+  public SwipeButtonView(Context context, AttributeSet attrs) {
+    this(context, attrs, 0);
+  }
+
+  public SwipeButtonView(Context context, AttributeSet attrs, int defStyleAttr) {
+    this(context, attrs, defStyleAttr, 0);
+  }
+
+  public SwipeButtonView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+    super(context, attrs, defStyleAttr, defStyleRes);
+    circlePaint = new Paint();
+    circlePaint.setAntiAlias(true);
+    circleColor = 0xffffffff;
+    circlePaint.setColor(circleColor);
+
+    normalColor = 0xffffffff;
+    inverseColor = 0xff000000;
+    minBackgroundRadius =
+        context
+            .getResources()
+            .getDimensionPixelSize(R.dimen.answer_affordance_min_background_radius);
+    colorInterpolator = new ArgbEvaluator();
+    flingAnimationUtils = new FlingAnimationUtils(context, 0.3f);
+  }
+
+  @Override
+  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+    super.onLayout(changed, left, top, right, bottom);
+    centerX = getWidth() / 2;
+    centerY = getHeight() / 2;
+    maxCircleSize = getMaxCircleSize();
+  }
+
+  @Override
+  protected void onDraw(Canvas canvas) {
+    drawBackgroundCircle(canvas);
+    canvas.save();
+    canvas.scale(tmageScale, tmageScale, getWidth() / 2, getHeight() / 2);
+    super.onDraw(canvas);
+    canvas.restore();
+  }
+
+  public void setPreviewView(@Nullable View v) {
+    View oldPreviewView = previewView;
+    previewView = v;
+    if (previewView != null) {
+      previewView.setVisibility(launchingAffordance ? oldPreviewView.getVisibility() : INVISIBLE);
+    }
+  }
+
+  private void updateIconColor() {
+    Drawable drawable = getDrawable().mutate();
+    float alpha = circleRadius / minBackgroundRadius;
+    alpha = Math.min(1.0f, alpha);
+    int color = (int) colorInterpolator.evaluate(alpha, normalColor, inverseColor);
+    drawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP);
+  }
+
+  private void drawBackgroundCircle(Canvas canvas) {
+    if (circleRadius > 0 || finishing) {
+      updateCircleColor();
+      canvas.drawCircle(centerX, centerY, circleRadius, circlePaint);
+    }
+  }
+
+  private void updateCircleColor() {
+    float fraction =
+        0.5f
+            + 0.5f
+                * Math.max(
+                    0.0f,
+                    Math.min(
+                        1.0f, (circleRadius - minBackgroundRadius) / (0.5f * minBackgroundRadius)));
+    if (previewView != null && previewView.getVisibility() == VISIBLE) {
+      float finishingFraction =
+          1 - Math.max(0, circleRadius - circleStartRadius) / (maxCircleSize - circleStartRadius);
+      fraction *= finishingFraction;
+    }
+    int color =
+        Color.argb(
+            (int) (Color.alpha(circleColor) * fraction),
+            Color.red(circleColor),
+            Color.green(circleColor),
+            Color.blue(circleColor));
+    circlePaint.setColor(color);
+  }
+
+  public void finishAnimation(float velocity, @Nullable final Runnable mAnimationEndRunnable) {
+    cancelAnimator(circleAnimator);
+    cancelAnimator(previewClipper);
+    finishing = true;
+    circleStartRadius = circleRadius;
+    final float maxCircleSize = getMaxCircleSize();
+    Animator animatorToRadius;
+    animatorToRadius = getAnimatorToRadius(maxCircleSize);
+    flingAnimationUtils.applyDismissing(
+        animatorToRadius, circleRadius, maxCircleSize, velocity, maxCircleSize);
+    animatorToRadius.addListener(
+        new AnimatorListenerAdapter() {
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            if (mAnimationEndRunnable != null) {
+              mAnimationEndRunnable.run();
+            }
+            finishing = false;
+            circleRadius = maxCircleSize;
+            invalidate();
+          }
+        });
+    animatorToRadius.start();
+    setImageAlpha(0, true);
+    if (previewView != null) {
+      previewView.setVisibility(View.VISIBLE);
+      previewClipper =
+          ViewAnimationUtils.createCircularReveal(
+              previewView, getLeft() + centerX, getTop() + centerY, circleRadius, maxCircleSize);
+      flingAnimationUtils.applyDismissing(
+          previewClipper, circleRadius, maxCircleSize, velocity, maxCircleSize);
+      previewClipper.addListener(clipEndListener);
+      previewClipper.start();
+    }
+  }
+
+  public void instantFinishAnimation() {
+    cancelAnimator(previewClipper);
+    if (previewView != null) {
+      previewView.setClipBounds(null);
+      previewView.setVisibility(View.VISIBLE);
+    }
+    circleRadius = getMaxCircleSize();
+    setImageAlpha(0, false);
+    invalidate();
+  }
+
+  private float getMaxCircleSize() {
+    getLocationInWindow(tempPoint);
+    float rootWidth = getRootView().getWidth();
+    float width = tempPoint[0] + centerX;
+    width = Math.max(rootWidth - width, width);
+    float height = tempPoint[1] + centerY;
+    return (float) Math.hypot(width, height);
+  }
+
+  public void setCircleRadius(float circleRadius) {
+    setCircleRadius(circleRadius, false, false);
+  }
+
+  public void setCircleRadius(float circleRadius, boolean slowAnimation) {
+    setCircleRadius(circleRadius, slowAnimation, false);
+  }
+
+  public void setCircleRadiusWithoutAnimation(float circleRadius) {
+    cancelAnimator(circleAnimator);
+    setCircleRadius(circleRadius, false, true);
+  }
+
+  private void setCircleRadius(float circleRadius, boolean slowAnimation, boolean noAnimation) {
+
+    // Check if we need a new animation
+    boolean radiusHidden =
+        (circleAnimator != null && circleWillBeHidden)
+            || (circleAnimator == null && this.circleRadius == 0.0f);
+    boolean nowHidden = circleRadius == 0.0f;
+    boolean radiusNeedsAnimation = (radiusHidden != nowHidden) && !noAnimation;
+    if (!radiusNeedsAnimation) {
+      if (circleAnimator == null) {
+        this.circleRadius = circleRadius;
+        updateIconColor();
+        invalidate();
+        if (nowHidden) {
+          if (previewView != null) {
+            previewView.setVisibility(View.INVISIBLE);
+          }
+        }
+      } else if (!circleWillBeHidden) {
+
+        // We just update the end value
+        float diff = circleRadius - minBackgroundRadius;
+        PropertyValuesHolder[] values = circleAnimator.getValues();
+        values[0].setFloatValues(circleStartValue + diff, circleRadius);
+        circleAnimator.setCurrentPlayTime(circleAnimator.getCurrentPlayTime());
+      }
+    } else {
+      cancelAnimator(circleAnimator);
+      cancelAnimator(previewClipper);
+      ValueAnimator animator = getAnimatorToRadius(circleRadius);
+      Interpolator interpolator =
+          circleRadius == 0.0f
+              ? Interpolators.FAST_OUT_LINEAR_IN
+              : Interpolators.LINEAR_OUT_SLOW_IN;
+      animator.setInterpolator(interpolator);
+      long duration = 250;
+      if (!slowAnimation) {
+        float durationFactor =
+            Math.abs(this.circleRadius - circleRadius) / (float) minBackgroundRadius;
+        duration = (long) (CIRCLE_APPEAR_DURATION * durationFactor);
+        duration = Math.min(duration, CIRCLE_DISAPPEAR_MAX_DURATION);
+      }
+      animator.setDuration(duration);
+      animator.start();
+      if (previewView != null && previewView.getVisibility() == View.VISIBLE) {
+        previewView.setVisibility(View.VISIBLE);
+        previewClipper =
+            ViewAnimationUtils.createCircularReveal(
+                previewView,
+                getLeft() + centerX,
+                getTop() + centerY,
+                this.circleRadius,
+                circleRadius);
+        previewClipper.setInterpolator(interpolator);
+        previewClipper.setDuration(duration);
+        previewClipper.addListener(clipEndListener);
+        previewClipper.addListener(
+            new AnimatorListenerAdapter() {
+              @Override
+              public void onAnimationEnd(Animator animation) {
+                previewView.setVisibility(View.INVISIBLE);
+              }
+            });
+        previewClipper.start();
+      }
+    }
+  }
+
+  private ValueAnimator getAnimatorToRadius(float circleRadius) {
+    ValueAnimator animator = ValueAnimator.ofFloat(this.circleRadius, circleRadius);
+    circleAnimator = animator;
+    circleStartValue = this.circleRadius;
+    circleWillBeHidden = circleRadius == 0.0f;
+    animator.addUpdateListener(
+        new ValueAnimator.AnimatorUpdateListener() {
+          @Override
+          public void onAnimationUpdate(ValueAnimator animation) {
+            SwipeButtonView.this.circleRadius = (float) animation.getAnimatedValue();
+            updateIconColor();
+            invalidate();
+          }
+        });
+    animator.addListener(circleEndListener);
+    return animator;
+  }
+
+  private void cancelAnimator(Animator animator) {
+    if (animator != null) {
+      animator.cancel();
+    }
+  }
+
+  public void setImageScale(float imageScale, boolean animate) {
+    setImageScale(imageScale, animate, -1, null);
+  }
+
+  /**
+   * Sets the scale of the containing image
+   *
+   * @param imageScale The new Scale.
+   * @param animate Should an animation be performed
+   * @param duration If animate, whats the duration? When -1 we take the default duration
+   * @param interpolator If animate, whats the interpolator? When null we take the default
+   *     interpolator.
+   */
+  public void setImageScale(
+      float imageScale, boolean animate, long duration, @Nullable Interpolator interpolator) {
+    cancelAnimator(scaleAnimator);
+    if (!animate) {
+      tmageScale = imageScale;
+      invalidate();
+    } else {
+      ValueAnimator animator = ValueAnimator.ofFloat(tmageScale, imageScale);
+      scaleAnimator = animator;
+      animator.addUpdateListener(
+          new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+              tmageScale = (float) animation.getAnimatedValue();
+              invalidate();
+            }
+          });
+      animator.addListener(scaleEndListener);
+      if (interpolator == null) {
+        interpolator =
+            imageScale == 0.0f
+                ? Interpolators.FAST_OUT_LINEAR_IN
+                : Interpolators.LINEAR_OUT_SLOW_IN;
+      }
+      animator.setInterpolator(interpolator);
+      if (duration == -1) {
+        float durationFactor = Math.abs(tmageScale - imageScale) / (1.0f - MIN_ICON_SCALE_AMOUNT);
+        durationFactor = Math.min(1.0f, durationFactor);
+        duration = (long) (NORMAL_ANIMATION_DURATION * durationFactor);
+      }
+      animator.setDuration(duration);
+      animator.start();
+    }
+  }
+
+  public void setRestingAlpha(float alpha) {
+    restingAlpha = alpha;
+
+    // TODO: Handle the case an animation is playing.
+    setImageAlpha(alpha, false);
+  }
+
+  public float getRestingAlpha() {
+    return restingAlpha;
+  }
+
+  public void setImageAlpha(float alpha, boolean animate) {
+    setImageAlpha(alpha, animate, -1, null, null);
+  }
+
+  /**
+   * Sets the alpha of the containing image
+   *
+   * @param alpha The new alpha.
+   * @param animate Should an animation be performed
+   * @param duration If animate, whats the duration? When -1 we take the default duration
+   * @param interpolator If animate, whats the interpolator? When null we take the default
+   *     interpolator.
+   */
+  public void setImageAlpha(
+      float alpha,
+      boolean animate,
+      long duration,
+      @Nullable Interpolator interpolator,
+      @Nullable Runnable runnable) {
+    cancelAnimator(alphaAnimator);
+    alpha = launchingAffordance ? 0 : alpha;
+    int endAlpha = (int) (alpha * 255);
+    final Drawable background = getBackground();
+    if (!animate) {
+      if (background != null) {
+        background.mutate().setAlpha(endAlpha);
+      }
+      setImageAlpha(endAlpha);
+    } else {
+      int currentAlpha = getImageAlpha();
+      ValueAnimator animator = ValueAnimator.ofInt(currentAlpha, endAlpha);
+      alphaAnimator = animator;
+      animator.addUpdateListener(
+          new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+              int alpha = (int) animation.getAnimatedValue();
+              if (background != null) {
+                background.mutate().setAlpha(alpha);
+              }
+              setImageAlpha(alpha);
+            }
+          });
+      animator.addListener(alphaEndListener);
+      if (interpolator == null) {
+        interpolator =
+            alpha == 0.0f ? Interpolators.FAST_OUT_LINEAR_IN : Interpolators.LINEAR_OUT_SLOW_IN;
+      }
+      animator.setInterpolator(interpolator);
+      if (duration == -1) {
+        float durationFactor = Math.abs(currentAlpha - endAlpha) / 255f;
+        durationFactor = Math.min(1.0f, durationFactor);
+        duration = (long) (NORMAL_ANIMATION_DURATION * durationFactor);
+      }
+      animator.setDuration(duration);
+      if (runnable != null) {
+        animator.addListener(getEndListener(runnable));
+      }
+      animator.start();
+    }
+  }
+
+  private Animator.AnimatorListener getEndListener(final Runnable runnable) {
+    return new AnimatorListenerAdapter() {
+      boolean mCancelled;
+
+      @Override
+      public void onAnimationCancel(Animator animation) {
+        mCancelled = true;
+      }
+
+      @Override
+      public void onAnimationEnd(Animator animation) {
+        if (!mCancelled) {
+          runnable.run();
+        }
+      }
+    };
+  }
+
+  public float getCircleRadius() {
+    return circleRadius;
+  }
+
+  @Override
+  public boolean performClick() {
+    return isClickable() && super.performClick();
+  }
+
+  public void setLaunchingAffordance(boolean launchingAffordance) {
+    this.launchingAffordance = launchingAffordance;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/affordance/res/values/dimens.xml b/java/com/android/incallui/answer/impl/affordance/res/values/dimens.xml
new file mode 100644
index 0000000..71d014d
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/affordance/res/values/dimens.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_min_swipe_amount">110dp</dimen>
+  <dimen name="answer_affordance_min_background_radius">30dp</dimen>
+  <dimen name="answer_affordance_touch_target_size">120dp</dimen>
+  <dimen name="hint_grow_amount_sideways">60dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/AndroidManifest.xml b/java/com/android/incallui/answer/impl/answermethod/AndroidManifest.xml
new file mode 100644
index 0000000..9082407
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.answer.impl.answermethod">
+</manifest>
diff --git a/java/com/android/incallui/answer/impl/answermethod/AnswerMethod.java b/java/com/android/incallui/answer/impl/answermethod/AnswerMethod.java
new file mode 100644
index 0000000..5efd3f0
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/AnswerMethod.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import com.android.dialer.common.FragmentUtils;
+
+/** A fragment that can be used to answer/reject calls. */
+public abstract class AnswerMethod extends Fragment {
+
+  public abstract void setHintText(@Nullable CharSequence hintText);
+
+  public abstract void setShowIncomingWillDisconnect(boolean incomingWillDisconnect);
+
+  public void setContactPhoto(@Nullable Drawable contactPhoto) {
+    // default implementation does nothing. Only some AnswerMethods show a photo
+  }
+
+  protected AnswerMethodHolder getParent() {
+    return FragmentUtils.getParentUnsafe(this, AnswerMethodHolder.class);
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    FragmentUtils.checkParent(this, AnswerMethodHolder.class);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/AnswerMethodFactory.java b/java/com/android/incallui/answer/impl/answermethod/AnswerMethodFactory.java
new file mode 100644
index 0000000..35f36f7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/AnswerMethodFactory.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.app.Activity;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import com.android.dialer.compat.ActivityCompat;
+import com.android.incallui.util.AccessibilityUtil;
+
+/** Creates the appropriate {@link AnswerMethod} for the circumstances. */
+public class AnswerMethodFactory {
+
+  @NonNull
+  public static AnswerMethod createAnswerMethod(@NonNull Activity activity) {
+    if (needTwoButton(activity)) {
+      return new TwoButtonMethod();
+    } else {
+      return new FlingUpDownMethod();
+    }
+  }
+
+  public static boolean needsReplacement(@Nullable Fragment answerMethod) {
+    //noinspection SimplifiableIfStatement
+    if (answerMethod == null) {
+      return true;
+    }
+    // If we have already started showing TwoButtonMethod, we should keep showing TwoButtonMethod.
+    // Otherwise check if we need to change to TwoButtonMethod
+    return !(answerMethod instanceof TwoButtonMethod) && needTwoButton(answerMethod.getActivity());
+  }
+
+  private static boolean needTwoButton(@NonNull Activity activity) {
+    return AccessibilityUtil.isTouchExplorationEnabled(activity)
+        || ActivityCompat.isInMultiWindowMode(activity);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/AnswerMethodHolder.java b/java/com/android/incallui/answer/impl/answermethod/AnswerMethodHolder.java
new file mode 100644
index 0000000..4052281
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/AnswerMethodHolder.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.support.annotation.FloatRange;
+
+/** Defines callbacks {@link AnswerMethod AnswerMethods} may use to update their parent. */
+public interface AnswerMethodHolder {
+
+  /**
+   * Update animation based on method progress.
+   *
+   * @param answerProgress float representing progress. -1 is fully declined, 1 is fully answered,
+   *     and 0 is neutral.
+   */
+  void onAnswerProgressUpdate(@FloatRange(from = -1f, to = 1f) float answerProgress);
+
+  /** Answer the current call. */
+  void answerFromMethod();
+
+  /** Reject the current call. */
+  void rejectFromMethod();
+
+  /** Set AnswerProgress to zero (not due to normal updates). */
+  void resetAnswerProgress();
+
+  /**
+   * Check whether the current call is a video call.
+   *
+   * @return true iff the current call is a video call.
+   */
+  boolean isVideoCall();
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/FlingUpDownMethod.java b/java/com/android/incallui/answer/impl/answermethod/FlingUpDownMethod.java
new file mode 100644
index 0000000..0bc6581
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/FlingUpDownMethod.java
@@ -0,0 +1,1149 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.PorterDuff.Mode;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.support.annotation.ColorInt;
+import android.support.annotation.FloatRange;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import android.support.v4.graphics.ColorUtils;
+import android.support.v4.view.animation.FastOutLinearInInterpolator;
+import android.support.v4.view.animation.FastOutSlowInInterpolator;
+import android.support.v4.view.animation.LinearOutSlowInInterpolator;
+import android.support.v4.view.animation.PathInterpolatorCompat;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.AccessibilityDelegate;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
+import android.view.animation.BounceInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.widget.ImageView;
+import android.widget.TextView;
+import com.android.dialer.common.DpUtil;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.MathUtil;
+import com.android.dialer.util.DrawableConverter;
+import com.android.dialer.util.ViewUtil;
+import com.android.incallui.answer.impl.answermethod.FlingUpDownTouchHandler.OnProgressChangedListener;
+import com.android.incallui.answer.impl.classifier.FalsingManager;
+import com.android.incallui.answer.impl.hint.AnswerHint;
+import com.android.incallui.answer.impl.hint.AnswerHintFactory;
+import com.android.incallui.answer.impl.hint.EventPayloadLoaderImpl;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/** Answer method that swipes up to answer or down to reject. */
+@SuppressLint("ClickableViewAccessibility")
+public class FlingUpDownMethod extends AnswerMethod implements OnProgressChangedListener {
+
+  private static final float SWIPE_LERP_PROGRESS_FACTOR = 0.5f;
+  private static final long ANIMATE_DURATION_SHORT_MILLIS = 667;
+  private static final long ANIMATE_DURATION_NORMAL_MILLIS = 1_333;
+  private static final long ANIMATE_DURATION_LONG_MILLIS = 1_500;
+  private static final long BOUNCE_ANIMATION_DELAY = 167;
+  private static final long VIBRATION_TIME_MILLIS = 1_833;
+  private static final long SETTLE_ANIMATION_DURATION_MILLIS = 100;
+  private static final int HINT_JUMP_DP = 60;
+  private static final int HINT_DIP_DP = 8;
+  private static final float HINT_SCALE_RATIO = 1.15f;
+  private static final long SWIPE_TO_DECLINE_FADE_IN_DELAY_MILLIS = 333;
+  private static final int HINT_REJECT_SHOW_DURATION_MILLIS = 2000;
+  private static final int ICON_END_CALL_ROTATION_DEGREES = 135;
+  private static final int HINT_REJECT_FADE_TRANSLATION_Y_DP = -8;
+  private static final float SWIPE_TO_ANSWER_MAX_TRANSLATION_Y_DP = 150;
+  private static final int SWIPE_TO_REJECT_MAX_TRANSLATION_Y_DP = 24;
+
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef(
+    value = {
+      AnimationState.NONE,
+      AnimationState.ENTRY,
+      AnimationState.BOUNCE,
+      AnimationState.SWIPE,
+      AnimationState.SETTLE,
+      AnimationState.HINT,
+      AnimationState.COMPLETED
+    }
+  )
+  @VisibleForTesting
+  @interface AnimationState {
+
+    int NONE = 0;
+    int ENTRY = 1; // Entry animation for incoming call
+    int BOUNCE = 2; // An idle state in which text and icon slightly bounces off its base repeatedly
+    int SWIPE = 3; // A special state in which text and icon follows the finger movement
+    int SETTLE = 4; // A short animation to reset from swipe and prepare for hint or bounce
+    int HINT = 5; // Jump animation to suggest what to do
+    int COMPLETED = 6; // Animation loop completed. Occurs after user swipes beyond threshold
+  }
+
+  private static void moveTowardY(View view, float newY) {
+    view.setTranslationY(MathUtil.lerp(view.getTranslationY(), newY, SWIPE_LERP_PROGRESS_FACTOR));
+  }
+
+  private static void moveTowardX(View view, float newX) {
+    view.setTranslationX(MathUtil.lerp(view.getTranslationX(), newX, SWIPE_LERP_PROGRESS_FACTOR));
+  }
+
+  private static void fadeToward(View view, float newAlpha) {
+    view.setAlpha(MathUtil.lerp(view.getAlpha(), newAlpha, SWIPE_LERP_PROGRESS_FACTOR));
+  }
+
+  private static void rotateToward(View view, float newRotation) {
+    view.setRotation(MathUtil.lerp(view.getRotation(), newRotation, SWIPE_LERP_PROGRESS_FACTOR));
+  }
+
+  private TextView swipeToAnswerText;
+  private TextView swipeToRejectText;
+  private View contactPuckContainer;
+  private ImageView contactPuckBackground;
+  private ImageView contactPuckIcon;
+  private View incomingDisconnectText;
+  private Animator lockBounceAnim;
+  private AnimatorSet lockEntryAnim;
+  private AnimatorSet lockHintAnim;
+  private AnimatorSet lockSettleAnim;
+  @AnimationState private int animationState = AnimationState.NONE;
+  @AnimationState private int afterSettleAnimationState = AnimationState.NONE;
+  // a value for finger swipe progress. -1 or less for "reject"; 1 or more for "accept".
+  private float swipeProgress;
+  private Animator rejectHintHide;
+  private Animator vibrationAnimator;
+  private Drawable contactPhoto;
+  private boolean incomingWillDisconnect;
+  private FlingUpDownTouchHandler touchHandler;
+  private FalsingManager falsingManager;
+
+  private AnswerHint answerHint;
+
+  @Override
+  public void onCreate(@Nullable Bundle bundle) {
+    super.onCreate(bundle);
+    falsingManager = new FalsingManager(getContext());
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    falsingManager.onScreenOn();
+    if (getView() != null) {
+      if (animationState == AnimationState.SWIPE || animationState == AnimationState.HINT) {
+        swipeProgress = 0;
+        updateContactPuck();
+        onMoveReset(false);
+      } else if (animationState == AnimationState.ENTRY) {
+        // When starting from the lock screen, the activity may be stopped and started briefly.
+        // Don't let that interrupt the entry animation
+        startSwipeToAnswerEntryAnimation();
+      }
+    }
+  }
+
+  @Override
+  public void onStop() {
+    endAnimation();
+    falsingManager.onScreenOff();
+    if (getActivity().isFinishing()) {
+      setAnimationState(AnimationState.COMPLETED);
+    }
+    super.onStop();
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    View view = layoutInflater.inflate(R.layout.swipe_up_down_method, viewGroup, false);
+
+    contactPuckContainer = view.findViewById(R.id.incoming_call_puck_container);
+    contactPuckBackground = (ImageView) view.findViewById(R.id.incoming_call_puck_bg);
+    contactPuckIcon = (ImageView) view.findViewById(R.id.incoming_call_puck_icon);
+    swipeToAnswerText = (TextView) view.findViewById(R.id.incoming_swipe_to_answer_text);
+    swipeToRejectText = (TextView) view.findViewById(R.id.incoming_swipe_to_reject_text);
+    incomingDisconnectText = view.findViewById(R.id.incoming_will_disconnect_text);
+    incomingDisconnectText.setAlpha(incomingWillDisconnect ? 1 : 0);
+
+    view.setAccessibilityDelegate(
+        new AccessibilityDelegate() {
+          @Override
+          public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
+            super.onInitializeAccessibilityNodeInfo(host, info);
+            info.addAction(
+                new AccessibilityAction(
+                    R.id.accessibility_action_answer, getString(R.string.call_incoming_answer)));
+            info.addAction(
+                new AccessibilityAction(
+                    R.id.accessibility_action_decline, getString(R.string.call_incoming_decline)));
+          }
+
+          @Override
+          public boolean performAccessibilityAction(View host, int action, Bundle args) {
+            if (action == R.id.accessibility_action_answer) {
+              performAccept();
+              return true;
+            } else if (action == R.id.accessibility_action_decline) {
+              performReject();
+              return true;
+            }
+            return super.performAccessibilityAction(host, action, args);
+          }
+        });
+
+    swipeProgress = 0;
+
+    updateContactPuck();
+
+    touchHandler = FlingUpDownTouchHandler.attach(view, this, falsingManager);
+
+    answerHint =
+        new AnswerHintFactory(new EventPayloadLoaderImpl())
+            .create(getContext(), ANIMATE_DURATION_LONG_MILLIS, BOUNCE_ANIMATION_DELAY);
+    answerHint.onCreateView(
+        layoutInflater,
+        (ViewGroup) view.findViewById(R.id.hint_container),
+        contactPuckContainer,
+        swipeToAnswerText);
+    return view;
+  }
+
+  @Override
+  public void onViewCreated(View view, @Nullable Bundle bundle) {
+    super.onViewCreated(view, bundle);
+    setAnimationState(AnimationState.ENTRY);
+  }
+
+  @Override
+  public void onDestroyView() {
+    super.onDestroyView();
+    if (touchHandler != null) {
+      touchHandler.detach();
+      touchHandler = null;
+    }
+  }
+
+  @Override
+  public void onProgressChanged(@FloatRange(from = -1f, to = 1f) float progress) {
+    swipeProgress = progress;
+    if (animationState == AnimationState.SWIPE && getContext() != null && isVisible()) {
+      updateSwipeTextAndPuckForTouch();
+    }
+  }
+
+  @Override
+  public void onTrackingStart() {
+    setAnimationState(AnimationState.SWIPE);
+  }
+
+  @Override
+  public void onTrackingStopped() {}
+
+  @Override
+  public void onMoveReset(boolean showHint) {
+    if (showHint) {
+      showSwipeHint();
+    } else {
+      setAnimationState(AnimationState.BOUNCE);
+    }
+    resetTouchState();
+    getParent().resetAnswerProgress();
+  }
+
+  @Override
+  public void onMoveFinish(boolean accept) {
+    touchHandler.setTouchEnabled(false);
+    answerHint.onAnswered();
+    if (accept) {
+      performAccept();
+    } else {
+      performReject();
+    }
+  }
+
+  @Override
+  public boolean shouldUseFalsing(@NonNull MotionEvent downEvent) {
+    if (contactPuckContainer == null) {
+      return false;
+    }
+
+    float puckCenterX = contactPuckContainer.getX() + (contactPuckContainer.getWidth() / 2);
+    float puckCenterY = contactPuckContainer.getY() + (contactPuckContainer.getHeight() / 2);
+    double radius = contactPuckContainer.getHeight() / 2;
+
+    // Squaring a number is more performant than taking a sqrt, so we compare the square of the
+    // distance with the square of the radius.
+    double distSq =
+        Math.pow(downEvent.getX() - puckCenterX, 2) + Math.pow(downEvent.getY() - puckCenterY, 2);
+    return distSq >= Math.pow(radius, 2);
+  }
+
+  @Override
+  public void setContactPhoto(Drawable contactPhoto) {
+    this.contactPhoto = contactPhoto;
+
+    updateContactPuck();
+  }
+
+  private void updateContactPuck() {
+    if (contactPuckIcon == null) {
+      return;
+    }
+    if (getParent().isVideoCall()) {
+      contactPuckIcon.setImageResource(R.drawable.quantum_ic_videocam_white_24);
+    } else {
+      contactPuckIcon.setImageResource(R.drawable.quantum_ic_call_white_24);
+    }
+
+    int size =
+        contactPuckBackground
+            .getResources()
+            .getDimensionPixelSize(
+                shouldShowPhotoInPuck()
+                    ? R.dimen.answer_contact_puck_size_photo
+                    : R.dimen.answer_contact_puck_size_no_photo);
+    contactPuckBackground.setImageDrawable(
+        shouldShowPhotoInPuck()
+            ? makeRoundedDrawable(contactPuckBackground.getContext(), contactPhoto, size)
+            : null);
+    ViewGroup.LayoutParams contactPuckParams = contactPuckBackground.getLayoutParams();
+    contactPuckParams.height = size;
+    contactPuckParams.width = size;
+    contactPuckBackground.setLayoutParams(contactPuckParams);
+    contactPuckIcon.setAlpha(shouldShowPhotoInPuck() ? 0f : 1f);
+  }
+
+  private Drawable makeRoundedDrawable(Context context, Drawable contactPhoto, int size) {
+    return DrawableConverter.getRoundedDrawable(context, contactPhoto, size, size);
+  }
+
+  private boolean shouldShowPhotoInPuck() {
+    return getParent().isVideoCall() && contactPhoto != null;
+  }
+
+  @Override
+  public void setHintText(@Nullable CharSequence hintText) {
+    if (hintText == null) {
+      swipeToAnswerText.setText(R.string.call_incoming_swipe_to_answer);
+      swipeToRejectText.setText(R.string.call_incoming_swipe_to_reject);
+    } else {
+      swipeToAnswerText.setText(hintText);
+      swipeToRejectText.setText(null);
+    }
+  }
+
+  @Override
+  public void setShowIncomingWillDisconnect(boolean incomingWillDisconnect) {
+    this.incomingWillDisconnect = incomingWillDisconnect;
+    if (incomingDisconnectText != null) {
+      incomingDisconnectText.animate().alpha(incomingWillDisconnect ? 1 : 0);
+    }
+  }
+
+  private void showSwipeHint() {
+    setAnimationState(AnimationState.HINT);
+  }
+
+  private void updateSwipeTextAndPuckForTouch() {
+    // Clamp progress value between -1 and 1.
+    final float clampedProgress = MathUtil.clamp(swipeProgress, -1 /* min */, 1 /* max */);
+    final float positiveAdjustedProgress = Math.abs(clampedProgress);
+    final boolean isAcceptingFlow = clampedProgress >= 0;
+
+    // Cancel view property animators on views we're about to mutate
+    swipeToAnswerText.animate().cancel();
+    contactPuckIcon.animate().cancel();
+
+    // Since the animation progression is controlled by user gesture instead of real timeline, the
+    // spec timeline can be divided into 9 slots. Each slot is equivalent to 83ms in the spec.
+    // Therefore, we use 9 slots of 83ms to map user gesture into the spec timeline.
+    final float progressSlots = 9;
+
+    // Fade out the "swipe up to answer". It only takes 1 slot to complete the fade.
+    float swipeTextAlpha = Math.max(0, 1 - Math.abs(clampedProgress) * progressSlots);
+    fadeToward(swipeToAnswerText, swipeTextAlpha);
+    // Fade out the "swipe down to dismiss" at the same time. Don't ever increase its alpha
+    fadeToward(swipeToRejectText, Math.min(swipeTextAlpha, swipeToRejectText.getAlpha()));
+    // Fade out the "incoming will disconnect" text
+    fadeToward(incomingDisconnectText, incomingWillDisconnect ? swipeTextAlpha : 0);
+
+    // Move swipe text back to zero.
+    moveTowardX(swipeToAnswerText, 0 /* newX */);
+    moveTowardY(swipeToAnswerText, 0 /* newY */);
+
+    // Animate puck color
+    @ColorInt
+    int destPuckColor =
+        getContext()
+            .getColor(
+                isAcceptingFlow ? R.color.call_accept_background : R.color.call_hangup_background);
+    destPuckColor =
+        ColorUtils.setAlphaComponent(destPuckColor, (int) (0xFF * positiveAdjustedProgress));
+    contactPuckBackground.setBackgroundTintList(ColorStateList.valueOf(destPuckColor));
+    contactPuckBackground.setBackgroundTintMode(Mode.SRC_ATOP);
+    contactPuckBackground.setColorFilter(destPuckColor);
+
+    // Animate decline icon
+    if (isAcceptingFlow || getParent().isVideoCall()) {
+      rotateToward(contactPuckIcon, 0f);
+    } else {
+      rotateToward(contactPuckIcon, positiveAdjustedProgress * ICON_END_CALL_ROTATION_DEGREES);
+    }
+
+    // Fade in icon
+    if (shouldShowPhotoInPuck()) {
+      fadeToward(contactPuckIcon, positiveAdjustedProgress);
+    }
+    float iconProgress = Math.min(1f, positiveAdjustedProgress * 4);
+    @ColorInt
+    int iconColor =
+        ColorUtils.setAlphaComponent(
+            contactPuckIcon.getContext().getColor(R.color.incoming_answer_icon),
+            (int) (0xFF * (1 - iconProgress)));
+    contactPuckIcon.setImageTintList(ColorStateList.valueOf(iconColor));
+
+    // Move puck.
+    if (isAcceptingFlow) {
+      moveTowardY(
+          contactPuckContainer,
+          -clampedProgress * DpUtil.dpToPx(getContext(), SWIPE_TO_ANSWER_MAX_TRANSLATION_Y_DP));
+    } else {
+      moveTowardY(
+          contactPuckContainer,
+          -clampedProgress * DpUtil.dpToPx(getContext(), SWIPE_TO_REJECT_MAX_TRANSLATION_Y_DP));
+    }
+
+    getParent().onAnswerProgressUpdate(clampedProgress);
+  }
+
+  private void startSwipeToAnswerSwipeAnimation() {
+    LogUtil.i("FlingUpDownMethod.startSwipeToAnswerSwipeAnimation", "Start swipe animation.");
+    resetTouchState();
+    endAnimation();
+  }
+
+  private void setPuckTouchState() {
+    contactPuckBackground.setActivated(touchHandler.isTracking());
+  }
+
+  private void resetTouchState() {
+    if (getContext() == null) {
+      // State will be reset in onStart(), so just abort.
+      return;
+    }
+    contactPuckContainer.animate().scaleX(1 /* scaleX */);
+    contactPuckContainer.animate().scaleY(1 /* scaleY */);
+    contactPuckBackground.animate().scaleX(1 /* scaleX */);
+    contactPuckBackground.animate().scaleY(1 /* scaleY */);
+    contactPuckBackground.setBackgroundTintList(null);
+    contactPuckBackground.setColorFilter(null);
+    contactPuckIcon.setImageTintList(
+        ColorStateList.valueOf(getContext().getColor(R.color.incoming_answer_icon)));
+    contactPuckIcon.animate().rotation(0);
+
+    getParent().resetAnswerProgress();
+    setPuckTouchState();
+
+    final float alpha = 1;
+    swipeToAnswerText.animate().alpha(alpha);
+    contactPuckContainer.animate().alpha(alpha);
+    contactPuckBackground.animate().alpha(alpha);
+    contactPuckIcon.animate().alpha(shouldShowPhotoInPuck() ? 0 : alpha);
+  }
+
+  @VisibleForTesting
+  void setAnimationState(@AnimationState int state) {
+    if (state != AnimationState.HINT && animationState == state) {
+      return;
+    }
+
+    if (animationState == AnimationState.COMPLETED) {
+      LogUtil.e(
+          "FlingUpDownMethod.setAnimationState",
+          "Animation loop has completed. Cannot switch to new state: " + state);
+      return;
+    }
+
+    if (state == AnimationState.HINT || state == AnimationState.BOUNCE) {
+      if (animationState == AnimationState.SWIPE) {
+        afterSettleAnimationState = state;
+        state = AnimationState.SETTLE;
+      }
+    }
+
+    LogUtil.i("FlingUpDownMethod.setAnimationState", "animation state: " + state);
+    animationState = state;
+
+    // Start animation after the current one is finished completely.
+    View view = getView();
+    if (view != null) {
+      // As long as the fragment is added, we can start update the animation state.
+      if (isAdded() && (animationState == state)) {
+        updateAnimationState();
+      } else {
+        endAnimation();
+      }
+    }
+  }
+
+  @AnimationState
+  @VisibleForTesting
+  int getAnimationState() {
+    return animationState;
+  }
+
+  private void updateAnimationState() {
+    switch (animationState) {
+      case AnimationState.ENTRY:
+        startSwipeToAnswerEntryAnimation();
+        break;
+      case AnimationState.BOUNCE:
+        startSwipeToAnswerBounceAnimation();
+        break;
+      case AnimationState.SWIPE:
+        startSwipeToAnswerSwipeAnimation();
+        break;
+      case AnimationState.SETTLE:
+        startSwipeToAnswerSettleAnimation();
+        break;
+      case AnimationState.COMPLETED:
+        clearSwipeToAnswerUi();
+        break;
+      case AnimationState.HINT:
+        startSwipeToAnswerHintAnimation();
+        break;
+      case AnimationState.NONE:
+      default:
+        LogUtil.e(
+            "FlingUpDownMethod.updateAnimationState",
+            "Unexpected animation state: " + animationState);
+        break;
+    }
+  }
+
+  private void startSwipeToAnswerEntryAnimation() {
+    LogUtil.i("FlingUpDownMethod.startSwipeToAnswerEntryAnimation", "Swipe entry animation.");
+    endAnimation();
+
+    lockEntryAnim = new AnimatorSet();
+    Animator textUp =
+        ObjectAnimator.ofFloat(
+            swipeToAnswerText,
+            View.TRANSLATION_Y,
+            DpUtil.dpToPx(getContext(), 192 /* dp */),
+            DpUtil.dpToPx(getContext(), -20 /* dp */));
+    textUp.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+    textUp.setInterpolator(new LinearOutSlowInInterpolator());
+
+    Animator textDown =
+        ObjectAnimator.ofFloat(
+            swipeToAnswerText,
+            View.TRANSLATION_Y,
+            DpUtil.dpToPx(getContext(), -20) /* dp */,
+            0 /* end pos */);
+    textDown.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+    textUp.setInterpolator(new FastOutSlowInInterpolator());
+
+    // "Swipe down to reject" text fades in with a slight translation
+    swipeToRejectText.setAlpha(0f);
+    Animator rejectTextShow =
+        ObjectAnimator.ofPropertyValuesHolder(
+            swipeToRejectText,
+            PropertyValuesHolder.ofFloat(View.ALPHA, 1f),
+            PropertyValuesHolder.ofFloat(
+                View.TRANSLATION_Y,
+                DpUtil.dpToPx(getContext(), HINT_REJECT_FADE_TRANSLATION_Y_DP),
+                0f));
+    rejectTextShow.setInterpolator(new FastOutLinearInInterpolator());
+    rejectTextShow.setDuration(ANIMATE_DURATION_SHORT_MILLIS);
+    rejectTextShow.setStartDelay(SWIPE_TO_DECLINE_FADE_IN_DELAY_MILLIS);
+
+    Animator puckUp =
+        ObjectAnimator.ofFloat(
+            contactPuckContainer,
+            View.TRANSLATION_Y,
+            DpUtil.dpToPx(getContext(), 400 /* dp */),
+            DpUtil.dpToPx(getContext(), -12 /* dp */));
+    puckUp.setDuration(ANIMATE_DURATION_LONG_MILLIS);
+    puckUp.setInterpolator(
+        PathInterpolatorCompat.create(
+            0 /* controlX1 */, 0 /* controlY1 */, 0 /* controlX2 */, 1 /* controlY2 */));
+
+    Animator puckDown =
+        ObjectAnimator.ofFloat(
+            contactPuckContainer,
+            View.TRANSLATION_Y,
+            DpUtil.dpToPx(getContext(), -12 /* dp */),
+            0 /* end pos */);
+    puckDown.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+    puckDown.setInterpolator(new FastOutSlowInInterpolator());
+
+    Animator puckScaleUp =
+        createUniformScaleAnimators(
+            contactPuckBackground,
+            0.33f /* beginScale */,
+            1.1f /* endScale */,
+            ANIMATE_DURATION_NORMAL_MILLIS,
+            PathInterpolatorCompat.create(
+                0.4f /* controlX1 */, 0 /* controlY1 */, 0 /* controlX2 */, 1 /* controlY2 */));
+    Animator puckScaleDown =
+        createUniformScaleAnimators(
+            contactPuckBackground,
+            1.1f /* beginScale */,
+            1 /* endScale */,
+            ANIMATE_DURATION_NORMAL_MILLIS,
+            new FastOutSlowInInterpolator());
+
+    // Upward animation chain.
+    lockEntryAnim.play(textUp).with(puckScaleUp).with(puckUp);
+
+    // Downward animation chain.
+    lockEntryAnim.play(textDown).with(puckDown).with(puckScaleDown).after(puckUp);
+
+    lockEntryAnim.play(rejectTextShow).after(puckUp);
+
+    // Add vibration animation.
+    addVibrationAnimator(lockEntryAnim);
+
+    lockEntryAnim.addListener(
+        new AnimatorListenerAdapter() {
+
+          public boolean canceled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            super.onAnimationCancel(animation);
+            canceled = true;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            super.onAnimationEnd(animation);
+            if (!canceled) {
+              onEntryAnimationDone();
+            }
+          }
+        });
+    lockEntryAnim.start();
+  }
+
+  @VisibleForTesting
+  void onEntryAnimationDone() {
+    LogUtil.i("FlingUpDownMethod.onEntryAnimationDone", "Swipe entry anim ends.");
+    if (animationState == AnimationState.ENTRY) {
+      setAnimationState(AnimationState.BOUNCE);
+    }
+  }
+
+  private void startSwipeToAnswerBounceAnimation() {
+    LogUtil.i("FlingUpDownMethod.startSwipeToAnswerBounceAnimation", "Swipe bounce animation.");
+    endAnimation();
+
+    if (ViewUtil.areAnimationsDisabled(getContext())) {
+      swipeToAnswerText.setTranslationY(0);
+      contactPuckContainer.setTranslationY(0);
+      contactPuckBackground.setScaleY(1f);
+      contactPuckBackground.setScaleX(1f);
+      swipeToRejectText.setAlpha(1f);
+      swipeToRejectText.setTranslationY(0);
+      return;
+    }
+
+    lockBounceAnim = createBreatheAnimation();
+
+    answerHint.onBounceStart();
+    lockBounceAnim.addListener(
+        new AnimatorListenerAdapter() {
+          boolean firstPass = true;
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            super.onAnimationEnd(animation);
+            if (getContext() != null
+                && lockBounceAnim != null
+                && animationState == AnimationState.BOUNCE) {
+              // AnimatorSet doesn't have repeat settings. Instead, we start a new one after the
+              // previous set is completed, until endAnimation is called.
+              LogUtil.v("FlingUpDownMethod.onAnimationEnd", "Bounce again.");
+
+              // If this is the first time repeating the animation, we should recreate it so its
+              // starting values will be correct
+              if (firstPass) {
+                lockBounceAnim = createBreatheAnimation();
+                lockBounceAnim.addListener(this);
+              }
+              firstPass = false;
+              answerHint.onBounceStart();
+              lockBounceAnim.start();
+            }
+          }
+        });
+    lockBounceAnim.start();
+  }
+
+  private Animator createBreatheAnimation() {
+    AnimatorSet breatheAnimation = new AnimatorSet();
+    float textOffset = DpUtil.dpToPx(getContext(), 42 /* dp */);
+    Animator textUp =
+        ObjectAnimator.ofFloat(
+            swipeToAnswerText, View.TRANSLATION_Y, 0 /* begin pos */, -textOffset);
+    textUp.setInterpolator(new FastOutSlowInInterpolator());
+    textUp.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+
+    Animator textDown =
+        ObjectAnimator.ofFloat(swipeToAnswerText, View.TRANSLATION_Y, -textOffset, 0 /* end pos */);
+    textDown.setInterpolator(new FastOutSlowInInterpolator());
+    textDown.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+
+    // "Swipe down to reject" text fade in
+    Animator rejectTextShow = ObjectAnimator.ofFloat(swipeToRejectText, View.ALPHA, 1f);
+    rejectTextShow.setInterpolator(new LinearOutSlowInInterpolator());
+    rejectTextShow.setDuration(ANIMATE_DURATION_SHORT_MILLIS);
+    rejectTextShow.setStartDelay(SWIPE_TO_DECLINE_FADE_IN_DELAY_MILLIS);
+
+    // reject hint text translate in
+    Animator rejectTextTranslate =
+        ObjectAnimator.ofFloat(
+            swipeToRejectText,
+            View.TRANSLATION_Y,
+            DpUtil.dpToPx(getContext(), HINT_REJECT_FADE_TRANSLATION_Y_DP),
+            0f);
+    rejectTextTranslate.setInterpolator(new FastOutSlowInInterpolator());
+    rejectTextTranslate.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+
+    // reject hint text fade out
+    Animator rejectTextHide = ObjectAnimator.ofFloat(swipeToRejectText, View.ALPHA, 0f);
+    rejectTextHide.setInterpolator(new FastOutLinearInInterpolator());
+    rejectTextHide.setDuration(ANIMATE_DURATION_SHORT_MILLIS);
+
+    Interpolator curve =
+        PathInterpolatorCompat.create(
+            0.4f /* controlX1 */, 0 /* controlY1 */, 0 /* controlX2 */, 1 /* controlY2 */);
+    float puckOffset = DpUtil.dpToPx(getContext(), 42 /* dp */);
+    Animator puckUp = ObjectAnimator.ofFloat(contactPuckContainer, View.TRANSLATION_Y, -puckOffset);
+    puckUp.setInterpolator(curve);
+    puckUp.setDuration(ANIMATE_DURATION_LONG_MILLIS);
+
+    final float scale = 1.0625f;
+    Animator puckScaleUp =
+        createUniformScaleAnimators(
+            contactPuckBackground,
+            1 /* beginScale */,
+            scale,
+            ANIMATE_DURATION_NORMAL_MILLIS,
+            curve);
+
+    Animator puckDown =
+        ObjectAnimator.ofFloat(contactPuckContainer, View.TRANSLATION_Y, 0 /* end pos */);
+    puckDown.setInterpolator(new FastOutSlowInInterpolator());
+    puckDown.setDuration(ANIMATE_DURATION_NORMAL_MILLIS);
+
+    Animator puckScaleDown =
+        createUniformScaleAnimators(
+            contactPuckBackground,
+            scale,
+            1 /* endScale */,
+            ANIMATE_DURATION_NORMAL_MILLIS,
+            new FastOutSlowInInterpolator());
+
+    // Bounce upward animation chain.
+    breatheAnimation
+        .play(textUp)
+        .with(rejectTextHide)
+        .with(puckUp)
+        .with(puckScaleUp)
+        .after(167 /* delay */);
+
+    // Bounce downward animation chain.
+    breatheAnimation
+        .play(puckDown)
+        .with(textDown)
+        .with(puckScaleDown)
+        .with(rejectTextShow)
+        .with(rejectTextTranslate)
+        .after(puckUp);
+
+    // Add vibration animation to the animator set.
+    addVibrationAnimator(breatheAnimation);
+
+    return breatheAnimation;
+  }
+
+  private void startSwipeToAnswerSettleAnimation() {
+    endAnimation();
+
+    ObjectAnimator puckScale =
+        ObjectAnimator.ofPropertyValuesHolder(
+            contactPuckBackground,
+            PropertyValuesHolder.ofFloat(View.SCALE_X, 1),
+            PropertyValuesHolder.ofFloat(View.SCALE_Y, 1));
+    puckScale.setDuration(SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator iconRotation = ObjectAnimator.ofFloat(contactPuckIcon, View.ROTATION, 0);
+    iconRotation.setDuration(SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator swipeToAnswerTextFade =
+        createFadeAnimation(swipeToAnswerText, 1, SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator contactPuckContainerFade =
+        createFadeAnimation(contactPuckContainer, 1, SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator contactPuckBackgroundFade =
+        createFadeAnimation(contactPuckBackground, 1, SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator contactPuckIconFade =
+        createFadeAnimation(
+            contactPuckIcon, shouldShowPhotoInPuck() ? 0 : 1, SETTLE_ANIMATION_DURATION_MILLIS);
+
+    ObjectAnimator contactPuckTranslation =
+        ObjectAnimator.ofPropertyValuesHolder(
+            contactPuckContainer,
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_X, 0),
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, 0));
+    contactPuckTranslation.setDuration(SETTLE_ANIMATION_DURATION_MILLIS);
+
+    lockSettleAnim = new AnimatorSet();
+    lockSettleAnim
+        .play(puckScale)
+        .with(iconRotation)
+        .with(swipeToAnswerTextFade)
+        .with(contactPuckContainerFade)
+        .with(contactPuckBackgroundFade)
+        .with(contactPuckIconFade)
+        .with(contactPuckTranslation);
+
+    lockSettleAnim.addListener(
+        new AnimatorListenerAdapter() {
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            afterSettleAnimationState = AnimationState.NONE;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            onSettleAnimationDone();
+          }
+        });
+
+    lockSettleAnim.start();
+  }
+
+  @VisibleForTesting
+  void onSettleAnimationDone() {
+    if (afterSettleAnimationState != AnimationState.NONE) {
+      int nextState = afterSettleAnimationState;
+      afterSettleAnimationState = AnimationState.NONE;
+      lockSettleAnim = null;
+
+      setAnimationState(nextState);
+    }
+  }
+
+  private ObjectAnimator createFadeAnimation(View target, float targetAlpha, long duration) {
+    ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(target, View.ALPHA, targetAlpha);
+    objectAnimator.setDuration(duration);
+    return objectAnimator;
+  }
+
+  private void startSwipeToAnswerHintAnimation() {
+    if (rejectHintHide != null) {
+      rejectHintHide.cancel();
+    }
+
+    endAnimation();
+    resetTouchState();
+
+    if (ViewUtil.areAnimationsDisabled(getContext())) {
+      onHintAnimationDone(false);
+      return;
+    }
+
+    lockHintAnim = new AnimatorSet();
+    float jumpOffset = DpUtil.dpToPx(getContext(), HINT_JUMP_DP);
+    float dipOffset = DpUtil.dpToPx(getContext(), HINT_DIP_DP);
+    float scaleSize = HINT_SCALE_RATIO;
+    float textOffset = jumpOffset + (scaleSize - 1) * contactPuckBackground.getHeight();
+    int shortAnimTime =
+        getContext().getResources().getInteger(android.R.integer.config_shortAnimTime);
+    int mediumAnimTime =
+        getContext().getResources().getInteger(android.R.integer.config_mediumAnimTime);
+
+    // Puck squashes to anticipate jump
+    ObjectAnimator puckAnticipate =
+        ObjectAnimator.ofPropertyValuesHolder(
+            contactPuckContainer,
+            PropertyValuesHolder.ofFloat(View.SCALE_Y, .95f),
+            PropertyValuesHolder.ofFloat(View.SCALE_X, 1.05f));
+    puckAnticipate.setRepeatCount(1);
+    puckAnticipate.setRepeatMode(ValueAnimator.REVERSE);
+    puckAnticipate.setDuration(shortAnimTime / 2);
+    puckAnticipate.setInterpolator(new DecelerateInterpolator());
+    puckAnticipate.addListener(
+        new AnimatorListenerAdapter() {
+          @Override
+          public void onAnimationStart(Animator animation) {
+            super.onAnimationStart(animation);
+            contactPuckContainer.setPivotY(contactPuckContainer.getHeight());
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            super.onAnimationEnd(animation);
+            contactPuckContainer.setPivotY(contactPuckContainer.getHeight() / 2);
+          }
+        });
+
+    // Ensure puck is at the right starting point for the jump
+    ObjectAnimator puckResetTranslation =
+        ObjectAnimator.ofPropertyValuesHolder(
+            contactPuckContainer,
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, 0),
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_X, 0));
+    puckResetTranslation.setDuration(shortAnimTime / 2);
+    puckAnticipate.setInterpolator(new DecelerateInterpolator());
+
+    Animator textUp = ObjectAnimator.ofFloat(swipeToAnswerText, View.TRANSLATION_Y, -textOffset);
+    textUp.setInterpolator(new LinearOutSlowInInterpolator());
+    textUp.setDuration(shortAnimTime);
+
+    Animator puckUp = ObjectAnimator.ofFloat(contactPuckContainer, View.TRANSLATION_Y, -jumpOffset);
+    puckUp.setInterpolator(new LinearOutSlowInInterpolator());
+    puckUp.setDuration(shortAnimTime);
+
+    Animator puckScaleUp =
+        createUniformScaleAnimators(
+            contactPuckBackground, 1f, scaleSize, shortAnimTime, new LinearOutSlowInInterpolator());
+
+    Animator rejectHintShow =
+        ObjectAnimator.ofPropertyValuesHolder(
+            swipeToRejectText,
+            PropertyValuesHolder.ofFloat(View.ALPHA, 1f),
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, 0f));
+    rejectHintShow.setDuration(shortAnimTime);
+
+    Animator rejectHintDip =
+        ObjectAnimator.ofFloat(swipeToRejectText, View.TRANSLATION_Y, dipOffset);
+    rejectHintDip.setInterpolator(new LinearOutSlowInInterpolator());
+    rejectHintDip.setDuration(shortAnimTime);
+
+    Animator textDown = ObjectAnimator.ofFloat(swipeToAnswerText, View.TRANSLATION_Y, 0);
+    textDown.setInterpolator(new LinearOutSlowInInterpolator());
+    textDown.setDuration(mediumAnimTime);
+
+    Animator puckDown = ObjectAnimator.ofFloat(contactPuckContainer, View.TRANSLATION_Y, 0);
+    BounceInterpolator bounce = new BounceInterpolator();
+    puckDown.setInterpolator(bounce);
+    puckDown.setDuration(mediumAnimTime);
+
+    Animator puckScaleDown =
+        createUniformScaleAnimators(
+            contactPuckBackground, scaleSize, 1f, shortAnimTime, new LinearOutSlowInInterpolator());
+
+    Animator rejectHintUp = ObjectAnimator.ofFloat(swipeToRejectText, View.TRANSLATION_Y, 0);
+    rejectHintUp.setInterpolator(new LinearOutSlowInInterpolator());
+    rejectHintUp.setDuration(mediumAnimTime);
+
+    lockHintAnim.play(puckAnticipate).with(puckResetTranslation).before(puckUp);
+    lockHintAnim
+        .play(textUp)
+        .with(puckUp)
+        .with(puckScaleUp)
+        .with(rejectHintDip)
+        .with(rejectHintShow);
+    lockHintAnim.play(textDown).with(puckDown).with(puckScaleDown).with(rejectHintUp).after(puckUp);
+    lockHintAnim.start();
+
+    rejectHintHide = ObjectAnimator.ofFloat(swipeToRejectText, View.ALPHA, 0);
+    rejectHintHide.setStartDelay(HINT_REJECT_SHOW_DURATION_MILLIS);
+    rejectHintHide.addListener(
+        new AnimatorListenerAdapter() {
+
+          private boolean canceled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            super.onAnimationCancel(animation);
+            canceled = true;
+            rejectHintHide = null;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            super.onAnimationEnd(animation);
+            onHintAnimationDone(canceled);
+          }
+        });
+    rejectHintHide.start();
+  }
+
+  @VisibleForTesting
+  void onHintAnimationDone(boolean canceled) {
+    if (!canceled && animationState == AnimationState.HINT) {
+      setAnimationState(AnimationState.BOUNCE);
+    }
+    rejectHintHide = null;
+  }
+
+  private void clearSwipeToAnswerUi() {
+    LogUtil.i("FlingUpDownMethod.clearSwipeToAnswerUi", "Clear swipe animation.");
+    endAnimation();
+    swipeToAnswerText.setVisibility(View.GONE);
+    contactPuckContainer.setVisibility(View.GONE);
+  }
+
+  private void endAnimation() {
+    LogUtil.i("FlingUpDownMethod.endAnimation", "End animations.");
+    if (lockSettleAnim != null) {
+      lockSettleAnim.cancel();
+      lockSettleAnim = null;
+    }
+    if (lockBounceAnim != null) {
+      lockBounceAnim.cancel();
+      lockBounceAnim = null;
+    }
+    if (lockEntryAnim != null) {
+      lockEntryAnim.cancel();
+      lockEntryAnim = null;
+    }
+    if (lockHintAnim != null) {
+      lockHintAnim.cancel();
+      lockHintAnim = null;
+    }
+    if (rejectHintHide != null) {
+      rejectHintHide.cancel();
+      rejectHintHide = null;
+    }
+    if (vibrationAnimator != null) {
+      vibrationAnimator.end();
+      vibrationAnimator = null;
+    }
+    answerHint.onBounceEnd();
+  }
+
+  // Create an animator to scale on X/Y directions uniformly.
+  private Animator createUniformScaleAnimators(
+      View target, float begin, float end, long duration, Interpolator interpolator) {
+    ObjectAnimator animator =
+        ObjectAnimator.ofPropertyValuesHolder(
+            target,
+            PropertyValuesHolder.ofFloat(View.SCALE_X, begin, end),
+            PropertyValuesHolder.ofFloat(View.SCALE_Y, begin, end));
+    animator.setDuration(duration);
+    animator.setInterpolator(interpolator);
+    return animator;
+  }
+
+  private void addVibrationAnimator(AnimatorSet animatorSet) {
+    if (vibrationAnimator != null) {
+      vibrationAnimator.end();
+    }
+
+    // Note that we animate the value between 0 and 1, but internally VibrateInterpolator will
+    // translate it into actually X translation value.
+    vibrationAnimator =
+        ObjectAnimator.ofFloat(
+            contactPuckContainer, View.TRANSLATION_X, 0 /* begin value */, 1 /* end value */);
+    vibrationAnimator.setDuration(VIBRATION_TIME_MILLIS);
+    vibrationAnimator.setInterpolator(new VibrateInterpolator(getContext()));
+
+    animatorSet.play(vibrationAnimator).after(0 /* delay */);
+  }
+
+  private void performAccept() {
+    LogUtil.i("FlingUpDownMethod.performAccept", null);
+    swipeToAnswerText.setVisibility(View.GONE);
+    contactPuckContainer.setVisibility(View.GONE);
+
+    // Complete the animation loop.
+    setAnimationState(AnimationState.COMPLETED);
+    getParent().answerFromMethod();
+  }
+
+  private void performReject() {
+    LogUtil.i("FlingUpDownMethod.performReject", null);
+    swipeToAnswerText.setVisibility(View.GONE);
+    contactPuckContainer.setVisibility(View.GONE);
+
+    // Complete the animation loop.
+    setAnimationState(AnimationState.COMPLETED);
+    getParent().rejectFromMethod();
+  }
+
+  /** Custom interpolator class for puck vibration. */
+  private static class VibrateInterpolator implements Interpolator {
+
+    private static final long RAMP_UP_BEGIN_MS = 583;
+    private static final long RAMP_UP_DURATION_MS = 167;
+    private static final long RAMP_UP_END_MS = RAMP_UP_BEGIN_MS + RAMP_UP_DURATION_MS;
+    private static final long RAMP_DOWN_BEGIN_MS = 1_583;
+    private static final long RAMP_DOWN_DURATION_MS = 250;
+    private static final long RAMP_DOWN_END_MS = RAMP_DOWN_BEGIN_MS + RAMP_DOWN_DURATION_MS;
+    private static final long RAMP_TOTAL_TIME_MS = RAMP_DOWN_END_MS;
+    private final float ampMax;
+    private final float freqMax = 80;
+    private Interpolator sliderInterpolator = new FastOutSlowInInterpolator();
+
+    VibrateInterpolator(Context context) {
+      ampMax = DpUtil.dpToPx(context, 1 /* dp */);
+    }
+
+    @Override
+    public float getInterpolation(float t) {
+      float slider = 0;
+      float time = t * RAMP_TOTAL_TIME_MS;
+
+      // Calculate the slider value based on RAMP_UP and RAMP_DOWN times. Between RAMP_UP and
+      // RAMP_DOWN, the slider remains the maximum value of 1.
+      if (time > RAMP_UP_BEGIN_MS && time < RAMP_UP_END_MS) {
+        // Ramp up.
+        slider =
+            sliderInterpolator.getInterpolation(
+                (time - RAMP_UP_BEGIN_MS) / (float) RAMP_UP_DURATION_MS);
+      } else if ((time >= RAMP_UP_END_MS) && time <= RAMP_DOWN_BEGIN_MS) {
+        // Vibrate at maximum
+        slider = 1;
+      } else if (time > RAMP_DOWN_BEGIN_MS && time < RAMP_DOWN_END_MS) {
+        // Ramp down.
+        slider =
+            1
+                - sliderInterpolator.getInterpolation(
+                    (time - RAMP_DOWN_BEGIN_MS) / (float) RAMP_DOWN_DURATION_MS);
+      }
+
+      float ampNormalized = ampMax * slider;
+      float freqNormalized = freqMax * slider;
+
+      return (float) (ampNormalized * Math.sin(time * freqNormalized));
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/FlingUpDownTouchHandler.java b/java/com/android/incallui/answer/impl/answermethod/FlingUpDownTouchHandler.java
new file mode 100644
index 0000000..a21073d
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/FlingUpDownTouchHandler.java
@@ -0,0 +1,496 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.support.annotation.FloatRange;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.view.ViewConfiguration;
+import com.android.dialer.common.DpUtil;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.MathUtil;
+import com.android.incallui.answer.impl.classifier.FalsingManager;
+import com.android.incallui.answer.impl.utils.FlingAnimationUtils;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/** Touch handler that keeps track of flings for {@link FlingUpDownMethod}. */
+@SuppressLint("ClickableViewAccessibility")
+class FlingUpDownTouchHandler implements OnTouchListener {
+
+  /** Callback interface for significant events with this touch handler */
+  interface OnProgressChangedListener {
+
+    /**
+     * Called when the visible answer progress has changed. Implementations should use this for
+     * animation, but should not perform accepts or rejects until {@link #onMoveFinish(boolean)} is
+     * called.
+     *
+     * @param progress float representation of the progress with +1f fully accepted, -1f fully
+     *     rejected, and 0 neutral.
+     */
+    void onProgressChanged(@FloatRange(from = -1f, to = 1f) float progress);
+
+    /** Called when a touch event has started being tracked. */
+    void onTrackingStart();
+
+    /** Called when touch events stop being tracked. */
+    void onTrackingStopped();
+
+    /**
+     * Called when the progress has fully animated back to neutral. Normal resting animation should
+     * resume, possibly with a hint animation first.
+     *
+     * @param showHint {@code true} iff the hint animation should be run before resuming normal
+     *     animation.
+     */
+    void onMoveReset(boolean showHint);
+
+    /**
+     * Called when the progress has animated fully to accept or reject.
+     *
+     * @param accept {@code true} if the call has been accepted, {@code false} if it has been
+     *     rejected.
+     */
+    void onMoveFinish(boolean accept);
+
+    /**
+     * Determine whether this gesture should use the {@link FalsingManager} to reject accidental
+     * touches
+     *
+     * @param downEvent the MotionEvent corresponding to the start of the gesture
+     * @return {@code true} if the {@link FalsingManager} should be used to reject accidental
+     *     touches for this gesture
+     */
+    boolean shouldUseFalsing(@NonNull MotionEvent downEvent);
+  }
+
+  // Progress that must be moved through to not show the hint animation after gesture completes
+  private static final float HINT_MOVE_THRESHOLD_RATIO = .1f;
+  // Dp touch needs to move upward to be considered fully accepted
+  private static final int ACCEPT_THRESHOLD_DP = 150;
+  // Dp touch needs to move downward to be considered fully rejected
+  private static final int REJECT_THRESHOLD_DP = 150;
+  // Dp touch needs to move for it to not be considered a false touch (if FalsingManager is not
+  // enabled)
+  private static final int FALSING_THRESHOLD_DP = 40;
+
+  // Progress at which a fling in the opposite direction will recenter instead of
+  // accepting/rejecting
+  private static final float PROGRESS_FLING_RECENTER = .1f;
+
+  // Progress at which a slow swipe would continue toward accept/reject after the
+  // touch has been let go, otherwise will recenter
+  private static final float PROGRESS_SWIPE_RECENTER = .8f;
+
+  private static final float REJECT_FLING_THRESHOLD_MODIFIER = 2f;
+
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({FlingTarget.CENTER, FlingTarget.ACCEPT, FlingTarget.REJECT})
+  private @interface FlingTarget {
+    int CENTER = 0;
+    int ACCEPT = 1;
+    int REJECT = -1;
+  }
+
+  /**
+   * Create a new FlingUpDownTouchHandler and attach it to the target. Will call {@link
+   * View#setOnTouchListener(OnTouchListener)} before returning.
+   *
+   * @param target View whose touches are to be listened to
+   * @param listener Callback to listen to major events
+   * @param falsingManager FalsingManager to identify false touches
+   * @return the instance of FlingUpDownTouchHandler that has been added as a touch listener
+   */
+  public static FlingUpDownTouchHandler attach(
+      @NonNull View target,
+      @NonNull OnProgressChangedListener listener,
+      @Nullable FalsingManager falsingManager) {
+    FlingUpDownTouchHandler handler = new FlingUpDownTouchHandler(target, listener, falsingManager);
+    target.setOnTouchListener(handler);
+    return handler;
+  }
+
+  @NonNull private final View target;
+  @NonNull private final OnProgressChangedListener listener;
+
+  private VelocityTracker velocityTracker;
+  private FlingAnimationUtils flingAnimationUtils;
+
+  private boolean touchEnabled = true;
+  private boolean flingEnabled = true;
+  private float currentProgress;
+  private boolean tracking;
+
+  private boolean motionAborted;
+  private boolean touchSlopExceeded;
+  private boolean hintDistanceExceeded;
+  private int trackingPointer;
+  private Animator progressAnimator;
+
+  private float touchSlop;
+  private float initialTouchY;
+  private float acceptThresholdY;
+  private float rejectThresholdY;
+  private float zeroY;
+
+  private boolean touchAboveFalsingThreshold;
+  private float falsingThresholdPx;
+  private boolean touchUsesFalsing;
+
+  private final float acceptThresholdPx;
+  private final float rejectThresholdPx;
+  private final float deadZoneTopPx;
+
+  @Nullable private final FalsingManager falsingManager;
+
+  private FlingUpDownTouchHandler(
+      @NonNull View target,
+      @NonNull OnProgressChangedListener listener,
+      @Nullable FalsingManager falsingManager) {
+    this.target = target;
+    this.listener = listener;
+    Context context = target.getContext();
+    touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
+    flingAnimationUtils = new FlingAnimationUtils(context, .6f);
+    falsingThresholdPx = DpUtil.dpToPx(context, FALSING_THRESHOLD_DP);
+    acceptThresholdPx = DpUtil.dpToPx(context, ACCEPT_THRESHOLD_DP);
+    rejectThresholdPx = DpUtil.dpToPx(context, REJECT_THRESHOLD_DP);
+
+    deadZoneTopPx =
+        Math.max(
+            context.getResources().getDimension(R.dimen.answer_swipe_dead_zone_top),
+            acceptThresholdPx);
+    this.falsingManager = falsingManager;
+  }
+
+  /** Returns {@code true} iff a touch is being tracked */
+  public boolean isTracking() {
+    return tracking;
+  }
+
+  /**
+   * Sets whether touch events will continue to be listened to
+   *
+   * @param touchEnabled whether future touch events will be listened to
+   */
+  public void setTouchEnabled(boolean touchEnabled) {
+    this.touchEnabled = touchEnabled;
+  }
+
+  /**
+   * Sets whether fling velocity is used to affect accept/reject behavior
+   *
+   * @param flingEnabled whether fling velocity will be used when determining whether to
+   *     accept/reject or recenter
+   */
+  public void setFlingEnabled(boolean flingEnabled) {
+    this.flingEnabled = flingEnabled;
+  }
+
+  public void detach() {
+    cancelProgressAnimator();
+    setTouchEnabled(false);
+  }
+
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    if (falsingManager != null) {
+      falsingManager.onTouchEvent(event);
+    }
+    if (!touchEnabled) {
+      return false;
+    }
+    if (motionAborted && (event.getActionMasked() != MotionEvent.ACTION_DOWN)) {
+      return false;
+    }
+
+    int pointerIndex = event.findPointerIndex(trackingPointer);
+    if (pointerIndex < 0) {
+      pointerIndex = 0;
+      trackingPointer = event.getPointerId(pointerIndex);
+    }
+    final float pointerY = event.getY(pointerIndex);
+
+    switch (event.getActionMasked()) {
+      case MotionEvent.ACTION_DOWN:
+        if (pointerY < deadZoneTopPx) {
+          return false;
+        }
+        motionAborted = false;
+        startMotion(pointerY, false, currentProgress);
+        touchAboveFalsingThreshold = false;
+        touchUsesFalsing = listener.shouldUseFalsing(event);
+        if (velocityTracker == null) {
+          initVelocityTracker();
+        }
+        trackMovement(event);
+        cancelProgressAnimator();
+        touchSlopExceeded = progressAnimator != null;
+        onTrackingStarted();
+        break;
+      case MotionEvent.ACTION_POINTER_UP:
+        final int upPointer = event.getPointerId(event.getActionIndex());
+        if (trackingPointer == upPointer) {
+          // gesture is ongoing, find a new pointer to track
+          int newIndex = event.getPointerId(0) != upPointer ? 0 : 1;
+          float newY = event.getY(newIndex);
+          trackingPointer = event.getPointerId(newIndex);
+          startMotion(newY, true, currentProgress);
+        }
+        break;
+      case MotionEvent.ACTION_POINTER_DOWN:
+        motionAborted = true;
+        endMotionEvent(event, pointerY, true);
+        return false;
+      case MotionEvent.ACTION_MOVE:
+        float deltaY = pointerY - initialTouchY;
+
+        if (Math.abs(deltaY) > touchSlop) {
+          touchSlopExceeded = true;
+        }
+        if (Math.abs(deltaY) >= falsingThresholdPx) {
+          touchAboveFalsingThreshold = true;
+        }
+        setCurrentProgress(pointerYToProgress(pointerY));
+        trackMovement(event);
+        break;
+
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_CANCEL:
+        trackMovement(event);
+        endMotionEvent(event, pointerY, false);
+    }
+    return true;
+  }
+
+  private void endMotionEvent(MotionEvent event, float pointerY, boolean forceCancel) {
+    trackingPointer = -1;
+    if ((tracking && touchSlopExceeded)
+        || Math.abs(pointerY - initialTouchY) > touchSlop
+        || event.getActionMasked() == MotionEvent.ACTION_CANCEL
+        || forceCancel) {
+      float vel = 0f;
+      float vectorVel = 0f;
+      if (velocityTracker != null) {
+        velocityTracker.computeCurrentVelocity(1000);
+        vel = velocityTracker.getYVelocity();
+        vectorVel =
+            Math.copySign(
+                (float) Math.hypot(velocityTracker.getXVelocity(), velocityTracker.getYVelocity()),
+                vel);
+      }
+
+      boolean falseTouch = isFalseTouch();
+      boolean forceRecenter =
+          falseTouch
+              || !touchSlopExceeded
+              || forceCancel
+              || event.getActionMasked() == MotionEvent.ACTION_CANCEL;
+
+      @FlingTarget
+      int target = forceRecenter ? FlingTarget.CENTER : getFlingTarget(pointerY, vectorVel);
+
+      fling(vel, target, falseTouch);
+      onTrackingStopped();
+    } else {
+      onTrackingStopped();
+      setCurrentProgress(0);
+      onMoveEnded();
+    }
+
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+      velocityTracker = null;
+    }
+  }
+
+  @FlingTarget
+  private int getFlingTarget(float pointerY, float vectorVel) {
+    float progress = pointerYToProgress(pointerY);
+
+    float minVelocityPxPerSecond = flingAnimationUtils.getMinVelocityPxPerSecond();
+    if (vectorVel > 0) {
+      minVelocityPxPerSecond *= REJECT_FLING_THRESHOLD_MODIFIER;
+    }
+    if (!flingEnabled || Math.abs(vectorVel) < minVelocityPxPerSecond) {
+      // Not a fling
+      if (Math.abs(progress) > PROGRESS_SWIPE_RECENTER) {
+        // Progress near one of the edges
+        return progress > 0 ? FlingTarget.ACCEPT : FlingTarget.REJECT;
+      } else {
+        return FlingTarget.CENTER;
+      }
+    }
+
+    boolean sameDirection = vectorVel < 0 == progress > 0;
+    if (!sameDirection && Math.abs(progress) >= PROGRESS_FLING_RECENTER) {
+      // Being flung back toward center
+      return FlingTarget.CENTER;
+    }
+    // Flung toward an edge
+    return vectorVel < 0 ? FlingTarget.ACCEPT : FlingTarget.REJECT;
+  }
+
+  @FloatRange(from = -1f, to = 1f)
+  private float pointerYToProgress(float pointerY) {
+    boolean pointerAboveZero = pointerY > zeroY;
+    float nearestThreshold = pointerAboveZero ? rejectThresholdY : acceptThresholdY;
+
+    float absoluteProgress = (pointerY - zeroY) / (nearestThreshold - zeroY);
+    return MathUtil.clamp(absoluteProgress * (pointerAboveZero ? -1 : 1), -1f, 1f);
+  }
+
+  private boolean isFalseTouch() {
+    if (falsingManager != null && falsingManager.isEnabled()) {
+      if (falsingManager.isFalseTouch()) {
+        if (touchUsesFalsing) {
+          LogUtil.i("FlingUpDownTouchHandler.isFalseTouch", "rejecting false touch");
+          return true;
+        } else {
+          LogUtil.i(
+              "FlingUpDownTouchHandler.isFalseTouch",
+              "Suspected false touch, but not using false touch rejection for this gesture");
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    return !touchAboveFalsingThreshold;
+  }
+
+  private void trackMovement(MotionEvent event) {
+    if (velocityTracker != null) {
+      velocityTracker.addMovement(event);
+    }
+  }
+
+  private void fling(float velocity, @FlingTarget int target, boolean centerBecauseOfFalsing) {
+    ValueAnimator animator = createProgressAnimator(target);
+    if (target == FlingTarget.CENTER) {
+      flingAnimationUtils.apply(animator, currentProgress, target, velocity);
+    } else {
+      flingAnimationUtils.applyDismissing(animator, currentProgress, target, velocity, 1);
+    }
+    if (target == FlingTarget.CENTER && centerBecauseOfFalsing) {
+      velocity = 0;
+    }
+    if (velocity == 0) {
+      animator.setDuration(350);
+    }
+
+    animator.addListener(
+        new AnimatorListenerAdapter() {
+          boolean canceled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            canceled = true;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            progressAnimator = null;
+            if (!canceled) {
+              onMoveEnded();
+            }
+          }
+        });
+    progressAnimator = animator;
+    animator.start();
+  }
+
+  private void onMoveEnded() {
+    if (currentProgress == 0) {
+      listener.onMoveReset(!hintDistanceExceeded);
+    } else {
+      listener.onMoveFinish(currentProgress > 0);
+    }
+  }
+
+  private ValueAnimator createProgressAnimator(float targetProgress) {
+    ValueAnimator animator = ValueAnimator.ofFloat(currentProgress, targetProgress);
+    animator.addUpdateListener(
+        new AnimatorUpdateListener() {
+          @Override
+          public void onAnimationUpdate(ValueAnimator animation) {
+            setCurrentProgress((Float) animation.getAnimatedValue());
+          }
+        });
+    return animator;
+  }
+
+  private void initVelocityTracker() {
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+    }
+    velocityTracker = VelocityTracker.obtain();
+  }
+
+  private void startMotion(float newY, boolean startTracking, float startProgress) {
+    initialTouchY = newY;
+    hintDistanceExceeded = false;
+
+    if (startProgress <= .25) {
+      acceptThresholdY = Math.max(0, initialTouchY - acceptThresholdPx);
+      rejectThresholdY = Math.min(target.getHeight(), initialTouchY + rejectThresholdPx);
+      zeroY = initialTouchY;
+    }
+
+    if (startTracking) {
+      touchSlopExceeded = true;
+      onTrackingStarted();
+      setCurrentProgress(startProgress);
+    }
+  }
+
+  private void onTrackingStarted() {
+    tracking = true;
+    listener.onTrackingStart();
+  }
+
+  private void onTrackingStopped() {
+    tracking = false;
+    listener.onTrackingStopped();
+  }
+
+  private void cancelProgressAnimator() {
+    if (progressAnimator != null) {
+      progressAnimator.cancel();
+    }
+  }
+
+  private void setCurrentProgress(float progress) {
+    if (Math.abs(progress) > HINT_MOVE_THRESHOLD_RATIO) {
+      hintDistanceExceeded = true;
+    }
+    currentProgress = progress;
+    listener.onProgressChanged(progress);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/TwoButtonMethod.java b/java/com/android/incallui/answer/impl/answermethod/TwoButtonMethod.java
new file mode 100644
index 0000000..67b1b96
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/TwoButtonMethod.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.answermethod;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.os.Bundle;
+import android.support.annotation.FloatRange;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.ActivityCompat;
+import com.android.incallui.answer.impl.answermethod.FlingUpDownTouchHandler.OnProgressChangedListener;
+import com.android.incallui.util.AccessibilityUtil;
+
+/** Answer method that shows two buttons for answer/reject. */
+public class TwoButtonMethod extends AnswerMethod
+    implements OnClickListener, AnimatorUpdateListener {
+
+  private static final String STATE_HINT_TEXT = "hintText";
+  private static final String STATE_INCOMING_WILL_DISCONNECT = "incomingWillDisconnect";
+
+  private View answerButton;
+  private View answerLabel;
+  private View declineButton;
+  private View declineLabel;
+  private TextView hintTextView;
+  private boolean incomingWillDisconnect;
+  private boolean buttonClicked;
+  private CharSequence hintText;
+  @Nullable private FlingUpDownTouchHandler touchHandler;
+
+  @Override
+  public void onCreate(@Nullable Bundle bundle) {
+    super.onCreate(bundle);
+    if (bundle != null) {
+      incomingWillDisconnect = bundle.getBoolean(STATE_INCOMING_WILL_DISCONNECT);
+      hintText = bundle.getCharSequence(STATE_HINT_TEXT);
+    }
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle bundle) {
+    super.onSaveInstanceState(bundle);
+    bundle.putBoolean(STATE_INCOMING_WILL_DISCONNECT, incomingWillDisconnect);
+    bundle.putCharSequence(STATE_HINT_TEXT, hintText);
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    View view = layoutInflater.inflate(R.layout.two_button_method, viewGroup, false);
+
+    hintTextView = (TextView) view.findViewById(R.id.two_button_hint_text);
+    updateHintText();
+
+    answerButton = view.findViewById(R.id.two_button_answer_button);
+    answerLabel = view.findViewById(R.id.two_button_answer_label);
+    declineButton = view.findViewById(R.id.two_button_decline_button);
+    declineLabel = view.findViewById(R.id.two_button_decline_label);
+
+    boolean showLabels = getResources().getBoolean(R.bool.two_button_show_button_labels);
+    answerLabel.setVisibility(showLabels ? View.VISIBLE : View.GONE);
+    declineLabel.setVisibility(showLabels ? View.VISIBLE : View.GONE);
+
+    answerButton.setOnClickListener(this);
+    declineButton.setOnClickListener(this);
+
+    if (AccessibilityUtil.isTouchExplorationEnabled(getContext())) {
+      /* Falsing already handled by AccessibilityManager */
+      touchHandler =
+          FlingUpDownTouchHandler.attach(
+              view,
+              new OnProgressChangedListener() {
+                @Override
+                public void onProgressChanged(@FloatRange(from = -1f, to = 1f) float progress) {}
+
+                @Override
+                public void onTrackingStart() {}
+
+                @Override
+                public void onTrackingStopped() {}
+
+                @Override
+                public void onMoveReset(boolean showHint) {}
+
+                @Override
+                public void onMoveFinish(boolean accept) {
+                  if (accept) {
+                    answerCall();
+                  } else {
+                    rejectCall();
+                  }
+                }
+
+                @Override
+                public boolean shouldUseFalsing(@NonNull MotionEvent downEvent) {
+                  return false;
+                }
+              },
+              null /* Falsing already handled by AccessibilityManager */);
+      touchHandler.setFlingEnabled(false);
+    }
+    return view;
+  }
+
+  @Override
+  public void onDestroyView() {
+    super.onDestroyView();
+    if (touchHandler != null) {
+      touchHandler.detach();
+      touchHandler = null;
+    }
+  }
+
+  @Override
+  public void setHintText(@Nullable CharSequence hintText) {
+    this.hintText = hintText;
+    updateHintText();
+  }
+
+  @Override
+  public void setShowIncomingWillDisconnect(boolean incomingWillDisconnect) {
+    this.incomingWillDisconnect = incomingWillDisconnect;
+    updateHintText();
+  }
+
+  private void updateHintText() {
+    if (hintTextView == null) {
+      return;
+    }
+    hintTextView.setVisibility(
+        ActivityCompat.isInMultiWindowMode(getActivity()) ? View.GONE : View.VISIBLE);
+    if (!TextUtils.isEmpty(hintText) && !buttonClicked) {
+      hintTextView.setText(hintText);
+      hintTextView.animate().alpha(1f).start();
+    } else if (incomingWillDisconnect && !buttonClicked) {
+      hintTextView.setText(R.string.call_incoming_will_disconnect);
+      hintTextView.animate().alpha(1f).start();
+    } else {
+      hintTextView.animate().alpha(0f).start();
+    }
+  }
+
+  @Override
+  public void onClick(View view) {
+    if (view == answerButton) {
+      answerCall();
+      LogUtil.v("TwoButtonMethod.onClick", "Call answered");
+    } else if (view == declineButton) {
+      rejectCall();
+      LogUtil.v("TwoButtonMethod.onClick", "two_buttonMethod Call rejected");
+    } else {
+      Assert.fail("Unknown click from view: " + view);
+    }
+    buttonClicked = true;
+  }
+
+  private void answerCall() {
+    ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
+    animator.addUpdateListener(this);
+    animator.addListener(
+        new AnimatorListenerAdapter() {
+          private boolean canceled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            canceled = true;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            if (!canceled) {
+              getParent().answerFromMethod();
+            }
+          }
+        });
+    AnimatorSet animatorSet = new AnimatorSet();
+    animatorSet.play(animator).with(createViewHideAnimation());
+    animatorSet.start();
+  }
+
+  private void rejectCall() {
+    ValueAnimator animator = ValueAnimator.ofFloat(0, -1);
+    animator.addUpdateListener(this);
+    animator.addListener(
+        new AnimatorListenerAdapter() {
+          private boolean canceled;
+
+          @Override
+          public void onAnimationCancel(Animator animation) {
+            canceled = true;
+          }
+
+          @Override
+          public void onAnimationEnd(Animator animation) {
+            if (!canceled) {
+              getParent().rejectFromMethod();
+            }
+          }
+        });
+    AnimatorSet animatorSet = new AnimatorSet();
+    animatorSet.play(animator).with(createViewHideAnimation());
+    animatorSet.start();
+  }
+
+  @Override
+  public void onAnimationUpdate(ValueAnimator animation) {
+    getParent().onAnswerProgressUpdate(((float) animation.getAnimatedValue()));
+  }
+
+  private Animator createViewHideAnimation() {
+    ObjectAnimator answerButtonHide =
+        ObjectAnimator.ofPropertyValuesHolder(
+            answerButton,
+            PropertyValuesHolder.ofFloat(View.SCALE_X, 0f),
+            PropertyValuesHolder.ofFloat(View.SCALE_Y, 0f));
+
+    ObjectAnimator declineButtonHide =
+        ObjectAnimator.ofPropertyValuesHolder(
+            declineButton,
+            PropertyValuesHolder.ofFloat(View.SCALE_X, 0f),
+            PropertyValuesHolder.ofFloat(View.SCALE_Y, 0f));
+
+    ObjectAnimator answerLabelHide = ObjectAnimator.ofFloat(answerLabel, View.ALPHA, 0f);
+
+    ObjectAnimator declineLabelHide = ObjectAnimator.ofFloat(declineLabel, View.ALPHA, 0f);
+
+    ObjectAnimator hintHide = ObjectAnimator.ofFloat(hintTextView, View.ALPHA, 0f);
+
+    AnimatorSet hideSet = new AnimatorSet();
+    hideSet
+        .play(answerButtonHide)
+        .with(declineButtonHide)
+        .with(answerLabelHide)
+        .with(declineLabelHide)
+        .with(hintHide);
+    return hideSet;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml b/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml
new file mode 100644
index 0000000..451c862
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:height="24dp"
+  android:viewportHeight="32.0"
+  android:viewportWidth="32.0"
+  android:width="24dp">
+  <group
+    android:name="rotationGroup"
+    android:pivotX="12"
+    android:pivotY="12"
+    android:translateX="4"
+    android:translateY="4"
+    android:rotation="0"
+    >
+    <path
+      android:fillColor="#FFFFFFFF"
+      android:pathData="M6.62,10.79c1.44,2.83 3.76,5.14 6.59,6.59l2.2,-2.2c0.27,-0.27 0.67,-0.36 1.02,-0.24 1.12,0.37 2.33,0.57 3.57,0.57 0.55,0 1,0.45 1,1V20c0,0.55 -0.45,1 -1,1 -9.39,0 -17,-7.61 -17,-17 0,-0.55 0.45,-1 1,-1h3.5c0.55,0 1,0.45 1,1 0,1.25 0.2,2.45 0.57,3.57 0.11,0.35 0.03,0.74 -0.25,1.02l-2.2,2.2z"/>
+  </group>
+</vector>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/drawable/circular_background.xml b/java/com/android/incallui/answer/impl/answermethod/res/drawable/circular_background.xml
new file mode 100644
index 0000000..938ddc2
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/drawable/circular_background.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="#FFFFFFFF"/>
+</shape>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/layout/swipe_up_down_method.xml b/java/com/android/incallui/answer/impl/answermethod/res/layout/swipe_up_down_method.xml
new file mode 100644
index 0000000..78e0979
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/layout/swipe_up_down_method.xml
@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<FrameLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:layout_marginStart="@dimen/answer_swipe_dead_zone_sides"
+  android:clipChildren="false"
+  android:clipToPadding="false"
+  android:layout_marginEnd="@dimen/answer_swipe_dead_zone_sides">
+  <LinearLayout
+    android:id="@+id/incoming_swipe_to_answer_container"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:accessibilityLiveRegion="polite"
+    android:clipChildren="false"
+    android:clipToPadding="false"
+    android:gravity="center_horizontal|bottom"
+    android:orientation="vertical"
+    android:visibility="visible">
+    <TextView
+      android:id="@+id/incoming_will_disconnect_text"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_marginBottom="116dp"
+      android:layout_gravity="center_horizontal"
+      android:alpha="0"
+      android:text="@string/call_incoming_will_disconnect"
+      android:textColor="@color/blue_grey_100"
+      android:textSize="16sp"
+      tools:alpha="1"/>
+    <TextView
+      android:id="@+id/incoming_swipe_to_answer_text"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_marginBottom="18dp"
+      android:layout_gravity="center_horizontal"
+      android:focusable="false"
+      android:text="@string/call_incoming_swipe_to_answer"
+      android:textAppearance="@style/Dialer.Incall.TextAppearance.Hint"/>
+
+    <FrameLayout
+      android:id="@+id/incoming_call_puck_container"
+      android:layout_width="@dimen/answer_contact_puck_size_photo"
+      android:layout_height="@dimen/answer_contact_puck_size_photo"
+      android:layout_marginBottom="10dp"
+      android:layout_gravity="center_horizontal"
+      android:clipChildren="false"
+      android:clipToPadding="false"
+      android:contentDescription="@string/a11y_incoming_call_swipe_to_answer">
+
+      <!-- Puck background and icon are hosted in the separated views to animate separately. -->
+      <ImageView
+        android:id="@+id/incoming_call_puck_bg"
+        android:layout_width="@dimen/answer_contact_puck_size_no_photo"
+        android:layout_height="@dimen/answer_contact_puck_size_no_photo"
+        android:layout_gravity="center"
+        android:background="@drawable/circular_background"
+        android:contentDescription="@null"
+        android:duplicateParentState="true"
+        android:elevation="8dp"
+        android:focusable="false"
+        android:stateListAnimator="@animator/activated_button_elevation"/>
+
+      <ImageView
+        android:id="@+id/incoming_call_puck_icon"
+        android:layout_width="30dp"
+        android:layout_height="30dp"
+        android:layout_gravity="center"
+        android:contentDescription="@null"
+        android:duplicateParentState="true"
+        android:elevation="16dp"
+        android:focusable="false"
+        android:outlineProvider="none"
+        android:src="@drawable/quantum_ic_call_white_24"
+        android:tint="@color/incoming_answer_icon"
+        android:tintMode="src_atop"
+        tools:outlineProvider="background"/>
+
+    </FrameLayout>
+    <TextView
+      android:id="@+id/incoming_swipe_to_reject_text"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_marginBottom="20dp"
+      android:layout_gravity="center_horizontal"
+      android:alpha="0"
+      android:focusable="false"
+      android:text="@string/call_incoming_swipe_to_reject"
+      android:textAppearance="@style/Dialer.Incall.TextAppearance.Hint"
+      tools:alpha="1"/>
+  </LinearLayout>
+  <FrameLayout
+    android:id="@+id/hint_container"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:clipChildren="false"
+    android:clipToPadding="false"/>
+</FrameLayout>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/layout/two_button_method.xml b/java/com/android/incallui/answer/impl/answermethod/res/layout/two_button_method.xml
new file mode 100644
index 0000000..f92f3c4
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/layout/two_button_method.xml
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:gravity="bottom|center_horizontal"
+  android:orientation="vertical">
+  <TextView
+    android:id="@+id/two_button_hint_text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_marginBottom="32dp"
+    android:accessibilityLiveRegion="polite"
+    android:alpha="0"/>
+
+  <LinearLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:paddingBottom="@dimen/two_button_bottom_padding"
+    android:gravity="bottom|center_horizontal"
+    android:orientation="horizontal">
+
+    <LinearLayout
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_marginEnd="88dp"
+      android:clipChildren="false"
+      android:clipToPadding="false"
+      android:padding="@dimen/incall_call_button_elevation"
+      android:gravity="center_horizontal"
+      android:orientation="vertical">
+
+      <ImageButton
+        android:id="@+id/two_button_decline_button"
+        style="@style/Answer.Button.Decline"
+        android:layout_width="@dimen/two_button_button_size"
+        android:layout_height="@dimen/two_button_button_size"
+        android:contentDescription="@string/a11y_call_incoming_decline_description"
+        android:src="@drawable/quantum_ic_call_end_white_24"/>
+
+      <TextView
+        android:id="@+id/two_button_decline_label"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="@dimen/two_button_label_padding"
+        android:importantForAccessibility="no"
+        android:text="@string/call_incoming_decline"
+        android:textColor="#ffffffff"
+        android:textSize="@dimen/two_button_label_size"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:clipChildren="false"
+      android:clipToPadding="false"
+      android:padding="@dimen/incall_call_button_elevation"
+      android:gravity="center_horizontal"
+      android:orientation="vertical">
+
+      <ImageButton
+        android:id="@+id/two_button_answer_button"
+        style="@style/Answer.Button.Answer"
+        android:layout_width="@dimen/two_button_button_size"
+        android:layout_height="@dimen/two_button_button_size"
+        android:contentDescription="@string/a11y_call_incoming_answer_description"
+        android:src="@drawable/quantum_ic_call_white_24"/>
+
+      <TextView
+        android:id="@+id/two_button_answer_label"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="@dimen/two_button_label_padding"
+        android:importantForAccessibility="no"
+        android:text="@string/call_incoming_answer"
+        android:textColor="#ffffffff"
+        android:textSize="@dimen/two_button_label_size"/>
+
+    </LinearLayout>
+  </LinearLayout>
+</LinearLayout>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values-h240dp/values.xml b/java/com/android/incallui/answer/impl/answermethod/res/values-h240dp/values.xml
new file mode 100644
index 0000000..7d99b29
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values-h240dp/values.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <bool name="two_button_show_button_labels">true</bool>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values-h280dp/dimens.xml b/java/com/android/incallui/answer/impl/answermethod/res/values-h280dp/dimens.xml
new file mode 100644
index 0000000..e7e223d
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values-h280dp/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="two_button_button_size">64dp</dimen>
+  <dimen name="two_button_label_padding">16dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values-h480dp/dimens.xml b/java/com/android/incallui/answer/impl/answermethod/res/values-h480dp/dimens.xml
new file mode 100644
index 0000000..b7b4bd8
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values-h480dp/dimens.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="two_button_bottom_padding">60dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/dimens.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/dimens.xml
new file mode 100644
index 0000000..bf160f9
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/dimens.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_contact_puck_size_photo">88dp</dimen>
+  <dimen name="answer_contact_puck_size_no_photo">72dp</dimen>
+  <dimen name="two_button_button_size">48dp</dimen>
+  <dimen name="two_button_label_size">12sp</dimen>
+  <dimen name="two_button_label_padding">8dp</dimen>
+  <dimen name="two_button_bottom_padding">24dp</dimen>
+  <dimen name="answer_swipe_dead_zone_sides">50dp</dimen>
+  <dimen name="answer_swipe_dead_zone_top">150dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/ids.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/ids.xml
new file mode 100644
index 0000000..fc03cac
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/ids.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <item name="accessibility_action_answer" type="id"/>
+  <item name="accessibility_action_decline" type="id"/>
+</resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/strings.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/strings.xml
new file mode 100644
index 0000000..8b50dbf
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/strings.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="call_incoming_swipe_to_answer">Swipe up to answer</string>
+  <string name="call_incoming_swipe_to_reject">Swipe down to reject</string>
+  <string name="a11y_incoming_call_swipe_to_answer">Swipe up with two fingers to answer or down to reject the call</string>
+  <string name="call_incoming_will_disconnect">Answering this call will end your video call</string>
+
+  <string name="a11y_call_incoming_decline_description">Decline</string>
+  <string name="call_incoming_decline">Decline</string>
+
+  <string name="a11y_call_incoming_answer_description">Answer</string>
+  <string name="call_incoming_answer">Answer</string>
+
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/styles.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/styles.xml
new file mode 100644
index 0000000..fd3ca7c
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/styles.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <style name="Dialer.Incall.TextAppearance.Hint">
+    <item name="android:textSize">14sp</item>
+    <item name="android:textStyle">italic</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml
new file mode 100644
index 0000000..43b2cd2
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <color name="incoming_or_outgoing_call_screen_mask">@android:color/transparent</color>
+  <color name="call_hangup_background">#DF0000</color>
+  <color name="call_accept_background">#00C853</color>
+  <color name="incoming_answer_icon">#00C853</color>
+  <integer name="button_exit_fade_delay_ms">300</integer>
+  <bool name="two_button_show_button_labels">false</bool>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/classifier/AccelerationClassifier.java b/java/com/android/incallui/answer/impl/classifier/AccelerationClassifier.java
new file mode 100644
index 0000000..ac50444
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/AccelerationClassifier.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+import android.util.ArrayMap;
+import android.view.MotionEvent;
+import java.util.Map;
+
+/**
+ * A classifier which looks at the speed and distance between successive points of a Stroke. It
+ * looks at two consecutive speeds between two points and calculates the ratio between them. The
+ * final result is the maximum of these values. It does the same for distances. If some speed or
+ * distance is equal to zero then the ratio between this and the next part is not calculated. To the
+ * duration of each part there is added one nanosecond so that it is always possible to calculate
+ * the speed of a part.
+ */
+class AccelerationClassifier extends StrokeClassifier {
+  private final Map<Stroke, Data> mStrokeMap = new ArrayMap<>();
+
+  public AccelerationClassifier(ClassifierData classifierData) {
+    mClassifierData = classifierData;
+  }
+
+  @Override
+  public String getTag() {
+    return "ACC";
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      mStrokeMap.clear();
+    }
+
+    for (int i = 0; i < event.getPointerCount(); i++) {
+      Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));
+      Point point = stroke.getPoints().get(stroke.getPoints().size() - 1);
+      if (mStrokeMap.get(stroke) == null) {
+        mStrokeMap.put(stroke, new Data(point));
+      } else {
+        mStrokeMap.get(stroke).addPoint(point);
+      }
+    }
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    Data data = mStrokeMap.get(stroke);
+    return 2 * SpeedRatioEvaluator.evaluate(data.maxSpeedRatio);
+  }
+
+  private static class Data {
+
+    static final float MILLIS_TO_NANOS = 1e6f;
+
+    Point previousPoint;
+    float previousSpeed = 0;
+    float maxSpeedRatio = 0;
+
+    public Data(Point point) {
+      previousPoint = point;
+    }
+
+    public void addPoint(Point point) {
+      float distance = previousPoint.dist(point);
+      float duration = (float) (point.timeOffsetNano - previousPoint.timeOffsetNano + 1);
+      float speed = distance / duration;
+
+      if (duration > 20 * MILLIS_TO_NANOS || duration < 5 * MILLIS_TO_NANOS) {
+        // reject this segment and ensure we won't use data about it in the next round.
+        previousSpeed = 0;
+        previousPoint = point;
+        return;
+      }
+      if (previousSpeed != 0.0f) {
+        maxSpeedRatio = Math.max(maxSpeedRatio, speed / previousSpeed);
+      }
+
+      previousSpeed = speed;
+      previousPoint = point;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/AnglesClassifier.java b/java/com/android/incallui/answer/impl/classifier/AnglesClassifier.java
new file mode 100644
index 0000000..dbfbcfc
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/AnglesClassifier.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+import android.util.ArrayMap;
+import android.view.MotionEvent;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A classifier which calculates the variance of differences between successive angles in a stroke.
+ * For each stroke it keeps its last three points. If some successive points are the same, it
+ * ignores the repetitions. If a new point is added, the classifier calculates the angle between the
+ * last three points. After that, it calculates the difference between this angle and the previously
+ * calculated angle. Then it calculates the variance of the differences from a stroke. To the
+ * differences there is artificially added value 0.0 and the difference between the first angle and
+ * PI (angles are in radians). It helps with strokes which have few points and punishes more strokes
+ * which are not smooth.
+ *
+ * <p>This classifier also tries to split the stroke into two parts in the place in which the
+ * biggest angle is. It calculates the angle variance of the two parts and sums them up. The reason
+ * the classifier is doing this, is because some human swipes at the beginning go for a moment in
+ * one direction and then they rapidly change direction for the rest of the stroke (like a tick).
+ * The final result is the minimum of angle variance of the whole stroke and the sum of angle
+ * variances of the two parts split up. The classifier tries the tick option only if the first part
+ * is shorter than the second part.
+ *
+ * <p>Additionally, the classifier classifies the angles as left angles (those angles which value is
+ * in [0.0, PI - ANGLE_DEVIATION) interval), straight angles ([PI - ANGLE_DEVIATION, PI +
+ * ANGLE_DEVIATION] interval) and right angles ((PI + ANGLE_DEVIATION, 2 * PI) interval) and then
+ * calculates the percentage of angles which are in the same direction (straight angles can be left
+ * angels or right angles)
+ */
+class AnglesClassifier extends StrokeClassifier {
+  private Map<Stroke, Data> mStrokeMap = new ArrayMap<>();
+
+  public AnglesClassifier(ClassifierData classifierData) {
+    mClassifierData = classifierData;
+  }
+
+  @Override
+  public String getTag() {
+    return "ANG";
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      mStrokeMap.clear();
+    }
+
+    for (int i = 0; i < event.getPointerCount(); i++) {
+      Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));
+
+      if (mStrokeMap.get(stroke) == null) {
+        mStrokeMap.put(stroke, new Data());
+      }
+      mStrokeMap.get(stroke).addPoint(stroke.getPoints().get(stroke.getPoints().size() - 1));
+    }
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    Data data = mStrokeMap.get(stroke);
+    return AnglesVarianceEvaluator.evaluate(data.getAnglesVariance())
+        + AnglesPercentageEvaluator.evaluate(data.getAnglesPercentage());
+  }
+
+  private static class Data {
+    private static final float ANGLE_DEVIATION = (float) Math.PI / 20.0f;
+    private static final float MIN_MOVE_DIST_DP = .01f;
+
+    private List<Point> mLastThreePoints = new ArrayList<>();
+    private float mFirstAngleVariance;
+    private float mPreviousAngle;
+    private float mBiggestAngle;
+    private float mSumSquares;
+    private float mSecondSumSquares;
+    private float mSum;
+    private float mSecondSum;
+    private float mCount;
+    private float mSecondCount;
+    private float mFirstLength;
+    private float mLength;
+    private float mAnglesCount;
+    private float mLeftAngles;
+    private float mRightAngles;
+    private float mStraightAngles;
+
+    public Data() {
+      mFirstAngleVariance = 0.0f;
+      mPreviousAngle = (float) Math.PI;
+      mBiggestAngle = 0.0f;
+      mSumSquares = mSecondSumSquares = 0.0f;
+      mSum = mSecondSum = 0.0f;
+      mCount = mSecondCount = 1.0f;
+      mLength = mFirstLength = 0.0f;
+      mAnglesCount = mLeftAngles = mRightAngles = mStraightAngles = 0.0f;
+    }
+
+    public void addPoint(Point point) {
+      // Checking if the added point is different than the previously added point
+      // Repetitions and short distances are being ignored so that proper angles are calculated.
+      if (mLastThreePoints.isEmpty()
+          || (!mLastThreePoints.get(mLastThreePoints.size() - 1).equals(point)
+              && (mLastThreePoints.get(mLastThreePoints.size() - 1).dist(point)
+                  > MIN_MOVE_DIST_DP))) {
+        if (!mLastThreePoints.isEmpty()) {
+          mLength += mLastThreePoints.get(mLastThreePoints.size() - 1).dist(point);
+        }
+        mLastThreePoints.add(point);
+        if (mLastThreePoints.size() == 4) {
+          mLastThreePoints.remove(0);
+
+          float angle =
+              mLastThreePoints.get(1).getAngle(mLastThreePoints.get(0), mLastThreePoints.get(2));
+
+          mAnglesCount++;
+          if (angle < Math.PI - ANGLE_DEVIATION) {
+            mLeftAngles++;
+          } else if (angle <= Math.PI + ANGLE_DEVIATION) {
+            mStraightAngles++;
+          } else {
+            mRightAngles++;
+          }
+
+          float difference = angle - mPreviousAngle;
+
+          // If this is the biggest angle of the stroke so then we save the value of
+          // the angle variance so far and start to count the values for the angle
+          // variance of the second part.
+          if (mBiggestAngle < angle) {
+            mBiggestAngle = angle;
+            mFirstLength = mLength;
+            mFirstAngleVariance = getAnglesVariance(mSumSquares, mSum, mCount);
+            mSecondSumSquares = 0.0f;
+            mSecondSum = 0.0f;
+            mSecondCount = 1.0f;
+          } else {
+            mSecondSum += difference;
+            mSecondSumSquares += difference * difference;
+            mSecondCount += 1.0f;
+          }
+
+          mSum += difference;
+          mSumSquares += difference * difference;
+          mCount += 1.0f;
+          mPreviousAngle = angle;
+        }
+      }
+    }
+
+    public float getAnglesVariance(float sumSquares, float sum, float count) {
+      return sumSquares / count - (sum / count) * (sum / count);
+    }
+
+    public float getAnglesVariance() {
+      float anglesVariance = getAnglesVariance(mSumSquares, mSum, mCount);
+      if (mFirstLength < mLength / 2f) {
+        anglesVariance =
+            Math.min(
+                anglesVariance,
+                mFirstAngleVariance
+                    + getAnglesVariance(mSecondSumSquares, mSecondSum, mSecondCount));
+      }
+      return anglesVariance;
+    }
+
+    public float getAnglesPercentage() {
+      if (mAnglesCount == 0.0f) {
+        return 1.0f;
+      }
+      return (Math.max(mLeftAngles, mRightAngles) + mStraightAngles) / mAnglesCount;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/AnglesPercentageEvaluator.java b/java/com/android/incallui/answer/impl/classifier/AnglesPercentageEvaluator.java
new file mode 100644
index 0000000..49a1835
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/AnglesPercentageEvaluator.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class AnglesPercentageEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 1.00) {
+      evaluation++;
+    }
+    if (value < 0.90) {
+      evaluation++;
+    }
+    if (value < 0.70) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/AnglesVarianceEvaluator.java b/java/com/android/incallui/answer/impl/classifier/AnglesVarianceEvaluator.java
new file mode 100644
index 0000000..db4de6a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/AnglesVarianceEvaluator.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class AnglesVarianceEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value > 0.05) {
+      evaluation++;
+    }
+    if (value > 0.10) {
+      evaluation++;
+    }
+    if (value > 0.20) {
+      evaluation++;
+    }
+    if (value > 0.40) {
+      evaluation++;
+    }
+    if (value > 0.80) {
+      evaluation++;
+    }
+    if (value > 1.50) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/Classifier.java b/java/com/android/incallui/answer/impl/classifier/Classifier.java
new file mode 100644
index 0000000..c6fbff3
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/Classifier.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.hardware.SensorEvent;
+import android.view.MotionEvent;
+
+/** An abstract class for classifiers for touch and sensor events. */
+abstract class Classifier {
+
+  /** Contains all the information about touch events from which the classifier can query */
+  protected ClassifierData mClassifierData;
+
+  /** Informs the classifier that a new touch event has occurred */
+  public void onTouchEvent(MotionEvent event) {}
+
+  /** Informs the classifier that a sensor change occurred */
+  public void onSensorChanged(SensorEvent event) {}
+
+  public abstract String getTag();
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/ClassifierData.java b/java/com/android/incallui/answer/impl/classifier/ClassifierData.java
new file mode 100644
index 0000000..ae07d27
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/ClassifierData.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.util.SparseArray;
+import android.view.MotionEvent;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Contains data which is used to classify interaction sequences on the lockscreen. It does, for
+ * example, provide information on the current touch state.
+ */
+class ClassifierData {
+  private SparseArray<Stroke> mCurrentStrokes = new SparseArray<>();
+  private ArrayList<Stroke> mEndingStrokes = new ArrayList<>();
+  private final float mDpi;
+  private final float mScreenHeight;
+
+  public ClassifierData(float dpi, float screenHeight) {
+    mDpi = dpi;
+    mScreenHeight = screenHeight / dpi;
+  }
+
+  public void update(MotionEvent event) {
+    mEndingStrokes.clear();
+    int action = event.getActionMasked();
+    if (action == MotionEvent.ACTION_DOWN) {
+      mCurrentStrokes.clear();
+    }
+
+    for (int i = 0; i < event.getPointerCount(); i++) {
+      int id = event.getPointerId(i);
+      if (mCurrentStrokes.get(id) == null) {
+        // TODO (keyboardr): See if there's a way to use event.getEventTimeNanos() instead
+        mCurrentStrokes.put(
+            id, new Stroke(TimeUnit.MILLISECONDS.toNanos(event.getEventTime()), mDpi));
+      }
+      mCurrentStrokes
+          .get(id)
+          .addPoint(
+              event.getX(i), event.getY(i), TimeUnit.MILLISECONDS.toNanos(event.getEventTime()));
+
+      if (action == MotionEvent.ACTION_UP
+          || action == MotionEvent.ACTION_CANCEL
+          || (action == MotionEvent.ACTION_POINTER_UP && i == event.getActionIndex())) {
+        mEndingStrokes.add(getStroke(id));
+      }
+    }
+  }
+
+  void cleanUp(MotionEvent event) {
+    mEndingStrokes.clear();
+    int action = event.getActionMasked();
+    for (int i = 0; i < event.getPointerCount(); i++) {
+      int id = event.getPointerId(i);
+      if (action == MotionEvent.ACTION_UP
+          || action == MotionEvent.ACTION_CANCEL
+          || (action == MotionEvent.ACTION_POINTER_UP && i == event.getActionIndex())) {
+        mCurrentStrokes.remove(id);
+      }
+    }
+  }
+
+  /** @return the list of Strokes which are ending in the recently added MotionEvent */
+  public ArrayList<Stroke> getEndingStrokes() {
+    return mEndingStrokes;
+  }
+
+  /**
+   * @param id the id from MotionEvent
+   * @return the Stroke assigned to the id
+   */
+  public Stroke getStroke(int id) {
+    return mCurrentStrokes.get(id);
+  }
+
+  /** @return the height of the screen in inches */
+  public float getScreenHeight() {
+    return mScreenHeight;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/DirectionClassifier.java b/java/com/android/incallui/answer/impl/classifier/DirectionClassifier.java
new file mode 100644
index 0000000..0686268
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/DirectionClassifier.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the general direction of a stroke and evaluates it depending on the
+ * type of action that takes place.
+ */
+public class DirectionClassifier extends StrokeClassifier {
+  public DirectionClassifier(ClassifierData classifierData) {}
+
+  @Override
+  public String getTag() {
+    return "DIR";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    Point firstPoint = stroke.getPoints().get(0);
+    Point lastPoint = stroke.getPoints().get(stroke.getPoints().size() - 1);
+    return DirectionEvaluator.evaluate(lastPoint.x - firstPoint.x, lastPoint.y - firstPoint.y);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/DirectionEvaluator.java b/java/com/android/incallui/answer/impl/classifier/DirectionEvaluator.java
new file mode 100644
index 0000000..cdc1cfe
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/DirectionEvaluator.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class DirectionEvaluator {
+  public static float evaluate(float xDiff, float yDiff) {
+    return Math.abs(yDiff) < Math.abs(xDiff) ? 5.5f : 0.0f;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/DurationCountClassifier.java b/java/com/android/incallui/answer/impl/classifier/DurationCountClassifier.java
new file mode 100644
index 0000000..0b9f113
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/DurationCountClassifier.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the ratio between the duration of the stroke and its number of
+ * points.
+ */
+class DurationCountClassifier extends StrokeClassifier {
+  public DurationCountClassifier(ClassifierData classifierData) {}
+
+  @Override
+  public String getTag() {
+    return "DUR";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    return DurationCountEvaluator.evaluate(stroke.getDurationSeconds() / stroke.getCount());
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/DurationCountEvaluator.java b/java/com/android/incallui/answer/impl/classifier/DurationCountEvaluator.java
new file mode 100644
index 0000000..5b232fe
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/DurationCountEvaluator.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class DurationCountEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 0.0105) {
+      evaluation++;
+    }
+    if (value < 0.00909) {
+      evaluation++;
+    }
+    if (value < 0.00667) {
+      evaluation++;
+    }
+    if (value > 0.0333) {
+      evaluation++;
+    }
+    if (value > 0.0500) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/EndPointLengthClassifier.java b/java/com/android/incallui/answer/impl/classifier/EndPointLengthClassifier.java
new file mode 100644
index 0000000..95b3176
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/EndPointLengthClassifier.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the distance between the first and the last point from the stroke.
+ */
+class EndPointLengthClassifier extends StrokeClassifier {
+  public EndPointLengthClassifier(ClassifierData classifierData) {
+    mClassifierData = classifierData;
+  }
+
+  @Override
+  public String getTag() {
+    return "END_LNGTH";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    return EndPointLengthEvaluator.evaluate(stroke.getEndPointLength());
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/EndPointLengthEvaluator.java b/java/com/android/incallui/answer/impl/classifier/EndPointLengthEvaluator.java
new file mode 100644
index 0000000..74bfffb
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/EndPointLengthEvaluator.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class EndPointLengthEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 0.05) {
+      evaluation += 2.0f;
+    }
+    if (value < 0.1) {
+      evaluation += 2.0f;
+    }
+    if (value < 0.2) {
+      evaluation += 2.0f;
+    }
+    if (value < 0.3) {
+      evaluation += 2.0f;
+    }
+    if (value < 0.4) {
+      evaluation += 2.0f;
+    }
+    if (value < 0.5) {
+      evaluation += 2.0f;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/EndPointRatioClassifier.java b/java/com/android/incallui/answer/impl/classifier/EndPointRatioClassifier.java
new file mode 100644
index 0000000..01a35c1
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/EndPointRatioClassifier.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the ratio between the total length covered by the stroke and the
+ * distance between the first and last point from this stroke.
+ */
+class EndPointRatioClassifier extends StrokeClassifier {
+  public EndPointRatioClassifier(ClassifierData classifierData) {
+    mClassifierData = classifierData;
+  }
+
+  @Override
+  public String getTag() {
+    return "END_RTIO";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    float ratio;
+    if (stroke.getTotalLength() == 0.0f) {
+      ratio = 1.0f;
+    } else {
+      ratio = stroke.getEndPointLength() / stroke.getTotalLength();
+    }
+    return EndPointRatioEvaluator.evaluate(ratio);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/EndPointRatioEvaluator.java b/java/com/android/incallui/answer/impl/classifier/EndPointRatioEvaluator.java
new file mode 100644
index 0000000..1d64bea
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/EndPointRatioEvaluator.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class EndPointRatioEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 0.85) {
+      evaluation++;
+    }
+    if (value < 0.75) {
+      evaluation++;
+    }
+    if (value < 0.65) {
+      evaluation++;
+    }
+    if (value < 0.55) {
+      evaluation++;
+    }
+    if (value < 0.45) {
+      evaluation++;
+    }
+    if (value < 0.35) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/FalsingManager.java b/java/com/android/incallui/answer/impl/classifier/FalsingManager.java
new file mode 100644
index 0000000..fdcc0a3
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/FalsingManager.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.PowerManager;
+import android.view.MotionEvent;
+import android.view.accessibility.AccessibilityManager;
+
+/**
+ * When the phone is locked, listens to touch, sensor and phone events and sends them to
+ * HumanInteractionClassifier to determine if touches are coming from a human.
+ */
+public class FalsingManager implements SensorEventListener {
+  private static final int[] CLASSIFIER_SENSORS =
+      new int[] {
+        Sensor.TYPE_PROXIMITY,
+      };
+
+  private final SensorManager mSensorManager;
+  private final HumanInteractionClassifier mHumanInteractionClassifier;
+  private final AccessibilityManager mAccessibilityManager;
+
+  private boolean mSessionActive = false;
+  private boolean mScreenOn;
+
+  public FalsingManager(Context context) {
+    mSensorManager = context.getSystemService(SensorManager.class);
+    mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
+    mHumanInteractionClassifier = new HumanInteractionClassifier(context);
+    mScreenOn = context.getSystemService(PowerManager.class).isInteractive();
+  }
+
+  /** Returns {@code true} iff the FalsingManager is enabled and able to classify touches */
+  public boolean isEnabled() {
+    return mHumanInteractionClassifier.isEnabled();
+  }
+
+  /**
+   * Returns {@code true} iff the classifier determined that this is not a human interacting with
+   * the phone.
+   */
+  public boolean isFalseTouch() {
+    // Touch exploration triggers false positives in the classifier and
+    // already sufficiently prevents false unlocks.
+    return !mAccessibilityManager.isTouchExplorationEnabled()
+        && mHumanInteractionClassifier.isFalseTouch();
+  }
+
+  /**
+   * Should be called when the screen turns on and the related Views become visible. This will start
+   * tracking changes if the manager is enabled.
+   */
+  public void onScreenOn() {
+    mScreenOn = true;
+    sessionEntrypoint();
+  }
+
+  /**
+   * Should be called when the screen turns off or the related Views are no longer visible. This
+   * will cause the manager to stop tracking changes.
+   */
+  public void onScreenOff() {
+    mScreenOn = false;
+    sessionExitpoint();
+  }
+
+  /**
+   * Should be called when a new touch event has been received and should be classified.
+   *
+   * @param event MotionEvent to be classified as human or false.
+   */
+  public void onTouchEvent(MotionEvent event) {
+    if (mSessionActive) {
+      mHumanInteractionClassifier.onTouchEvent(event);
+    }
+  }
+
+  @Override
+  public synchronized void onSensorChanged(SensorEvent event) {
+    mHumanInteractionClassifier.onSensorChanged(event);
+  }
+
+  @Override
+  public void onAccuracyChanged(Sensor sensor, int accuracy) {}
+
+  private boolean shouldSessionBeActive() {
+    return isEnabled() && mScreenOn;
+  }
+
+  private boolean sessionEntrypoint() {
+    if (!mSessionActive && shouldSessionBeActive()) {
+      onSessionStart();
+      return true;
+    }
+    return false;
+  }
+
+  private void sessionExitpoint() {
+    if (mSessionActive && !shouldSessionBeActive()) {
+      mSessionActive = false;
+      mSensorManager.unregisterListener(this);
+    }
+  }
+
+  private void onSessionStart() {
+    mSessionActive = true;
+
+    if (mHumanInteractionClassifier.isEnabled()) {
+      registerSensors(CLASSIFIER_SENSORS);
+    }
+  }
+
+  private void registerSensors(int[] sensors) {
+    for (int sensorType : sensors) {
+      Sensor s = mSensorManager.getDefaultSensor(sensorType);
+      if (s != null) {
+        mSensorManager.registerListener(this, s, SensorManager.SENSOR_DELAY_GAME);
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/GestureClassifier.java b/java/com/android/incallui/answer/impl/classifier/GestureClassifier.java
new file mode 100644
index 0000000..afd7ea0
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/GestureClassifier.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * An abstract class for classifiers which classify the whole gesture (all the strokes which
+ * occurred from DOWN event to UP/CANCEL event)
+ */
+abstract class GestureClassifier extends Classifier {
+
+  /**
+   * @return a non-negative value which is used to determine whether the most recent gesture is a
+   *     false interaction; the bigger the value the greater the chance that this a false
+   *     interaction.
+   */
+  public abstract float getFalseTouchEvaluation();
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/HistoryEvaluator.java b/java/com/android/incallui/answer/impl/classifier/HistoryEvaluator.java
new file mode 100644
index 0000000..3f302c6
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/HistoryEvaluator.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.os.SystemClock;
+
+import java.util.ArrayList;
+
+/**
+ * Holds the evaluations for ended strokes and gestures. These values are decreased through time.
+ */
+class HistoryEvaluator {
+  private static final float INTERVAL = 50.0f;
+  private static final float HISTORY_FACTOR = 0.9f;
+  private static final float EPSILON = 1e-5f;
+
+  private final ArrayList<Data> mStrokes = new ArrayList<>();
+  private final ArrayList<Data> mGestureWeights = new ArrayList<>();
+  private long mLastUpdate;
+
+  public HistoryEvaluator() {
+    mLastUpdate = SystemClock.elapsedRealtime();
+  }
+
+  public void addStroke(float evaluation) {
+    decayValue();
+    mStrokes.add(new Data(evaluation));
+  }
+
+  public void addGesture(float evaluation) {
+    decayValue();
+    mGestureWeights.add(new Data(evaluation));
+  }
+
+  /** Calculates the weighted average of strokes and adds to it the weighted average of gestures */
+  public float getEvaluation() {
+    return weightedAverage(mStrokes) + weightedAverage(mGestureWeights);
+  }
+
+  private float weightedAverage(ArrayList<Data> list) {
+    float sumValue = 0.0f;
+    float sumWeight = 0.0f;
+    int size = list.size();
+    for (int i = 0; i < size; i++) {
+      Data data = list.get(i);
+      sumValue += data.evaluation * data.weight;
+      sumWeight += data.weight;
+    }
+
+    if (sumWeight == 0.0f) {
+      return 0.0f;
+    }
+
+    return sumValue / sumWeight;
+  }
+
+  private void decayValue() {
+    long time = SystemClock.elapsedRealtime();
+
+    if (time <= mLastUpdate) {
+      return;
+    }
+
+    // All weights are multiplied by HISTORY_FACTOR after each INTERVAL milliseconds.
+    float factor = (float) Math.pow(HISTORY_FACTOR, (time - mLastUpdate) / INTERVAL);
+
+    decayValue(mStrokes, factor);
+    decayValue(mGestureWeights, factor);
+    mLastUpdate = time;
+  }
+
+  private void decayValue(ArrayList<Data> list, float factor) {
+    int size = list.size();
+    for (int i = 0; i < size; i++) {
+      list.get(i).weight *= factor;
+    }
+
+    // Removing evaluations with such small weights that they do not matter anymore
+    while (!list.isEmpty() && isZero(list.get(0).weight)) {
+      list.remove(0);
+    }
+  }
+
+  private boolean isZero(float x) {
+    return x <= EPSILON && x >= -EPSILON;
+  }
+
+  /**
+   * For each stroke it holds its initial value and the current weight. Initially the weight is set
+   * to 1.0
+   */
+  private static class Data {
+    public float evaluation;
+    public float weight;
+
+    public Data(float evaluation) {
+      this.evaluation = evaluation;
+      weight = 1.0f;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java b/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java
new file mode 100644
index 0000000..1d3d7ef
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+import android.content.Context;
+import android.hardware.SensorEvent;
+import android.util.DisplayMetrics;
+import android.view.MotionEvent;
+import com.android.dialer.common.ConfigProviderBindings;
+
+/** An classifier trying to determine whether it is a human interacting with the phone or not. */
+class HumanInteractionClassifier extends Classifier {
+
+  private static final String CONFIG_ANSWER_FALSE_TOUCH_DETECTION_ENABLED =
+      "answer_false_touch_detection_enabled";
+
+  private final StrokeClassifier[] mStrokeClassifiers;
+  private final GestureClassifier[] mGestureClassifiers;
+  private final HistoryEvaluator mHistoryEvaluator;
+  private final boolean mEnabled;
+
+  HumanInteractionClassifier(Context context) {
+    DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+
+    // If the phone is rotated to landscape, the calculations would be wrong if xdpi and ydpi
+    // were to be used separately. Due negligible differences in xdpi and ydpi we can just
+    // take the average.
+    // Note that xdpi and ydpi are the physical pixels per inch and are not affected by scaling.
+    float dpi = (displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f;
+    mClassifierData = new ClassifierData(dpi, displayMetrics.heightPixels);
+    mHistoryEvaluator = new HistoryEvaluator();
+    mEnabled =
+        ConfigProviderBindings.get(context)
+            .getBoolean(CONFIG_ANSWER_FALSE_TOUCH_DETECTION_ENABLED, true);
+
+    mStrokeClassifiers =
+        new StrokeClassifier[] {
+          new AnglesClassifier(mClassifierData),
+          new SpeedClassifier(mClassifierData),
+          new DurationCountClassifier(mClassifierData),
+          new EndPointRatioClassifier(mClassifierData),
+          new EndPointLengthClassifier(mClassifierData),
+          new AccelerationClassifier(mClassifierData),
+          new SpeedAnglesClassifier(mClassifierData),
+          new LengthCountClassifier(mClassifierData),
+          new DirectionClassifier(mClassifierData)
+        };
+
+    mGestureClassifiers =
+        new GestureClassifier[] {
+          new PointerCountClassifier(mClassifierData), new ProximityClassifier(mClassifierData)
+        };
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+
+    // If the user is dragging down the notification, they might want to drag it down
+    // enough to see the content, read it for a while and then lift the finger to open
+    // the notification. This kind of motion scores very bad in the Classifier so the
+    // MotionEvents which are close to the current position of the finger are not
+    // sent to the classifiers until the finger moves far enough. When the finger if lifted
+    // up, the last MotionEvent which was far enough from the finger is set as the final
+    // MotionEvent and sent to the Classifiers.
+    addTouchEvent(event);
+  }
+
+  private void addTouchEvent(MotionEvent event) {
+    mClassifierData.update(event);
+
+    for (StrokeClassifier c : mStrokeClassifiers) {
+      c.onTouchEvent(event);
+    }
+
+    for (GestureClassifier c : mGestureClassifiers) {
+      c.onTouchEvent(event);
+    }
+
+    int size = mClassifierData.getEndingStrokes().size();
+    for (int i = 0; i < size; i++) {
+      Stroke stroke = mClassifierData.getEndingStrokes().get(i);
+      float evaluation = 0.0f;
+      for (StrokeClassifier c : mStrokeClassifiers) {
+        float e = c.getFalseTouchEvaluation(stroke);
+        evaluation += e;
+      }
+
+      mHistoryEvaluator.addStroke(evaluation);
+    }
+
+    int action = event.getActionMasked();
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+      float evaluation = 0.0f;
+      for (GestureClassifier c : mGestureClassifiers) {
+        float e = c.getFalseTouchEvaluation();
+        evaluation += e;
+      }
+      mHistoryEvaluator.addGesture(evaluation);
+    }
+
+    mClassifierData.cleanUp(event);
+  }
+
+  @Override
+  public void onSensorChanged(SensorEvent event) {
+    for (Classifier c : mStrokeClassifiers) {
+      c.onSensorChanged(event);
+    }
+
+    for (Classifier c : mGestureClassifiers) {
+      c.onSensorChanged(event);
+    }
+  }
+
+  boolean isFalseTouch() {
+    float evaluation = mHistoryEvaluator.getEvaluation();
+    return evaluation >= 5.0f;
+  }
+
+  public boolean isEnabled() {
+    return mEnabled;
+  }
+
+  @Override
+  public String getTag() {
+    return "HIC";
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/LengthCountClassifier.java b/java/com/android/incallui/answer/impl/classifier/LengthCountClassifier.java
new file mode 100644
index 0000000..7dd2ab6
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/LengthCountClassifier.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the ratio between the length of the stroke and its number of points.
+ * The number of points is subtracted by 2 because the UP event comes in with some delay and it
+ * should not influence the ratio and also strokes which are long and have a small number of points
+ * are punished more (these kind of strokes are usually bad ones and they tend to score well in
+ * other classifiers).
+ */
+class LengthCountClassifier extends StrokeClassifier {
+  public LengthCountClassifier(ClassifierData classifierData) {}
+
+  @Override
+  public String getTag() {
+    return "LEN_CNT";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    return LengthCountEvaluator.evaluate(
+        stroke.getTotalLength() / Math.max(1.0f, stroke.getCount() - 2));
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/LengthCountEvaluator.java b/java/com/android/incallui/answer/impl/classifier/LengthCountEvaluator.java
new file mode 100644
index 0000000..2a2225a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/LengthCountEvaluator.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/**
+ * A classifier which looks at the ratio between the length of the stroke and its number of points.
+ */
+class LengthCountEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 0.09) {
+      evaluation++;
+    }
+    if (value < 0.05) {
+      evaluation++;
+    }
+    if (value < 0.02) {
+      evaluation++;
+    }
+    if (value > 0.6) {
+      evaluation++;
+    }
+    if (value > 0.9) {
+      evaluation++;
+    }
+    if (value > 1.2) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/Point.java b/java/com/android/incallui/answer/impl/classifier/Point.java
new file mode 100644
index 0000000..5ea48b4
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/Point.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class Point {
+  public float x;
+  public float y;
+  public long timeOffsetNano;
+
+  public Point(float x, float y) {
+    this.x = x;
+    this.y = y;
+    this.timeOffsetNano = 0;
+  }
+
+  public Point(float x, float y, long timeOffsetNano) {
+    this.x = x;
+    this.y = y;
+    this.timeOffsetNano = timeOffsetNano;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof Point)) {
+      return false;
+    }
+    Point otherPoint = ((Point) other);
+    return x == otherPoint.x && y == otherPoint.y;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = (x != +0.0f ? Float.floatToIntBits(x) : 0);
+    result = 31 * result + (y != +0.0f ? Float.floatToIntBits(y) : 0);
+    return result;
+  }
+
+  public float dist(Point a) {
+    return (float) Math.hypot(a.x - x, a.y - y);
+  }
+
+  /**
+   * Calculates the cross product of vec(this, a) and vec(this, b) where vec(x,y) is the vector from
+   * point x to point y
+   */
+  public float crossProduct(Point a, Point b) {
+    return (a.x - x) * (b.y - y) - (a.y - y) * (b.x - x);
+  }
+
+  /**
+   * Calculates the dot product of vec(this, a) and vec(this, b) where vec(x,y) is the vector from
+   * point x to point y
+   */
+  public float dotProduct(Point a, Point b) {
+    return (a.x - x) * (b.x - x) + (a.y - y) * (b.y - y);
+  }
+
+  /**
+   * Calculates the angle in radians created by points (a, this, b). If any two of these points are
+   * the same, the method will return 0.0f
+   *
+   * @return the angle in radians
+   */
+  public float getAngle(Point a, Point b) {
+    float dist1 = dist(a);
+    float dist2 = dist(b);
+
+    if (dist1 == 0.0f || dist2 == 0.0f) {
+      return 0.0f;
+    }
+
+    float crossProduct = crossProduct(a, b);
+    float dotProduct = dotProduct(a, b);
+    float cos = Math.min(1.0f, Math.max(-1.0f, dotProduct / dist1 / dist2));
+    float angle = (float) Math.acos(cos);
+    if (crossProduct < 0.0) {
+      angle = 2.0f * (float) Math.PI - angle;
+    }
+    return angle;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/PointerCountClassifier.java b/java/com/android/incallui/answer/impl/classifier/PointerCountClassifier.java
new file mode 100644
index 0000000..070de6c
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/PointerCountClassifier.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.view.MotionEvent;
+
+/** A classifier which looks at the total number of traces in the whole gesture. */
+class PointerCountClassifier extends GestureClassifier {
+  private int mCount;
+
+  public PointerCountClassifier(ClassifierData classifierData) {
+    mCount = 0;
+  }
+
+  @Override
+  public String getTag() {
+    return "PTR_CNT";
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      mCount = 1;
+    }
+
+    if (action == MotionEvent.ACTION_POINTER_DOWN) {
+      ++mCount;
+    }
+  }
+
+  @Override
+  public float getFalseTouchEvaluation() {
+    return PointerCountEvaluator.evaluate(mCount);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/PointerCountEvaluator.java b/java/com/android/incallui/answer/impl/classifier/PointerCountEvaluator.java
new file mode 100644
index 0000000..aa972da
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/PointerCountEvaluator.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class PointerCountEvaluator {
+  public static float evaluate(int value) {
+    return (value - 1) * (value - 1);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/ProximityClassifier.java b/java/com/android/incallui/answer/impl/classifier/ProximityClassifier.java
new file mode 100644
index 0000000..28701ea
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/ProximityClassifier.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.view.MotionEvent;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A classifier which looks at the proximity sensor during the gesture. It calculates the percentage
+ * the proximity sensor showing the near state during the whole gesture
+ */
+class ProximityClassifier extends GestureClassifier {
+  private long mGestureStartTimeNano;
+  private long mNearStartTimeNano;
+  private long mNearDuration;
+  private boolean mNear;
+  private float mAverageNear;
+
+  public ProximityClassifier(ClassifierData classifierData) {}
+
+  @Override
+  public String getTag() {
+    return "PROX";
+  }
+
+  @Override
+  public void onSensorChanged(SensorEvent event) {
+    if (event.sensor.getType() == Sensor.TYPE_PROXIMITY) {
+      update(event.values[0] < event.sensor.getMaximumRange(), event.timestamp);
+    }
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      mGestureStartTimeNano = TimeUnit.MILLISECONDS.toNanos(event.getEventTime());
+      mNearStartTimeNano = TimeUnit.MILLISECONDS.toNanos(event.getEventTime());
+      mNearDuration = 0;
+    }
+
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+      update(mNear, TimeUnit.MILLISECONDS.toNanos(event.getEventTime()));
+      long duration = TimeUnit.MILLISECONDS.toNanos(event.getEventTime()) - mGestureStartTimeNano;
+
+      if (duration == 0) {
+        mAverageNear = mNear ? 1.0f : 0.0f;
+      } else {
+        mAverageNear = (float) mNearDuration / (float) duration;
+      }
+    }
+  }
+
+  /**
+   * @param near is the sensor showing the near state right now
+   * @param timestampNano time of this event in nanoseconds
+   */
+  private void update(boolean near, long timestampNano) {
+    // This if is necessary because MotionEvents and SensorEvents do not come in
+    // chronological order
+    if (timestampNano > mNearStartTimeNano) {
+      // if the state before was near then add the difference of the current time and
+      // mNearStartTimeNano to mNearDuration.
+      if (mNear) {
+        mNearDuration += timestampNano - mNearStartTimeNano;
+      }
+
+      // if the new state is near, set mNearStartTimeNano equal to this moment.
+      if (near) {
+        mNearStartTimeNano = timestampNano;
+      }
+    }
+    mNear = near;
+  }
+
+  @Override
+  public float getFalseTouchEvaluation() {
+    return ProximityEvaluator.evaluate(mAverageNear);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/ProximityEvaluator.java b/java/com/android/incallui/answer/impl/classifier/ProximityEvaluator.java
new file mode 100644
index 0000000..14636c6
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/ProximityEvaluator.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class ProximityEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    float threshold = 0.1f;
+    if (value >= threshold) {
+      evaluation += 2.0f;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedAnglesClassifier.java b/java/com/android/incallui/answer/impl/classifier/SpeedAnglesClassifier.java
new file mode 100644
index 0000000..36ae3ad
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedAnglesClassifier.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+import android.util.ArrayMap;
+import android.view.MotionEvent;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A classifier which for each point from a stroke, it creates a point on plane with coordinates
+ * (timeOffsetNano, distanceCoveredUpToThisPoint) (scaled by DURATION_SCALE and LENGTH_SCALE) and
+ * then it calculates the angle variance of these points like the class {@link AnglesClassifier}
+ * (without splitting it into two parts). The classifier ignores the last point of a stroke because
+ * the UP event comes in with some delay and this ruins the smoothness of this curve. Additionally,
+ * the classifier classifies calculates the percentage of angles which value is in [PI -
+ * ANGLE_DEVIATION, 2* PI) interval. The reason why the classifier does that is because the speed of
+ * a good stroke is most often increases, so most of these angels should be in this interval.
+ */
+class SpeedAnglesClassifier extends StrokeClassifier {
+  private Map<Stroke, Data> mStrokeMap = new ArrayMap<>();
+
+  public SpeedAnglesClassifier(ClassifierData classifierData) {
+    mClassifierData = classifierData;
+  }
+
+  @Override
+  public String getTag() {
+    return "SPD_ANG";
+  }
+
+  @Override
+  public void onTouchEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      mStrokeMap.clear();
+    }
+
+    for (int i = 0; i < event.getPointerCount(); i++) {
+      Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));
+
+      if (mStrokeMap.get(stroke) == null) {
+        mStrokeMap.put(stroke, new Data());
+      }
+
+      if (action != MotionEvent.ACTION_UP
+          && action != MotionEvent.ACTION_CANCEL
+          && !(action == MotionEvent.ACTION_POINTER_UP && i == event.getActionIndex())) {
+        mStrokeMap.get(stroke).addPoint(stroke.getPoints().get(stroke.getPoints().size() - 1));
+      }
+    }
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    Data data = mStrokeMap.get(stroke);
+    return SpeedVarianceEvaluator.evaluate(data.getAnglesVariance())
+        + SpeedAnglesPercentageEvaluator.evaluate(data.getAnglesPercentage());
+  }
+
+  private static class Data {
+    private static final float DURATION_SCALE = 1e8f;
+    private static final float LENGTH_SCALE = 1.0f;
+    private static final float ANGLE_DEVIATION = (float) Math.PI / 10.0f;
+
+    private List<Point> mLastThreePoints = new ArrayList<>();
+    private Point mPreviousPoint;
+    private float mPreviousAngle;
+    private float mSumSquares;
+    private float mSum;
+    private float mCount;
+    private float mDist;
+    private float mAnglesCount;
+    private float mAcceleratingAngles;
+
+    public Data() {
+      mPreviousPoint = null;
+      mPreviousAngle = (float) Math.PI;
+      mSumSquares = 0.0f;
+      mSum = 0.0f;
+      mCount = 1.0f;
+      mDist = 0.0f;
+      mAnglesCount = mAcceleratingAngles = 0.0f;
+    }
+
+    public void addPoint(Point point) {
+      if (mPreviousPoint != null) {
+        mDist += mPreviousPoint.dist(point);
+      }
+
+      mPreviousPoint = point;
+      Point speedPoint =
+          new Point((float) point.timeOffsetNano / DURATION_SCALE, mDist / LENGTH_SCALE);
+
+      // Checking if the added point is different than the previously added point
+      // Repetitions are being ignored so that proper angles are calculated.
+      if (mLastThreePoints.isEmpty()
+          || !mLastThreePoints.get(mLastThreePoints.size() - 1).equals(speedPoint)) {
+        mLastThreePoints.add(speedPoint);
+        if (mLastThreePoints.size() == 4) {
+          mLastThreePoints.remove(0);
+
+          float angle =
+              mLastThreePoints.get(1).getAngle(mLastThreePoints.get(0), mLastThreePoints.get(2));
+
+          mAnglesCount++;
+          if (angle >= (float) Math.PI - ANGLE_DEVIATION) {
+            mAcceleratingAngles++;
+          }
+
+          float difference = angle - mPreviousAngle;
+          mSum += difference;
+          mSumSquares += difference * difference;
+          mCount += 1.0f;
+          mPreviousAngle = angle;
+        }
+      }
+    }
+
+    public float getAnglesVariance() {
+      return mSumSquares / mCount - (mSum / mCount) * (mSum / mCount);
+    }
+
+    public float getAnglesPercentage() {
+      if (mAnglesCount == 0.0f) {
+        return 1.0f;
+      }
+      return (mAcceleratingAngles) / mAnglesCount;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedAnglesPercentageEvaluator.java b/java/com/android/incallui/answer/impl/classifier/SpeedAnglesPercentageEvaluator.java
new file mode 100644
index 0000000..5a8bc35
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedAnglesPercentageEvaluator.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class SpeedAnglesPercentageEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 1.00) {
+      evaluation++;
+    }
+    if (value < 0.90) {
+      evaluation++;
+    }
+    if (value < 0.70) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedClassifier.java b/java/com/android/incallui/answer/impl/classifier/SpeedClassifier.java
new file mode 100644
index 0000000..f3ade3f
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedClassifier.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+/**
+ * A classifier that looks at the speed of the stroke. It calculates the speed of a stroke in inches
+ * per second.
+ */
+class SpeedClassifier extends StrokeClassifier {
+
+  public SpeedClassifier(ClassifierData classifierData) {}
+
+  @Override
+  public String getTag() {
+    return "SPD";
+  }
+
+  @Override
+  public float getFalseTouchEvaluation(Stroke stroke) {
+    float duration = stroke.getDurationSeconds();
+    if (duration == 0.0f) {
+      return SpeedEvaluator.evaluate(0.0f);
+    }
+    return SpeedEvaluator.evaluate(stroke.getTotalLength() / duration);
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedEvaluator.java b/java/com/android/incallui/answer/impl/classifier/SpeedEvaluator.java
new file mode 100644
index 0000000..4f9aace
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedEvaluator.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class SpeedEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value < 4.0) {
+      evaluation++;
+    }
+    if (value < 2.2) {
+      evaluation++;
+    }
+    if (value > 35.0) {
+      evaluation++;
+    }
+    if (value > 50.0) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedRatioEvaluator.java b/java/com/android/incallui/answer/impl/classifier/SpeedRatioEvaluator.java
new file mode 100644
index 0000000..7ae1113
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedRatioEvaluator.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class SpeedRatioEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value == 0) {
+      return 0;
+    }
+    if (value <= 1.0) {
+      evaluation++;
+    }
+    if (value <= 0.5) {
+      evaluation++;
+    }
+    if (value > 9.0) {
+      evaluation++;
+    }
+    if (value > 18.0) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/SpeedVarianceEvaluator.java b/java/com/android/incallui/answer/impl/classifier/SpeedVarianceEvaluator.java
new file mode 100644
index 0000000..211650c
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/SpeedVarianceEvaluator.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+class SpeedVarianceEvaluator {
+  public static float evaluate(float value) {
+    float evaluation = 0.0f;
+    if (value > 0.06) {
+      evaluation++;
+    }
+    if (value > 0.15) {
+      evaluation++;
+    }
+    if (value > 0.3) {
+      evaluation++;
+    }
+    if (value > 0.6) {
+      evaluation++;
+    }
+    return evaluation;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/Stroke.java b/java/com/android/incallui/answer/impl/classifier/Stroke.java
new file mode 100644
index 0000000..c542d0f
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/Stroke.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.classifier;
+
+import java.util.ArrayList;
+
+/**
+ * Contains data about a stroke (a single trace, all the events from a given id from the
+ * DOWN/POINTER_DOWN event till the UP/POINTER_UP/CANCEL event.)
+ */
+class Stroke {
+
+  private static final float NANOS_TO_SECONDS = 1e9f;
+
+  private ArrayList<Point> mPoints = new ArrayList<>();
+  private long mStartTimeNano;
+  private long mEndTimeNano;
+  private float mLength;
+  private final float mDpi;
+
+  public Stroke(long eventTimeNano, float dpi) {
+    mDpi = dpi;
+    mStartTimeNano = mEndTimeNano = eventTimeNano;
+  }
+
+  public void addPoint(float x, float y, long eventTimeNano) {
+    mEndTimeNano = eventTimeNano;
+    Point point = new Point(x / mDpi, y / mDpi, eventTimeNano - mStartTimeNano);
+    if (!mPoints.isEmpty()) {
+      mLength += mPoints.get(mPoints.size() - 1).dist(point);
+    }
+    mPoints.add(point);
+  }
+
+  public int getCount() {
+    return mPoints.size();
+  }
+
+  public float getTotalLength() {
+    return mLength;
+  }
+
+  public float getEndPointLength() {
+    return mPoints.get(0).dist(mPoints.get(mPoints.size() - 1));
+  }
+
+  public long getDurationNanos() {
+    return mEndTimeNano - mStartTimeNano;
+  }
+
+  public float getDurationSeconds() {
+    return (float) getDurationNanos() / NANOS_TO_SECONDS;
+  }
+
+  public ArrayList<Point> getPoints() {
+    return mPoints;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/classifier/StrokeClassifier.java b/java/com/android/incallui/answer/impl/classifier/StrokeClassifier.java
new file mode 100644
index 0000000..8abd7e2
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/classifier/StrokeClassifier.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.answer.impl.classifier;
+
+/** An abstract class for classifiers which classify each stroke separately. */
+abstract class StrokeClassifier extends Classifier {
+
+  /**
+   * @param stroke the stroke for which the evaluation will be calculated
+   * @return a non-negative value which is used to determine whether this a false touch; the bigger
+   *     the value the greater the chance that this a false touch
+   */
+  public abstract float getFalseTouchEvaluation(Stroke stroke);
+}
diff --git a/java/com/android/incallui/answer/impl/hint/AndroidManifest.xml b/java/com/android/incallui/answer/impl/hint/AndroidManifest.xml
new file mode 100644
index 0000000..b5fa6da
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/AndroidManifest.xml
@@ -0,0 +1,13 @@
+<manifest
+  package="com.android.incallui.answer.impl.hint"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <application>
+    <receiver android:name=".EventSecretCodeListener">
+      <intent-filter>
+        <action android:name="android.provider.Telephony.SECRET_CODE" />
+        <data android:scheme="android_secret_code" />
+      </intent-filter>
+    </receiver>
+  </application>
+</manifest>
diff --git a/java/com/android/incallui/answer/impl/hint/AnswerHint.java b/java/com/android/incallui/answer/impl/hint/AnswerHint.java
new file mode 100644
index 0000000..dd3b822
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/AnswerHint.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+/** Interface to overlay a hint of how to answer the call. */
+public interface AnswerHint {
+
+  /**
+   * Inflates the hint's layout into the container.
+   *
+   * <p>TODO: if the hint becomes more dependent on other UI elements of the AnswerFragment,
+   * should put put and hintText into another data structure.
+   */
+  void onCreateView(LayoutInflater inflater, ViewGroup container, View puck, TextView hintText);
+
+  /** Called when the puck bounce animation begins. */
+  void onBounceStart();
+
+  /**
+   * Called when the bounce animation has ended (transitioned into other animations). The hint
+   * should reset itself.
+   */
+  void onBounceEnd();
+
+  /** Called when the call is accepted or rejected through user interaction. */
+  void onAnswered();
+}
diff --git a/java/com/android/incallui/answer/impl/hint/AnswerHintFactory.java b/java/com/android/incallui/answer/impl/hint/AnswerHintFactory.java
new file mode 100644
index 0000000..45395a7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/AnswerHintFactory.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.preference.PreferenceManager;
+import android.support.annotation.NonNull;
+import android.support.annotation.VisibleForTesting;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProvider;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.util.AccessibilityUtil;
+import java.util.Calendar;
+
+/**
+ * Selects a AnswerHint to show. If there's no suitable hints {@link EmptyAnswerHint} will be used,
+ * which does nothing.
+ */
+public class AnswerHintFactory {
+
+  private static final String CONFIG_ANSWER_HINT_ANSWERED_THRESHOLD_KEY =
+      "answer_hint_answered_threshold";
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_ANSWER_HINT_WHITELISTED_DEVICES_KEY =
+      "answer_hint_whitelisted_devices";
+  // Most popular devices released before NDR1 is whitelisted. Their user are likely to have seen
+  // the legacy UI.
+  private static final String DEFAULT_WHITELISTED_DEVICES_CSV =
+      "/hammerhead//bullhead//angler//shamu//gm4g//gm4g_s//AQ4501//gce_x86_phone//gm4gtkc_s/"
+          + "/Sparkle_V//Mi-498//AQ4502//imobileiq2//A65//H940//m8_google//m0xx//A10//ctih220/"
+          + "/Mi438S//bacon/";
+
+  @VisibleForTesting
+  static final String ANSWERED_COUNT_PREFERENCE_KEY = "answer_hint_answered_count";
+
+  private final EventPayloadLoader eventPayloadLoader;
+
+  public AnswerHintFactory(@NonNull EventPayloadLoader eventPayloadLoader) {
+    this.eventPayloadLoader = Assert.isNotNull(eventPayloadLoader);
+  }
+
+  @NonNull
+  public AnswerHint create(Context context, long puckUpDuration, long puckUpDelay) {
+
+    if (shouldShowAnswerHint(
+        context,
+        ConfigProviderBindings.get(context),
+        getDeviceProtectedPreferences(context),
+        Build.PRODUCT)) {
+      return new DotAnswerHint(context, puckUpDuration, puckUpDelay);
+    }
+
+    // Display the event answer hint if the payload is available.
+    Drawable eventPayload =
+        eventPayloadLoader.loadPayload(
+            context, System.currentTimeMillis(), Calendar.getInstance().getTimeZone());
+    if (eventPayload != null) {
+      return new EventAnswerHint(context, eventPayload, puckUpDuration, puckUpDelay);
+    }
+
+    return new EmptyAnswerHint();
+  }
+
+  public static void increaseAnsweredCount(Context context) {
+    SharedPreferences sharedPreferences = getDeviceProtectedPreferences(context);
+    int answeredCount = sharedPreferences.getInt(ANSWERED_COUNT_PREFERENCE_KEY, 0);
+    sharedPreferences.edit().putInt(ANSWERED_COUNT_PREFERENCE_KEY, answeredCount + 1).apply();
+  }
+
+  @VisibleForTesting
+  static boolean shouldShowAnswerHint(
+      Context context,
+      ConfigProvider configProvider,
+      SharedPreferences sharedPreferences,
+      String device) {
+    if (AccessibilityUtil.isTouchExplorationEnabled(context)) {
+      return false;
+    }
+    // Devices that has the legacy dialer installed are whitelisted as they are likely to go through
+    // a UX change during updates.
+    if (!isDeviceWhitelisted(device, configProvider)) {
+      return false;
+    }
+
+    // If the user has gone through the process a few times we can assume they have learnt the
+    // method.
+    int answeredCount = sharedPreferences.getInt(ANSWERED_COUNT_PREFERENCE_KEY, 0);
+    long threshold = configProvider.getLong(CONFIG_ANSWER_HINT_ANSWERED_THRESHOLD_KEY, 3);
+    LogUtil.i(
+        "AnswerHintFactory.shouldShowAnswerHint",
+        "answerCount: %d, threshold: %d",
+        answeredCount,
+        threshold);
+    return answeredCount < threshold;
+  }
+
+  /**
+   * @param device should be the value of{@link Build#PRODUCT}.
+   * @param configProvider should provide a list of devices quoted with '/' concatenated to a
+   *     string.
+   */
+  private static boolean isDeviceWhitelisted(String device, ConfigProvider configProvider) {
+    return configProvider
+        .getString(CONFIG_ANSWER_HINT_WHITELISTED_DEVICES_KEY, DEFAULT_WHITELISTED_DEVICES_CSV)
+        .contains("/" + device + "/");
+  }
+
+  private static SharedPreferences getDeviceProtectedPreferences(Context context) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      return PreferenceManager.getDefaultSharedPreferences(context);
+    }
+    return PreferenceManager.getDefaultSharedPreferences(
+        context.createDeviceProtectedStorageContext());
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/hint/DotAnswerHint.java b/java/com/android/incallui/answer/impl/hint/DotAnswerHint.java
new file mode 100644
index 0000000..394fe58
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/DotAnswerHint.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.support.annotation.DimenRes;
+import android.support.v4.view.animation.FastOutSlowInInterpolator;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+import android.widget.TextView;
+
+/** An Answer hint that uses a green swiping dot. */
+public class DotAnswerHint implements AnswerHint {
+
+  private static final float ANSWER_HINT_SMALL_ALPHA = 0.8f;
+  private static final float ANSWER_HINT_MID_ALPHA = 0.5f;
+  private static final float ANSWER_HINT_LARGE_ALPHA = 0.2f;
+
+  private static final long FADE_IN_DELAY_SCALE_MILLIS = 380;
+  private static final long FADE_IN_DURATION_SCALE_MILLIS = 200;
+  private static final long FADE_IN_DELAY_ALPHA_MILLIS = 340;
+  private static final long FADE_IN_DURATION_ALPHA_MILLIS = 50;
+
+  private static final long SWIPE_UP_DURATION_ALPHA_MILLIS = 500;
+
+  private static final long FADE_OUT_DELAY_SCALE_SMALL_MILLIS = 90;
+  private static final long FADE_OUT_DELAY_SCALE_MID_MILLIS = 70;
+  private static final long FADE_OUT_DELAY_SCALE_LARGE_MILLIS = 10;
+  private static final long FADE_OUT_DURATION_SCALE_MILLIS = 100;
+  private static final long FADE_OUT_DELAY_ALPHA_MILLIS = 130;
+  private static final long FADE_OUT_DURATION_ALPHA_MILLIS = 170;
+
+  private final Context context;
+  private final long puckUpDurationMillis;
+  private final long puckUpDelayMillis;
+
+  private View puck;
+
+  private View answerHintSmall;
+  private View answerHintMid;
+  private View answerHintLarge;
+  private View answerHintContainer;
+  private AnimatorSet answerGestureHintAnim;
+
+  public DotAnswerHint(Context context, long puckUpDurationMillis, long puckUpDelayMillis) {
+    this.context = context;
+    this.puckUpDurationMillis = puckUpDurationMillis;
+    this.puckUpDelayMillis = puckUpDelayMillis;
+  }
+
+  @Override
+  public void onCreateView(
+      LayoutInflater inflater, ViewGroup container, View puck, TextView hintText) {
+    this.puck = puck;
+    View view = inflater.inflate(R.layout.dot_hint, container, true);
+    answerHintContainer = view.findViewById(R.id.answer_hint_container);
+    answerHintSmall = view.findViewById(R.id.answer_hint_small);
+    answerHintMid = view.findViewById(R.id.answer_hint_mid);
+    answerHintLarge = view.findViewById(R.id.answer_hint_large);
+    hintText.setTextSize(
+        TypedValue.COMPLEX_UNIT_PX, context.getResources().getDimension(R.dimen.hint_text_size));
+  }
+
+  @Override
+  public void onBounceStart() {
+    if (answerGestureHintAnim == null) {
+      answerGestureHintAnim = new AnimatorSet();
+      answerHintContainer.setY(puck.getY() + getDimension(R.dimen.hint_initial_offset));
+
+      Animator fadeIn = createFadeIn();
+
+      Animator swipeUp =
+          ObjectAnimator.ofFloat(
+              answerHintContainer,
+              View.TRANSLATION_Y,
+              puck.getY() - getDimension(R.dimen.hint_offset));
+      swipeUp.setInterpolator(new FastOutSlowInInterpolator());
+      swipeUp.setDuration(SWIPE_UP_DURATION_ALPHA_MILLIS);
+
+      Animator fadeOut = createFadeOut();
+
+      answerGestureHintAnim.play(fadeIn).after(puckUpDelayMillis);
+      answerGestureHintAnim.play(swipeUp).after(fadeIn);
+      // The fade out should start fading the alpha just as the puck is dropping. Scaling will start
+      // a bit earlier.
+      answerGestureHintAnim
+          .play(fadeOut)
+          .after(puckUpDelayMillis + puckUpDurationMillis - FADE_OUT_DELAY_ALPHA_MILLIS);
+
+      fadeIn.addListener(
+          new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+              super.onAnimationStart(animation);
+              answerHintSmall.setAlpha(0);
+              answerHintSmall.setScaleX(1);
+              answerHintSmall.setScaleY(1);
+              answerHintMid.setAlpha(0);
+              answerHintMid.setScaleX(1);
+              answerHintMid.setScaleY(1);
+              answerHintLarge.setAlpha(0);
+              answerHintLarge.setScaleX(1);
+              answerHintLarge.setScaleY(1);
+              answerHintContainer.setY(puck.getY() + getDimension(R.dimen.hint_initial_offset));
+              answerHintContainer.setVisibility(View.VISIBLE);
+            }
+          });
+    }
+
+    answerGestureHintAnim.start();
+  }
+
+  private Animator createFadeIn() {
+    AnimatorSet set = new AnimatorSet();
+    set.play(
+            createFadeInScaleAndAlpha(
+                answerHintSmall,
+                R.dimen.hint_small_begin_size,
+                R.dimen.hint_small_end_size,
+                ANSWER_HINT_SMALL_ALPHA))
+        .with(
+            createFadeInScaleAndAlpha(
+                answerHintMid,
+                R.dimen.hint_mid_begin_size,
+                R.dimen.hint_mid_end_size,
+                ANSWER_HINT_MID_ALPHA))
+        .with(
+            createFadeInScaleAndAlpha(
+                answerHintLarge,
+                R.dimen.hint_large_begin_size,
+                R.dimen.hint_large_end_size,
+                ANSWER_HINT_LARGE_ALPHA));
+    return set;
+  }
+
+  private Animator createFadeInScaleAndAlpha(
+      View target, @DimenRes int beginSize, @DimenRes int endSize, float endAlpha) {
+    Animator scale =
+        createUniformScaleAnimator(
+            target,
+            getDimension(beginSize),
+            getDimension(beginSize),
+            getDimension(endSize),
+            FADE_IN_DURATION_SCALE_MILLIS,
+            FADE_IN_DELAY_SCALE_MILLIS,
+            new LinearInterpolator());
+    Animator alpha =
+        createAlphaAnimator(
+            target,
+            0f,
+            endAlpha,
+            FADE_IN_DURATION_ALPHA_MILLIS,
+            FADE_IN_DELAY_ALPHA_MILLIS,
+            new LinearInterpolator());
+    AnimatorSet set = new AnimatorSet();
+    set.play(scale).with(alpha);
+    return set;
+  }
+
+  private Animator createFadeOut() {
+    AnimatorSet set = new AnimatorSet();
+    set.play(
+            createFadeOutScaleAndAlpha(
+                answerHintSmall,
+                R.dimen.hint_small_begin_size,
+                R.dimen.hint_small_end_size,
+                FADE_OUT_DELAY_SCALE_SMALL_MILLIS,
+                ANSWER_HINT_SMALL_ALPHA))
+        .with(
+            createFadeOutScaleAndAlpha(
+                answerHintMid,
+                R.dimen.hint_mid_begin_size,
+                R.dimen.hint_mid_end_size,
+                FADE_OUT_DELAY_SCALE_MID_MILLIS,
+                ANSWER_HINT_MID_ALPHA))
+        .with(
+            createFadeOutScaleAndAlpha(
+                answerHintLarge,
+                R.dimen.hint_large_begin_size,
+                R.dimen.hint_large_end_size,
+                FADE_OUT_DELAY_SCALE_LARGE_MILLIS,
+                ANSWER_HINT_LARGE_ALPHA));
+    return set;
+  }
+
+  private Animator createFadeOutScaleAndAlpha(
+      View target,
+      @DimenRes int beginSize,
+      @DimenRes int endSize,
+      long scaleDelay,
+      float endAlpha) {
+    Animator scale =
+        createUniformScaleAnimator(
+            target,
+            getDimension(beginSize),
+            getDimension(endSize),
+            getDimension(beginSize),
+            FADE_OUT_DURATION_SCALE_MILLIS,
+            scaleDelay,
+            new LinearInterpolator());
+    Animator alpha =
+        createAlphaAnimator(
+            target,
+            endAlpha,
+            0.0f,
+            FADE_OUT_DURATION_ALPHA_MILLIS,
+            FADE_OUT_DELAY_ALPHA_MILLIS,
+            new LinearInterpolator());
+    AnimatorSet set = new AnimatorSet();
+    set.play(scale).with(alpha);
+    return set;
+  }
+
+  @Override
+  public void onBounceEnd() {
+    if (answerGestureHintAnim != null) {
+      answerGestureHintAnim.end();
+      answerGestureHintAnim = null;
+      answerHintContainer.setVisibility(View.GONE);
+    }
+  }
+
+  @Override
+  public void onAnswered() {
+    AnswerHintFactory.increaseAnsweredCount(context);
+  }
+
+  private float getDimension(@DimenRes int id) {
+    return context.getResources().getDimension(id);
+  }
+
+  private static Animator createUniformScaleAnimator(
+      View target,
+      float original,
+      float begin,
+      float end,
+      long duration,
+      long delay,
+      Interpolator interpolator) {
+    float scaleBegin = begin / original;
+    float scaleEnd = end / original;
+    Animator scaleX = ObjectAnimator.ofFloat(target, View.SCALE_X, scaleBegin, scaleEnd);
+    Animator scaleY = ObjectAnimator.ofFloat(target, View.SCALE_Y, scaleBegin, scaleEnd);
+    scaleX.setDuration(duration);
+    scaleY.setDuration(duration);
+    scaleX.setInterpolator(interpolator);
+    scaleY.setInterpolator(interpolator);
+    AnimatorSet set = new AnimatorSet();
+    set.play(scaleX).with(scaleY).after(delay);
+    return set;
+  }
+
+  private static Animator createAlphaAnimator(
+      View target, float begin, float end, long duration, long delay, Interpolator interpolator) {
+    Animator alpha = ObjectAnimator.ofFloat(target, View.ALPHA, begin, end);
+    alpha.setDuration(duration);
+    alpha.setInterpolator(interpolator);
+    alpha.setStartDelay(delay);
+    return alpha;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/hint/EmptyAnswerHint.java b/java/com/android/incallui/answer/impl/hint/EmptyAnswerHint.java
new file mode 100644
index 0000000..e52b4ee
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/EmptyAnswerHint.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+/** Does nothing. Used to avoid null checks on AnswerHint. */
+public class EmptyAnswerHint implements AnswerHint {
+
+  @Override
+  public void onCreateView(
+      LayoutInflater inflater, ViewGroup container, View puck, TextView hintText) {}
+
+  @Override
+  public void onBounceStart() {}
+
+  @Override
+  public void onBounceEnd() {}
+
+  @Override
+  public void onAnswered() {}
+}
diff --git a/java/com/android/incallui/answer/impl/hint/EventAnswerHint.java b/java/com/android/incallui/answer/impl/hint/EventAnswerHint.java
new file mode 100644
index 0000000..7ee327d
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/EventAnswerHint.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.DimenRes;
+import android.support.annotation.NonNull;
+import android.support.v4.view.animation.FastOutSlowInInterpolator;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+import android.widget.ImageView;
+import android.widget.TextView;
+import com.android.dialer.common.Assert;
+
+/**
+ * An Answer hint that animates a {@link Drawable} payload with animation similar to {@link
+ * DotAnswerHint}.
+ */
+public final class EventAnswerHint implements AnswerHint {
+
+  private static final long FADE_IN_DELAY_SCALE_MILLIS = 380;
+  private static final long FADE_IN_DURATION_SCALE_MILLIS = 200;
+  private static final long FADE_IN_DELAY_ALPHA_MILLIS = 340;
+  private static final long FADE_IN_DURATION_ALPHA_MILLIS = 50;
+
+  private static final long SWIPE_UP_DURATION_ALPHA_MILLIS = 500;
+
+  private static final long FADE_OUT_DELAY_SCALE_SMALL_MILLIS = 90;
+  private static final long FADE_OUT_DURATION_SCALE_MILLIS = 100;
+  private static final long FADE_OUT_DELAY_ALPHA_MILLIS = 130;
+  private static final long FADE_OUT_DURATION_ALPHA_MILLIS = 170;
+
+  private static final float FADE_SCALE = 1.2f;
+
+  private final Context context;
+  private final Drawable payload;
+  private final long puckUpDurationMillis;
+  private final long puckUpDelayMillis;
+
+  private View puck;
+  private View payloadView;
+  private View answerHintContainer;
+  private AnimatorSet answerGestureHintAnim;
+
+  public EventAnswerHint(
+      @NonNull Context context,
+      @NonNull Drawable payload,
+      long puckUpDurationMillis,
+      long puckUpDelayMillis) {
+    this.context = Assert.isNotNull(context);
+    this.payload = Assert.isNotNull(payload);
+    this.puckUpDurationMillis = puckUpDurationMillis;
+    this.puckUpDelayMillis = puckUpDelayMillis;
+  }
+
+  @Override
+  public void onCreateView(
+      LayoutInflater inflater, ViewGroup container, View puck, TextView hintText) {
+    this.puck = puck;
+    View view = inflater.inflate(R.layout.event_hint, container, true);
+    answerHintContainer = view.findViewById(R.id.answer_hint_container);
+    payloadView = view.findViewById(R.id.payload);
+    hintText.setTextSize(
+        TypedValue.COMPLEX_UNIT_PX, context.getResources().getDimension(R.dimen.hint_text_size));
+    ((ImageView) payloadView).setImageDrawable(payload);
+  }
+
+  @Override
+  public void onBounceStart() {
+    if (answerGestureHintAnim == null) {
+
+      answerGestureHintAnim = new AnimatorSet();
+      answerHintContainer.setY(puck.getY() + getDimension(R.dimen.hint_initial_offset));
+
+      Animator fadeIn = createFadeIn();
+
+      Animator swipeUp =
+          ObjectAnimator.ofFloat(
+              answerHintContainer,
+              View.TRANSLATION_Y,
+              puck.getY() - getDimension(R.dimen.hint_offset));
+      swipeUp.setInterpolator(new FastOutSlowInInterpolator());
+      swipeUp.setDuration(SWIPE_UP_DURATION_ALPHA_MILLIS);
+
+      Animator fadeOut = createFadeOut();
+
+      answerGestureHintAnim.play(fadeIn).after(puckUpDelayMillis);
+      answerGestureHintAnim.play(swipeUp).after(fadeIn);
+      // The fade out should start fading the alpha just as the puck is dropping. Scaling will start
+      // a bit earlier.
+      answerGestureHintAnim
+          .play(fadeOut)
+          .after(puckUpDelayMillis + puckUpDurationMillis - FADE_OUT_DELAY_ALPHA_MILLIS);
+
+      fadeIn.addListener(
+          new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+              super.onAnimationStart(animation);
+              payloadView.setAlpha(0);
+              payloadView.setScaleX(1);
+              payloadView.setScaleY(1);
+              answerHintContainer.setY(puck.getY() + getDimension(R.dimen.hint_initial_offset));
+              answerHintContainer.setVisibility(View.VISIBLE);
+            }
+          });
+    }
+
+    answerGestureHintAnim.start();
+  }
+
+  private Animator createFadeIn() {
+    AnimatorSet set = new AnimatorSet();
+    set.play(createFadeInScaleAndAlpha(payloadView));
+    return set;
+  }
+
+  private static Animator createFadeInScaleAndAlpha(View target) {
+    Animator scale =
+        createUniformScaleAnimator(
+            target,
+            FADE_SCALE,
+            1.0f,
+            FADE_IN_DURATION_SCALE_MILLIS,
+            FADE_IN_DELAY_SCALE_MILLIS,
+            new LinearInterpolator());
+    Animator alpha =
+        createAlphaAnimator(
+            target,
+            0f,
+            1.0f,
+            FADE_IN_DURATION_ALPHA_MILLIS,
+            FADE_IN_DELAY_ALPHA_MILLIS,
+            new LinearInterpolator());
+    AnimatorSet set = new AnimatorSet();
+    set.play(scale).with(alpha);
+    return set;
+  }
+
+  private Animator createFadeOut() {
+    AnimatorSet set = new AnimatorSet();
+    set.play(createFadeOutScaleAndAlpha(payloadView, FADE_OUT_DELAY_SCALE_SMALL_MILLIS));
+    return set;
+  }
+
+  private static Animator createFadeOutScaleAndAlpha(View target, long scaleDelay) {
+    Animator scale =
+        createUniformScaleAnimator(
+            target,
+            1.0f,
+            FADE_SCALE,
+            FADE_OUT_DURATION_SCALE_MILLIS,
+            scaleDelay,
+            new LinearInterpolator());
+    Animator alpha =
+        createAlphaAnimator(
+            target,
+            01.0f,
+            0.0f,
+            FADE_OUT_DURATION_ALPHA_MILLIS,
+            FADE_OUT_DELAY_ALPHA_MILLIS,
+            new LinearInterpolator());
+    AnimatorSet set = new AnimatorSet();
+    set.play(scale).with(alpha);
+    return set;
+  }
+
+  @Override
+  public void onBounceEnd() {
+    if (answerGestureHintAnim != null) {
+      answerGestureHintAnim.end();
+      answerGestureHintAnim = null;
+      answerHintContainer.setVisibility(View.GONE);
+    }
+  }
+
+  @Override
+  public void onAnswered() {
+    // Do nothing
+  }
+
+  private float getDimension(@DimenRes int id) {
+    return context.getResources().getDimension(id);
+  }
+
+  private static Animator createUniformScaleAnimator(
+      View target,
+      float scaleBegin,
+      float scaleEnd,
+      long duration,
+      long delay,
+      Interpolator interpolator) {
+    Animator scaleX = ObjectAnimator.ofFloat(target, View.SCALE_X, scaleBegin, scaleEnd);
+    Animator scaleY = ObjectAnimator.ofFloat(target, View.SCALE_Y, scaleBegin, scaleEnd);
+    scaleX.setDuration(duration);
+    scaleY.setDuration(duration);
+    scaleX.setInterpolator(interpolator);
+    scaleY.setInterpolator(interpolator);
+    AnimatorSet set = new AnimatorSet();
+    set.play(scaleX).with(scaleY).after(delay);
+    return set;
+  }
+
+  private static Animator createAlphaAnimator(
+      View target, float begin, float end, long duration, long delay, Interpolator interpolator) {
+    Animator alpha = ObjectAnimator.ofFloat(target, View.ALPHA, begin, end);
+    alpha.setDuration(duration);
+    alpha.setInterpolator(interpolator);
+    alpha.setStartDelay(delay);
+    return alpha;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/hint/EventPayloadLoader.java b/java/com/android/incallui/answer/impl/hint/EventPayloadLoader.java
new file mode 100644
index 0000000..09e3bed
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/EventPayloadLoader.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import java.util.TimeZone;
+
+/** Loads a {@link Drawable} payload for the {@link EventAnswerHint} if it should be displayed. */
+public interface EventPayloadLoader {
+  @Nullable
+  Drawable loadPayload(
+      @NonNull Context context, long currentTimeUtcMillis, @NonNull TimeZone timeZone);
+}
diff --git a/java/com/android/incallui/answer/impl/hint/EventPayloadLoaderImpl.java b/java/com/android/incallui/answer/impl/hint/EventPayloadLoaderImpl.java
new file mode 100644
index 0000000..bd8d736
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/EventPayloadLoaderImpl.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.hint;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build.VERSION_CODES;
+import android.preference.PreferenceManager;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProvider;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import java.io.InputStream;
+import java.util.TimeZone;
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+
+/** Decrypt the event payload to be shown if in a specific time range and the key is received. */
+@TargetApi(VERSION_CODES.M)
+public final class EventPayloadLoaderImpl implements EventPayloadLoader {
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_EVENT_KEY = "event_key";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_EVENT_BINARY = "event_binary";
+
+  // Time is stored as a UTC UNIX timestamp in milliseconds, but interpreted as local time.
+  // For example, 946684800 (2000/1/1 00:00:00 @UTC) is the new year midnight at every timezone.
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_EVENT_START_UTC_AS_LOCAL_MILLIS = "event_time_start_millis";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_EVENT_TIME_END_UTC_AS_LOCAL_MILLIS = "event_time_end_millis";
+
+  @Override
+  @Nullable
+  public Drawable loadPayload(
+      @NonNull Context context, long currentTimeUtcMillis, @NonNull TimeZone timeZone) {
+    Assert.isNotNull(context);
+    Assert.isNotNull(timeZone);
+    ConfigProvider configProvider = ConfigProviderBindings.get(context);
+
+    String pbeKey = configProvider.getString(CONFIG_EVENT_KEY, null);
+    if (pbeKey == null) {
+      return null;
+    }
+    long timeRangeStart = configProvider.getLong(CONFIG_EVENT_START_UTC_AS_LOCAL_MILLIS, 0);
+    long timeRangeEnd = configProvider.getLong(CONFIG_EVENT_TIME_END_UTC_AS_LOCAL_MILLIS, 0);
+
+    String eventBinary = configProvider.getString(CONFIG_EVENT_BINARY, null);
+    if (eventBinary == null) {
+      return null;
+    }
+
+    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+    if (!preferences.getBoolean(
+        EventSecretCodeListener.EVENT_ENABLED_WITH_SECRET_CODE_KEY, false)) {
+      long localTimestamp = currentTimeUtcMillis + timeZone.getRawOffset();
+
+      if (localTimestamp < timeRangeStart) {
+        return null;
+      }
+
+      if (localTimestamp > timeRangeEnd) {
+        return null;
+      }
+    }
+
+    // Use openssl aes-128-cbc -in <input> -out <output> -pass <PBEKey> to generate the asset
+    try (InputStream input = context.getAssets().open(eventBinary)) {
+      byte[] encryptedFile = new byte[input.available()];
+      input.read(encryptedFile);
+
+      Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");
+
+      byte[] salt = new byte[8];
+      System.arraycopy(encryptedFile, 8, salt, 0, 8);
+      SecretKey key =
+          SecretKeyFactory.getInstance("PBEWITHMD5AND128BITAES-CBC-OPENSSL", "BC")
+              .generateSecret(new PBEKeySpec(pbeKey.toCharArray(), salt, 100));
+      cipher.init(Cipher.DECRYPT_MODE, key);
+
+      byte[] decryptedFile = cipher.doFinal(encryptedFile, 16, encryptedFile.length - 16);
+
+      return new BitmapDrawable(
+          context.getResources(),
+          BitmapFactory.decodeByteArray(decryptedFile, 0, decryptedFile.length));
+    } catch (Exception e) {
+      // Avoid crashing dialer for any reason.
+      LogUtil.e("EventPayloadLoader.loadPayload", "error decrypting payload:", e);
+      return null;
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/hint/EventSecretCodeListener.java b/java/com/android/incallui/answer/impl/hint/EventSecretCodeListener.java
new file mode 100644
index 0000000..7cf4054
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/EventSecretCodeListener.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2017 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.answer.impl.hint;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.support.annotation.VisibleForTesting;
+import android.text.TextUtils;
+import android.widget.Toast;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+
+/**
+ * Listen to the broadcast when the user dials "*#*#[number]#*#*" to toggle the event answer hint.
+ */
+public class EventSecretCodeListener extends BroadcastReceiver {
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String CONFIG_EVENT_SECRET_CODE = "event_secret_code";
+
+  public static final String EVENT_ENABLED_WITH_SECRET_CODE_KEY = "event_enabled_with_secret_code";
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    String host = intent.getData().getHost();
+    String secretCode =
+        ConfigProviderBindings.get(context).getString(CONFIG_EVENT_SECRET_CODE, null);
+    if (secretCode == null) {
+      return;
+    }
+    if (!TextUtils.equals(secretCode, host)) {
+      return;
+    }
+    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+    boolean wasEnabled = preferences.getBoolean(EVENT_ENABLED_WITH_SECRET_CODE_KEY, false);
+    if (wasEnabled) {
+      preferences.edit().putBoolean(EVENT_ENABLED_WITH_SECRET_CODE_KEY, false).apply();
+      Toast.makeText(context, R.string.event_deactivated, Toast.LENGTH_SHORT).show();
+      Logger.get(context).logImpression(DialerImpression.Type.EVENT_ANSWER_HINT_DEACTIVATED);
+      LogUtil.i("EventSecretCodeListener.onReceive", "EventAnswerHint disabled");
+    } else {
+      preferences.edit().putBoolean(EVENT_ENABLED_WITH_SECRET_CODE_KEY, true).apply();
+      Toast.makeText(context, R.string.event_activated, Toast.LENGTH_SHORT).show();
+      Logger.get(context).logImpression(DialerImpression.Type.EVENT_ANSWER_HINT_ACTIVATED);
+      LogUtil.i("EventSecretCodeListener.onReceive", "EventAnswerHint enabled");
+    }
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_large.xml b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_large.xml
new file mode 100644
index 0000000..f585ce5
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_large.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+  <solid android:color="#00C853"/>
+</shape>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_mid.xml b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_mid.xml
new file mode 100644
index 0000000..f585ce5
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_mid.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+  <solid android:color="#00C853"/>
+</shape>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_small.xml b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_small.xml
new file mode 100644
index 0000000..6a24d6a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/drawable/answer_hint_small.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+  <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+    <solid android:color="#00C853"/>
+    <stroke android:color="#00C853" android:width="2dp"/>
+  </shape>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/layout/dot_hint.xml b/java/com/android/incallui/answer/impl/hint/res/layout/dot_hint.xml
new file mode 100644
index 0000000..84b10e7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/layout/dot_hint.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/answer_hint_container"
+  android:layout_width="160dp"
+  android:layout_height="160dp"
+  android:layout_gravity="center_horizontal"
+  android:visibility="gone">
+  <ImageView
+    android:id="@+id/answer_hint_large"
+    android:layout_width="@dimen/hint_large_begin_size"
+    android:layout_height="@dimen/hint_large_begin_size"
+    android:layout_gravity="center"
+    android:alpha="0"
+    android:src="@drawable/answer_hint_large"/>
+  <ImageView
+    android:id="@+id/answer_hint_mid"
+    android:layout_width="@dimen/hint_mid_begin_size"
+    android:layout_height="@dimen/hint_mid_begin_size"
+    android:src="@drawable/answer_hint_mid"
+    android:alpha="0"
+    android:layout_gravity="center"/>
+  <ImageView
+    android:id="@+id/answer_hint_small"
+    android:layout_width="@dimen/hint_small_begin_size"
+    android:layout_height="@dimen/hint_small_begin_size"
+    android:src="@drawable/answer_hint_small"
+    android:alpha="0"
+    android:layout_gravity="center" />
+</FrameLayout>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/layout/event_hint.xml b/java/com/android/incallui/answer/impl/hint/res/layout/event_hint.xml
new file mode 100644
index 0000000..d505014
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/layout/event_hint.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<FrameLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/answer_hint_container"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:layout_gravity="center_horizontal"
+  android:clipChildren="false"
+  android:clipToPadding="false"
+  android:visibility="gone">
+  <ImageView
+    android:id="@+id/payload"
+    android:layout_width="191dp"
+    android:layout_height="773dp"
+    android:layout_gravity="center"
+    android:alpha="0"
+    android:rotation="-30"
+    android:transformPivotY="90dp"
+    android:clipChildren="false"
+    android:clipToPadding="false"/>
+</FrameLayout>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/values/dimens.xml b/java/com/android/incallui/answer/impl/hint/res/values/dimens.xml
new file mode 100644
index 0000000..d86084b
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/values/dimens.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="hint_text_size">18sp</dimen>
+  <dimen name="hint_initial_offset">-100dp</dimen>
+  <dimen name="hint_offset">300dp</dimen>
+  <dimen name="hint_small_begin_size">50dp</dimen>
+  <dimen name="hint_small_end_size">42dp</dimen>
+  <dimen name="hint_mid_begin_size">56dp</dimen>
+  <dimen name="hint_mid_end_size">64dp</dimen>
+  <dimen name="hint_large_begin_size">64dp</dimen>
+  <dimen name="hint_large_end_size">160dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/hint/res/values/strings.xml b/java/com/android/incallui/answer/impl/hint/res/values/strings.xml
new file mode 100644
index 0000000..d76021a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/hint/res/values/strings.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="event_activated">Event Activated</string>
+  <string name="event_deactivated">Event Deactvated</string>
+</resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml
new file mode 100644
index 0000000..6490bbc
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+  android:ordering="together">
+  <alpha
+    android:duration="583"
+    android:fromAlpha="0.0"
+    android:interpolator="@android:anim/accelerate_interpolator"
+    android:startOffset="167"
+    android:toAlpha="1.0"/>
+  <scale
+    android:duration="600"
+    android:fromXScale="0px"
+    android:fromYScale="0px"
+    android:interpolator="@android:anim/accelerate_interpolator"
+    android:pivotX="50%"
+    android:pivotY="50%"
+    android:toXScale="100%"
+    android:toYScale="100%"/>
+</set>
diff --git a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml
new file mode 100644
index 0000000..9d3195a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+  <alpha
+    android:duration="583"
+    android:fromAlpha="0.0"
+    android:interpolator="@android:anim/accelerate_interpolator"
+    android:startOffset="167"
+    android:toAlpha="1.0"/>
+</set>
diff --git a/java/com/android/incallui/answer/impl/res/layout/fragment_avatar.xml b/java/com/android/incallui/answer/impl/res/layout/fragment_avatar.xml
new file mode 100644
index 0000000..d656ceb
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/layout/fragment_avatar.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+
+<ImageView
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@id/contactgrid_avatar"
+  android:layout_width="@dimen/answer_avatar_size"
+  android:layout_height="@dimen/answer_avatar_size"
+  android:layout_marginTop="20dp"
+  android:layout_gravity="center_horizontal"
+  android:elevation="@dimen/answer_data_elevation"/>
diff --git a/java/com/android/incallui/answer/impl/res/layout/fragment_custom_sms_dialog.xml b/java/com/android/incallui/answer/impl/res/layout/fragment_custom_sms_dialog.xml
new file mode 100644
index 0000000..c36386e
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/layout/fragment_custom_sms_dialog.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:paddingLeft="24dp"
+  android:paddingRight="24dp">
+
+  <EditText
+    android:id="@+id/custom_sms_input"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"/>
+
+</FrameLayout>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/res/layout/fragment_incoming_call.xml b/java/com/android/incallui/answer/impl/res/layout/fragment_incoming_call.xml
new file mode 100644
index 0000000..aa153dd
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/layout/fragment_incoming_call.xml
@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<com.android.incallui.answer.impl.AffordanceHolderLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:id="@+id/incoming_container"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:clipChildren="false"
+  android:clipToPadding="false"
+  android:keepScreenOn="true">
+
+  <TextureView
+    android:id="@+id/incoming_preview_texture_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:importantForAccessibility="no"
+    android:visibility="gone"/>
+
+  <View
+    android:id="@+id/incoming_preview_texture_view_overlay"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/videocall_overlay_background_color"
+    android:visibility="gone"/>
+
+  <FrameLayout
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <TextView
+      android:id="@+id/videocall_video_off"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_gravity="center"
+      android:padding="64dp"
+      android:accessibilityTraversalBefore="@+id/videocall_speaker_button"
+      android:drawablePadding="8dp"
+      android:drawableTop="@drawable/quantum_ic_videocam_off_white_36"
+      android:gravity="center"
+      android:text="@string/call_incoming_video_is_off"
+      android:textAppearance="@style/Dialer.Incall.TextAppearance"
+      android:visibility="gone"/>
+
+    <LinearLayout
+      android:id="@+id/incall_contact_grid"
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:layout_marginTop="24dp"
+      android:clipChildren="false"
+      android:clipToPadding="false"
+      android:gravity="top|center_horizontal"
+      android:orientation="vertical">
+
+      <include
+        android:id="@id/contactgrid_top_row"
+        layout="@layout/incall_contactgrid_top_row"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="8dp"
+        android:layout_marginStart="24dp"
+        android:layout_marginEnd="24dp"/>
+
+      <!-- We have to keep deprecated singleLine to allow long text being truncated with ellipses.
+           b/31396406 -->
+      <com.android.incallui.autoresizetext.AutoResizeTextView
+        android:id="@id/contactgrid_contact_name"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="8dp"
+        android:layout_marginStart="24dp"
+        android:layout_marginEnd="24dp"
+        android:singleLine="true"
+        android:textAppearance="@style/Dialer.Incall.TextAppearance.Large"
+        android:textSize="@dimen/answer_contact_name_text_size"
+        app:autoResizeText_minTextSize="@dimen/answer_contact_name_min_size"
+        tools:ignore="Deprecated"
+        tools:text="Jake Peralta"/>
+
+      <include
+        android:id="@id/contactgrid_bottom_row"
+        layout="@layout/incall_contactgrid_bottom_row"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="24dp"
+        android:layout_marginEnd="24dp"/>
+
+      <TextView
+        android:id="@+id/incall_important_call_badge"
+        android:layout_width="wrap_content"
+        android:layout_height="48dp"
+        android:layout_marginTop="4dp"
+        android:layout_marginBottom="@dimen/answer_importance_margin_bottom"
+        android:elevation="@dimen/answer_data_elevation"
+        android:gravity="center"
+        android:singleLine="true"
+        android:text="@string/call_incoming_important"
+        android:textAllCaps="true"
+        android:textAppearance="@style/Dialer.Incall.TextAppearance"
+        android:textColor="@android:color/black"/>
+
+      <FrameLayout
+        android:id="@+id/incall_location_holder"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"/>
+
+      <FrameLayout
+        android:id="@+id/incall_data_container"
+        android:layout_width="match_parent"
+        android:layout_height="@dimen/answer_data_size"
+        android:clipChildren="false"
+        android:clipToPadding="false"/>
+
+    </LinearLayout>
+
+    <FrameLayout
+      android:id="@+id/answer_method_container"
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:clipChildren="false"
+      android:clipToPadding="false"/>
+
+  </FrameLayout>
+
+  <com.android.incallui.answer.impl.affordance.SwipeButtonView
+    android:id="@+id/incoming_secondary_button"
+    android:layout_width="56dp"
+    android:layout_height="56dp"
+    android:layout_gravity="bottom|start"
+    android:scaleType="center"
+    android:src="@drawable/quantum_ic_message_white_24"
+    android:visibility="invisible"
+    tools:visibility="visible"/>
+
+</com.android.incallui.answer.impl.AffordanceHolderLayout>
diff --git a/java/com/android/incallui/answer/impl/res/values-h240dp/dimens.xml b/java/com/android/incallui/answer/impl/res/values-h240dp/dimens.xml
new file mode 100644
index 0000000..ca384ef
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values-h240dp/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_contact_name_text_size">36sp</dimen>
+  <dimen name="answer_contact_name_min_size">32sp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/res/values-h300dp/dimens.xml b/java/com/android/incallui/answer/impl/res/values-h300dp/dimens.xml
new file mode 100644
index 0000000..fdecbb7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values-h300dp/dimens.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_contact_name_text_size">54sp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/res/values-h480dp/dimens.xml b/java/com/android/incallui/answer/impl/res/values-h480dp/dimens.xml
new file mode 100644
index 0000000..5dc3f2a
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values-h480dp/dimens.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<resources>
+  <dimen name="answer_data_size">150dp</dimen>
+  <dimen name="answer_avatar_size">100dp</dimen>
+  <dimen name="answer_importance_margin_bottom">8dp</dimen>
+  <bool name="answer_important_call_allowed">true</bool>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/res/values-h540dp/dimens.xml b/java/com/android/incallui/answer/impl/res/values-h540dp/dimens.xml
new file mode 100644
index 0000000..69716e0
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values-h540dp/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<resources>
+  <dimen name="answer_data_size">258dp</dimen>
+  <dimen name="answer_avatar_size">172dp</dimen>
+  <dimen name="answer_importance_margin_bottom">8dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/res/values/dimens.xml b/java/com/android/incallui/answer/impl/res/values/dimens.xml
new file mode 100644
index 0000000..c48b68f
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values/dimens.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_contact_name_text_size">24sp</dimen>
+  <dimen name="answer_contact_name_min_size">24sp</dimen>
+  <dimen name="answer_data_size">0dp</dimen>
+  <dimen name="answer_avatar_size">0dp</dimen>
+  <dimen name="answer_importance_margin_bottom">0dp</dimen>
+  <bool name="answer_important_call_allowed">false</bool>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/res/values/strings.xml b/java/com/android/incallui/answer/impl/res/values/strings.xml
new file mode 100644
index 0000000..7fc91fc
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/res/values/strings.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="call_incoming_swipe_to_decline_with_message">Swipe from icon to decline with message</string>
+  <string name="call_incoming_swipe_to_answer_video_as_audio">Swipe from icon to answer as an audio call</string>
+  <string name="call_incoming_message_custom">Write your own…</string>
+  <string name="call_incoming_audio_handset">Handset</string>
+  <string name="call_incoming_audio_speakerphone">Speakerphone</string>
+  <!-- "Respond via SMS" option that lets you compose a custom response. [CHAR LIMIT=30] -->
+  <string name="call_incoming_respond_via_sms_custom_message">Write your own…</string>
+  <!-- "Custom Message" Cancel alert dialog button -->
+  <string name="call_incoming_custom_message_cancel">Cancel</string>
+  <!-- "Custom Message" Send alert dialog button -->
+  <string name="call_incoming_custom_message_send">Send</string>
+  <string name="a11y_incoming_call_reject_with_sms">Reject this call with a message</string>
+  <string name="a11y_incoming_call_answer_video_as_audio">Answer as audio call</string>
+  <string name="a11y_description_incoming_call_reject_with_sms">Reject with message</string>
+  <string name="a11y_description_incoming_call_answer_video_as_audio">Answer as audio call</string>
+
+  <!-- Text indicates the video local camera is off. [CHAR LIMIT=40] -->
+  <string name="call_incoming_video_is_off">Video is off</string>
+
+  <!-- Voice prompt of swipe gesture when accessibility is turned on. -->
+  <string description="The message announced to accessibility assistance on incoming call."
+    name="a11y_incoming_call_swipe_gesture_prompt">Two finger swipe up to answer. Two finger swipe down to decline.</string>
+  <string name="call_incoming_important">Important call</string>
+</resources>
diff --git a/java/com/android/incallui/answer/impl/utils/FlingAnimationUtils.java b/java/com/android/incallui/answer/impl/utils/FlingAnimationUtils.java
new file mode 100644
index 0000000..3acb2a2
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/utils/FlingAnimationUtils.java
@@ -0,0 +1,293 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.utils;
+
+import android.animation.Animator;
+import android.content.Context;
+import android.view.ViewPropertyAnimator;
+import android.view.animation.Interpolator;
+import android.view.animation.PathInterpolator;
+
+/** Utility class to calculate general fling animation when the finger is released. */
+public class FlingAnimationUtils {
+
+  private static final float LINEAR_OUT_SLOW_IN_X2 = 0.35f;
+  private static final float LINEAR_OUT_FASTER_IN_X2 = 0.5f;
+  private static final float LINEAR_OUT_FASTER_IN_Y2_MIN = 0.4f;
+  private static final float LINEAR_OUT_FASTER_IN_Y2_MAX = 0.5f;
+  private static final float MIN_VELOCITY_DP_PER_SECOND = 250;
+  private static final float HIGH_VELOCITY_DP_PER_SECOND = 3000;
+
+  /** Crazy math. http://en.wikipedia.org/wiki/B%C3%A9zier_curve */
+  private static final float LINEAR_OUT_SLOW_IN_START_GRADIENT = 1.0f / LINEAR_OUT_SLOW_IN_X2;
+
+  private Interpolator linearOutSlowIn;
+
+  private float minVelocityPxPerSecond;
+  private float maxLengthSeconds;
+  private float highVelocityPxPerSecond;
+
+  private AnimatorProperties mAnimatorProperties = new AnimatorProperties();
+
+  public FlingAnimationUtils(Context ctx, float maxLengthSeconds) {
+    this.maxLengthSeconds = maxLengthSeconds;
+    linearOutSlowIn = new PathInterpolator(0, 0, LINEAR_OUT_SLOW_IN_X2, 1);
+    minVelocityPxPerSecond =
+        MIN_VELOCITY_DP_PER_SECOND * ctx.getResources().getDisplayMetrics().density;
+    highVelocityPxPerSecond =
+        HIGH_VELOCITY_DP_PER_SECOND * ctx.getResources().getDisplayMetrics().density;
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   */
+  public void apply(Animator animator, float currValue, float endValue, float velocity) {
+    apply(animator, currValue, endValue, velocity, Math.abs(endValue - currValue));
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   */
+  public void apply(
+      ViewPropertyAnimator animator, float currValue, float endValue, float velocity) {
+    apply(animator, currValue, endValue, velocity, Math.abs(endValue - currValue));
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   * @param maxDistance the maximum distance for this interaction; the maximum animation length gets
+   *     multiplied by the ratio between the actual distance and this value
+   */
+  public void apply(
+      Animator animator, float currValue, float endValue, float velocity, float maxDistance) {
+    AnimatorProperties properties = getProperties(currValue, endValue, velocity, maxDistance);
+    animator.setDuration(properties.duration);
+    animator.setInterpolator(properties.interpolator);
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   * @param maxDistance the maximum distance for this interaction; the maximum animation length gets
+   *     multiplied by the ratio between the actual distance and this value
+   */
+  public void apply(
+      ViewPropertyAnimator animator,
+      float currValue,
+      float endValue,
+      float velocity,
+      float maxDistance) {
+    AnimatorProperties properties = getProperties(currValue, endValue, velocity, maxDistance);
+    animator.setDuration(properties.duration);
+    animator.setInterpolator(properties.interpolator);
+  }
+
+  private AnimatorProperties getProperties(
+      float currValue, float endValue, float velocity, float maxDistance) {
+    float maxLengthSeconds =
+        (float) (this.maxLengthSeconds * Math.sqrt(Math.abs(endValue - currValue) / maxDistance));
+    float diff = Math.abs(endValue - currValue);
+    float velAbs = Math.abs(velocity);
+    float durationSeconds = LINEAR_OUT_SLOW_IN_START_GRADIENT * diff / velAbs;
+    if (durationSeconds <= maxLengthSeconds) {
+      mAnimatorProperties.interpolator = linearOutSlowIn;
+    } else if (velAbs >= minVelocityPxPerSecond) {
+
+      // Cross fade between fast-out-slow-in and linear interpolator with current velocity.
+      durationSeconds = maxLengthSeconds;
+      VelocityInterpolator velocityInterpolator =
+          new VelocityInterpolator(durationSeconds, velAbs, diff);
+      mAnimatorProperties.interpolator =
+          new InterpolatorInterpolator(velocityInterpolator, linearOutSlowIn, linearOutSlowIn);
+    } else {
+
+      // Just use a normal interpolator which doesn't take the velocity into account.
+      durationSeconds = maxLengthSeconds;
+      mAnimatorProperties.interpolator = Interpolators.FAST_OUT_SLOW_IN;
+    }
+    mAnimatorProperties.duration = (long) (durationSeconds * 1000);
+    return mAnimatorProperties;
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion for the case when the animation is making something
+   * disappear.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   * @param maxDistance the maximum distance for this interaction; the maximum animation length gets
+   *     multiplied by the ratio between the actual distance and this value
+   */
+  public void applyDismissing(
+      Animator animator, float currValue, float endValue, float velocity, float maxDistance) {
+    AnimatorProperties properties =
+        getDismissingProperties(currValue, endValue, velocity, maxDistance);
+    animator.setDuration(properties.duration);
+    animator.setInterpolator(properties.interpolator);
+  }
+
+  /**
+   * Applies the interpolator and length to the animator, such that the fling animation is
+   * consistent with the finger motion for the case when the animation is making something
+   * disappear.
+   *
+   * @param animator the animator to apply
+   * @param currValue the current value
+   * @param endValue the end value of the animator
+   * @param velocity the current velocity of the motion
+   * @param maxDistance the maximum distance for this interaction; the maximum animation length gets
+   *     multiplied by the ratio between the actual distance and this value
+   */
+  public void applyDismissing(
+      ViewPropertyAnimator animator,
+      float currValue,
+      float endValue,
+      float velocity,
+      float maxDistance) {
+    AnimatorProperties properties =
+        getDismissingProperties(currValue, endValue, velocity, maxDistance);
+    animator.setDuration(properties.duration);
+    animator.setInterpolator(properties.interpolator);
+  }
+
+  private AnimatorProperties getDismissingProperties(
+      float currValue, float endValue, float velocity, float maxDistance) {
+    float maxLengthSeconds =
+        (float)
+            (this.maxLengthSeconds * Math.pow(Math.abs(endValue - currValue) / maxDistance, 0.5f));
+    float diff = Math.abs(endValue - currValue);
+    float velAbs = Math.abs(velocity);
+    float y2 = calculateLinearOutFasterInY2(velAbs);
+
+    float startGradient = y2 / LINEAR_OUT_FASTER_IN_X2;
+    Interpolator mLinearOutFasterIn = new PathInterpolator(0, 0, LINEAR_OUT_FASTER_IN_X2, y2);
+    float durationSeconds = startGradient * diff / velAbs;
+    if (durationSeconds <= maxLengthSeconds) {
+      mAnimatorProperties.interpolator = mLinearOutFasterIn;
+    } else if (velAbs >= minVelocityPxPerSecond) {
+
+      // Cross fade between linear-out-faster-in and linear interpolator with current
+      // velocity.
+      durationSeconds = maxLengthSeconds;
+      VelocityInterpolator velocityInterpolator =
+          new VelocityInterpolator(durationSeconds, velAbs, diff);
+      InterpolatorInterpolator superInterpolator =
+          new InterpolatorInterpolator(velocityInterpolator, mLinearOutFasterIn, linearOutSlowIn);
+      mAnimatorProperties.interpolator = superInterpolator;
+    } else {
+
+      // Just use a normal interpolator which doesn't take the velocity into account.
+      durationSeconds = maxLengthSeconds;
+      mAnimatorProperties.interpolator = Interpolators.FAST_OUT_LINEAR_IN;
+    }
+    mAnimatorProperties.duration = (long) (durationSeconds * 1000);
+    return mAnimatorProperties;
+  }
+
+  /**
+   * Calculates the y2 control point for a linear-out-faster-in path interpolator depending on the
+   * velocity. The faster the velocity, the more "linear" the interpolator gets.
+   *
+   * @param velocity the velocity of the gesture.
+   * @return the y2 control point for a cubic bezier path interpolator
+   */
+  private float calculateLinearOutFasterInY2(float velocity) {
+    float t =
+        (velocity - minVelocityPxPerSecond) / (highVelocityPxPerSecond - minVelocityPxPerSecond);
+    t = Math.max(0, Math.min(1, t));
+    return (1 - t) * LINEAR_OUT_FASTER_IN_Y2_MIN + t * LINEAR_OUT_FASTER_IN_Y2_MAX;
+  }
+
+  /** @return the minimum velocity a gesture needs to have to be considered a fling */
+  public float getMinVelocityPxPerSecond() {
+    return minVelocityPxPerSecond;
+  }
+
+  /** An interpolator which interpolates two interpolators with an interpolator. */
+  private static final class InterpolatorInterpolator implements Interpolator {
+
+    private Interpolator mInterpolator1;
+    private Interpolator mInterpolator2;
+    private Interpolator mCrossfader;
+
+    InterpolatorInterpolator(
+        Interpolator interpolator1, Interpolator interpolator2, Interpolator crossfader) {
+      mInterpolator1 = interpolator1;
+      mInterpolator2 = interpolator2;
+      mCrossfader = crossfader;
+    }
+
+    @Override
+    public float getInterpolation(float input) {
+      float t = mCrossfader.getInterpolation(input);
+      return (1 - t) * mInterpolator1.getInterpolation(input)
+          + t * mInterpolator2.getInterpolation(input);
+    }
+  }
+
+  /** An interpolator which interpolates with a fixed velocity. */
+  private static final class VelocityInterpolator implements Interpolator {
+
+    private float mDurationSeconds;
+    private float mVelocity;
+    private float mDiff;
+
+    private VelocityInterpolator(float durationSeconds, float velocity, float diff) {
+      mDurationSeconds = durationSeconds;
+      mVelocity = velocity;
+      mDiff = diff;
+    }
+
+    @Override
+    public float getInterpolation(float input) {
+      float time = input * mDurationSeconds;
+      return time * mVelocity / mDiff;
+    }
+  }
+
+  private static class AnimatorProperties {
+
+    Interpolator interpolator;
+    long duration;
+  }
+}
diff --git a/java/com/android/incallui/answer/impl/utils/Interpolators.java b/java/com/android/incallui/answer/impl/utils/Interpolators.java
new file mode 100644
index 0000000..efc68f7
--- /dev/null
+++ b/java/com/android/incallui/answer/impl/utils/Interpolators.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 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.answer.impl.utils;
+
+import android.view.animation.Interpolator;
+import android.view.animation.PathInterpolator;
+
+/**
+ * Common interpolators used in answer methods.
+ */
+public class Interpolators {
+
+  public static final Interpolator FAST_OUT_LINEAR_IN = new PathInterpolator(0.4f, 0f, 1f, 1f);
+  public static final Interpolator LINEAR_OUT_SLOW_IN = new PathInterpolator(0f, 0f, 0.2f, 1f);
+  public static final Interpolator FAST_OUT_SLOW_IN = new PathInterpolator(0.4f, 0f, 0.2f, 1f);
+}
diff --git a/java/com/android/incallui/answer/protocol/AnswerScreen.java b/java/com/android/incallui/answer/protocol/AnswerScreen.java
new file mode 100644
index 0000000..0c374eb
--- /dev/null
+++ b/java/com/android/incallui/answer/protocol/AnswerScreen.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 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.answer.protocol;
+
+import android.support.v4.app.Fragment;
+import java.util.List;
+
+/** Interface for the answer module. */
+public interface AnswerScreen {
+
+  String getCallId();
+
+  int getVideoState();
+
+  boolean isVideoUpgradeRequest();
+
+  void setTextResponses(List<String> textResponses);
+
+  boolean hasPendingDialogs();
+
+  void dismissPendingDialogs();
+
+  Fragment getAnswerScreenFragment();
+}
diff --git a/java/com/android/incallui/answer/protocol/AnswerScreenDelegate.java b/java/com/android/incallui/answer/protocol/AnswerScreenDelegate.java
new file mode 100644
index 0000000..9934497
--- /dev/null
+++ b/java/com/android/incallui/answer/protocol/AnswerScreenDelegate.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 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.answer.protocol;
+
+import android.support.annotation.FloatRange;
+
+/** Callbacks implemented by the container app for this module. */
+public interface AnswerScreenDelegate {
+
+  void onAnswerScreenUnready();
+
+  void onDismissDialog();
+
+  void onRejectCallWithMessage(String message);
+
+  void onAnswer(int videoState);
+
+  void onReject();
+
+  /**
+   * Sets the window background color based on foreground call's theme and the given progress. This
+   * is called from the answer UI to animate the accept and reject action.
+   *
+   * <p>When the user is rejecting we animate the background color to a mostly transparent gray. The
+   * end effect is that the home screen shows through.
+   *
+   * @param progress float from -1 to 1. -1 is fully rejected, 1 is fully accepted, and 0 is neutral
+   */
+  void updateWindowBackgroundColor(@FloatRange(from = -1f, to = 1.0f) float progress);
+}
diff --git a/java/com/android/incallui/answer/protocol/AnswerScreenDelegateFactory.java b/java/com/android/incallui/answer/protocol/AnswerScreenDelegateFactory.java
new file mode 100644
index 0000000..a09cb1a
--- /dev/null
+++ b/java/com/android/incallui/answer/protocol/AnswerScreenDelegateFactory.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 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.answer.protocol;
+
+/** Used to create an instance of the delegate, should be implemented by the container activity. */
+public interface AnswerScreenDelegateFactory {
+
+  AnswerScreenDelegate newAnswerScreenDelegate(AnswerScreen answerScreen);
+}
diff --git a/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java b/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java
new file mode 100644
index 0000000..edc3db3
--- /dev/null
+++ b/java/com/android/incallui/answerproximitysensor/AnswerProximitySensor.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2016 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.answerproximitysensor;
+
+import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.os.PowerManager;
+import android.view.Display;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.DialerCallListener;
+
+/**
+ * This class prevents users from accidentally answering calls by keeping the screen off until the
+ * proximity sensor is unblocked. If the screen is already on or if this is a call waiting call then
+ * nothing is done.
+ */
+public class AnswerProximitySensor
+    implements DialerCallListener, AnswerProximityWakeLock.ScreenOnListener {
+
+  private static final String CONFIG_ANSWER_PROXIMITY_SENSOR_ENABLED =
+      "answer_proximity_sensor_enabled";
+  private static final String CONFIG_ANSWER_PSEUDO_PROXIMITY_WAKE_LOCK_ENABLED =
+      "answer_pseudo_proximity_wake_lock_enabled";
+
+  private final DialerCall call;
+  private final AnswerProximityWakeLock answerProximityWakeLock;
+
+  public static boolean shouldUse(Context context, DialerCall call) {
+    // 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) {
+      LogUtil.i("AnswerProximitySensor.shouldUse", "call state is not incoming");
+      return false;
+    }
+
+    if (!ConfigProviderBindings.get(context)
+        .getBoolean(CONFIG_ANSWER_PROXIMITY_SENSOR_ENABLED, true)) {
+      LogUtil.i("AnswerProximitySensor.shouldUse", "disabled by config");
+      return false;
+    }
+
+    if (!context
+        .getSystemService(PowerManager.class)
+        .isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+      LogUtil.i("AnswerProximitySensor.shouldUse", "wake lock level not supported");
+      return false;
+    }
+
+    if (isDefaultDisplayOn(context)) {
+      LogUtil.i("AnswerProximitySensor.shouldUse", "display is already on");
+      return false;
+    }
+
+    return true;
+  }
+
+  public AnswerProximitySensor(
+      Context context, DialerCall call, PseudoScreenState pseudoScreenState) {
+    this.call = call;
+
+    LogUtil.i("AnswerProximitySensor.constructor", "acquiring lock");
+    if (ConfigProviderBindings.get(context)
+        .getBoolean(CONFIG_ANSWER_PSEUDO_PROXIMITY_WAKE_LOCK_ENABLED, true)) {
+      answerProximityWakeLock = new PseudoProximityWakeLock(context, pseudoScreenState);
+    } else {
+      // TODO: choose a wake lock implementation base on framework/device.
+      // These bugs requires the PseudoProximityWakeLock workaround:
+      // b/30439151 Proximity sensor not working on M
+      // b/31499931 fautly touch input when screen is off on marlin/sailfish
+      answerProximityWakeLock = new SystemProximityWakeLock(context);
+    }
+    answerProximityWakeLock.setScreenOnListener(this);
+    answerProximityWakeLock.acquire();
+
+    call.addListener(this);
+  }
+
+  private void cleanup() {
+    call.removeListener(this);
+    releaseProximityWakeLock();
+  }
+
+  private void releaseProximityWakeLock() {
+    if (answerProximityWakeLock.isHeld()) {
+      LogUtil.i("AnswerProximitySensor.releaseProximityWakeLock", "releasing lock");
+      answerProximityWakeLock.release();
+    }
+  }
+
+  private static boolean isDefaultDisplayOn(Context context) {
+    Display display =
+        context.getSystemService(DisplayManager.class).getDisplay(Display.DEFAULT_DISPLAY);
+    return display.getState() == Display.STATE_ON;
+  }
+
+  @Override
+  public void onDialerCallDisconnect() {
+    LogUtil.i("AnswerProximitySensor.onDialerCallDisconnect", null);
+    cleanup();
+  }
+
+  @Override
+  public void onDialerCallUpdate() {
+    if (call.getState() != State.INCOMING) {
+      LogUtil.i("AnswerProximitySensor.onDialerCallUpdate", "no longer incoming, cleaning up");
+      cleanup();
+    }
+  }
+
+  @Override
+  public void onDialerCallChildNumberChange() {}
+
+  @Override
+  public void onDialerCallLastForwardedNumberChange() {}
+
+  @Override
+  public void onDialerCallUpgradeToVideo() {}
+
+  @Override
+  public void onWiFiToLteHandover() {}
+
+  @Override
+  public void onHandoverToWifiFailure() {}
+
+  @Override
+  public void onDialerCallSessionModificationStateChange(@SessionModificationState int state) {}
+
+  @Override
+  public void onScreenOn() {
+    cleanup();
+  }
+}
diff --git a/java/com/android/incallui/answerproximitysensor/AnswerProximityWakeLock.java b/java/com/android/incallui/answerproximitysensor/AnswerProximityWakeLock.java
new file mode 100644
index 0000000..94abe9c
--- /dev/null
+++ b/java/com/android/incallui/answerproximitysensor/AnswerProximityWakeLock.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 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.answerproximitysensor;
+
+/**
+ * Interface to wrap around the {@link android.os.PowerManager.WakeLock} for custom implementations.
+ */
+public interface AnswerProximityWakeLock {
+
+  /** Called when the wake lock turned the screen back on. */
+  interface ScreenOnListener {
+
+    void onScreenOn();
+  }
+
+  void acquire();
+
+  void release();
+
+  boolean isHeld();
+
+  void setScreenOnListener(ScreenOnListener listener);
+}
diff --git a/java/com/android/incallui/answerproximitysensor/PseudoProximityWakeLock.java b/java/com/android/incallui/answerproximitysensor/PseudoProximityWakeLock.java
new file mode 100644
index 0000000..c7844d4
--- /dev/null
+++ b/java/com/android/incallui/answerproximitysensor/PseudoProximityWakeLock.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 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.answerproximitysensor;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.support.annotation.Nullable;
+import com.android.dialer.common.LogUtil;
+
+/**
+ * A fake PROXIMITY_SCREEN_OFF_WAKE_LOCK implemented by the app. It will use {@link
+ * PseudoScreenState} to fake a black screen when the proximity sensor is near.
+ */
+public class PseudoProximityWakeLock implements AnswerProximityWakeLock, SensorEventListener {
+
+  private final Context context;
+  private final PseudoScreenState pseudoScreenState;
+  private final Sensor proximitySensor;
+
+  @Nullable private ScreenOnListener listener;
+  private boolean isHeld;
+
+  public PseudoProximityWakeLock(Context context, PseudoScreenState pseudoScreenState) {
+    this.context = context;
+    this.pseudoScreenState = pseudoScreenState;
+    pseudoScreenState.setOn(true);
+    proximitySensor =
+        context.getSystemService(SensorManager.class).getDefaultSensor(Sensor.TYPE_PROXIMITY);
+  }
+
+  @Override
+  public void acquire() {
+    isHeld = true;
+    context
+        .getSystemService(SensorManager.class)
+        .registerListener(this, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
+  }
+
+  @Override
+  public void release() {
+    isHeld = false;
+    context.getSystemService(SensorManager.class).unregisterListener(this);
+    pseudoScreenState.setOn(true);
+  }
+
+  @Override
+  public boolean isHeld() {
+    return isHeld;
+  }
+
+  @Override
+  public void setScreenOnListener(ScreenOnListener listener) {
+    this.listener = listener;
+  }
+
+  @Override
+  public void onSensorChanged(SensorEvent sensorEvent) {
+    boolean near = sensorEvent.values[0] < sensorEvent.sensor.getMaximumRange();
+    LogUtil.i("AnswerProximitySensor.PseudoProximityWakeLock.onSensorChanged", "near: " + near);
+    pseudoScreenState.setOn(!near);
+    if (!near && listener != null) {
+      listener.onScreenOn();
+    }
+  }
+
+  @Override
+  public void onAccuracyChanged(Sensor sensor, int i) {}
+}
diff --git a/java/com/android/incallui/answerproximitysensor/PseudoScreenState.java b/java/com/android/incallui/answerproximitysensor/PseudoScreenState.java
new file mode 100644
index 0000000..eda0ee7
--- /dev/null
+++ b/java/com/android/incallui/answerproximitysensor/PseudoScreenState.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2016 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.answerproximitysensor;
+
+import android.util.ArraySet;
+import java.util.Set;
+
+/**
+ * Stores a fake screen on/off state for the {@link InCallActivity}. If InCallActivity see the state
+ * is off, it will draw a black view over the activity pretending the screen is off.
+ *
+ * <p>If the screen is already touched when the screen is turned on, the OS behavior is sending a
+ * new DOWN event once the point started moving and then behave as a normal gesture. To prevent
+ * accidental answer/rejects, touches that started when the screen is off should be ignored.
+ *
+ * <p>b/31499931 on certain devices with N-DR1, if the screen is already touched when the screen is
+ * turned on, a "DOWN MOVE UP" will be sent for each movement before the touch is actually released.
+ * These events is hard to discern from other normal events, and keeping the screen on reduces its'
+ * probability.
+ */
+public class PseudoScreenState {
+
+  /** Notifies when the on state has changed. */
+  public interface StateChangedListener {
+    void onPseudoScreenStateChanged(boolean isOn);
+  }
+
+  private final Set<StateChangedListener> listeners = new ArraySet<>();
+
+  private boolean on = true;
+
+  public boolean isOn() {
+    return on;
+  }
+
+  public void setOn(boolean value) {
+    if (on != value) {
+      on = value;
+      for (StateChangedListener listener : listeners) {
+        listener.onPseudoScreenStateChanged(on);
+      }
+    }
+  }
+
+  public void addListener(StateChangedListener listener) {
+    listeners.add(listener);
+  }
+
+  public void removeListener(StateChangedListener listener) {
+    listeners.remove(listener);
+  }
+}
diff --git a/java/com/android/incallui/answerproximitysensor/SystemProximityWakeLock.java b/java/com/android/incallui/answerproximitysensor/SystemProximityWakeLock.java
new file mode 100644
index 0000000..776e9a4
--- /dev/null
+++ b/java/com/android/incallui/answerproximitysensor/SystemProximityWakeLock.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2016 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.answerproximitysensor;
+
+import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
+import android.os.PowerManager;
+import android.support.annotation.Nullable;
+import android.view.Display;
+import com.android.dialer.common.LogUtil;
+
+/** The normal PROXIMITY_SCREEN_OFF_WAKE_LOCK provided by the OS. */
+public class SystemProximityWakeLock implements AnswerProximityWakeLock, DisplayListener {
+
+  private static final String TAG = "SystemProximityWakeLock";
+
+  private final Context context;
+  private final PowerManager.WakeLock wakeLock;
+
+  @Nullable private ScreenOnListener listener;
+
+  public SystemProximityWakeLock(Context context) {
+    this.context = context;
+    wakeLock =
+        context
+            .getSystemService(PowerManager.class)
+            .newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);
+  }
+
+  @Override
+  public void acquire() {
+    wakeLock.acquire();
+    context.getSystemService(DisplayManager.class).registerDisplayListener(this, null);
+  }
+
+  @Override
+  public void release() {
+    wakeLock.release();
+    context.getSystemService(DisplayManager.class).unregisterDisplayListener(this);
+  }
+
+  @Override
+  public boolean isHeld() {
+    return wakeLock.isHeld();
+  }
+
+  @Override
+  public void setScreenOnListener(ScreenOnListener listener) {
+    this.listener = listener;
+  }
+
+  @Override
+  public void onDisplayAdded(int displayId) {}
+
+  @Override
+  public void onDisplayRemoved(int displayId) {}
+
+  @Override
+  public void onDisplayChanged(int displayId) {
+    if (displayId == Display.DEFAULT_DISPLAY) {
+      if (isDefaultDisplayOn(context)) {
+        LogUtil.i("SystemProximityWakeLock.onDisplayChanged", "display turned on");
+        if (listener != null) {
+          listener.onScreenOn();
+        }
+      }
+    }
+  }
+
+  private static boolean isDefaultDisplayOn(Context context) {
+    Display display =
+        context.getSystemService(DisplayManager.class).getDisplay(Display.DEFAULT_DISPLAY);
+    return display.getState() != Display.STATE_OFF;
+  }
+}
diff --git a/java/com/android/incallui/async/PausableExecutor.java b/java/com/android/incallui/async/PausableExecutor.java
new file mode 100644
index 0000000..e10757e
--- /dev/null
+++ b/java/com/android/incallui/async/PausableExecutor.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2016 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.async;
+
+import java.util.concurrent.Executor;
+
+/**
+ * Executor that can be used to easily synchronize testing and production code. Production code
+ * should call {@link #milestone()} at points in the code where the state of the system is worthy of
+ * testing. In a test scenario, this method will pause execution until the test acknowledges the
+ * milestone through the use of {@link #ackMilestoneForTesting()}.
+ */
+public interface PausableExecutor extends Executor {
+
+  /**
+   * Method called from asynchronous production code to inform this executor that it has reached a
+   * point that puts the system into a state worth testing. TestableExecutors intended for use in a
+   * testing environment should cause the calling thread to block. In the production environment
+   * this should be a no-op.
+   */
+  void milestone();
+
+  /**
+   * Method called from the test code to inform this executor that the state of the production
+   * system at the current milestone has been sufficiently tested. Every milestone must be
+   * acknowledged.
+   */
+  void ackMilestoneForTesting();
+
+  /**
+   * Method called from the test code to inform this executor that the tests are finished with all
+   * milestones. Future calls to {@link #milestone()} or {@link #awaitMilestoneForTesting()} should
+   * return immediately.
+   */
+  void ackAllMilestonesForTesting();
+
+  /**
+   * Method called from the test code to block until a milestone has been reached in the production
+   * code.
+   */
+  void awaitMilestoneForTesting() throws InterruptedException;
+}
diff --git a/java/com/android/incallui/async/PausableExecutorImpl.java b/java/com/android/incallui/async/PausableExecutorImpl.java
new file mode 100644
index 0000000..6876061
--- /dev/null
+++ b/java/com/android/incallui/async/PausableExecutorImpl.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2016 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.async;
+
+import java.util.concurrent.Executors;
+
+/** {@link PausableExecutor} intended for use in production environments. */
+public class PausableExecutorImpl implements PausableExecutor {
+
+  @Override
+  public void milestone() {}
+
+  @Override
+  public void ackMilestoneForTesting() {}
+
+  @Override
+  public void ackAllMilestonesForTesting() {}
+
+  @Override
+  public void awaitMilestoneForTesting() {}
+
+  @Override
+  public void execute(Runnable command) {
+    Executors.newSingleThreadExecutor().execute(command);
+  }
+}
diff --git a/java/com/android/incallui/audioroute/AndroidManifest.xml b/java/com/android/incallui/audioroute/AndroidManifest.xml
new file mode 100644
index 0000000..36431f1
--- /dev/null
+++ b/java/com/android/incallui/audioroute/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.audioroute">
+</manifest>
diff --git a/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java b/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java
new file mode 100644
index 0000000..c757477
--- /dev/null
+++ b/java/com/android/incallui/audioroute/AudioRouteSelectorDialogFragment.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2016 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.audioroute;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.PorterDuff.Mode;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.design.widget.BottomSheetDialogFragment;
+import android.telecom.CallAudioState;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.TextView;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+
+/** Shows picker for audio routes */
+public class AudioRouteSelectorDialogFragment extends BottomSheetDialogFragment {
+
+  private static final String ARG_AUDIO_STATE = "audio_state";
+
+  /** Called when an audio route is picked */
+  public interface AudioRouteSelectorPresenter {
+    void onAudioRouteSelected(int audioRoute);
+  }
+
+  public static AudioRouteSelectorDialogFragment newInstance(CallAudioState audioState) {
+    AudioRouteSelectorDialogFragment fragment = new AudioRouteSelectorDialogFragment();
+    Bundle args = new Bundle();
+    args.putParcelable(ARG_AUDIO_STATE, audioState);
+    fragment.setArguments(args);
+    return fragment;
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    FragmentUtils.checkParent(this, AudioRouteSelectorPresenter.class);
+  }
+
+  @Override
+  public Dialog onCreateDialog(final Bundle savedInstanceState) {
+    LogUtil.i("AudioRouteSelectorDialogFragment.onCreateDialog", null);
+    Dialog dialog = super.onCreateDialog(savedInstanceState);
+    dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+    return dialog;
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    View view = layoutInflater.inflate(R.layout.audioroute_selector, viewGroup, false);
+    CallAudioState audioState = getArguments().getParcelable(ARG_AUDIO_STATE);
+
+    initItem(
+        (TextView) view.findViewById(R.id.audioroute_bluetooth),
+        CallAudioState.ROUTE_BLUETOOTH,
+        audioState);
+    initItem(
+        (TextView) view.findViewById(R.id.audioroute_speaker),
+        CallAudioState.ROUTE_SPEAKER,
+        audioState);
+    initItem(
+        (TextView) view.findViewById(R.id.audioroute_headset),
+        CallAudioState.ROUTE_WIRED_HEADSET,
+        audioState);
+    initItem(
+        (TextView) view.findViewById(R.id.audioroute_earpiece),
+        CallAudioState.ROUTE_EARPIECE,
+        audioState);
+    return view;
+  }
+
+  private void initItem(TextView item, final int itemRoute, CallAudioState audioState) {
+    int selectedColor = getResources().getColor(R.color.dialer_theme_color);
+    if ((audioState.getSupportedRouteMask() & itemRoute) == 0) {
+      item.setVisibility(View.GONE);
+    } else if (audioState.getRoute() == itemRoute) {
+      item.setTextColor(selectedColor);
+      item.setCompoundDrawableTintList(ColorStateList.valueOf(selectedColor));
+      item.setCompoundDrawableTintMode(Mode.SRC_ATOP);
+    }
+    item.setOnClickListener(
+        new OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            dismiss();
+            FragmentUtils.getParentUnsafe(
+                    AudioRouteSelectorDialogFragment.this, AudioRouteSelectorPresenter.class)
+                .onAudioRouteSelected(itemRoute);
+          }
+        });
+  }
+}
diff --git a/java/com/android/incallui/audioroute/res/drawable-hdpi/ic_phone_audio_grey600_24dp.png b/java/com/android/incallui/audioroute/res/drawable-hdpi/ic_phone_audio_grey600_24dp.png
new file mode 100644
index 0000000..4ea921a
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/drawable-hdpi/ic_phone_audio_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/audioroute/res/drawable-mdpi/ic_phone_audio_grey600_24dp.png b/java/com/android/incallui/audioroute/res/drawable-mdpi/ic_phone_audio_grey600_24dp.png
new file mode 100644
index 0000000..acef550
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/drawable-mdpi/ic_phone_audio_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/audioroute/res/drawable-xhdpi/ic_phone_audio_grey600_24dp.png b/java/com/android/incallui/audioroute/res/drawable-xhdpi/ic_phone_audio_grey600_24dp.png
new file mode 100644
index 0000000..a30aa5c
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/drawable-xhdpi/ic_phone_audio_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/audioroute/res/drawable-xxhdpi/ic_phone_audio_grey600_24dp.png b/java/com/android/incallui/audioroute/res/drawable-xxhdpi/ic_phone_audio_grey600_24dp.png
new file mode 100644
index 0000000..beb85a8
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/drawable-xxhdpi/ic_phone_audio_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml b/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml
new file mode 100644
index 0000000..ef2220e
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/layout/audioroute_selector.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<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_bluetooth"
+    style="@style/AudioRouteItem"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:drawableStart="@drawable/quantum_ic_bluetooth_audio_grey600_24"
+    android:text="@string/audioroute_bluetooth"/>
+  <TextView
+    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"/>
+  <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"/>
+  <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"/>
+
+</LinearLayout>
diff --git a/java/com/android/incallui/audioroute/res/values/strings.xml b/java/com/android/incallui/audioroute/res/values/strings.xml
new file mode 100644
index 0000000..b166393
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/values/strings.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="audioroute_bluetooth">Bluetooth</string>
+  <string name="audioroute_speaker">Speaker</string>
+  <string name="audioroute_phone">Phone</string>
+  <string name="audioroute_headset">Wired headset</string>
+</resources>
diff --git a/java/com/android/incallui/audioroute/res/values/styles.xml b/java/com/android/incallui/audioroute/res/values/styles.xml
new file mode 100644
index 0000000..4484b70
--- /dev/null
+++ b/java/com/android/incallui/audioroute/res/values/styles.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <style name="AudioRouteItem">
+    <item name="android:padding">16dp</item>
+    <item name="android:background">?android:selectableItemBackground</item>
+    <item name="android:drawablePadding">24dp</item>
+    <item name="android:gravity">center_vertical</item>
+    <item name="android:textAppearance">
+      @style/TextAppearance.AppCompat.Light.Widget.PopupMenu.Large
+    </item>
+    <item name="android:textColor">?android:textColorSecondary</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/autoresizetext/AndroidManifest.xml b/java/com/android/incallui/autoresizetext/AndroidManifest.xml
new file mode 100644
index 0000000..53a8961
--- /dev/null
+++ b/java/com/android/incallui/autoresizetext/AndroidManifest.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.android.incallui.autoresizetext">
+
+  <uses-sdk
+      android:minSdkVersion="23"
+      android:targetSdkVersion="25"/>
+
+  <application />
+</manifest>
diff --git a/java/com/android/incallui/autoresizetext/AutoResizeTextView.java b/java/com/android/incallui/autoresizetext/AutoResizeTextView.java
new file mode 100644
index 0000000..eedcbe5
--- /dev/null
+++ b/java/com/android/incallui/autoresizetext/AutoResizeTextView.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2016 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.autoresizetext;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.RectF;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.text.Layout.Alignment;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+import android.util.AttributeSet;
+import android.util.DisplayMetrics;
+import android.util.SparseIntArray;
+import android.util.TypedValue;
+import android.widget.TextView;
+import javax.annotation.Nullable;
+
+/**
+ * A TextView that automatically scales its text to completely fill its allotted width.
+ *
+ * <p>Note: In some edge cases, the binary search algorithm to find the best fit may slightly
+ * overshoot / undershoot its constraints. See b/26704434. No minimal repro case has been
+ * found yet. A known workaround is the solution provided on StackOverflow:
+ * http://stackoverflow.com/a/5535672
+ */
+public class AutoResizeTextView extends TextView {
+  private static final int NO_LINE_LIMIT = -1;
+  private static final float DEFAULT_MIN_TEXT_SIZE = 16.0f;
+  private static final int DEFAULT_RESIZE_STEP_UNIT = TypedValue.COMPLEX_UNIT_PX;
+
+  private final DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
+  private final RectF availableSpaceRect = new RectF();
+  private final SparseIntArray textSizesCache = new SparseIntArray();
+  private final TextPaint textPaint = new TextPaint();
+  private int resizeStepUnit = DEFAULT_RESIZE_STEP_UNIT;
+  private float minTextSize = DEFAULT_MIN_TEXT_SIZE;
+  private float maxTextSize;
+  private int maxWidth;
+  private int maxLines;
+  private float lineSpacingMultiplier = 1.0f;
+  private float lineSpacingExtra = 0.0f;
+
+  public AutoResizeTextView(Context context) {
+    super(context, null, 0);
+    initialize(context, null, 0, 0);
+  }
+
+  public AutoResizeTextView(Context context, AttributeSet attrs) {
+    super(context, attrs, 0);
+    initialize(context, attrs, 0, 0);
+  }
+
+  public AutoResizeTextView(Context context, AttributeSet attrs, int defStyleAttr) {
+    super(context, attrs, defStyleAttr);
+    initialize(context, attrs, defStyleAttr, 0);
+  }
+
+  public AutoResizeTextView(
+      Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+    super(context, attrs, defStyleAttr, defStyleRes);
+    initialize(context, attrs, defStyleAttr, defStyleRes);
+  }
+
+  private void initialize(
+      Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+    TypedArray typedArray = context.getTheme().obtainStyledAttributes(
+        attrs, R.styleable.AutoResizeTextView, defStyleAttr, defStyleRes);
+    readAttrs(typedArray);
+    textPaint.set(getPaint());
+  }
+
+  /** Overridden because getMaxLines is only defined in JB+. */
+  @Override
+  public final int getMaxLines() {
+    if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
+      return super.getMaxLines();
+    } else {
+      return maxLines;
+    }
+  }
+
+  /** Overridden because getMaxLines is only defined in JB+. */
+  @Override
+  public final void setMaxLines(int maxLines) {
+    super.setMaxLines(maxLines);
+    this.maxLines = maxLines;
+  }
+
+  /** Overridden because getLineSpacingMultiplier is only defined in JB+. */
+  @Override
+  public final float getLineSpacingMultiplier() {
+    if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
+      return super.getLineSpacingMultiplier();
+    } else {
+      return lineSpacingMultiplier;
+    }
+  }
+
+  /** Overridden because getLineSpacingExtra is only defined in JB+. */
+  @Override
+  public final float getLineSpacingExtra() {
+    if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
+      return super.getLineSpacingExtra();
+    } else {
+      return lineSpacingExtra;
+    }
+  }
+
+  /**
+   * Overridden because getLineSpacingMultiplier and getLineSpacingExtra are only defined in JB+.
+   */
+  @Override
+  public final void setLineSpacing(float add, float mult) {
+    super.setLineSpacing(add, mult);
+    lineSpacingMultiplier = mult;
+    lineSpacingExtra = add;
+  }
+
+  /**
+   * Although this overrides the setTextSize method from the TextView base class, it changes the
+   * semantics a bit: Calling setTextSize now specifies the maximum text size to be used by this
+   * view. If the text can't fit with that text size, the text size will be scaled down, up to the
+   * minimum text size specified in {@link #setMinTextSize}.
+   *
+   * <p>Note that the final size unit will be truncated to the nearest integer value of the
+   * specified unit.
+   */
+  @Override
+  public final void setTextSize(int unit, float size) {
+    float maxTextSize = TypedValue.applyDimension(unit, size, displayMetrics);
+    if (this.maxTextSize != maxTextSize) {
+      this.maxTextSize = maxTextSize;
+      // TODO: It's not actually necessary to clear the whole cache here. To optimize cache
+      // deletion we'd have to delete all entries in the cache with a value equal or larger than
+      // MIN(old_max_size, new_max_size) when changing maxTextSize; and all entries with a value
+      // equal or smaller than MAX(old_min_size, new_min_size) when changing minTextSize.
+      textSizesCache.clear();
+      requestLayout();
+    }
+  }
+
+  /**
+   * Sets the lower text size limit and invalidate the view.
+   *
+   * <p>The parameters follow the same behavior as they do in {@link #setTextSize}.
+   *
+   * <p>Note that the final size unit will be truncated to the nearest integer value of the
+   * specified unit.
+   */
+  public final void setMinTextSize(int unit, float size) {
+    float minTextSize = TypedValue.applyDimension(unit, size, displayMetrics);
+    if (this.minTextSize != minTextSize) {
+      this.minTextSize = minTextSize;
+      textSizesCache.clear();
+      requestLayout();
+    }
+  }
+
+  /**
+   * Sets the unit to use as step units when computing the resized font size. This view's text
+   * contents will always be rendered as a whole integer value in the unit specified here. For
+   * example, if the unit is {@link TypedValue#COMPLEX_UNIT_SP}, then the text size may end up
+   * being 13sp or 14sp, but never 13.5sp.
+   *
+   * <p>By default, the AutoResizeTextView uses the unit {@link TypedValue#COMPLEX_UNIT_PX}.
+   *
+   * @param unit the unit type to use; must be a known unit type from {@link TypedValue}.
+   */
+  public final void setResizeStepUnit(int unit) {
+    if (resizeStepUnit != unit) {
+      resizeStepUnit = unit;
+      requestLayout();
+    }
+  }
+
+  private void readAttrs(TypedArray typedArray) {
+    resizeStepUnit = typedArray.getInt(
+        R.styleable.AutoResizeTextView_autoResizeText_resizeStepUnit, DEFAULT_RESIZE_STEP_UNIT);
+    minTextSize = (int) typedArray.getDimension(
+        R.styleable.AutoResizeTextView_autoResizeText_minTextSize, DEFAULT_MIN_TEXT_SIZE);
+    maxTextSize = (int) getTextSize();
+  }
+
+  private void adjustTextSize() {
+    int maxWidth = getMeasuredWidth() - getPaddingLeft() - getPaddingRight();
+    int maxHeight = getMeasuredHeight() - getPaddingBottom() - getPaddingTop();
+
+    if (maxWidth <= 0 || maxHeight <= 0) {
+      return;
+    }
+
+    this.maxWidth = maxWidth;
+    availableSpaceRect.right = maxWidth;
+    availableSpaceRect.bottom = maxHeight;
+    int minSizeInStepSizeUnits = (int) Math.ceil(convertToResizeStepUnits(minTextSize));
+    int maxSizeInStepSizeUnits = (int) Math.floor(convertToResizeStepUnits(maxTextSize));
+    float textSize = computeTextSize(
+        minSizeInStepSizeUnits, maxSizeInStepSizeUnits, availableSpaceRect);
+    super.setTextSize(resizeStepUnit, textSize);
+  }
+
+  private boolean suggestedSizeFitsInSpace(float suggestedSizeInPx, RectF availableSpace) {
+    textPaint.setTextSize(suggestedSizeInPx);
+    String text = getText().toString();
+    int maxLines = getMaxLines();
+    if (maxLines == 1) {
+      // If single line, check the line's height and width.
+      return textPaint.getFontSpacing() <= availableSpace.bottom
+          && textPaint.measureText(text) <= availableSpace.right;
+    } else {
+      // If multiline, lay the text out, then check the number of lines, the layout's height,
+      // and each line's width.
+      StaticLayout layout = new StaticLayout(text,
+          textPaint,
+          maxWidth,
+          Alignment.ALIGN_NORMAL,
+          getLineSpacingMultiplier(),
+          getLineSpacingExtra(),
+          true);
+
+      // Return false if we need more than maxLines. The text is obviously too big in this case.
+      if (maxLines != NO_LINE_LIMIT && layout.getLineCount() > maxLines) {
+        return false;
+      }
+      // Return false if the height of the layout is too big.
+      return layout.getHeight() <= availableSpace.bottom;
+    }
+  }
+
+  /**
+   * Computes the final text size to use for this text view, factoring in any previously
+   * cached computations.
+   *
+   * @param minSize the minimum text size to allow, in units of {@link #resizeStepUnit}
+   * @param maxSize the maximum text size to allow, in units of {@link #resizeStepUnit}
+   */
+  private float computeTextSize(int minSize, int maxSize, RectF availableSpace) {
+    CharSequence text = getText();
+    if (text != null && textSizesCache.get(text.hashCode()) != 0) {
+      return textSizesCache.get(text.hashCode());
+    }
+    int size = binarySearchSizes(minSize, maxSize, availableSpace);
+    textSizesCache.put(text == null ? 0 : text.hashCode(), size);
+    return size;
+  }
+
+  /**
+   * Performs a binary search to find the largest font size that will still fit within the size
+   * available to this view.
+   * @param minSize the minimum text size to allow, in units of {@link #resizeStepUnit}
+   * @param maxSize the maximum text size to allow, in units of {@link #resizeStepUnit}
+   */
+  private int binarySearchSizes(int minSize, int maxSize, RectF availableSpace) {
+    int bestSize = minSize;
+    int low = minSize + 1;
+    int high = maxSize;
+    int sizeToTry;
+    while (low <= high) {
+      sizeToTry = (low + high) / 2;
+      float dimension = TypedValue.applyDimension(resizeStepUnit, sizeToTry, displayMetrics);
+      if (suggestedSizeFitsInSpace(dimension, availableSpace)) {
+        bestSize = low;
+        low = sizeToTry + 1;
+      } else {
+        high = sizeToTry - 1;
+        bestSize = high;
+      }
+    }
+    return bestSize;
+  }
+
+  private float convertToResizeStepUnits(float dimension) {
+    // To figure out the multiplier between a raw dimension and the resizeStepUnit, we invert the
+    // conversion of 1 resizeStepUnit to a raw dimension.
+    float multiplier = 1 / TypedValue.applyDimension(resizeStepUnit, 1, displayMetrics);
+    return dimension * multiplier;
+  }
+
+  @Override
+  protected final void onTextChanged(
+      final CharSequence text, final int start, final int before, final int after) {
+    super.onTextChanged(text, start, before, after);
+    adjustTextSize();
+  }
+
+  @Override
+  protected final void onSizeChanged(int width, int height, int oldWidth, int oldHeight) {
+    super.onSizeChanged(width, height, oldWidth, oldHeight);
+    if (width != oldWidth || height != oldHeight) {
+      textSizesCache.clear();
+      adjustTextSize();
+    }
+  }
+
+  @Override
+  protected final void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+    adjustTextSize();
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+  }
+}
diff --git a/java/com/android/incallui/autoresizetext/res/values/attrs.xml b/java/com/android/incallui/autoresizetext/res/values/attrs.xml
new file mode 100644
index 0000000..e62feb9
--- /dev/null
+++ b/java/com/android/incallui/autoresizetext/res/values/attrs.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<resources>
+   <declare-styleable name="AutoResizeTextView">
+       <!--
+         The unit to use when computing step increments for the resize operation. That is, the
+         resized text will be guaranteed to be a whole number (integer) value in the unit
+         specified. For example, if the unit is scaled pixels (sp), then the font size might be
+         13sp or 14sp, but not 13.5sp.
+
+         The enum values must match the values from android.util.TypedValue.
+       -->
+       <attr name="autoResizeText_resizeStepUnit" format="enum">
+         <!-- Must match TypedValue.COMPLEX_UNIT_PX. -->
+         <enum name="unitPx" value="0" />
+         <!-- Must match TypedValue.COMPLEX_UNIT_DIP. -->
+         <enum name="unitDip" value="1" />
+         <!-- Must match TypedValue.COMPLEX_UNIT_SP. -->
+         <enum name="unitSp" value="2" />
+         <!-- Must match TypedValue.COMPLEX_UNIT_PT. -->
+         <enum name="unitPt" value="3" />
+         <!-- Must match TypedValue.COMPLEX_UNIT_IN. -->
+         <enum name="unitIn" value="4" />
+         <!-- Must match TypedValue.COMPLEX_UNIT_MM. -->
+         <enum name="unitMm" value="5" />
+       </attr>
+       <!--
+         The minimum text size to use in this view. Text size will be scale down to fit the text
+         in this view, but no smaller than the minimum size specified in this attribute.
+       -->
+       <attr name="autoResizeText_minTextSize" format="dimension" />
+   </declare-styleable>
+</resources>
diff --git a/java/com/android/incallui/baseui/BaseFragment.java b/java/com/android/incallui/baseui/BaseFragment.java
new file mode 100644
index 0000000..58b8c6f
--- /dev/null
+++ b/java/com/android/incallui/baseui/BaseFragment.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.baseui;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+
+/** Parent for all fragments that use Presenters and Ui design. */
+public abstract class BaseFragment<T extends Presenter<U>, U extends Ui> extends Fragment {
+
+  private static final String KEY_FRAGMENT_HIDDEN = "key_fragment_hidden";
+
+  private T mPresenter;
+
+  protected BaseFragment() {
+    mPresenter = createPresenter();
+  }
+
+  public abstract T createPresenter();
+
+  public abstract U getUi();
+
+  /**
+   * Presenter will be available after onActivityCreated().
+   *
+   * @return The presenter associated with this fragment.
+   */
+  public T getPresenter() {
+    return mPresenter;
+  }
+
+  @Override
+  public void onActivityCreated(Bundle savedInstanceState) {
+    super.onActivityCreated(savedInstanceState);
+    mPresenter.onUiReady(getUi());
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    if (savedInstanceState != null) {
+      mPresenter.onRestoreInstanceState(savedInstanceState);
+      if (savedInstanceState.getBoolean(KEY_FRAGMENT_HIDDEN)) {
+        getFragmentManager().beginTransaction().hide(this).commit();
+      }
+    }
+  }
+
+  @Override
+  public void onDestroyView() {
+    super.onDestroyView();
+    mPresenter.onUiDestroy(getUi());
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    mPresenter.onSaveInstanceState(outState);
+    outState.putBoolean(KEY_FRAGMENT_HIDDEN, isHidden());
+  }
+}
diff --git a/java/com/android/incallui/baseui/Presenter.java b/java/com/android/incallui/baseui/Presenter.java
new file mode 100644
index 0000000..581ad47
--- /dev/null
+++ b/java/com/android/incallui/baseui/Presenter.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.baseui;
+
+import android.os.Bundle;
+
+/** Base class for Presenters. */
+public abstract class Presenter<U extends Ui> {
+
+  private U mUi;
+
+  /**
+   * Called after the UI view has been created. That is when fragment.onViewCreated() is called.
+   *
+   * @param ui The Ui implementation that is now ready to be used.
+   */
+  public void onUiReady(U ui) {
+    mUi = ui;
+  }
+
+  /** Called when the UI view is destroyed in Fragment.onDestroyView(). */
+  public final void onUiDestroy(U ui) {
+    onUiUnready(ui);
+    mUi = null;
+  }
+
+  /**
+   * To be overriden by Presenter implementations. Called when the fragment is being destroyed but
+   * before ui is set to null.
+   */
+  public void onUiUnready(U ui) {}
+
+  public void onSaveInstanceState(Bundle outState) {}
+
+  public void onRestoreInstanceState(Bundle savedInstanceState) {}
+
+  public U getUi() {
+    return mUi;
+  }
+}
diff --git a/java/com/android/incallui/baseui/Ui.java b/java/com/android/incallui/baseui/Ui.java
new file mode 100644
index 0000000..439e415
--- /dev/null
+++ b/java/com/android/incallui/baseui/Ui.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.baseui;
+
+/** Base class for all presenter ui. */
+public interface Ui {}
diff --git a/java/com/android/incallui/bindings/ContactUtils.java b/java/com/android/incallui/bindings/ContactUtils.java
new file mode 100644
index 0000000..d2d365d
--- /dev/null
+++ b/java/com/android/incallui/bindings/ContactUtils.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.bindings;
+
+import android.location.Address;
+import android.util.Pair;
+import java.util.Calendar;
+import java.util.List;
+
+/** Utility functions to help manipulate contact data. */
+public interface ContactUtils {
+
+  boolean retrieveContactInteractionsFromLookupKey(String lookupKey, Listener listener);
+
+  interface Listener {
+
+    void onContactInteractionsFound(Address address, List<Pair<Calendar, Calendar>> openingHours);
+  }
+}
diff --git a/java/com/android/incallui/bindings/DistanceHelper.java b/java/com/android/incallui/bindings/DistanceHelper.java
new file mode 100644
index 0000000..6b2200d
--- /dev/null
+++ b/java/com/android/incallui/bindings/DistanceHelper.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.bindings;
+
+import android.location.Address;
+
+/** Superclass for a helper class to get the current location and distance to other locations. */
+public interface DistanceHelper {
+
+  float DISTANCE_NOT_FOUND = -1;
+  float MILES_PER_METER = (float) 0.000621371192;
+  float KILOMETERS_PER_METER = (float) 0.001;
+
+  void cleanUp();
+
+  float calculateDistance(Address address);
+
+  interface Listener {
+
+    void onLocationReady();
+  }
+}
diff --git a/java/com/android/incallui/bindings/InCallUiBindings.java b/java/com/android/incallui/bindings/InCallUiBindings.java
new file mode 100644
index 0000000..d3d3a8b
--- /dev/null
+++ b/java/com/android/incallui/bindings/InCallUiBindings.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2014 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.bindings;
+
+import android.content.Context;
+import android.content.Intent;
+import android.support.annotation.Nullable;
+import com.android.dialer.common.ConfigProvider;
+
+/** This interface allows the container application to customize the in call UI. */
+public interface InCallUiBindings {
+
+  @Nullable
+  PhoneNumberService newPhoneNumberService(Context context);
+
+  /** @return An {@link Intent} to be broadcast when the InCallUI is visible. */
+  @Nullable
+  Intent getUiReadyBroadcastIntent(Context context);
+
+  /**
+   * @return An {@link Intent} to be broadcast when the call state button in the InCallUI is touched
+   *     while in a call.
+   */
+  @Nullable
+  Intent getCallStateButtonBroadcastIntent(Context context);
+
+  @Nullable
+  DistanceHelper newDistanceHelper(Context context, DistanceHelper.Listener listener);
+
+  @Nullable
+  ContactUtils getContactUtilsInstance(Context context);
+
+  ConfigProvider getConfigProvider();
+}
diff --git a/java/com/android/incallui/bindings/InCallUiBindingsFactory.java b/java/com/android/incallui/bindings/InCallUiBindingsFactory.java
new file mode 100644
index 0000000..57c186d
--- /dev/null
+++ b/java/com/android/incallui/bindings/InCallUiBindingsFactory.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2016 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.bindings;
+
+/**
+ * This interface should be implementated by the Application subclass. It allows the in call UI
+ * module to get references to the InCallUiBindings.
+ */
+public interface InCallUiBindingsFactory {
+
+  InCallUiBindings newInCallUiBindings();
+}
diff --git a/java/com/android/incallui/bindings/InCallUiBindingsStub.java b/java/com/android/incallui/bindings/InCallUiBindingsStub.java
new file mode 100644
index 0000000..7b42fb3
--- /dev/null
+++ b/java/com/android/incallui/bindings/InCallUiBindingsStub.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2016 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.bindings;
+
+import android.content.Context;
+import android.content.Intent;
+import android.support.annotation.Nullable;
+import com.android.dialer.common.ConfigProvider;
+
+/** Default implementation for InCallUi bindings. */
+public class InCallUiBindingsStub implements InCallUiBindings {
+  private ConfigProvider configProvider;
+
+  @Override
+  @Nullable
+  public PhoneNumberService newPhoneNumberService(Context context) {
+    return null;
+  }
+
+  @Override
+  @Nullable
+  public Intent getUiReadyBroadcastIntent(Context context) {
+    return null;
+  }
+
+  @Override
+  @Nullable
+  public Intent getCallStateButtonBroadcastIntent(Context context) {
+    return null;
+  }
+
+  @Override
+  @Nullable
+  public DistanceHelper newDistanceHelper(Context context, DistanceHelper.Listener listener) {
+    return null;
+  }
+
+  @Override
+  @Nullable
+  public ContactUtils getContactUtilsInstance(Context context) {
+    return null;
+  }
+
+  @Override
+  public ConfigProvider getConfigProvider() {
+    if (configProvider == null) {
+      configProvider =
+          new ConfigProvider() {
+            @Override
+            public String getString(String key, String defaultValue) {
+              return defaultValue;
+            }
+
+            @Override
+            public long getLong(String key, long defaultValue) {
+              return defaultValue;
+            }
+
+            @Override
+            public boolean getBoolean(String key, boolean defaultValue) {
+              return defaultValue;
+            }
+          };
+    }
+    return configProvider;
+  }
+}
diff --git a/java/com/android/incallui/bindings/PhoneNumberService.java b/java/com/android/incallui/bindings/PhoneNumberService.java
new file mode 100644
index 0000000..bd2741a
--- /dev/null
+++ b/java/com/android/incallui/bindings/PhoneNumberService.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.bindings;
+
+import android.graphics.Bitmap;
+
+/** Provides phone number lookup services. */
+public interface PhoneNumberService {
+
+  /**
+   * Get a phone number number asynchronously.
+   *
+   * @param phoneNumber The phone number to lookup.
+   * @param listener The listener to notify when the phone number lookup is complete.
+   * @param imageListener The listener to notify when the image lookup is complete.
+   */
+  void getPhoneNumberInfo(
+      String phoneNumber,
+      NumberLookupListener listener,
+      ImageLookupListener imageListener,
+      boolean isIncoming);
+
+  interface NumberLookupListener {
+
+    /**
+     * Callback when a phone number has been looked up.
+     *
+     * @param info The looked up information. Or (@literal null} if there are no results.
+     */
+    void onPhoneNumberInfoComplete(PhoneNumberInfo info);
+  }
+
+  interface ImageLookupListener {
+
+    /**
+     * Callback when a image has been fetched.
+     *
+     * @param bitmap The fetched image.
+     */
+    void onImageFetchComplete(Bitmap bitmap);
+  }
+
+  interface PhoneNumberInfo {
+
+    String getDisplayName();
+
+    String getNumber();
+
+    int getPhoneType();
+
+    String getPhoneLabel();
+
+    String getNormalizedNumber();
+
+    String getImageUrl();
+
+    String getLookupKey();
+
+    boolean isBusiness();
+
+    int getLookupSource();
+  }
+}
diff --git a/java/com/android/incallui/call/CallList.java b/java/com/android/incallui/call/CallList.java
new file mode 100644
index 0000000..862c71c
--- /dev/null
+++ b/java/com/android/incallui/call/CallList.java
@@ -0,0 +1,763 @@
+/*
+ * Copyright (C) 2017 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;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Message;
+import android.os.Trace;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import android.support.v4.os.BuildCompat;
+import android.telecom.Call;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.util.ArrayMap;
+import com.android.contacts.common.GeoUtil;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.blocking.FilteredNumbersUtil;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.dialer.shortcuts.ShortcutUsageReporter;
+import com.android.dialer.spam.Spam;
+import com.android.dialer.spam.SpamBindings;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.latencyreport.LatencyReport;
+import com.android.incallui.util.TelecomCallUtil;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Maintains the list of active calls and notifies interested classes of changes to the call list as
+ * they are received from the telephony stack. Primary listener of changes to this class is
+ * InCallPresenter.
+ */
+public class CallList implements DialerCallDelegate {
+
+  private static final int DISCONNECTED_CALL_SHORT_TIMEOUT_MS = 200;
+  private static final int DISCONNECTED_CALL_MEDIUM_TIMEOUT_MS = 2000;
+  private static final int DISCONNECTED_CALL_LONG_TIMEOUT_MS = 5000;
+
+  private static final int EVENT_DISCONNECTED_TIMEOUT = 1;
+
+  private static CallList sInstance = new CallList();
+
+  private final Map<String, DialerCall> mCallById = new ArrayMap<>();
+  private final Map<android.telecom.Call, DialerCall> mCallByTelecomCall = new ArrayMap<>();
+
+  /**
+   * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is load factor before
+   * resizing, 1 means we only expect a single thread to access the map so make only a single shard
+   */
+  private final Set<Listener> mListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<Listener, Boolean>(8, 0.9f, 1));
+
+  private final Set<DialerCall> mPendingDisconnectCalls =
+      Collections.newSetFromMap(new ConcurrentHashMap<DialerCall, Boolean>(8, 0.9f, 1));
+  /** Handles the timeout for destroying disconnected calls. */
+  private final Handler mHandler =
+      new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+          switch (msg.what) {
+            case EVENT_DISCONNECTED_TIMEOUT:
+              LogUtil.d("CallList.handleMessage", "EVENT_DISCONNECTED_TIMEOUT ", msg.obj);
+              finishDisconnectedCall((DialerCall) msg.obj);
+              break;
+            default:
+              LogUtil.e("CallList.handleMessage", "Message not expected: " + msg.what);
+              break;
+          }
+        }
+      };
+
+  /**
+   * USED ONLY FOR TESTING Testing-only constructor. Instance should only be acquired through
+   * getInstance().
+   */
+  @VisibleForTesting
+  public CallList() {}
+
+  /** Static singleton accessor method. */
+  public static CallList getInstance() {
+    return sInstance;
+  }
+
+  public void onCallAdded(
+      final Context context, final android.telecom.Call telecomCall, LatencyReport latencyReport) {
+    Trace.beginSection("onCallAdded");
+    final DialerCall call =
+        new DialerCall(context, this, telecomCall, latencyReport, true /* registerCallback */);
+    final DialerCallListenerImpl dialerCallListener = new DialerCallListenerImpl(call);
+    call.addListener(dialerCallListener);
+    LogUtil.d("CallList.onCallAdded", "callState=" + call.getState());
+    if (Spam.get(context).isSpamEnabled()) {
+      String number = TelecomCallUtil.getNumber(telecomCall);
+      Spam.get(context)
+          .checkSpamStatus(
+              number,
+              null,
+              new SpamBindings.Listener() {
+                @Override
+                public void onComplete(boolean isSpam) {
+                  if (isSpam) {
+                    if (call.getState() != DialerCall.State.INCOMING
+                        && call.getState() != DialerCall.State.CALL_WAITING) {
+                      LogUtil.i(
+                          "CallList.onCallAdded",
+                          "marking spam call as not spam because it's not an incoming call");
+                      isSpam = false;
+                    } else if (isPotentialEmergencyCallback(context, call)) {
+                      LogUtil.i(
+                          "CallList.onCallAdded",
+                          "marking spam call as not spam because an emergency call was made on this"
+                              + " device recently");
+                      isSpam = false;
+                    }
+                  }
+
+                  Logger.get(context)
+                      .logCallImpression(
+                          isSpam
+                              ? DialerImpression.Type.INCOMING_SPAM_CALL
+                              : DialerImpression.Type.INCOMING_NON_SPAM_CALL,
+                          call.getUniqueCallId(),
+                          call.getTimeAddedMs());
+                  call.setSpam(isSpam);
+                  dialerCallListener.onDialerCallUpdate();
+                }
+              });
+
+      updateUserMarkedSpamStatus(call, context, number, dialerCallListener);
+    }
+
+    FilteredNumberAsyncQueryHandler filteredNumberAsyncQueryHandler =
+        new FilteredNumberAsyncQueryHandler(context);
+
+    filteredNumberAsyncQueryHandler.isBlockedNumber(
+        new FilteredNumberAsyncQueryHandler.OnCheckBlockedListener() {
+          @Override
+          public void onCheckComplete(Integer id) {
+            if (id != null && id != FilteredNumberAsyncQueryHandler.INVALID_ID) {
+              call.setBlockedStatus(true);
+              dialerCallListener.onDialerCallUpdate();
+            }
+          }
+        },
+        call.getNumber(),
+        GeoUtil.getCurrentCountryIso(context));
+
+    if (call.getState() == DialerCall.State.INCOMING
+        || call.getState() == DialerCall.State.CALL_WAITING) {
+      onIncoming(call);
+    } else {
+      dialerCallListener.onDialerCallUpdate();
+    }
+
+    if (call.getState() != State.INCOMING) {
+      // Only report outgoing calls
+      ShortcutUsageReporter.onOutgoingCallAdded(context, call.getNumber());
+    }
+
+    Trace.endSection();
+  }
+
+  private static boolean isPotentialEmergencyCallback(Context context, DialerCall call) {
+    if (BuildCompat.isAtLeastO()) {
+      return call.isPotentialEmergencyCallback();
+    } else {
+      long timestampMillis = FilteredNumbersUtil.getLastEmergencyCallTimeMillis(context);
+      return call.isInEmergencyCallbackWindow(timestampMillis);
+    }
+  }
+
+  @Override
+  public DialerCall getDialerCallFromTelecomCall(Call telecomCall) {
+    return mCallByTelecomCall.get(telecomCall);
+  }
+
+  public void updateUserMarkedSpamStatus(
+      final DialerCall call,
+      final Context context,
+      String number,
+      final DialerCallListenerImpl dialerCallListener) {
+
+    Spam.get(context)
+        .checkUserMarkedNonSpamStatus(
+            number,
+            null,
+            new SpamBindings.Listener() {
+              @Override
+              public void onComplete(boolean isInUserWhiteList) {
+                call.setIsInUserWhiteList(isInUserWhiteList);
+              }
+            });
+
+    Spam.get(context)
+        .checkGlobalSpamListStatus(
+            number,
+            null,
+            new SpamBindings.Listener() {
+              @Override
+              public void onComplete(boolean isInGlobalSpamList) {
+                call.setIsInGlobalSpamList(isInGlobalSpamList);
+              }
+            });
+
+    Spam.get(context)
+        .checkUserMarkedSpamStatus(
+            number,
+            null,
+            new SpamBindings.Listener() {
+              @Override
+              public void onComplete(boolean isInUserSpamList) {
+                call.setIsInUserSpamList(isInUserSpamList);
+              }
+            });
+  }
+
+  public void onCallRemoved(Context context, android.telecom.Call telecomCall) {
+    if (mCallByTelecomCall.containsKey(telecomCall)) {
+      DialerCall call = mCallByTelecomCall.get(telecomCall);
+      Assert.checkArgument(!call.isExternalCall());
+
+      // Don't log an already logged call. logCall() might be called multiple times
+      // for the same call due to b/24109437.
+      if (call.getLogState() != null && !call.getLogState().isLogged) {
+        getLegacyBindings(context).logCall(call);
+        call.getLogState().isLogged = true;
+      }
+
+      if (updateCallInMap(call)) {
+        LogUtil.w(
+            "CallList.onCallRemoved", "Removing call not previously disconnected " + call.getId());
+      }
+    }
+  }
+
+  InCallUiLegacyBindings getLegacyBindings(Context context) {
+    Objects.requireNonNull(context);
+
+    Context application = context.getApplicationContext();
+    InCallUiLegacyBindings legacyInstance = null;
+    if (application instanceof InCallUiLegacyBindingsFactory) {
+      legacyInstance = ((InCallUiLegacyBindingsFactory) application).newInCallUiLegacyBindings();
+    }
+
+    if (legacyInstance == null) {
+      legacyInstance = new InCallUiLegacyBindingsStub();
+    }
+    return legacyInstance;
+  }
+
+  /**
+   * Handles the case where an internal call has become an exteral call. We need to
+   *
+   * @param context
+   * @param telecomCall
+   */
+  public void onInternalCallMadeExternal(Context context, android.telecom.Call telecomCall) {
+
+    if (mCallByTelecomCall.containsKey(telecomCall)) {
+      DialerCall call = mCallByTelecomCall.get(telecomCall);
+
+      // Don't log an already logged call. logCall() might be called multiple times
+      // for the same call due to b/24109437.
+      if (call.getLogState() != null && !call.getLogState().isLogged) {
+        getLegacyBindings(context).logCall(call);
+        call.getLogState().isLogged = true;
+      }
+
+      // When removing a call from the call list because it became an external call, we need to
+      // ensure the callback is unregistered -- this is normally only done when calls disconnect.
+      // However, the call won't be disconnected in this case.  Also, logic in updateCallInMap
+      // would just re-add the call anyways.
+      call.unregisterCallback();
+      mCallById.remove(call.getId());
+      mCallByTelecomCall.remove(telecomCall);
+    }
+  }
+
+  /** Called when a single call has changed. */
+  private void onIncoming(DialerCall call) {
+    if (updateCallInMap(call)) {
+      LogUtil.i("CallList.onIncoming", String.valueOf(call));
+    }
+
+    for (Listener listener : mListeners) {
+      listener.onIncomingCall(call);
+    }
+  }
+
+  public void addListener(@NonNull Listener listener) {
+    Objects.requireNonNull(listener);
+
+    mListeners.add(listener);
+
+    // Let the listener know about the active calls immediately.
+    listener.onCallListChange(this);
+  }
+
+  public void removeListener(@Nullable Listener listener) {
+    if (listener != null) {
+      mListeners.remove(listener);
+    }
+  }
+
+  /**
+   * TODO: Change so that this function is not needed. Instead of assuming there is an active call,
+   * the code should rely on the status of a specific DialerCall and allow the presenters to update
+   * the DialerCall object when the active call changes.
+   */
+  public DialerCall getIncomingOrActive() {
+    DialerCall retval = getIncomingCall();
+    if (retval == null) {
+      retval = getActiveCall();
+    }
+    return retval;
+  }
+
+  public DialerCall getOutgoingOrActive() {
+    DialerCall retval = getOutgoingCall();
+    if (retval == null) {
+      retval = getActiveCall();
+    }
+    return retval;
+  }
+
+  /** A call that is waiting for {@link PhoneAccount} selection */
+  public DialerCall getWaitingForAccountCall() {
+    return getFirstCallWithState(DialerCall.State.SELECT_PHONE_ACCOUNT);
+  }
+
+  public DialerCall getPendingOutgoingCall() {
+    return getFirstCallWithState(DialerCall.State.CONNECTING);
+  }
+
+  public DialerCall getOutgoingCall() {
+    DialerCall call = getFirstCallWithState(DialerCall.State.DIALING);
+    if (call == null) {
+      call = getFirstCallWithState(DialerCall.State.REDIALING);
+    }
+    if (call == null) {
+      call = getFirstCallWithState(DialerCall.State.PULLING);
+    }
+    return call;
+  }
+
+  public DialerCall getActiveCall() {
+    return getFirstCallWithState(DialerCall.State.ACTIVE);
+  }
+
+  public DialerCall getSecondActiveCall() {
+    return getCallWithState(DialerCall.State.ACTIVE, 1);
+  }
+
+  public DialerCall getBackgroundCall() {
+    return getFirstCallWithState(DialerCall.State.ONHOLD);
+  }
+
+  public DialerCall getDisconnectedCall() {
+    return getFirstCallWithState(DialerCall.State.DISCONNECTED);
+  }
+
+  public DialerCall getDisconnectingCall() {
+    return getFirstCallWithState(DialerCall.State.DISCONNECTING);
+  }
+
+  public DialerCall getSecondBackgroundCall() {
+    return getCallWithState(DialerCall.State.ONHOLD, 1);
+  }
+
+  public DialerCall getActiveOrBackgroundCall() {
+    DialerCall call = getActiveCall();
+    if (call == null) {
+      call = getBackgroundCall();
+    }
+    return call;
+  }
+
+  public DialerCall getIncomingCall() {
+    DialerCall call = getFirstCallWithState(DialerCall.State.INCOMING);
+    if (call == null) {
+      call = getFirstCallWithState(DialerCall.State.CALL_WAITING);
+    }
+
+    return call;
+  }
+
+  public DialerCall getFirstCall() {
+    DialerCall result = getIncomingCall();
+    if (result == null) {
+      result = getPendingOutgoingCall();
+    }
+    if (result == null) {
+      result = getOutgoingCall();
+    }
+    if (result == null) {
+      result = getFirstCallWithState(DialerCall.State.ACTIVE);
+    }
+    if (result == null) {
+      result = getDisconnectingCall();
+    }
+    if (result == null) {
+      result = getDisconnectedCall();
+    }
+    return result;
+  }
+
+  public boolean hasLiveCall() {
+    DialerCall call = getFirstCall();
+    return call != null && call != getDisconnectingCall() && call != getDisconnectedCall();
+  }
+
+  /**
+   * Returns the first call found in the call map with the upgrade to video modification state.
+   *
+   * @return The first call with the upgrade to video state.
+   */
+  public DialerCall getVideoUpgradeRequestCall() {
+    for (DialerCall call : mCallById.values()) {
+      if (call.getSessionModificationState()
+          == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+        return call;
+      }
+    }
+    return null;
+  }
+
+  public DialerCall getCallById(String callId) {
+    return mCallById.get(callId);
+  }
+
+  /** Returns first call found in the call map with the specified state. */
+  public DialerCall getFirstCallWithState(int state) {
+    return getCallWithState(state, 0);
+  }
+
+  /**
+   * Returns the [position]th call found in the call map with the specified state. TODO: Improve
+   * this logic to sort by call time.
+   */
+  public DialerCall getCallWithState(int state, int positionToFind) {
+    DialerCall retval = null;
+    int position = 0;
+    for (DialerCall call : mCallById.values()) {
+      if (call.getState() == state) {
+        if (position >= positionToFind) {
+          retval = call;
+          break;
+        } else {
+          position++;
+        }
+      }
+    }
+
+    return retval;
+  }
+
+  /**
+   * This is called when the service disconnects, either expectedly or unexpectedly. For the
+   * expected case, it's because we have no calls left. For the unexpected case, it is likely a
+   * crash of phone and we need to clean up our calls manually. Without phone, there can be no
+   * active calls, so this is relatively safe thing to do.
+   */
+  public void clearOnDisconnect() {
+    for (DialerCall call : mCallById.values()) {
+      final int state = call.getState();
+      if (state != DialerCall.State.IDLE
+          && state != DialerCall.State.INVALID
+          && state != DialerCall.State.DISCONNECTED) {
+
+        call.setState(DialerCall.State.DISCONNECTED);
+        call.setDisconnectCause(new DisconnectCause(DisconnectCause.UNKNOWN));
+        updateCallInMap(call);
+      }
+    }
+    notifyGenericListeners();
+  }
+
+  /**
+   * Called when the user has dismissed an error dialog. This indicates acknowledgement of the
+   * disconnect cause, and that any pending disconnects should immediately occur.
+   */
+  public void onErrorDialogDismissed() {
+    final Iterator<DialerCall> iterator = mPendingDisconnectCalls.iterator();
+    while (iterator.hasNext()) {
+      DialerCall call = iterator.next();
+      iterator.remove();
+      finishDisconnectedCall(call);
+    }
+  }
+
+  /**
+   * Processes an update for a single call.
+   *
+   * @param call The call to update.
+   */
+  private void onUpdateCall(DialerCall call) {
+    LogUtil.d("CallList.onUpdateCall", String.valueOf(call));
+    if (!mCallById.containsKey(call.getId()) && call.isExternalCall()) {
+      // When a regular call becomes external, it is removed from the call list, and there may be
+      // pending updates to Telecom which are queued up on the Telecom call's handler which we no
+      // longer wish to cause updates to the call in the CallList.  Bail here if the list of tracked
+      // calls doesn't contain the call which received the update.
+      return;
+    }
+
+    if (updateCallInMap(call)) {
+      LogUtil.i("CallList.onUpdateCall", String.valueOf(call));
+    }
+  }
+
+  /**
+   * Sends a generic notification to all listeners that something has changed. It is up to the
+   * listeners to call back to determine what changed.
+   */
+  private void notifyGenericListeners() {
+    for (Listener listener : mListeners) {
+      listener.onCallListChange(this);
+    }
+  }
+
+  private void notifyListenersOfDisconnect(DialerCall call) {
+    for (Listener listener : mListeners) {
+      listener.onDisconnect(call);
+    }
+  }
+
+  /**
+   * Updates the call entry in the local map.
+   *
+   * @return false if no call previously existed and no call was added, otherwise true.
+   */
+  private boolean updateCallInMap(DialerCall call) {
+    Objects.requireNonNull(call);
+
+    boolean updated = false;
+
+    if (call.getState() == DialerCall.State.DISCONNECTED) {
+      // update existing (but do not add!!) disconnected calls
+      if (mCallById.containsKey(call.getId())) {
+        // For disconnected calls, we want to keep them alive for a few seconds so that the
+        // UI has a chance to display anything it needs when a call is disconnected.
+
+        // Set up a timer to destroy the call after X seconds.
+        final Message msg = mHandler.obtainMessage(EVENT_DISCONNECTED_TIMEOUT, call);
+        mHandler.sendMessageDelayed(msg, getDelayForDisconnect(call));
+        mPendingDisconnectCalls.add(call);
+
+        mCallById.put(call.getId(), call);
+        mCallByTelecomCall.put(call.getTelecomCall(), call);
+        updated = true;
+      }
+    } else if (!isCallDead(call)) {
+      mCallById.put(call.getId(), call);
+      mCallByTelecomCall.put(call.getTelecomCall(), call);
+      updated = true;
+    } else if (mCallById.containsKey(call.getId())) {
+      mCallById.remove(call.getId());
+      mCallByTelecomCall.remove(call.getTelecomCall());
+      updated = true;
+    }
+
+    return updated;
+  }
+
+  private int getDelayForDisconnect(DialerCall call) {
+    if (call.getState() != DialerCall.State.DISCONNECTED) {
+      throw new IllegalStateException();
+    }
+
+    final int cause = call.getDisconnectCause().getCode();
+    final int delay;
+    switch (cause) {
+      case DisconnectCause.LOCAL:
+        delay = DISCONNECTED_CALL_SHORT_TIMEOUT_MS;
+        break;
+      case DisconnectCause.REMOTE:
+      case DisconnectCause.ERROR:
+        delay = DISCONNECTED_CALL_MEDIUM_TIMEOUT_MS;
+        break;
+      case DisconnectCause.REJECTED:
+      case DisconnectCause.MISSED:
+      case DisconnectCause.CANCELED:
+        // no delay for missed/rejected incoming calls and canceled outgoing calls.
+        delay = 0;
+        break;
+      default:
+        delay = DISCONNECTED_CALL_LONG_TIMEOUT_MS;
+        break;
+    }
+
+    return delay;
+  }
+
+  private boolean isCallDead(DialerCall call) {
+    final int state = call.getState();
+    return DialerCall.State.IDLE == state || DialerCall.State.INVALID == state;
+  }
+
+  /** Sets up a call for deletion and notifies listeners of change. */
+  private void finishDisconnectedCall(DialerCall call) {
+    if (mPendingDisconnectCalls.contains(call)) {
+      mPendingDisconnectCalls.remove(call);
+    }
+    call.setState(DialerCall.State.IDLE);
+    updateCallInMap(call);
+    notifyGenericListeners();
+  }
+
+  /**
+   * Notifies all video calls of a change in device orientation.
+   *
+   * @param rotation The new rotation angle (in degrees).
+   */
+  public void notifyCallsOfDeviceRotation(int rotation) {
+    for (DialerCall call : mCallById.values()) {
+      // First, ensure that the call videoState has video enabled (there is no need to set
+      // device orientation on a voice call which has not yet been upgraded to video).
+      // Second, ensure a VideoCall is set on the call so that the change can be sent to the
+      // provider (a VideoCall can be present for a call that does not currently have video,
+      // but can be upgraded to video).
+
+      // NOTE: is it necessary to use this order because getVideoCall references the class
+      // VideoProfile which is not available on APIs <23 (M).
+      if (VideoUtils.isVideoCall(call) && call.getVideoCall() != null) {
+        call.getVideoCall().setDeviceOrientation(rotation);
+      }
+    }
+  }
+
+  public void onInCallUiShown(boolean forFullScreenIntent) {
+    for (DialerCall call : mCallById.values()) {
+      call.getLatencyReport().onInCallUiShown(forFullScreenIntent);
+    }
+  }
+
+  /** Listener interface for any class that wants to be notified of changes to the call list. */
+  public interface Listener {
+
+    /**
+     * Called when a new incoming call comes in. This is the only method that gets called for
+     * incoming calls. Listeners that want to perform an action on incoming call should respond in
+     * this method because {@link #onCallListChange} does not automatically get called for incoming
+     * calls.
+     */
+    void onIncomingCall(DialerCall call);
+
+    /**
+     * Called when a new modify call request comes in This is the only method that gets called for
+     * modify requests.
+     */
+    void onUpgradeToVideo(DialerCall call);
+
+    /** Called when the session modification state of a call changes. */
+    void onSessionModificationStateChange(@SessionModificationState int newState);
+
+    /**
+     * Called anytime there are changes to the call list. The change can be switching call states,
+     * updating information, etc. This method will NOT be called for new incoming calls and for
+     * calls that switch to disconnected state. Listeners must add actions to those method
+     * implementations if they want to deal with those actions.
+     */
+    void onCallListChange(CallList callList);
+
+    /**
+     * Called when a call switches to the disconnected state. This is the only method that will get
+     * called upon disconnection.
+     */
+    void onDisconnect(DialerCall call);
+
+    void onWiFiToLteHandover(DialerCall call);
+
+    /**
+     * Called when a user is in a video call and the call is unable to be handed off successfully to
+     * WiFi
+     */
+    void onHandoverToWifiFailed(DialerCall call);
+  }
+
+  private class DialerCallListenerImpl implements DialerCallListener {
+
+    private final DialerCall mCall;
+
+    DialerCallListenerImpl(DialerCall call) {
+      Assert.isNotNull(call);
+      mCall = call;
+    }
+
+    @Override
+    public void onDialerCallDisconnect() {
+      if (updateCallInMap(mCall)) {
+        LogUtil.i("DialerCallListenerImpl.onDialerCallDisconnect", String.valueOf(mCall));
+        // notify those listening for all disconnects
+        notifyListenersOfDisconnect(mCall);
+      }
+    }
+
+    @Override
+    public void onDialerCallUpdate() {
+      Trace.beginSection("onUpdate");
+      onUpdateCall(mCall);
+      notifyGenericListeners();
+      Trace.endSection();
+    }
+
+    @Override
+    public void onDialerCallChildNumberChange() {}
+
+    @Override
+    public void onDialerCallLastForwardedNumberChange() {}
+
+    @Override
+    public void onDialerCallUpgradeToVideo() {
+      for (Listener listener : mListeners) {
+        listener.onUpgradeToVideo(mCall);
+      }
+    }
+
+    @Override
+    public void onWiFiToLteHandover() {
+      for (Listener listener : mListeners) {
+        listener.onWiFiToLteHandover(mCall);
+      }
+    }
+
+    @Override
+    public void onHandoverToWifiFailure() {
+      for (Listener listener : mListeners) {
+        listener.onHandoverToWifiFailed(mCall);
+      }
+    }
+
+    @Override
+    public void onDialerCallSessionModificationStateChange(@SessionModificationState int state) {
+      for (Listener listener : mListeners) {
+        listener.onSessionModificationStateChange(state);
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/call/DialerCall.java b/java/com/android/incallui/call/DialerCall.java
new file mode 100644
index 0000000..bd8f006
--- /dev/null
+++ b/java/com/android/incallui/call/DialerCall.java
@@ -0,0 +1,1401 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.call;
+
+import android.content.Context;
+import android.hardware.camera2.CameraCharacteristics;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.Bundle;
+import android.os.Trace;
+import android.support.annotation.IntDef;
+import android.support.annotation.Nullable;
+import android.telecom.Call;
+import android.telecom.Call.Details;
+import android.telecom.Connection;
+import android.telecom.DisconnectCause;
+import android.telecom.GatewayInfo;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.StatusHints;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import com.android.contacts.common.compat.CallCompat;
+import com.android.contacts.common.compat.TelephonyManagerCompat;
+import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
+import com.android.dialer.callintent.CallIntentParser;
+import com.android.dialer.callintent.nano.CallInitiationType;
+import com.android.dialer.callintent.nano.CallSpecificAppData;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.ConfigProviderBindings;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.nano.ContactLookupResult;
+import com.android.dialer.util.CallUtil;
+import com.android.incallui.latencyreport.LatencyReport;
+import com.android.incallui.util.TelecomCallUtil;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+
+/** Describes a single call and its state. */
+public class DialerCall {
+
+  public static final int CALL_HISTORY_STATUS_UNKNOWN = 0;
+  public static final int CALL_HISTORY_STATUS_PRESENT = 1;
+  public static final int CALL_HISTORY_STATUS_NOT_PRESENT = 2;
+  private static final String ID_PREFIX = "DialerCall_";
+  private static final String CONFIG_EMERGENCY_CALLBACK_WINDOW_MILLIS =
+      "emergency_callback_window_millis";
+  private static int sIdCounter = 0;
+
+  /**
+   * The unique call ID for every call. This will help us to identify each call and allow us the
+   * ability to stitch impressions to calls if needed.
+   */
+  private final String uniqueCallId = UUID.randomUUID().toString();
+
+  private final Call mTelecomCall;
+  private final LatencyReport mLatencyReport;
+  private final String mId;
+  private final List<String> mChildCallIds = new ArrayList<>();
+  private final VideoSettings mVideoSettings = new VideoSettings();
+  private final LogState mLogState = new LogState();
+  private final Context mContext;
+  private final DialerCallDelegate mDialerCallDelegate;
+  private final List<DialerCallListener> mListeners = new CopyOnWriteArrayList<>();
+  private final List<CannedTextResponsesLoadedListener> mCannedTextResponsesLoadedListeners =
+      new CopyOnWriteArrayList<>();
+
+  private boolean mIsEmergencyCall;
+  private Uri mHandle;
+  private int mState = State.INVALID;
+  private DisconnectCause mDisconnectCause;
+
+  private boolean hasShownWiFiToLteHandoverToast;
+  private boolean doNotShowDialogForHandoffToWifiFailure;
+
+  @SessionModificationState private int mSessionModificationState;
+  private int mVideoState;
+  /** mRequestedVideoState is used to store requested upgrade / downgrade video state */
+  private int mRequestedVideoState = VideoProfile.STATE_AUDIO_ONLY;
+
+  private InCallVideoCallCallback mVideoCallCallback;
+  private boolean mIsVideoCallCallbackRegistered;
+  private String mChildNumber;
+  private String mLastForwardedNumber;
+  private String mCallSubject;
+  private PhoneAccountHandle mPhoneAccountHandle;
+  @CallHistoryStatus private int mCallHistoryStatus = CALL_HISTORY_STATUS_UNKNOWN;
+  private boolean mIsSpam;
+  private boolean mIsBlocked;
+  private boolean isInUserSpamList;
+  private boolean isInUserWhiteList;
+  private boolean isInGlobalSpamList;
+  private boolean didShowCameraPermission;
+  private String callProviderLabel;
+  private String callbackNumber;
+
+  public static String getNumberFromHandle(Uri handle) {
+    return handle == null ? "" : handle.getSchemeSpecificPart();
+  }
+
+  /**
+   * 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.
+   */
+  private boolean isRemotelyHeld;
+
+  /**
+   * Indicates whether the phone account associated with this call supports specifying a call
+   * subject.
+   */
+  private boolean mIsCallSubjectSupported;
+
+  private final Call.Callback mTelecomCallCallback =
+      new Call.Callback() {
+        @Override
+        public void onStateChanged(Call call, int newState) {
+          LogUtil.v("TelecomCallCallback.onStateChanged", "call=" + call + " newState=" + newState);
+          update();
+        }
+
+        @Override
+        public void onParentChanged(Call call, Call newParent) {
+          LogUtil.v(
+              "TelecomCallCallback.onParentChanged", "call=" + call + " newParent=" + newParent);
+          update();
+        }
+
+        @Override
+        public void onChildrenChanged(Call call, List<Call> children) {
+          update();
+        }
+
+        @Override
+        public void onDetailsChanged(Call call, Call.Details details) {
+          LogUtil.v("TelecomCallCallback.onStateChanged", " call=" + call + " details=" + details);
+          update();
+        }
+
+        @Override
+        public void onCannedTextResponsesLoaded(Call call, List<String> cannedTextResponses) {
+          LogUtil.v(
+              "TelecomCallCallback.onStateChanged",
+              "call=" + call + " cannedTextResponses=" + cannedTextResponses);
+          for (CannedTextResponsesLoadedListener listener : mCannedTextResponsesLoadedListeners) {
+            listener.onCannedTextResponsesLoaded(DialerCall.this);
+          }
+        }
+
+        @Override
+        public void onPostDialWait(Call call, String remainingPostDialSequence) {
+          LogUtil.v(
+              "TelecomCallCallback.onStateChanged",
+              "call=" + call + " remainingPostDialSequence=" + remainingPostDialSequence);
+          update();
+        }
+
+        @Override
+        public void onVideoCallChanged(Call call, VideoCall videoCall) {
+          LogUtil.v(
+              "TelecomCallCallback.onStateChanged", "call=" + call + " videoCall=" + videoCall);
+          update();
+        }
+
+        @Override
+        public void onCallDestroyed(Call call) {
+          LogUtil.v("TelecomCallCallback.onStateChanged", "call=" + call);
+          call.unregisterCallback(this);
+        }
+
+        @Override
+        public void onConferenceableCallsChanged(Call call, List<Call> conferenceableCalls) {
+          LogUtil.v(
+              "DialerCall.onConferenceableCallsChanged",
+              "call %s, conferenceable calls: %d",
+              call,
+              conferenceableCalls.size());
+          update();
+        }
+
+        @Override
+        public void onConnectionEvent(android.telecom.Call call, String event, Bundle extras) {
+          LogUtil.v(
+              "DialerCall.onConnectionEvent",
+              "Call: " + call + ", Event: " + event + ", Extras: " + extras);
+          switch (event) {
+              // The Previous attempt to Merge two calls together has failed in Telecom. We must
+              // now update the UI to possibly re-enable the Merge button based on the number of
+              // currently conferenceable calls available or Connection Capabilities.
+            case android.telecom.Connection.EVENT_CALL_MERGE_FAILED:
+              update();
+              break;
+            case TelephonyManagerCompat.EVENT_HANDOVER_VIDEO_FROM_WIFI_TO_LTE:
+              notifyWiFiToLteHandover();
+              break;
+            case TelephonyManagerCompat.EVENT_HANDOVER_TO_WIFI_FAILED:
+              notifyHandoverToWifiFailed();
+              break;
+            case TelephonyManagerCompat.EVENT_CALL_REMOTELY_HELD:
+              isRemotelyHeld = true;
+              update();
+              break;
+            case TelephonyManagerCompat.EVENT_CALL_REMOTELY_UNHELD:
+              isRemotelyHeld = false;
+              update();
+              break;
+            default:
+              break;
+          }
+        }
+      };
+  private long mTimeAddedMs;
+
+  public DialerCall(
+      Context context,
+      DialerCallDelegate dialerCallDelegate,
+      Call telecomCall,
+      LatencyReport latencyReport,
+      boolean registerCallback) {
+    Assert.isNotNull(context);
+    mContext = context;
+    mDialerCallDelegate = dialerCallDelegate;
+    mTelecomCall = telecomCall;
+    mLatencyReport = latencyReport;
+    mId = ID_PREFIX + Integer.toString(sIdCounter++);
+
+    updateFromTelecomCall(registerCallback);
+
+    if (registerCallback) {
+      mTelecomCall.registerCallback(mTelecomCallCallback);
+    }
+
+    mTimeAddedMs = System.currentTimeMillis();
+    parseCallSpecificAppData();
+  }
+
+  private static int translateState(int state) {
+    switch (state) {
+      case Call.STATE_NEW:
+      case Call.STATE_CONNECTING:
+        return DialerCall.State.CONNECTING;
+      case Call.STATE_SELECT_PHONE_ACCOUNT:
+        return DialerCall.State.SELECT_PHONE_ACCOUNT;
+      case Call.STATE_DIALING:
+        return DialerCall.State.DIALING;
+      case Call.STATE_PULLING_CALL:
+        return DialerCall.State.PULLING;
+      case Call.STATE_RINGING:
+        return DialerCall.State.INCOMING;
+      case Call.STATE_ACTIVE:
+        return DialerCall.State.ACTIVE;
+      case Call.STATE_HOLDING:
+        return DialerCall.State.ONHOLD;
+      case Call.STATE_DISCONNECTED:
+        return DialerCall.State.DISCONNECTED;
+      case Call.STATE_DISCONNECTING:
+        return DialerCall.State.DISCONNECTING;
+      default:
+        return DialerCall.State.INVALID;
+    }
+  }
+
+  public static boolean areSame(DialerCall call1, DialerCall call2) {
+    if (call1 == null && call2 == null) {
+      return true;
+    } else if (call1 == null || call2 == null) {
+      return false;
+    }
+
+    // otherwise compare call Ids
+    return call1.getId().equals(call2.getId());
+  }
+
+  public static boolean areSameNumber(DialerCall call1, DialerCall call2) {
+    if (call1 == null && call2 == null) {
+      return true;
+    } else if (call1 == null || call2 == null) {
+      return false;
+    }
+
+    // otherwise compare call Numbers
+    return TextUtils.equals(call1.getNumber(), call2.getNumber());
+  }
+
+  public void addListener(DialerCallListener listener) {
+    Assert.isMainThread();
+    mListeners.add(listener);
+  }
+
+  public void removeListener(DialerCallListener listener) {
+    Assert.isMainThread();
+    mListeners.remove(listener);
+  }
+
+  public void addCannedTextResponsesLoadedListener(CannedTextResponsesLoadedListener listener) {
+    Assert.isMainThread();
+    mCannedTextResponsesLoadedListeners.add(listener);
+  }
+
+  public void removeCannedTextResponsesLoadedListener(CannedTextResponsesLoadedListener listener) {
+    Assert.isMainThread();
+    mCannedTextResponsesLoadedListeners.remove(listener);
+  }
+
+  public void notifyWiFiToLteHandover() {
+    LogUtil.i("DialerCall.notifyWiFiToLteHandover", "");
+    for (DialerCallListener listener : mListeners) {
+      listener.onWiFiToLteHandover();
+    }
+  }
+
+  public void notifyHandoverToWifiFailed() {
+    LogUtil.i("DialerCall.notifyHandoverToWifiFailed", "");
+    for (DialerCallListener listener : mListeners) {
+      listener.onHandoverToWifiFailure();
+    }
+  }
+
+  /* package-private */ Call getTelecomCall() {
+    return mTelecomCall;
+  }
+
+  public StatusHints getStatusHints() {
+    return mTelecomCall.getDetails().getStatusHints();
+  }
+
+  /**
+   * @return video settings of the call, null if the call is not a video call.
+   * @see VideoProfile
+   */
+  public VideoSettings getVideoSettings() {
+    return mVideoSettings;
+  }
+
+  private void update() {
+    Trace.beginSection("Update");
+    int oldState = getState();
+    // We want to potentially register a video call callback here.
+    updateFromTelecomCall(true /* registerCallback */);
+    if (oldState != getState() && getState() == DialerCall.State.DISCONNECTED) {
+      for (DialerCallListener listener : mListeners) {
+        listener.onDialerCallDisconnect();
+      }
+    } else {
+      for (DialerCallListener listener : mListeners) {
+        listener.onDialerCallUpdate();
+      }
+    }
+    Trace.endSection();
+  }
+
+  private void updateFromTelecomCall(boolean registerCallback) {
+    LogUtil.v("DialerCall.updateFromTelecomCall", mTelecomCall.toString());
+    final int translatedState = translateState(mTelecomCall.getState());
+    if (mState != State.BLOCKED) {
+      setState(translatedState);
+      setDisconnectCause(mTelecomCall.getDetails().getDisconnectCause());
+      maybeCancelVideoUpgrade(mTelecomCall.getDetails().getVideoState());
+    }
+
+    if (registerCallback && mTelecomCall.getVideoCall() != null) {
+      if (mVideoCallCallback == null) {
+        mVideoCallCallback = new InCallVideoCallCallback(this);
+      }
+      mTelecomCall.getVideoCall().registerCallback(mVideoCallCallback);
+      mIsVideoCallCallbackRegistered = true;
+    }
+
+    mChildCallIds.clear();
+    final int numChildCalls = mTelecomCall.getChildren().size();
+    for (int i = 0; i < numChildCalls; i++) {
+      mChildCallIds.add(
+          mDialerCallDelegate
+              .getDialerCallFromTelecomCall(mTelecomCall.getChildren().get(i))
+              .getId());
+    }
+
+    // The number of conferenced calls can change over the course of the call, so use the
+    // maximum number of conferenced child calls as the metric for conference call usage.
+    mLogState.conferencedCalls = Math.max(numChildCalls, mLogState.conferencedCalls);
+
+    updateFromCallExtras(mTelecomCall.getDetails().getExtras());
+
+    // If the handle of the call has changed, update state for the call determining if it is an
+    // emergency call.
+    Uri newHandle = mTelecomCall.getDetails().getHandle();
+    if (!Objects.equals(mHandle, newHandle)) {
+      mHandle = newHandle;
+      updateEmergencyCallState();
+    }
+
+    // If the phone account handle of the call is set, cache capability bit indicating whether
+    // the phone account supports call subjects.
+    PhoneAccountHandle newPhoneAccountHandle = mTelecomCall.getDetails().getAccountHandle();
+    if (!Objects.equals(mPhoneAccountHandle, newPhoneAccountHandle)) {
+      mPhoneAccountHandle = newPhoneAccountHandle;
+
+      if (mPhoneAccountHandle != null) {
+        PhoneAccount phoneAccount =
+            mContext.getSystemService(TelecomManager.class).getPhoneAccount(mPhoneAccountHandle);
+        if (phoneAccount != null) {
+          mIsCallSubjectSupported =
+              phoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_CALL_SUBJECT);
+        }
+      }
+    }
+
+    if (mSessionModificationState
+            == DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE
+        && isVideoCall()) {
+      // We find out in {@link InCallVideoCallCallback.onSessionModifyResponseReceived}
+      // whether the video upgrade request was accepted. We don't clear the session modification
+      // state right away though to avoid having the UI switch from video to voice to video.
+      // Once the underlying telecom call updates to video mode it's safe to clear the state.
+      LogUtil.i(
+          "DialerCall.updateFromTelecomCall",
+          "upgraded to video, clearing session modification state");
+      setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    }
+  }
+
+  /**
+   * Tests corruption of the {@code callExtras} bundle by calling {@link
+   * Bundle#containsKey(String)}. If the bundle is corrupted a {@link IllegalArgumentException} will
+   * be thrown and caught by this function.
+   *
+   * @param callExtras the bundle to verify
+   * @return {@code true} if the bundle is corrupted, {@code false} otherwise.
+   */
+  protected boolean areCallExtrasCorrupted(Bundle callExtras) {
+    /**
+     * There's currently a bug in Telephony service (b/25613098) that could corrupt the extras
+     * bundle, resulting in a IllegalArgumentException while validating data under {@link
+     * Bundle#containsKey(String)}.
+     */
+    try {
+      callExtras.containsKey(Connection.EXTRA_CHILD_ADDRESS);
+      return false;
+    } catch (IllegalArgumentException e) {
+      LogUtil.e(
+          "DialerCall.areCallExtrasCorrupted", "callExtras is corrupted, ignoring exception", e);
+      return true;
+    }
+  }
+
+  protected void updateFromCallExtras(Bundle callExtras) {
+    if (callExtras == null || areCallExtrasCorrupted(callExtras)) {
+      /**
+       * If the bundle is corrupted, abandon information update as a work around. These are not
+       * critical for the dialer to function.
+       */
+      return;
+    }
+    // Check for a change in the child address and notify any listeners.
+    if (callExtras.containsKey(Connection.EXTRA_CHILD_ADDRESS)) {
+      String childNumber = callExtras.getString(Connection.EXTRA_CHILD_ADDRESS);
+      if (!Objects.equals(childNumber, mChildNumber)) {
+        mChildNumber = childNumber;
+        for (DialerCallListener listener : mListeners) {
+          listener.onDialerCallChildNumberChange();
+        }
+      }
+    }
+
+    // Last forwarded number comes in as an array of strings.  We want to choose the
+    // last item in the array.  The forwarding numbers arrive independently of when the
+    // call is originally set up, so we need to notify the the UI of the change.
+    if (callExtras.containsKey(Connection.EXTRA_LAST_FORWARDED_NUMBER)) {
+      ArrayList<String> lastForwardedNumbers =
+          callExtras.getStringArrayList(Connection.EXTRA_LAST_FORWARDED_NUMBER);
+
+      if (lastForwardedNumbers != null) {
+        String lastForwardedNumber = null;
+        if (!lastForwardedNumbers.isEmpty()) {
+          lastForwardedNumber = lastForwardedNumbers.get(lastForwardedNumbers.size() - 1);
+        }
+
+        if (!Objects.equals(lastForwardedNumber, mLastForwardedNumber)) {
+          mLastForwardedNumber = lastForwardedNumber;
+          for (DialerCallListener listener : mListeners) {
+            listener.onDialerCallLastForwardedNumberChange();
+          }
+        }
+      }
+    }
+
+    // DialerCall subject is present in the extras at the start of call, so we do not need to
+    // notify any other listeners of this.
+    if (callExtras.containsKey(Connection.EXTRA_CALL_SUBJECT)) {
+      String callSubject = callExtras.getString(Connection.EXTRA_CALL_SUBJECT);
+      if (!Objects.equals(mCallSubject, callSubject)) {
+        mCallSubject = callSubject;
+      }
+    }
+  }
+
+  /**
+   * Determines if a received upgrade to video request should be cancelled. This can happen if
+   * another InCall UI responds to the upgrade to video request.
+   *
+   * @param newVideoState The new video state.
+   */
+  private void maybeCancelVideoUpgrade(int newVideoState) {
+    boolean isVideoStateChanged = mVideoState != newVideoState;
+
+    if (mSessionModificationState
+            == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST
+        && isVideoStateChanged) {
+
+      LogUtil.i("DialerCall.maybeCancelVideoUpgrade", "cancelling upgrade notification");
+      setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    }
+    mVideoState = newVideoState;
+  }
+
+  public String getId() {
+    return mId;
+  }
+
+  public boolean hasShownWiFiToLteHandoverToast() {
+    return hasShownWiFiToLteHandoverToast;
+  }
+
+  public void setHasShownWiFiToLteHandoverToast() {
+    hasShownWiFiToLteHandoverToast = true;
+  }
+
+  public boolean showWifiHandoverAlertAsToast() {
+    return doNotShowDialogForHandoffToWifiFailure;
+  }
+
+  public void setDoNotShowDialogForHandoffToWifiFailure(boolean bool) {
+    doNotShowDialogForHandoffToWifiFailure = bool;
+  }
+
+  public long getTimeAddedMs() {
+    return mTimeAddedMs;
+  }
+
+  @Nullable
+  public String getNumber() {
+    return TelecomCallUtil.getNumber(mTelecomCall);
+  }
+
+  public void blockCall() {
+    mTelecomCall.reject(false, null);
+    setState(State.BLOCKED);
+  }
+
+  @Nullable
+  public Uri getHandle() {
+    return mTelecomCall == null ? null : mTelecomCall.getDetails().getHandle();
+  }
+
+  public boolean isEmergencyCall() {
+    return mIsEmergencyCall;
+  }
+
+  public boolean isPotentialEmergencyCallback() {
+    // The property PROPERTY_EMERGENCY_CALLBACK_MODE is only set for CDMA calls when the system
+    // is actually in emergency callback mode (ie data is disabled).
+    if (hasProperty(Details.PROPERTY_EMERGENCY_CALLBACK_MODE)) {
+      return true;
+    }
+    // We want to treat any incoming call that arrives a short time after an outgoing emergency call
+    // as a potential emergency callback.
+    if (getExtras() != null
+        && getExtras().getLong(TelecomManagerCompat.EXTRA_LAST_EMERGENCY_CALLBACK_TIME_MILLIS, 0)
+            > 0) {
+      long lastEmergencyCallMillis =
+          getExtras().getLong(TelecomManagerCompat.EXTRA_LAST_EMERGENCY_CALLBACK_TIME_MILLIS, 0);
+      if (isInEmergencyCallbackWindow(lastEmergencyCallMillis)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  boolean isInEmergencyCallbackWindow(long timestampMillis) {
+    long emergencyCallbackWindowMillis =
+        ConfigProviderBindings.get(mContext)
+            .getLong(CONFIG_EMERGENCY_CALLBACK_WINDOW_MILLIS, TimeUnit.MINUTES.toMillis(5));
+    return System.currentTimeMillis() - timestampMillis < emergencyCallbackWindowMillis;
+  }
+
+  public int getState() {
+    if (mTelecomCall != null && mTelecomCall.getParent() != null) {
+      return State.CONFERENCED;
+    } else {
+      return mState;
+    }
+  }
+
+  public void setState(int state) {
+    mState = state;
+    if (mState == State.INCOMING) {
+      mLogState.isIncoming = true;
+    } else if (mState == State.DISCONNECTED) {
+      mLogState.duration =
+          getConnectTimeMillis() == 0 ? 0 : System.currentTimeMillis() - getConnectTimeMillis();
+    }
+  }
+
+  public int getNumberPresentation() {
+    return mTelecomCall == null ? -1 : mTelecomCall.getDetails().getHandlePresentation();
+  }
+
+  public int getCnapNamePresentation() {
+    return mTelecomCall == null ? -1 : mTelecomCall.getDetails().getCallerDisplayNamePresentation();
+  }
+
+  @Nullable
+  public String getCnapName() {
+    return mTelecomCall == null ? null : getTelecomCall().getDetails().getCallerDisplayName();
+  }
+
+  public Bundle getIntentExtras() {
+    return mTelecomCall.getDetails().getIntentExtras();
+  }
+
+  @Nullable
+  public Bundle getExtras() {
+    return mTelecomCall == null ? null : mTelecomCall.getDetails().getExtras();
+  }
+
+  /** @return The child number for the call, or {@code null} if none specified. */
+  public String getChildNumber() {
+    return mChildNumber;
+  }
+
+  /** @return The last forwarded number for the call, or {@code null} if none specified. */
+  public String getLastForwardedNumber() {
+    return mLastForwardedNumber;
+  }
+
+  /** @return The call subject, or {@code null} if none specified. */
+  public String getCallSubject() {
+    return mCallSubject;
+  }
+
+  /**
+   * @return {@code true} if the call's phone account supports call subjects, {@code false}
+   *     otherwise.
+   */
+  public boolean isCallSubjectSupported() {
+    return mIsCallSubjectSupported;
+  }
+
+  /** Returns call disconnect cause, defined by {@link DisconnectCause}. */
+  public DisconnectCause getDisconnectCause() {
+    if (mState == State.DISCONNECTED || mState == State.IDLE) {
+      return mDisconnectCause;
+    }
+
+    return new DisconnectCause(DisconnectCause.UNKNOWN);
+  }
+
+  public void setDisconnectCause(DisconnectCause disconnectCause) {
+    mDisconnectCause = disconnectCause;
+    mLogState.disconnectCause = mDisconnectCause;
+  }
+
+  /** Returns the possible text message responses. */
+  public List<String> getCannedSmsResponses() {
+    return mTelecomCall.getCannedTextResponses();
+  }
+
+  /** Checks if the call supports the given set of capabilities supplied as a bit mask. */
+  public boolean can(int capabilities) {
+    int supportedCapabilities = mTelecomCall.getDetails().getCallCapabilities();
+
+    if ((capabilities & Call.Details.CAPABILITY_MERGE_CONFERENCE) != 0) {
+      // We allow you to merge if the capabilities allow it or if it is a call with
+      // conferenceable calls.
+      if (mTelecomCall.getConferenceableCalls().isEmpty()
+          && ((Call.Details.CAPABILITY_MERGE_CONFERENCE & supportedCapabilities) == 0)) {
+        // Cannot merge calls if there are no calls to merge with.
+        return false;
+      }
+      capabilities &= ~Call.Details.CAPABILITY_MERGE_CONFERENCE;
+    }
+    return (capabilities == (capabilities & supportedCapabilities));
+  }
+
+  public boolean hasProperty(int property) {
+    return mTelecomCall.getDetails().hasProperty(property);
+  }
+
+  public String getUniqueCallId() {
+    return uniqueCallId;
+  }
+
+  /** Gets the time when the call first became active. */
+  public long getConnectTimeMillis() {
+    return mTelecomCall.getDetails().getConnectTimeMillis();
+  }
+
+  public boolean isConferenceCall() {
+    return hasProperty(Call.Details.PROPERTY_CONFERENCE);
+  }
+
+  @Nullable
+  public GatewayInfo getGatewayInfo() {
+    return mTelecomCall == null ? null : mTelecomCall.getDetails().getGatewayInfo();
+  }
+
+  @Nullable
+  public PhoneAccountHandle getAccountHandle() {
+    return mTelecomCall == null ? null : mTelecomCall.getDetails().getAccountHandle();
+  }
+
+  /**
+   * @return The {@link VideoCall} instance associated with the {@link Call}. Will return {@code
+   *     null} until {@link #updateFromTelecomCall(boolean)} has registered a valid callback on the
+   *     {@link VideoCall}.
+   */
+  public VideoCall getVideoCall() {
+    return mTelecomCall == null || !mIsVideoCallCallbackRegistered
+        ? null
+        : mTelecomCall.getVideoCall();
+  }
+
+  public List<String> getChildCallIds() {
+    return mChildCallIds;
+  }
+
+  public String getParentId() {
+    Call parentCall = mTelecomCall.getParent();
+    if (parentCall != null) {
+      return mDialerCallDelegate.getDialerCallFromTelecomCall(parentCall).getId();
+    }
+    return null;
+  }
+
+  public int getVideoState() {
+    return mTelecomCall.getDetails().getVideoState();
+  }
+
+  public boolean isVideoCall() {
+    return CallUtil.isVideoEnabled(mContext) && VideoUtils.isVideoCall(getVideoState());
+  }
+
+  /**
+   * Determines if the call handle is an emergency number or not and caches the result to avoid
+   * repeated calls to isEmergencyNumber.
+   */
+  private void updateEmergencyCallState() {
+    mIsEmergencyCall = TelecomCallUtil.isEmergencyCall(mTelecomCall);
+  }
+
+  /**
+   * Gets the video state which was requested via a session modification request.
+   *
+   * @return The video state.
+   */
+  public int getRequestedVideoState() {
+    return mRequestedVideoState;
+  }
+
+  /**
+   * Handles incoming session modification requests. Stores the pending video request and sets the
+   * session modification state to {@link
+   * DialerCall#SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST} so that we can keep
+   * track of the fact the request was received. Only upgrade requests require user confirmation and
+   * will be handled by this method. The remote user can turn off their own camera without
+   * confirmation.
+   *
+   * @param videoState The requested video state.
+   */
+  public void setRequestedVideoState(int videoState) {
+    LogUtil.v("DialerCall.setRequestedVideoState", "videoState: " + videoState);
+    if (videoState == getVideoState()) {
+      LogUtil.e("DialerCall.setRequestedVideoState", "clearing session modification state");
+      setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+      return;
+    }
+
+    mRequestedVideoState = videoState;
+    setSessionModificationState(
+        DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST);
+    for (DialerCallListener listener : mListeners) {
+      listener.onDialerCallUpgradeToVideo();
+    }
+
+    LogUtil.i(
+        "DialerCall.setRequestedVideoState",
+        "mSessionModificationState: %d, videoState: %d",
+        mSessionModificationState,
+        videoState);
+    update();
+  }
+
+  /**
+   * Gets the current video session modification state.
+   *
+   * @return The session modification state.
+   */
+  @SessionModificationState
+  public int getSessionModificationState() {
+    return mSessionModificationState;
+  }
+
+  /**
+   * Set the session modification state. Used to keep track of pending video session modification
+   * operations and to inform listeners of these changes.
+   *
+   * @param state the new session modification state.
+   */
+  public void setSessionModificationState(@SessionModificationState int state) {
+    boolean hasChanged = mSessionModificationState != state;
+    if (hasChanged) {
+      LogUtil.i(
+          "DialerCall.setSessionModificationState", "%d -> %d", mSessionModificationState, state);
+      mSessionModificationState = state;
+      for (DialerCallListener listener : mListeners) {
+        listener.onDialerCallSessionModificationStateChange(state);
+      }
+    }
+  }
+
+  public LogState getLogState() {
+    return mLogState;
+  }
+
+  /**
+   * Determines if the call is an external call.
+   *
+   * <p>An external call is one which does not exist locally for the {@link
+   * android.telecom.ConnectionService} it is associated with.
+   *
+   * <p>External calls are only supported in N and higher.
+   *
+   * @return {@code true} if the call is an external call, {@code false} otherwise.
+   */
+  public boolean isExternalCall() {
+    return VERSION.SDK_INT >= VERSION_CODES.N
+        && hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL);
+  }
+
+  /**
+   * Determines if the external call is pullable.
+   *
+   * <p>An external call is one which does not exist locally for the {@link
+   * android.telecom.ConnectionService} it is associated with. An external call may be "pullable",
+   * which means that the user can request it be transferred to the current device.
+   *
+   * <p>External calls are only supported in N and higher.
+   *
+   * @return {@code true} if the call is an external call, {@code false} otherwise.
+   */
+  public boolean isPullableExternalCall() {
+    return VERSION.SDK_INT >= VERSION_CODES.N
+        && (mTelecomCall.getDetails().getCallCapabilities()
+                & CallCompat.Details.CAPABILITY_CAN_PULL_CALL)
+            == CallCompat.Details.CAPABILITY_CAN_PULL_CALL;
+  }
+
+  /**
+   * Determines if answering this call will cause an ongoing video call to be dropped.
+   *
+   * @return {@code true} if answering this call will drop an ongoing video call, {@code false}
+   *     otherwise.
+   */
+  public boolean answeringDisconnectsForegroundVideoCall() {
+    Bundle extras = getExtras();
+    if (extras == null
+        || !extras.containsKey(CallCompat.Details.EXTRA_ANSWERING_DROPS_FOREGROUND_CALL)) {
+      return false;
+    }
+    return extras.getBoolean(CallCompat.Details.EXTRA_ANSWERING_DROPS_FOREGROUND_CALL);
+  }
+
+  private void parseCallSpecificAppData() {
+    if (isExternalCall()) {
+      return;
+    }
+
+    mLogState.callSpecificAppData = CallIntentParser.getCallSpecificAppData(getIntentExtras());
+    if (mLogState.callSpecificAppData == null) {
+      mLogState.callSpecificAppData = new CallSpecificAppData();
+      mLogState.callSpecificAppData.callInitiationType =
+          CallInitiationType.Type.EXTERNAL_INITIATION;
+    }
+    if (getState() == State.INCOMING) {
+      mLogState.callSpecificAppData.callInitiationType =
+          CallInitiationType.Type.INCOMING_INITIATION;
+    }
+  }
+
+  @Override
+  public String toString() {
+    if (mTelecomCall == null) {
+      // This should happen only in testing since otherwise we would never have a null
+      // Telecom call.
+      return String.valueOf(mId);
+    }
+
+    return String.format(
+        Locale.US,
+        "[%s, %s, %s, %s, children:%s, parent:%s, "
+            + "conferenceable:%s, videoState:%s, mSessionModificationState:%d, VideoSettings:%s]",
+        mId,
+        State.toString(getState()),
+        Details.capabilitiesToString(mTelecomCall.getDetails().getCallCapabilities()),
+        Details.propertiesToString(mTelecomCall.getDetails().getCallProperties()),
+        mChildCallIds,
+        getParentId(),
+        this.mTelecomCall.getConferenceableCalls(),
+        VideoProfile.videoStateToString(mTelecomCall.getDetails().getVideoState()),
+        mSessionModificationState,
+        getVideoSettings());
+  }
+
+  public String toSimpleString() {
+    return super.toString();
+  }
+
+  @CallHistoryStatus
+  public int getCallHistoryStatus() {
+    return mCallHistoryStatus;
+  }
+
+  public void setCallHistoryStatus(@CallHistoryStatus int callHistoryStatus) {
+    mCallHistoryStatus = callHistoryStatus;
+  }
+
+  public boolean didShowCameraPermission() {
+    return didShowCameraPermission;
+  }
+
+  public void setDidShowCameraPermission(boolean didShow) {
+    didShowCameraPermission = didShow;
+  }
+
+  public boolean isInGlobalSpamList() {
+    return isInGlobalSpamList;
+  }
+
+  public void setIsInGlobalSpamList(boolean inSpamList) {
+    isInGlobalSpamList = inSpamList;
+  }
+
+  public boolean isInUserSpamList() {
+    return isInUserSpamList;
+  }
+
+  public void setIsInUserSpamList(boolean inSpamList) {
+    isInUserSpamList = inSpamList;
+  }
+
+  public boolean isInUserWhiteList() {
+    return isInUserWhiteList;
+  }
+
+  public void setIsInUserWhiteList(boolean inWhiteList) {
+    isInUserWhiteList = inWhiteList;
+  }
+
+  public boolean isSpam() {
+    return mIsSpam;
+  }
+
+  public void setSpam(boolean isSpam) {
+    mIsSpam = isSpam;
+  }
+
+  public boolean isBlocked() {
+    return mIsBlocked;
+  }
+
+  public void setBlockedStatus(boolean isBlocked) {
+    mIsBlocked = isBlocked;
+  }
+
+  public boolean isRemotelyHeld() {
+    return isRemotelyHeld;
+  }
+
+  public boolean isIncoming() {
+    return mLogState.isIncoming;
+  }
+
+  public LatencyReport getLatencyReport() {
+    return mLatencyReport;
+  }
+
+  public void unregisterCallback() {
+    mTelecomCall.unregisterCallback(mTelecomCallCallback);
+  }
+
+  public void acceptUpgradeRequest(int videoState) {
+    LogUtil.i("DialerCall.acceptUpgradeRequest", "videoState: " + videoState);
+    VideoProfile videoProfile = new VideoProfile(videoState);
+    getVideoCall().sendSessionModifyResponse(videoProfile);
+    setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+  }
+
+  public void declineUpgradeRequest() {
+    LogUtil.i("DialerCall.declineUpgradeRequest", "");
+    VideoProfile videoProfile = new VideoProfile(getVideoState());
+    getVideoCall().sendSessionModifyResponse(videoProfile);
+    setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+  }
+
+  public void phoneAccountSelected(PhoneAccountHandle accountHandle, boolean setDefault) {
+    LogUtil.i(
+        "DialerCall.phoneAccountSelected",
+        "accountHandle: %s, setDefault: %b",
+        accountHandle,
+        setDefault);
+    mTelecomCall.phoneAccountSelected(accountHandle, setDefault);
+  }
+
+  public void disconnect() {
+    LogUtil.i("DialerCall.disconnect", "");
+    setState(DialerCall.State.DISCONNECTING);
+    for (DialerCallListener listener : mListeners) {
+      listener.onDialerCallUpdate();
+    }
+    mTelecomCall.disconnect();
+  }
+
+  public void hold() {
+    LogUtil.i("DialerCall.hold", "");
+    mTelecomCall.hold();
+  }
+
+  public void unhold() {
+    LogUtil.i("DialerCall.unhold", "");
+    mTelecomCall.unhold();
+  }
+
+  public void splitFromConference() {
+    LogUtil.i("DialerCall.splitFromConference", "");
+    mTelecomCall.splitFromConference();
+  }
+
+  public void answer(int videoState) {
+    LogUtil.i("DialerCall.answer", "videoState: " + videoState);
+    mTelecomCall.answer(videoState);
+  }
+
+  public void reject(boolean rejectWithMessage, String message) {
+    LogUtil.i("DialerCall.reject", "");
+    mTelecomCall.reject(rejectWithMessage, message);
+  }
+
+  /** Return the string label to represent the call provider */
+  public String getCallProviderLabel() {
+    if (callProviderLabel == null) {
+      PhoneAccount account = getPhoneAccount();
+      if (account != null && !TextUtils.isEmpty(account.getLabel())) {
+        List<PhoneAccountHandle> accounts =
+            mContext.getSystemService(TelecomManager.class).getCallCapablePhoneAccounts();
+        if (accounts != null && accounts.size() > 1) {
+          callProviderLabel = account.getLabel().toString();
+        }
+      }
+      if (callProviderLabel == null) {
+        callProviderLabel = "";
+      }
+    }
+    return callProviderLabel;
+  }
+
+  private PhoneAccount getPhoneAccount() {
+    PhoneAccountHandle accountHandle = getAccountHandle();
+    if (accountHandle == null) {
+      return null;
+    }
+    return mContext.getSystemService(TelecomManager.class).getPhoneAccount(accountHandle);
+  }
+
+  public String getCallbackNumber() {
+    if (callbackNumber == null) {
+      // Show the emergency callback number if either:
+      // 1. This is an emergency call.
+      // 2. The phone is in Emergency Callback Mode, which means we should show the callback
+      //    number.
+      boolean showCallbackNumber = hasProperty(Details.PROPERTY_EMERGENCY_CALLBACK_MODE);
+
+      if (isEmergencyCall() || showCallbackNumber) {
+        callbackNumber = getSubscriptionNumber();
+      } else {
+        StatusHints statusHints = getTelecomCall().getDetails().getStatusHints();
+        if (statusHints != null) {
+          Bundle extras = statusHints.getExtras();
+          if (extras != null) {
+            callbackNumber = extras.getString(TelecomManager.EXTRA_CALL_BACK_NUMBER);
+          }
+        }
+      }
+
+      String simNumber =
+          mContext.getSystemService(TelecomManager.class).getLine1Number(getAccountHandle());
+      if (!showCallbackNumber && PhoneNumberUtils.compare(callbackNumber, simNumber)) {
+        LogUtil.v(
+            "DialerCall.getCallbackNumber",
+            "numbers are the same (and callback number is not being forced to show);"
+                + " not showing the callback number");
+        callbackNumber = "";
+      }
+      if (callbackNumber == null) {
+        callbackNumber = "";
+      }
+    }
+    return callbackNumber;
+  }
+
+  private String getSubscriptionNumber() {
+    // If it's an emergency call, and they're not populating the callback number,
+    // then try to fall back to the phone sub info (to hopefully get the SIM's
+    // number directly from the telephony layer).
+    PhoneAccountHandle accountHandle = getAccountHandle();
+    if (accountHandle != null) {
+      PhoneAccount account =
+          mContext.getSystemService(TelecomManager.class).getPhoneAccount(accountHandle);
+      if (account != null) {
+        return getNumberFromHandle(account.getSubscriptionAddress());
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Specifies whether a number is in the call history or not. {@link #CALL_HISTORY_STATUS_UNKNOWN}
+   * means there is no result.
+   */
+  @IntDef({
+    CALL_HISTORY_STATUS_UNKNOWN,
+    CALL_HISTORY_STATUS_PRESENT,
+    CALL_HISTORY_STATUS_NOT_PRESENT
+  })
+  @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 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";
+      }
+    }
+  }
+
+  /**
+   * Defines different states of session modify requests, which are used to upgrade to video, or
+   * downgrade to audio.
+   */
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({
+    SESSION_MODIFICATION_STATE_NO_REQUEST,
+    SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE,
+    SESSION_MODIFICATION_STATE_REQUEST_FAILED,
+    SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST,
+    SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT,
+    SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_FAILED,
+    SESSION_MODIFICATION_STATE_REQUEST_REJECTED,
+    SESSION_MODIFICATION_STATE_WAITING_FOR_RESPONSE
+  })
+  public @interface SessionModificationState {}
+
+  public static final int SESSION_MODIFICATION_STATE_NO_REQUEST = 0;
+  public static final int SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE = 1;
+  public static final int SESSION_MODIFICATION_STATE_REQUEST_FAILED = 2;
+  public static final int SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST = 3;
+  public static final int SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT = 4;
+  public static final int SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_FAILED = 5;
+  public static final int SESSION_MODIFICATION_STATE_REQUEST_REJECTED = 6;
+  public static final int SESSION_MODIFICATION_STATE_WAITING_FOR_RESPONSE = 7;
+
+  public static class VideoSettings {
+
+    public static final int CAMERA_DIRECTION_UNKNOWN = -1;
+    public static final int CAMERA_DIRECTION_FRONT_FACING = CameraCharacteristics.LENS_FACING_FRONT;
+    public static final int CAMERA_DIRECTION_BACK_FACING = CameraCharacteristics.LENS_FACING_BACK;
+
+    private int mCameraDirection = CAMERA_DIRECTION_UNKNOWN;
+
+    /**
+     * Gets the camera direction. if camera direction is set to CAMERA_DIRECTION_UNKNOWN, the video
+     * state of the call should be used to infer the camera direction.
+     *
+     * @see {@link CameraCharacteristics#LENS_FACING_FRONT}
+     * @see {@link CameraCharacteristics#LENS_FACING_BACK}
+     */
+    public int getCameraDir() {
+      return mCameraDirection;
+    }
+
+    /**
+     * Sets the camera direction. if camera direction is set to CAMERA_DIRECTION_UNKNOWN, the video
+     * state of the call should be used to infer the camera direction.
+     *
+     * @see {@link CameraCharacteristics#LENS_FACING_FRONT}
+     * @see {@link CameraCharacteristics#LENS_FACING_BACK}
+     */
+    public void setCameraDir(int cameraDirection) {
+      if (cameraDirection == CAMERA_DIRECTION_FRONT_FACING
+          || cameraDirection == CAMERA_DIRECTION_BACK_FACING) {
+        mCameraDirection = cameraDirection;
+      } else {
+        mCameraDirection = CAMERA_DIRECTION_UNKNOWN;
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "(CameraDir:" + getCameraDir() + ")";
+    }
+  }
+
+  /**
+   * Tracks any state variables that is useful for logging. There is some amount of overlap with
+   * existing call member variables, but this duplication helps to ensure that none of these logging
+   * variables will interface with/and affect call logic.
+   */
+  public static class LogState {
+
+    public DisconnectCause disconnectCause;
+    public boolean isIncoming = false;
+    public int contactLookupResult = ContactLookupResult.Type.UNKNOWN_LOOKUP_RESULT_TYPE;
+    public CallSpecificAppData callSpecificAppData;
+    // If this was a conference call, the total number of calls involved in the conference.
+    public int conferencedCalls = 0;
+    public long duration = 0;
+    public boolean isLogged = false;
+
+    private static String lookupToString(int lookupType) {
+      switch (lookupType) {
+        case ContactLookupResult.Type.LOCAL_CONTACT:
+          return "Local";
+        case ContactLookupResult.Type.LOCAL_CACHE:
+          return "Cache";
+        case ContactLookupResult.Type.REMOTE:
+          return "Remote";
+        case ContactLookupResult.Type.EMERGENCY:
+          return "Emergency";
+        case ContactLookupResult.Type.VOICEMAIL:
+          return "Voicemail";
+        default:
+          return "Not found";
+      }
+    }
+
+    private static String initiationToString(CallSpecificAppData callSpecificAppData) {
+      if (callSpecificAppData == null) {
+        return "null";
+      }
+      switch (callSpecificAppData.callInitiationType) {
+        case CallInitiationType.Type.INCOMING_INITIATION:
+          return "Incoming";
+        case CallInitiationType.Type.DIALPAD:
+          return "Dialpad";
+        case CallInitiationType.Type.SPEED_DIAL:
+          return "Speed Dial";
+        case CallInitiationType.Type.REMOTE_DIRECTORY:
+          return "Remote Directory";
+        case CallInitiationType.Type.SMART_DIAL:
+          return "Smart Dial";
+        case CallInitiationType.Type.REGULAR_SEARCH:
+          return "Regular Search";
+        case CallInitiationType.Type.CALL_LOG:
+          return "DialerCall Log";
+        case CallInitiationType.Type.CALL_LOG_FILTER:
+          return "DialerCall Log Filter";
+        case CallInitiationType.Type.VOICEMAIL_LOG:
+          return "Voicemail Log";
+        case CallInitiationType.Type.CALL_DETAILS:
+          return "DialerCall Details";
+        case CallInitiationType.Type.QUICK_CONTACTS:
+          return "Quick Contacts";
+        case CallInitiationType.Type.EXTERNAL_INITIATION:
+          return "External";
+        case CallInitiationType.Type.LAUNCHER_SHORTCUT:
+          return "Launcher Shortcut";
+        default:
+          return "Unknown: " + callSpecificAppData.callInitiationType;
+      }
+    }
+
+    @Override
+    public String toString() {
+      return String.format(
+          Locale.US,
+          "["
+              + "%s, " // DisconnectCause toString already describes the object type
+              + "isIncoming: %s, "
+              + "contactLookup: %s, "
+              + "callInitiation: %s, "
+              + "duration: %s"
+              + "]",
+          disconnectCause,
+          isIncoming,
+          lookupToString(contactLookupResult),
+          initiationToString(callSpecificAppData),
+          duration);
+    }
+  }
+
+  /** Called when canned text responses have been loaded. */
+  public interface CannedTextResponsesLoadedListener {
+    void onCannedTextResponsesLoaded(DialerCall call);
+  }
+}
diff --git a/java/com/android/incallui/call/DialerCallDelegate.java b/java/com/android/incallui/call/DialerCallDelegate.java
new file mode 100644
index 0000000..463b491
--- /dev/null
+++ b/java/com/android/incallui/call/DialerCallDelegate.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 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;
+
+import android.telecom.Call;
+
+/** Callback from the call module to the container. */
+public interface DialerCallDelegate {
+
+  DialerCall getDialerCallFromTelecomCall(Call telecomCall);
+}
diff --git a/java/com/android/incallui/call/DialerCallListener.java b/java/com/android/incallui/call/DialerCallListener.java
new file mode 100644
index 0000000..b426cd7
--- /dev/null
+++ b/java/com/android/incallui/call/DialerCallListener.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 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;
+
+import com.android.incallui.call.DialerCall.SessionModificationState;
+
+/** Used to monitor state changes in a dialer call. */
+public interface DialerCallListener {
+
+  void onDialerCallDisconnect();
+
+  void onDialerCallUpdate();
+
+  void onDialerCallChildNumberChange();
+
+  void onDialerCallLastForwardedNumberChange();
+
+  void onDialerCallUpgradeToVideo();
+
+  void onDialerCallSessionModificationStateChange(@SessionModificationState int state);
+
+  void onWiFiToLteHandover();
+
+  void onHandoverToWifiFailure();
+}
diff --git a/java/com/android/incallui/call/ExternalCallList.java b/java/com/android/incallui/call/ExternalCallList.java
new file mode 100644
index 0000000..52a7a30
--- /dev/null
+++ b/java/com/android/incallui/call/ExternalCallList.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2017 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;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.support.annotation.NonNull;
+import android.telecom.Call;
+import android.util.ArraySet;
+import com.android.contacts.common.compat.CallCompat;
+import com.android.dialer.common.LogUtil;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Tracks the external calls known to the InCall UI.
+ *
+ * <p>External calls are those with {@code android.telecom.Call.Details#PROPERTY_IS_EXTERNAL_CALL}.
+ */
+public class ExternalCallList {
+
+  private final Set<Call> mExternalCalls = new ArraySet<>();
+  private final Set<ExternalCallListener> mExternalCallListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<ExternalCallListener, Boolean>(8, 0.9f, 1));
+  /** Handles {@link android.telecom.Call.Callback} callbacks. */
+  private final Call.Callback mTelecomCallCallback =
+      new Call.Callback() {
+        @Override
+        public void onDetailsChanged(Call call, Call.Details details) {
+          notifyExternalCallUpdated(call);
+        }
+      };
+
+  /** Begins tracking an external call and notifies listeners of the new call. */
+  public void onCallAdded(Call telecomCall) {
+    if (!telecomCall.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+      throw new IllegalArgumentException();
+    }
+    mExternalCalls.add(telecomCall);
+    telecomCall.registerCallback(mTelecomCallCallback, new Handler(Looper.getMainLooper()));
+    notifyExternalCallAdded(telecomCall);
+  }
+
+  /** Stops tracking an external call and notifies listeners of the removal of the call. */
+  public void onCallRemoved(Call telecomCall) {
+    if (!mExternalCalls.contains(telecomCall)) {
+      // This can happen on M for external calls from blocked numbers
+      LogUtil.i("ExternalCallList.onCallRemoved", "attempted to remove unregistered call");
+      return;
+    }
+    mExternalCalls.remove(telecomCall);
+    telecomCall.unregisterCallback(mTelecomCallCallback);
+    notifyExternalCallRemoved(telecomCall);
+  }
+
+  /** Adds a new listener to external call events. */
+  public void addExternalCallListener(@NonNull ExternalCallListener listener) {
+    mExternalCallListeners.add(listener);
+  }
+
+  /** Removes a listener to external call events. */
+  public void removeExternalCallListener(@NonNull ExternalCallListener listener) {
+    if (!mExternalCallListeners.contains(listener)) {
+      LogUtil.i(
+          "ExternalCallList.removeExternalCallListener",
+          "attempt to remove unregistered listener.");
+    }
+    mExternalCallListeners.remove(listener);
+  }
+
+  public boolean isCallTracked(@NonNull android.telecom.Call telecomCall) {
+    return mExternalCalls.contains(telecomCall);
+  }
+
+  /** Notifies listeners of the addition of a new external call. */
+  private void notifyExternalCallAdded(Call call) {
+    for (ExternalCallListener listener : mExternalCallListeners) {
+      listener.onExternalCallAdded(call);
+    }
+  }
+
+  /** Notifies listeners of the removal of an external call. */
+  private void notifyExternalCallRemoved(Call call) {
+    for (ExternalCallListener listener : mExternalCallListeners) {
+      listener.onExternalCallRemoved(call);
+    }
+  }
+
+  /** Notifies listeners of changes to an external call. */
+  private void notifyExternalCallUpdated(Call call) {
+    if (!call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+      // A previous external call has been pulled and is now a regular call, so we will remove
+      // it from the external call listener and ensure that the CallList is informed of the
+      // change.
+      onCallRemoved(call);
+
+      for (ExternalCallListener listener : mExternalCallListeners) {
+        listener.onExternalCallPulled(call);
+      }
+    } else {
+      for (ExternalCallListener listener : mExternalCallListeners) {
+        listener.onExternalCallUpdated(call);
+      }
+    }
+  }
+
+  /**
+   * Defines events which the {@link ExternalCallList} exposes to interested components (e.g. {@link
+   * com.android.incallui.ExternalCallNotifier ExternalCallNotifier}).
+   */
+  public interface ExternalCallListener {
+
+    void onExternalCallAdded(Call call);
+
+    void onExternalCallRemoved(Call call);
+
+    void onExternalCallUpdated(Call call);
+
+    void onExternalCallPulled(Call call);
+  }
+}
diff --git a/java/com/android/incallui/call/InCallServiceListener.java b/java/com/android/incallui/call/InCallServiceListener.java
new file mode 100644
index 0000000..e48ce9d
--- /dev/null
+++ b/java/com/android/incallui/call/InCallServiceListener.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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;
+
+import android.telecom.InCallService;
+
+/**
+ * Interface implemented by In-Call components that maintain a reference to the Telecom API {@code
+ * InCallService} object. Clarifies the expectations associated with the relevant method calls.
+ */
+public interface InCallServiceListener {
+
+  /**
+   * Called once at {@code InCallService} startup time with a valid instance. At that time, there
+   * will be no existing {@code DialerCall}s.
+   *
+   * @param inCallService The {@code InCallService} object.
+   */
+  void setInCallService(InCallService inCallService);
+
+  /**
+   * Called once at {@code InCallService} shutdown time. At that time, any {@code DialerCall}s will
+   * have transitioned through the disconnected state and will no longer exist.
+   */
+  void clearInCallService();
+}
diff --git a/java/com/android/incallui/call/InCallUiLegacyBindings.java b/java/com/android/incallui/call/InCallUiLegacyBindings.java
new file mode 100644
index 0000000..1b0ed45
--- /dev/null
+++ b/java/com/android/incallui/call/InCallUiLegacyBindings.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 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;
+
+/**
+ * These are old bindings between InCallUi and the container application. All new bindings should be
+ * added to the bindings module and not here.
+ */
+public interface InCallUiLegacyBindings {
+
+  void logCall(DialerCall call);
+}
diff --git a/java/com/android/incallui/call/InCallUiLegacyBindingsFactory.java b/java/com/android/incallui/call/InCallUiLegacyBindingsFactory.java
new file mode 100644
index 0000000..8604976
--- /dev/null
+++ b/java/com/android/incallui/call/InCallUiLegacyBindingsFactory.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 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;
+
+/**
+ * This interface should be implementated by the Application subclass. It allows the in call UI
+ * module to get references to the InCallUiLegacyBindings.
+ */
+public interface InCallUiLegacyBindingsFactory {
+
+  InCallUiLegacyBindings newInCallUiLegacyBindings();
+}
diff --git a/java/com/android/incallui/call/InCallUiLegacyBindingsStub.java b/java/com/android/incallui/call/InCallUiLegacyBindingsStub.java
new file mode 100644
index 0000000..8869c64
--- /dev/null
+++ b/java/com/android/incallui/call/InCallUiLegacyBindingsStub.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2017 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;
+
+/** Default implementation for in call UI legacy bindings. */
+public class InCallUiLegacyBindingsStub implements InCallUiLegacyBindings {
+
+  @Override
+  public void logCall(DialerCall call) {}
+}
diff --git a/java/com/android/incallui/call/InCallVideoCallCallback.java b/java/com/android/incallui/call/InCallVideoCallCallback.java
new file mode 100644
index 0000000..f897ac9
--- /dev/null
+++ b/java/com/android/incallui/call/InCallVideoCallCallback.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2014 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;
+
+import android.os.Handler;
+import android.support.annotation.Nullable;
+import android.telecom.Connection;
+import android.telecom.Connection.VideoProvider;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+
+/** Implements the InCallUI VideoCall Callback. */
+public class InCallVideoCallCallback extends VideoCall.Callback implements Runnable {
+
+  private static final int CLEAR_FAILED_REQUEST_TIMEOUT_MILLIS = 4000;
+
+  private final DialerCall call;
+  @Nullable private Handler handler;
+  @SessionModificationState private int newSessionModificationState;
+
+  public InCallVideoCallCallback(DialerCall call) {
+    this.call = call;
+  }
+
+  @Override
+  public void onSessionModifyRequestReceived(VideoProfile videoProfile) {
+    LogUtil.i(
+        "InCallVideoCallCallback.onSessionModifyRequestReceived", "videoProfile: " + videoProfile);
+    int previousVideoState = VideoUtils.getUnPausedVideoState(call.getVideoState());
+    int newVideoState = VideoUtils.getUnPausedVideoState(videoProfile.getVideoState());
+
+    boolean wasVideoCall = VideoUtils.isVideoCall(previousVideoState);
+    boolean isVideoCall = VideoUtils.isVideoCall(newVideoState);
+
+    if (wasVideoCall && !isVideoCall) {
+      LogUtil.v(
+          "InCallVideoCallCallback.onSessionModifyRequestReceived",
+          "call downgraded to " + newVideoState);
+    } else if (previousVideoState != newVideoState) {
+      InCallVideoCallCallbackNotifier.getInstance().upgradeToVideoRequest(call, newVideoState);
+    }
+  }
+
+  /**
+   * @param status Status of the session modify request. Valid values are {@link
+   *     Connection.VideoProvider#SESSION_MODIFY_REQUEST_SUCCESS}, {@link
+   *     Connection.VideoProvider#SESSION_MODIFY_REQUEST_FAIL}, {@link
+   *     Connection.VideoProvider#SESSION_MODIFY_REQUEST_INVALID}
+   * @param responseProfile The actual profile changes made by the peer device.
+   */
+  @Override
+  public void onSessionModifyResponseReceived(
+      int status, VideoProfile requestedProfile, VideoProfile responseProfile) {
+    LogUtil.i(
+        "InCallVideoCallCallback.onSessionModifyResponseReceived",
+        "status: %d, "
+            + "requestedProfile: %s, responseProfile: %s, current session modification state: %d",
+        status,
+        requestedProfile,
+        responseProfile,
+        call.getSessionModificationState());
+
+    if (call.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE) {
+      if (handler == null) {
+        handler = new Handler();
+      } else {
+        handler.removeCallbacks(this);
+      }
+
+      newSessionModificationState = getDialerSessionModifyStateTelecomStatus(status);
+      if (status != VideoProvider.SESSION_MODIFY_REQUEST_SUCCESS) {
+        // This will update the video UI to display the error message.
+        call.setSessionModificationState(newSessionModificationState);
+      }
+
+      // Wait for 4 seconds and then clean the session modification state. This allows the video UI
+      // to stay up so that the user can read the error message.
+      //
+      // If the other person accepted the upgrade request then this will keep the video UI up until
+      // the call's video state change. Without this we would switch to the voice call and then
+      // switch back to video UI.
+      handler.postDelayed(this, CLEAR_FAILED_REQUEST_TIMEOUT_MILLIS);
+    } else if (call.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+      call.setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    } else if (call.getSessionModificationState()
+        == DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_RESPONSE) {
+      call.setSessionModificationState(getDialerSessionModifyStateTelecomStatus(status));
+    } else {
+      LogUtil.i(
+          "InCallVideoCallCallback.onSessionModifyResponseReceived",
+          "call is not waiting for " + "response, doing nothing");
+    }
+  }
+
+  @SessionModificationState
+  private int getDialerSessionModifyStateTelecomStatus(int telecomStatus) {
+    switch (telecomStatus) {
+      case VideoProvider.SESSION_MODIFY_REQUEST_SUCCESS:
+        return DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST;
+      case VideoProvider.SESSION_MODIFY_REQUEST_FAIL:
+      case VideoProvider.SESSION_MODIFY_REQUEST_INVALID:
+        // Check if it's already video call, which means the request is not video upgrade request.
+        if (VideoUtils.isVideoCall(call.getVideoState())) {
+          return DialerCall.SESSION_MODIFICATION_STATE_REQUEST_FAILED;
+        } else {
+          return DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_FAILED;
+        }
+      case VideoProvider.SESSION_MODIFY_REQUEST_TIMED_OUT:
+        return DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT;
+      case VideoProvider.SESSION_MODIFY_REQUEST_REJECTED_BY_REMOTE:
+        return DialerCall.SESSION_MODIFICATION_STATE_REQUEST_REJECTED;
+      default:
+        LogUtil.e(
+            "InCallVideoCallCallback.getDialerSessionModifyStateTelecomStatus",
+            "unknown status: %d",
+            telecomStatus);
+        return DialerCall.SESSION_MODIFICATION_STATE_REQUEST_FAILED;
+    }
+  }
+
+  @Override
+  public void onCallSessionEvent(int event) {
+    InCallVideoCallCallbackNotifier.getInstance().callSessionEvent(event);
+  }
+
+  @Override
+  public void onPeerDimensionsChanged(int width, int height) {
+    InCallVideoCallCallbackNotifier.getInstance().peerDimensionsChanged(call, width, height);
+  }
+
+  @Override
+  public void onVideoQualityChanged(int videoQuality) {
+    InCallVideoCallCallbackNotifier.getInstance().videoQualityChanged(call, videoQuality);
+  }
+
+  /**
+   * Handles a change to the call data usage. No implementation as the in-call UI does not display
+   * data usage.
+   *
+   * @param dataUsage The updated data usage.
+   */
+  @Override
+  public void onCallDataUsageChanged(long dataUsage) {
+    LogUtil.v("InCallVideoCallCallback.onCallDataUsageChanged", "dataUsage = " + dataUsage);
+    InCallVideoCallCallbackNotifier.getInstance().callDataUsageChanged(dataUsage);
+  }
+
+  /**
+   * Handles changes to the camera capabilities. No implementation as the in-call UI does not make
+   * use of camera capabilities.
+   *
+   * @param cameraCapabilities The changed camera capabilities.
+   */
+  @Override
+  public void onCameraCapabilitiesChanged(CameraCapabilities cameraCapabilities) {
+    if (cameraCapabilities != null) {
+      InCallVideoCallCallbackNotifier.getInstance()
+          .cameraDimensionsChanged(
+              call, cameraCapabilities.getWidth(), cameraCapabilities.getHeight());
+    }
+  }
+
+  /**
+   * Called 4 seconds after the remote user responds to the video upgrade request. We use this to
+   * clear the session modify state.
+   */
+  @Override
+  public void run() {
+    if (call.getSessionModificationState() == newSessionModificationState) {
+      LogUtil.i("InCallVideoCallCallback.onSessionModifyResponseReceived", "clearing state");
+      call.setSessionModificationState(DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST);
+    } else {
+      LogUtil.i(
+          "InCallVideoCallCallback.onSessionModifyResponseReceived",
+          "session modification state has changed, not clearing state");
+    }
+  }
+}
diff --git a/java/com/android/incallui/call/InCallVideoCallCallbackNotifier.java b/java/com/android/incallui/call/InCallVideoCallCallbackNotifier.java
new file mode 100644
index 0000000..4a94926
--- /dev/null
+++ b/java/com/android/incallui/call/InCallVideoCallCallbackNotifier.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2014 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;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import com.android.dialer.common.LogUtil;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Class used by {@link InCallService.VideoCallCallback} to notify interested parties of incoming
+ * events.
+ */
+public class InCallVideoCallCallbackNotifier {
+
+  /** Singleton instance of this class. */
+  private static InCallVideoCallCallbackNotifier sInstance = new InCallVideoCallCallbackNotifier();
+
+  /**
+   * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is load factor before
+   * resizing, 1 means we only expect a single thread to access the map so make only a single shard
+   */
+  private final Set<SessionModificationListener> mSessionModificationListeners =
+      Collections.newSetFromMap(
+          new ConcurrentHashMap<SessionModificationListener, Boolean>(8, 0.9f, 1));
+
+  private final Set<VideoEventListener> mVideoEventListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<VideoEventListener, Boolean>(8, 0.9f, 1));
+  private final Set<SurfaceChangeListener> mSurfaceChangeListeners =
+      Collections.newSetFromMap(new ConcurrentHashMap<SurfaceChangeListener, Boolean>(8, 0.9f, 1));
+
+  /** Private constructor. Instance should only be acquired through getInstance(). */
+  private InCallVideoCallCallbackNotifier() {}
+
+  /** Static singleton accessor method. */
+  public static InCallVideoCallCallbackNotifier getInstance() {
+    return sInstance;
+  }
+
+  /**
+   * Adds a new {@link SessionModificationListener}.
+   *
+   * @param listener The listener.
+   */
+  public void addSessionModificationListener(@NonNull SessionModificationListener listener) {
+    Objects.requireNonNull(listener);
+    mSessionModificationListeners.add(listener);
+  }
+
+  /**
+   * Remove a {@link SessionModificationListener}.
+   *
+   * @param listener The listener.
+   */
+  public void removeSessionModificationListener(@Nullable SessionModificationListener listener) {
+    if (listener != null) {
+      mSessionModificationListeners.remove(listener);
+    }
+  }
+
+  /**
+   * Adds a new {@link VideoEventListener}.
+   *
+   * @param listener The listener.
+   */
+  public void addVideoEventListener(@NonNull VideoEventListener listener) {
+    Objects.requireNonNull(listener);
+    mVideoEventListeners.add(listener);
+  }
+
+  /**
+   * Remove a {@link VideoEventListener}.
+   *
+   * @param listener The listener.
+   */
+  public void removeVideoEventListener(@Nullable VideoEventListener listener) {
+    if (listener != null) {
+      mVideoEventListeners.remove(listener);
+    }
+  }
+
+  /**
+   * Adds a new {@link SurfaceChangeListener}.
+   *
+   * @param listener The listener.
+   */
+  public void addSurfaceChangeListener(@NonNull SurfaceChangeListener listener) {
+    Objects.requireNonNull(listener);
+    mSurfaceChangeListeners.add(listener);
+  }
+
+  /**
+   * Remove a {@link SurfaceChangeListener}.
+   *
+   * @param listener The listener.
+   */
+  public void removeSurfaceChangeListener(@Nullable SurfaceChangeListener listener) {
+    if (listener != null) {
+      mSurfaceChangeListeners.remove(listener);
+    }
+  }
+
+  /**
+   * Inform listeners of an upgrade to video request for a call.
+   *
+   * @param call The call.
+   * @param videoState The video state we want to upgrade to.
+   */
+  public void upgradeToVideoRequest(DialerCall call, int videoState) {
+    LogUtil.v(
+        "InCallVideoCallCallbackNotifier.upgradeToVideoRequest",
+        "call = " + call + " new video state = " + videoState);
+    for (SessionModificationListener listener : mSessionModificationListeners) {
+      listener.onUpgradeToVideoRequest(call, videoState);
+    }
+  }
+
+  /**
+   * Inform listeners of a call session event.
+   *
+   * @param event The call session event.
+   */
+  public void callSessionEvent(int event) {
+    for (VideoEventListener listener : mVideoEventListeners) {
+      listener.onCallSessionEvent(event);
+    }
+  }
+
+  /**
+   * Inform listeners of a downgrade to audio.
+   *
+   * @param call The call.
+   * @param paused The paused state.
+   */
+  public void peerPausedStateChanged(DialerCall call, boolean paused) {
+    for (VideoEventListener listener : mVideoEventListeners) {
+      listener.onPeerPauseStateChanged(call, paused);
+    }
+  }
+
+  /**
+   * Inform listeners of any change in the video quality of the call
+   *
+   * @param call The call.
+   * @param videoQuality The updated video quality of the call.
+   */
+  public void videoQualityChanged(DialerCall call, int videoQuality) {
+    for (VideoEventListener listener : mVideoEventListeners) {
+      listener.onVideoQualityChanged(call, videoQuality);
+    }
+  }
+
+  /**
+   * Inform listeners of a change to peer dimensions.
+   *
+   * @param call The call.
+   * @param width New peer width.
+   * @param height New peer height.
+   */
+  public void peerDimensionsChanged(DialerCall call, int width, int height) {
+    for (SurfaceChangeListener listener : mSurfaceChangeListeners) {
+      listener.onUpdatePeerDimensions(call, width, height);
+    }
+  }
+
+  /**
+   * Inform listeners of a change to camera dimensions.
+   *
+   * @param call The call.
+   * @param width The new camera video width.
+   * @param height The new camera video height.
+   */
+  public void cameraDimensionsChanged(DialerCall call, int width, int height) {
+    for (SurfaceChangeListener listener : mSurfaceChangeListeners) {
+      listener.onCameraDimensionsChange(call, width, height);
+    }
+  }
+
+  /**
+   * Inform listeners of a change to call data usage.
+   *
+   * @param dataUsage data usage value
+   */
+  public void callDataUsageChanged(long dataUsage) {
+    for (VideoEventListener listener : mVideoEventListeners) {
+      listener.onCallDataUsageChange(dataUsage);
+    }
+  }
+
+  /** Listener interface for any class that wants to be notified of upgrade to video request. */
+  public interface SessionModificationListener {
+
+    /**
+     * Called when a peer request is received to upgrade an audio-only call to a video call.
+     *
+     * @param call The call the request was received for.
+     * @param videoState The requested video state.
+     */
+    void onUpgradeToVideoRequest(DialerCall call, int videoState);
+  }
+
+  /**
+   * Listener interface for any class that wants to be notified of video events, including pause and
+   * un-pause of peer video, video quality changes.
+   */
+  public interface VideoEventListener {
+
+    /**
+     * Called when the peer pauses or un-pauses video transmission.
+     *
+     * @param call The call which paused or un-paused video transmission.
+     * @param paused {@code True} when the video transmission is paused, {@code false} otherwise.
+     */
+    void onPeerPauseStateChanged(DialerCall call, boolean paused);
+
+    /**
+     * Called when the video quality changes.
+     *
+     * @param call The call whose video quality changes.
+     * @param videoCallQuality - values are QUALITY_HIGH, MEDIUM, LOW and UNKNOWN.
+     */
+    void onVideoQualityChanged(DialerCall call, int videoCallQuality);
+
+    /*
+     * Called when call data usage value is requested or when call data usage value is updated
+     * because of a call state change
+     *
+     * @param dataUsage call data usage value
+     */
+    void onCallDataUsageChange(long dataUsage);
+
+    /**
+     * Called when call session event is raised.
+     *
+     * @param event The call session event.
+     */
+    void onCallSessionEvent(int event);
+  }
+
+  /**
+   * Listener interface for any class that wants to be notified of changes to the video surfaces.
+   */
+  public interface SurfaceChangeListener {
+
+    /**
+     * Called when the peer video feed changes dimensions. This can occur when the peer rotates
+     * their device, changing the aspect ratio of the video signal.
+     *
+     * @param call The call which experienced a peer video
+     */
+    void onUpdatePeerDimensions(DialerCall call, int width, int height);
+
+    /**
+     * Called when the local camera changes dimensions. This occurs when a change in camera occurs.
+     *
+     * @param call The call which experienced the camera dimension change.
+     * @param width The new camera video width.
+     * @param height The new camera video height.
+     */
+    void onCameraDimensionsChange(DialerCall call, int width, int height);
+  }
+}
diff --git a/java/com/android/incallui/call/TelecomAdapter.java b/java/com/android/incallui/call/TelecomAdapter.java
new file mode 100644
index 0000000..ebf4ecf
--- /dev/null
+++ b/java/com/android/incallui/call/TelecomAdapter.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2017 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;
+
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.os.Looper;
+import android.support.annotation.MainThread;
+import android.telecom.InCallService;
+import com.android.dialer.common.LogUtil;
+import java.util.List;
+
+/** Wrapper around Telecom APIs. */
+public final class TelecomAdapter implements InCallServiceListener {
+
+  private static final String ADD_CALL_MODE_KEY = "add_call_mode";
+
+  private static TelecomAdapter sInstance;
+  private InCallService mInCallService;
+
+  private TelecomAdapter() {}
+
+  @MainThread
+  public static TelecomAdapter getInstance() {
+    if (!Looper.getMainLooper().isCurrentThread()) {
+      throw new IllegalStateException();
+    }
+    if (sInstance == null) {
+      sInstance = new TelecomAdapter();
+    }
+    return sInstance;
+  }
+
+  @Override
+  public void setInCallService(InCallService inCallService) {
+    mInCallService = inCallService;
+  }
+
+  @Override
+  public void clearInCallService() {
+    mInCallService = null;
+  }
+
+  private android.telecom.Call getTelecomCallById(String callId) {
+    DialerCall call = CallList.getInstance().getCallById(callId);
+    return call == null ? null : call.getTelecomCall();
+  }
+
+  public void mute(boolean shouldMute) {
+    if (mInCallService != null) {
+      mInCallService.setMuted(shouldMute);
+    } else {
+      LogUtil.e("TelecomAdapter.mute", "mInCallService is null");
+    }
+  }
+
+  public void setAudioRoute(int route) {
+    if (mInCallService != null) {
+      mInCallService.setAudioRoute(route);
+    } else {
+      LogUtil.e("TelecomAdapter.setAudioRoute", "mInCallService is null");
+    }
+  }
+
+  public void merge(String callId) {
+    android.telecom.Call call = getTelecomCallById(callId);
+    if (call != null) {
+      List<android.telecom.Call> conferenceable = call.getConferenceableCalls();
+      if (!conferenceable.isEmpty()) {
+        call.conference(conferenceable.get(0));
+      } else {
+        if (call.getDetails().can(android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE)) {
+          call.mergeConference();
+        }
+      }
+    } else {
+      LogUtil.e("TelecomAdapter.merge", "call not in call list " + callId);
+    }
+  }
+
+  public void swap(String callId) {
+    android.telecom.Call call = getTelecomCallById(callId);
+    if (call != null) {
+      if (call.getDetails().can(android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE)) {
+        call.swapConference();
+      }
+    } else {
+      LogUtil.e("TelecomAdapter.swap", "call not in call list " + callId);
+    }
+  }
+
+  public void addCall() {
+    if (mInCallService != null) {
+      Intent intent = new Intent(Intent.ACTION_DIAL);
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+      // when we request the dialer come up, we also want to inform
+      // it that we're going through the "add call" option from the
+      // InCallScreen / PhoneUtils.
+      intent.putExtra(ADD_CALL_MODE_KEY, true);
+      try {
+        LogUtil.d("TelecomAdapter.addCall", "Sending the add DialerCall intent");
+        mInCallService.startActivity(intent);
+      } catch (ActivityNotFoundException e) {
+        // This is rather rare but possible.
+        // Note: this method is used even when the phone is encrypted. At that moment
+        // the system may not find any Activity which can accept this Intent.
+        LogUtil.e("TelecomAdapter.addCall", "Activity for adding calls isn't found.", e);
+      }
+    }
+  }
+
+  public void playDtmfTone(String callId, char digit) {
+    android.telecom.Call call = getTelecomCallById(callId);
+    if (call != null) {
+      call.playDtmfTone(digit);
+    } else {
+      LogUtil.e("TelecomAdapter.playDtmfTone", "call not in call list " + callId);
+    }
+  }
+
+  public void stopDtmfTone(String callId) {
+    android.telecom.Call call = getTelecomCallById(callId);
+    if (call != null) {
+      call.stopDtmfTone();
+    } else {
+      LogUtil.e("TelecomAdapter.stopDtmfTone", "call not in call list " + callId);
+    }
+  }
+
+  public void postDialContinue(String callId, boolean proceed) {
+    android.telecom.Call call = getTelecomCallById(callId);
+    if (call != null) {
+      call.postDialContinue(proceed);
+    } else {
+      LogUtil.e("TelecomAdapter.postDialContinue", "call not in call list " + callId);
+    }
+  }
+
+  public boolean canAddCall() {
+    if (mInCallService != null) {
+      return mInCallService.canAddCall();
+    }
+    return false;
+  }
+}
diff --git a/java/com/android/incallui/call/VideoUtils.java b/java/com/android/incallui/call/VideoUtils.java
new file mode 100644
index 0000000..80fbfb1
--- /dev/null
+++ b/java/com/android/incallui/call/VideoUtils.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.call;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.content.ContextCompat;
+import android.telecom.VideoProfile;
+import com.android.dialer.compat.CompatUtils;
+import com.android.dialer.util.DialerUtils;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import java.util.Objects;
+
+public class VideoUtils {
+
+  private static final String PREFERENCE_CAMERA_ALLOWED_BY_USER = "camera_allowed_by_user";
+
+  public static boolean isVideoCall(@Nullable DialerCall call) {
+    return call != null && isVideoCall(call.getVideoState());
+  }
+
+  public static boolean isVideoCall(int videoState) {
+    return CompatUtils.isVideoCompatible()
+        && (VideoProfile.isTransmissionEnabled(videoState)
+            || VideoProfile.isReceptionEnabled(videoState));
+  }
+
+  public static boolean hasSentVideoUpgradeRequest(@Nullable DialerCall call) {
+    return call != null && hasSentVideoUpgradeRequest(call.getSessionModificationState());
+  }
+
+  public static boolean hasSentVideoUpgradeRequest(@SessionModificationState int state) {
+    return state == DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE
+        || state == DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_FAILED
+        || state == DialerCall.SESSION_MODIFICATION_STATE_REQUEST_REJECTED
+        || state == DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT;
+  }
+
+  public static boolean hasReceivedVideoUpgradeRequest(@Nullable DialerCall call) {
+    return call != null && hasReceivedVideoUpgradeRequest(call.getSessionModificationState());
+  }
+
+  public static boolean hasReceivedVideoUpgradeRequest(@SessionModificationState int state) {
+    return state == DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+  }
+
+  public static boolean isBidirectionalVideoCall(DialerCall call) {
+    return CompatUtils.isVideoCompatible() && VideoProfile.isBidirectional(call.getVideoState());
+  }
+
+  public static boolean isTransmissionEnabled(DialerCall call) {
+    if (!CompatUtils.isVideoCompatible()) {
+      return false;
+    }
+
+    return VideoProfile.isTransmissionEnabled(call.getVideoState());
+  }
+
+  public static boolean isIncomingVideoCall(DialerCall call) {
+    if (!VideoUtils.isVideoCall(call)) {
+      return false;
+    }
+    final int state = call.getState();
+    return (state == DialerCall.State.INCOMING) || (state == DialerCall.State.CALL_WAITING);
+  }
+
+  public static boolean isActiveVideoCall(DialerCall call) {
+    return VideoUtils.isVideoCall(call) && call.getState() == DialerCall.State.ACTIVE;
+  }
+
+  public static boolean isOutgoingVideoCall(DialerCall call) {
+    if (!VideoUtils.isVideoCall(call)) {
+      return false;
+    }
+    final int state = call.getState();
+    return DialerCall.State.isDialing(state)
+        || state == DialerCall.State.CONNECTING
+        || state == DialerCall.State.SELECT_PHONE_ACCOUNT;
+  }
+
+  public static boolean isAudioCall(DialerCall call) {
+    if (!CompatUtils.isVideoCompatible()) {
+      return true;
+    }
+
+    return call != null && VideoProfile.isAudioOnly(call.getVideoState());
+  }
+
+  // TODO (ims-vt) Check if special handling is needed for CONF calls.
+  public static boolean canVideoPause(DialerCall call) {
+    return isVideoCall(call) && call.getState() == DialerCall.State.ACTIVE;
+  }
+
+  public static VideoProfile makeVideoPauseProfile(@NonNull DialerCall call) {
+    Objects.requireNonNull(call);
+    if (VideoProfile.isAudioOnly(call.getVideoState())) {
+      throw new IllegalStateException();
+    }
+    return new VideoProfile(getPausedVideoState(call.getVideoState()));
+  }
+
+  public static VideoProfile makeVideoUnPauseProfile(@NonNull DialerCall call) {
+    Objects.requireNonNull(call);
+    return new VideoProfile(getUnPausedVideoState(call.getVideoState()));
+  }
+
+  public static int getUnPausedVideoState(int videoState) {
+    return videoState & (~VideoProfile.STATE_PAUSED);
+  }
+
+  public static int getPausedVideoState(int videoState) {
+    return videoState | VideoProfile.STATE_PAUSED;
+  }
+
+  public static boolean hasCameraPermissionAndAllowedByUser(@NonNull Context context) {
+    return isCameraAllowedByUser(context) && hasCameraPermission(context);
+  }
+
+  public static boolean hasCameraPermission(@NonNull Context context) {
+    return ContextCompat.checkSelfPermission(context, android.Manifest.permission.CAMERA)
+        == PackageManager.PERMISSION_GRANTED;
+  }
+
+  public static boolean isCameraAllowedByUser(@NonNull Context context) {
+    return DialerUtils.getDefaultSharedPreferenceForDeviceProtectedStorageContext(context)
+        .getBoolean(PREFERENCE_CAMERA_ALLOWED_BY_USER, false);
+  }
+
+  public static void setCameraAllowedByUser(@NonNull Context context) {
+    DialerUtils.getDefaultSharedPreferenceForDeviceProtectedStorageContext(context)
+        .edit()
+        .putBoolean(PREFERENCE_CAMERA_ALLOWED_BY_USER, true)
+        .apply();
+  }
+}
diff --git a/java/com/android/incallui/commontheme/AndroidManifest.xml b/java/com/android/incallui/commontheme/AndroidManifest.xml
new file mode 100644
index 0000000..1d5914f
--- /dev/null
+++ b/java/com/android/incallui/commontheme/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.commontheme">
+</manifest>
diff --git a/java/com/android/incallui/commontheme/res/animator/button_state.xml b/java/com/android/incallui/commontheme/res/animator/button_state.xml
new file mode 100644
index 0000000..70958d6
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/animator/button_state.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:state_pressed="true" android:state_enabled="true">
+    <set>
+      <objectAnimator android:propertyName="translationZ"
+        android:duration="100"
+        android:valueTo="4dp"
+        android:valueType="floatType"/>
+      <objectAnimator android:propertyName="elevation"
+        android:duration="0"
+        android:valueTo="@dimen/incall_call_button_elevation"
+        android:valueType="floatType"/>
+    </set>
+  </item>
+  <!-- base state -->
+  <item android:state_enabled="true">
+    <set>
+      <objectAnimator android:propertyName="translationZ"
+        android:duration="100"
+        android:valueTo="0"
+        android:startDelay="100"
+        android:valueType="floatType"/>
+      <objectAnimator android:propertyName="elevation"
+        android:duration="0"
+        android:valueTo="@dimen/incall_call_button_elevation"
+        android:valueType="floatType" />
+    </set>
+  </item>
+  ...
+</selector>
\ No newline at end of file
diff --git a/java/com/android/incallui/commontheme/res/animator/disabled_alpha.xml b/java/com/android/incallui/commontheme/res/animator/disabled_alpha.xml
new file mode 100644
index 0000000..8d78f00
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/animator/disabled_alpha.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <item android:state_enabled="false">
+    <set>
+      <objectAnimator
+        android:propertyName="alpha"
+        android:duration="@android:integer/config_shortAnimTime"
+        android:valueTo=".3f"
+        android:valueType="floatType"/>
+    </set>
+  </item>
+  <item>
+    <set>
+      <objectAnimator
+        android:propertyName="alpha"
+        android:duration="@android:integer/config_shortAnimTime"
+        android:valueTo="1f"
+        android:valueType="floatType"/>
+    </set>
+  </item>
+</selector>
diff --git a/java/com/android/incallui/commontheme/res/color/incall_button_ripple.xml b/java/com/android/incallui/commontheme/res/color/incall_button_ripple.xml
new file mode 100644
index 0000000..cd474c5
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/color/incall_button_ripple.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="#80888888" android:state_checked="true"/>
+  <item android:color="#80ffffff"/>
+</selector>
diff --git a/java/com/android/incallui/commontheme/res/color/incall_button_white.xml b/java/com/android/incallui/commontheme/res/color/incall_button_white.xml
new file mode 100644
index 0000000..5df441f
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/color/incall_button_white.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="@android:color/white" android:state_enabled="true"/>
+  <item android:color="#99ffffff" android:state_enabled="false"/>
+</selector>
diff --git a/java/com/android/incallui/commontheme/res/drawable-hdpi/ic_phone_audio_white_36dp.png b/java/com/android/incallui/commontheme/res/drawable-hdpi/ic_phone_audio_white_36dp.png
new file mode 100644
index 0000000..26f3fe0
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable-hdpi/ic_phone_audio_white_36dp.png
Binary files differ
diff --git a/java/com/android/incallui/commontheme/res/drawable-mdpi/ic_phone_audio_white_36dp.png b/java/com/android/incallui/commontheme/res/drawable-mdpi/ic_phone_audio_white_36dp.png
new file mode 100644
index 0000000..5b0a9d6
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable-mdpi/ic_phone_audio_white_36dp.png
Binary files differ
diff --git a/java/com/android/incallui/commontheme/res/drawable-xhdpi/ic_phone_audio_white_36dp.png b/java/com/android/incallui/commontheme/res/drawable-xhdpi/ic_phone_audio_white_36dp.png
new file mode 100644
index 0000000..d595b19
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable-xhdpi/ic_phone_audio_white_36dp.png
Binary files differ
diff --git a/java/com/android/incallui/commontheme/res/drawable-xxhdpi/ic_phone_audio_white_36dp.png b/java/com/android/incallui/commontheme/res/drawable-xxhdpi/ic_phone_audio_white_36dp.png
new file mode 100644
index 0000000..fb7cf16
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable-xxhdpi/ic_phone_audio_white_36dp.png
Binary files differ
diff --git a/java/com/android/incallui/commontheme/res/drawable-xxxhdpi/ic_phone_audio_white_36dp.png b/java/com/android/incallui/commontheme/res/drawable-xxxhdpi/ic_phone_audio_white_36dp.png
new file mode 100644
index 0000000..4bb58d9
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable-xxxhdpi/ic_phone_audio_white_36dp.png
Binary files differ
diff --git a/java/com/android/incallui/commontheme/res/drawable/answer_answer_background.xml b/java/com/android/incallui/commontheme/res/drawable/answer_answer_background.xml
new file mode 100644
index 0000000..090506a
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable/answer_answer_background.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="#80FFFFFF">
+  <item>
+    <shape
+      android:shape="oval">
+      <solid android:color="#09ad00"/>
+    </shape>
+  </item>
+</ripple>
diff --git a/java/com/android/incallui/commontheme/res/drawable/answer_decline_background.xml b/java/com/android/incallui/commontheme/res/drawable/answer_decline_background.xml
new file mode 100644
index 0000000..abfd56e
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable/answer_decline_background.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="#80FFFFFF">
+  <item>
+    <shape
+      android:shape="oval">
+      <solid android:color="#DF0000"/>
+    </shape>
+  </item>
+</ripple>
diff --git a/java/com/android/incallui/commontheme/res/drawable/incall_end_call_background.xml b/java/com/android/incallui/commontheme/res/drawable/incall_end_call_background.xml
new file mode 100644
index 0000000..3c9f4bc
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/drawable/incall_end_call_background.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="#80FFFFFF">
+  <item>
+    <shape
+      android:shape="oval">
+      <solid android:color="#FFDF0000"/>
+    </shape>
+  </item>
+</ripple>
diff --git a/java/com/android/incallui/commontheme/res/values-w260dp-h520dp/dimens.xml b/java/com/android/incallui/commontheme/res/values-w260dp-h520dp/dimens.xml
new file mode 100644
index 0000000..e139059
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values-w260dp-h520dp/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="incall_end_call_button_size">64dp</dimen>
+  <drawable name="incall_end_call_icon">@drawable/quantum_ic_call_end_white_36</drawable>
+</resources>
diff --git a/java/com/android/incallui/commontheme/res/values-w520dp-h260dp-land/dimens.xml b/java/com/android/incallui/commontheme/res/values-w520dp-h260dp-land/dimens.xml
new file mode 100644
index 0000000..e139059
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values-w520dp-h260dp-land/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="incall_end_call_button_size">64dp</dimen>
+  <drawable name="incall_end_call_icon">@drawable/quantum_ic_call_end_white_36</drawable>
+</resources>
diff --git a/java/com/android/incallui/commontheme/res/values/colors.xml b/java/com/android/incallui/commontheme/res/values/colors.xml
new file mode 100644
index 0000000..d38e347
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values/colors.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <!-- 50% black background drawn over the video to make it easier to see text and buttons. -->
+  <color name="videocall_overlay_background_color">#7E000000</color>
+</resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/commontheme/res/values/dimens.xml b/java/com/android/incallui/commontheme/res/values/dimens.xml
new file mode 100644
index 0000000..649ba2c
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values/dimens.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="incall_end_call_button_size">48dp</dimen>
+  <dimen name="incall_call_button_elevation">8dp</dimen>
+  <drawable name="incall_end_call_icon">@drawable/quantum_ic_call_end_white_24</drawable>
+</resources>
diff --git a/java/com/android/incallui/commontheme/res/values/strings.xml b/java/com/android/incallui/commontheme/res/values/strings.xml
new file mode 100644
index 0000000..6f346a3
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values/strings.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <string name="incall_content_description_end_call">End call</string>
+
+  <string name="incall_content_description_muted">Muted</string>
+
+  <string name="incall_content_description_unmuted">Unmuted</string>
+
+  <string name="incall_content_description_swap_calls">Swap calls</string>
+
+  <string name="incall_content_description_merge_calls">Merge calls</string>
+
+  <string name="incall_content_description_earpiece">Handset earpiece</string>
+
+  <string name="incall_content_description_speaker">Speaker</string>
+
+  <string name="incall_content_description_bluetooth">Bluetooth</string>
+
+  <string name="incall_content_description_headset">Wired headset</string>
+
+  <!-- Text for the onscreen "Hold" button when it is not selected. Pressing it will put
+     the call on hold. -->
+  <string name="incall_content_description_hold">Hold call</string>
+  <!-- Text for the onscreen "Hold" button when it is selected. Pressing it will resume
+       the call from a previously held state. -->
+  <string name="incall_content_description_unhold">Resume call</string>
+
+  <string name="incall_content_description_video_on">Video on</string>
+
+  <string name="incall_content_description_video_off">Video off</string>
+
+  <string name="incall_content_description_swap_video">Swap video</string>
+
+</resources>
diff --git a/java/com/android/incallui/commontheme/res/values/styles.xml b/java/com/android/incallui/commontheme/res/values/styles.xml
new file mode 100644
index 0000000..311f9cf
--- /dev/null
+++ b/java/com/android/incallui/commontheme/res/values/styles.xml
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+
+  <style name="Dialer.Incall.TextAppearance.Large">
+    <item name="android:textColor">?android:textColorPrimary</item>
+    <item name="android:textSize">36sp</item>
+    <item name="android:fontFamily">sans-serif-light</item>
+  </style>
+
+  <style name="Dialer.Incall.TextAppearance.Label">
+    <item name="android:textColor">?android:textColorPrimary</item>
+    <item name="android:textSize">12sp</item>
+  </style>
+
+  <style name="Dialer.Incall.TextAppearance" parent="android:TextAppearance.Material">
+    <item name="android:textColor">?android:textColorSecondary</item>
+    <item name="android:textSize">18sp</item>
+  </style>
+
+  <style name="Incall.Button.End" parent="android:Widget.Material.Button">
+    <item name="android:background">@drawable/incall_end_call_background</item>
+    <item name="android:elevation">8dp</item>
+    <item name="android:layout_height">@dimen/incall_end_call_button_size</item>
+    <item name="android:layout_width">@dimen/incall_end_call_button_size</item>
+    <item name="android:padding">8dp</item>
+    <item name="android:src">@drawable/incall_end_call_icon</item>
+    <item name="android:stateListAnimator">@animator/disabled_alpha</item>
+  </style>
+
+  <style name="Answer.Button" parent="android:Widget.Material.Button">
+    <item name="android:stateListAnimator">@animator/button_state</item>
+  </style>
+
+  <style name="Answer.Button.Answer">
+    <item name="android:background">@drawable/answer_answer_background</item>
+  </style>
+
+  <style name="Answer.Button.Decline">
+    <item name="android:background">@drawable/answer_decline_background</item>
+  </style>
+
+</resources>
diff --git a/java/com/android/incallui/contactgrid/AndroidManifest.xml b/java/com/android/incallui/contactgrid/AndroidManifest.xml
new file mode 100644
index 0000000..5200105
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.contactgrid">
+</manifest>
diff --git a/java/com/android/incallui/contactgrid/BottomRow.java b/java/com/android/incallui/contactgrid/BottomRow.java
new file mode 100644
index 0000000..aaf7e82
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/BottomRow.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2016 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.contactgrid;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.telephony.PhoneNumberUtils;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+
+/**
+ * Gets the content of the bottom row. For example:
+ *
+ * <ul>
+ * <li>Mobile +1 (650) 253-0000
+ * <li>[HD icon] 00:15
+ * <li>Call ended
+ * <li>Hanging up
+ * </ul>
+ */
+public class BottomRow {
+
+  /** Content of the bottom row. */
+  public static class Info {
+
+    @Nullable public final CharSequence label;
+    public final boolean isTimerVisible;
+    public final boolean isWorkIconVisible;
+    public final boolean isHdIconVisible;
+    public final boolean isForwardIconVisible;
+    public final boolean isSpamIconVisible;
+    public final boolean shouldPopulateAccessibilityEvent;
+
+    public Info(
+        @Nullable CharSequence label,
+        boolean isTimerVisible,
+        boolean isWorkIconVisible,
+        boolean isHdIconVisible,
+        boolean isForwardIconVisible,
+        boolean isSpamIconVisible,
+        boolean shouldPopulateAccessibilityEvent) {
+      this.label = label;
+      this.isTimerVisible = isTimerVisible;
+      this.isWorkIconVisible = isWorkIconVisible;
+      this.isHdIconVisible = isHdIconVisible;
+      this.isForwardIconVisible = isForwardIconVisible;
+      this.isSpamIconVisible = isSpamIconVisible;
+      this.shouldPopulateAccessibilityEvent = shouldPopulateAccessibilityEvent;
+    }
+  }
+
+  private BottomRow() {}
+
+  public static Info getInfo(Context context, PrimaryCallState state, PrimaryInfo primaryInfo) {
+    CharSequence label;
+    boolean isTimerVisible = state.state == State.ACTIVE;
+    boolean isForwardIconVisible = state.isForwardedNumber;
+    boolean isWorkIconVisible = state.isWorkCall;
+    boolean isHdIconVisible = state.isHdAudioCall && !isForwardIconVisible;
+    boolean isSpamIconVisible = false;
+    boolean shouldPopulateAccessibilityEvent = true;
+
+    if (isIncoming(state) && primaryInfo.isSpam) {
+      label = context.getString(R.string.contact_grid_incoming_suspected_spam);
+      isSpamIconVisible = true;
+      isHdIconVisible = false;
+    } else if (state.state == State.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) {
+      label = state.disconnectCause.getLabel();
+      if (TextUtils.isEmpty(label)) {
+        label = context.getString(R.string.incall_call_ended);
+      }
+    } else if (!TextUtils.isEmpty(state.callbackNumber)) {
+      // This is used for carriers like Project Fi to show the callback number for emergency calls.
+      label =
+          context.getString(
+              R.string.contact_grid_callback_number,
+              PhoneNumberUtils.formatNumber(state.callbackNumber));
+      isTimerVisible = false;
+    } else {
+      label = getLabelForPhoneNumber(primaryInfo);
+      shouldPopulateAccessibilityEvent = primaryInfo.nameIsNumber;
+    }
+
+    return new Info(
+        label,
+        isTimerVisible,
+        isWorkIconVisible,
+        isHdIconVisible,
+        isForwardIconVisible,
+        isSpamIconVisible,
+        shouldPopulateAccessibilityEvent);
+  }
+
+  private static CharSequence getLabelForPhoneNumber(PrimaryInfo primaryInfo) {
+    if (primaryInfo.nameIsNumber) {
+      return primaryInfo.location;
+    }
+    if (!TextUtils.isEmpty(primaryInfo.number)) {
+      CharSequence spannedNumber = spanDisplayNumber(primaryInfo.number);
+      if (primaryInfo.label == null) {
+        return spannedNumber;
+      } else {
+        return TextUtils.concat(primaryInfo.label, " ", spannedNumber);
+      }
+    }
+    return null;
+  }
+
+  private static CharSequence spanDisplayNumber(String displayNumber) {
+    return PhoneNumberUtilsCompat.createTtsSpannable(
+        BidiFormatter.getInstance().unicodeWrap(displayNumber, TextDirectionHeuristics.LTR));
+  }
+
+  private static boolean isIncoming(PrimaryCallState state) {
+    return state.state == State.INCOMING || state.state == State.CALL_WAITING;
+  }
+}
diff --git a/java/com/android/incallui/contactgrid/ContactGridManager.java b/java/com/android/incallui/contactgrid/ContactGridManager.java
new file mode 100644
index 0000000..81c2251
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/ContactGridManager.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2016 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.contactgrid;
+
+import android.content.Context;
+import android.os.SystemClock;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.Chronometer;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.ViewAnimator;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.contacts.common.lettertiles.LetterTileDrawable;
+import com.android.dialer.common.Assert;
+import com.android.dialer.util.DrawableConverter;
+import com.android.incallui.incall.protocol.ContactPhotoType;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import java.util.List;
+
+/** Utility to manage the Contact grid */
+public class ContactGridManager {
+
+  private final Context context;
+  private final View contactGridLayout;
+
+  // Row 0: Captain Holt        ON HOLD
+  // Row 0: Calling...
+  // Row 0: [Wi-Fi icon] Calling via Starbucks Wi-Fi
+  // Row 0: [Wi-Fi icon] Starbucks Wi-Fi
+  // Row 0: Hey Jake, pick up!
+  private ImageView connectionIconImageView;
+  private TextView statusTextView;
+
+  // Row 1: Jake Peralta        [Contact photo]
+  // Row 1: Walgreens
+  // Row 1: +1 (650) 253-0000
+  private TextView contactNameTextView;
+  @Nullable private ImageView avatarImageView;
+
+  // Row 2: Mobile +1 (650) 253-0000
+  // Row 2: [HD icon] 00:15
+  // Row 2: Call ended
+  // Row 2: Hanging up
+  // Row 2: [Alert sign] Suspected spam caller
+  // Row 2: Your emergency callback number: +1 (650) 253-0000
+  private ImageView workIconImageView;
+  private ImageView hdIconImageView;
+  private ImageView forwardIconImageView;
+  private ImageView spamIconImageView;
+  private ViewAnimator bottomTextSwitcher;
+  private TextView bottomTextView;
+  private Chronometer bottomTimerView;
+  private int avatarSize;
+  private boolean hideAvatar;
+  private boolean showAnonymousAvatar;
+  private boolean middleRowVisible = true;
+
+  private PrimaryInfo primaryInfo = PrimaryInfo.createEmptyPrimaryInfo();
+  private PrimaryCallState primaryCallState = PrimaryCallState.createEmptyPrimaryCallState();
+  private final LetterTileDrawable letterTile;
+
+
+  public ContactGridManager(
+      View view, @Nullable ImageView avatarImageView, int avatarSize, boolean showAnonymousAvatar) {
+    context = view.getContext();
+    Assert.isNotNull(context);
+
+    this.avatarImageView = avatarImageView;
+    this.avatarSize = avatarSize;
+    this.showAnonymousAvatar = showAnonymousAvatar;
+    connectionIconImageView = (ImageView) view.findViewById(R.id.contactgrid_connection_icon);
+    statusTextView = (TextView) view.findViewById(R.id.contactgrid_status_text);
+    contactNameTextView = (TextView) view.findViewById(R.id.contactgrid_contact_name);
+    workIconImageView = (ImageView) view.findViewById(R.id.contactgrid_workIcon);
+    hdIconImageView = (ImageView) view.findViewById(R.id.contactgrid_hdIcon);
+    forwardIconImageView = (ImageView) view.findViewById(R.id.contactgrid_forwardIcon);
+    spamIconImageView = (ImageView) view.findViewById(R.id.contactgrid_spamIcon);
+    bottomTextSwitcher = (ViewAnimator) view.findViewById(R.id.contactgrid_bottom_text_switcher);
+    bottomTextView = (TextView) view.findViewById(R.id.contactgrid_bottom_text);
+    bottomTimerView = (Chronometer) view.findViewById(R.id.contactgrid_bottom_timer);
+
+    contactGridLayout = (View) contactNameTextView.getParent();
+    letterTile = new LetterTileDrawable(context.getResources());
+  }
+
+  public void show() {
+    contactGridLayout.setVisibility(View.VISIBLE);
+  }
+
+  public void hide() {
+    contactGridLayout.setVisibility(View.GONE);
+  }
+
+  public void setAvatarHidden(boolean hide) {
+    if (hide != hideAvatar) {
+      hideAvatar = hide;
+      updatePrimaryNameAndPhoto();
+    }
+  }
+
+  public boolean isAvatarHidden() {
+    return hideAvatar;
+  }
+
+  public View getContainerView() {
+    return contactGridLayout;
+  }
+
+  public void setIsMiddleRowVisible(boolean isMiddleRowVisible) {
+    if (middleRowVisible == isMiddleRowVisible) {
+      return;
+    }
+    middleRowVisible = isMiddleRowVisible;
+
+    contactNameTextView.setVisibility(isMiddleRowVisible ? View.VISIBLE : View.GONE);
+    updateAvatarVisibility();
+  }
+
+  public void setPrimary(PrimaryInfo primaryInfo) {
+    this.primaryInfo = primaryInfo;
+    updatePrimaryNameAndPhoto();
+    updateBottomRow();
+  }
+
+  public void setCallState(PrimaryCallState primaryCallState) {
+    this.primaryCallState = primaryCallState;
+    updatePrimaryNameAndPhoto();
+    updateBottomRow();
+    updateTopRow();
+  }
+
+  public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+    dispatchPopulateAccessibilityEvent(event, statusTextView);
+    dispatchPopulateAccessibilityEvent(event, contactNameTextView);
+    BottomRow.Info info = BottomRow.getInfo(context, primaryCallState, primaryInfo);
+    if (info.shouldPopulateAccessibilityEvent) {
+      dispatchPopulateAccessibilityEvent(event, bottomTextView);
+    }
+  }
+
+  public void setAvatarImageView(
+      @Nullable ImageView avatarImageView, int avatarSize, boolean showAnonymousAvatar) {
+    this.avatarImageView = avatarImageView;
+    this.avatarSize = avatarSize;
+    this.showAnonymousAvatar = showAnonymousAvatar;
+    updatePrimaryNameAndPhoto();
+  }
+
+  private void dispatchPopulateAccessibilityEvent(AccessibilityEvent event, View view) {
+    final List<CharSequence> eventText = event.getText();
+    int size = eventText.size();
+    view.dispatchPopulateAccessibilityEvent(event);
+    // If no text added write null to keep relative position.
+    if (size == eventText.size()) {
+      eventText.add(null);
+    }
+  }
+
+  private boolean updateAvatarVisibility() {
+    if (avatarImageView == null) {
+      return false;
+    }
+
+    if (!middleRowVisible) {
+      avatarImageView.setVisibility(View.GONE);
+      return false;
+    }
+
+    boolean hasPhoto =
+        primaryInfo.photo != null && primaryInfo.photoType == ContactPhotoType.CONTACT;
+    if (!hasPhoto && !showAnonymousAvatar) {
+      avatarImageView.setVisibility(View.GONE);
+      return false;
+    }
+
+    avatarImageView.setVisibility(View.VISIBLE);
+    return true;
+  }
+
+  /**
+   * Updates row 0. For example:
+   *
+   * <ul>
+   *   <li>Captain Holt ON HOLD
+   *   <li>Calling...
+   *   <li>[Wi-Fi icon] Calling via Starbucks Wi-Fi
+   *   <li>[Wi-Fi icon] Starbucks Wi-Fi
+   *   <li>Call from
+   * </ul>
+   */
+  private void updateTopRow() {
+    TopRow.Info info = TopRow.getInfo(context, primaryCallState);
+    if (TextUtils.isEmpty(info.label)) {
+      // Use INVISIBLE here to prevent the rows below this one from moving up and down.
+      statusTextView.setVisibility(View.INVISIBLE);
+      statusTextView.setText(null);
+    } else {
+      statusTextView.setText(info.label);
+      statusTextView.setVisibility(View.VISIBLE);
+      statusTextView.setSingleLine(info.labelIsSingleLine);
+    }
+
+    if (info.icon == null) {
+      connectionIconImageView.setVisibility(View.GONE);
+    } else {
+      connectionIconImageView.setVisibility(View.VISIBLE);
+      connectionIconImageView.setImageDrawable(info.icon);
+    }
+  }
+
+  /**
+   * Updates row 1. For example:
+   *
+   * <ul>
+   *   <li>Jake Peralta [Contact photo]
+   *   <li>Walgreens
+   *   <li>+1 (650) 253-0000
+   * </ul>
+   */
+  private void updatePrimaryNameAndPhoto() {
+    if (TextUtils.isEmpty(primaryInfo.name)) {
+      contactNameTextView.setText(null);
+    } else {
+      contactNameTextView.setText(
+          primaryInfo.nameIsNumber
+              ? PhoneNumberUtilsCompat.createTtsSpannable(primaryInfo.name)
+              : primaryInfo.name);
+
+      // Set direction of the name field
+      int nameDirection = View.TEXT_DIRECTION_INHERIT;
+      if (primaryInfo.nameIsNumber) {
+        nameDirection = View.TEXT_DIRECTION_LTR;
+      }
+      contactNameTextView.setTextDirection(nameDirection);
+    }
+
+    if (avatarImageView != null) {
+      if (hideAvatar) {
+        avatarImageView.setVisibility(View.GONE);
+      } else if (avatarImageView != null && avatarSize > 0 && updateAvatarVisibility()) {
+        boolean hasPhoto =
+            primaryInfo.photo != null && primaryInfo.photoType == ContactPhotoType.CONTACT;
+        // Contact has a photo, don't render a letter tile.
+        if (hasPhoto) {
+          avatarImageView.setBackground(
+              DrawableConverter.getRoundedDrawable(
+                  context, primaryInfo.photo, avatarSize, avatarSize));
+          // Contact has a name, that isn't a number.
+        } else {
+          int contactType =
+              primaryCallState.isVoiceMailNumber
+                  ? LetterTileDrawable.TYPE_VOICEMAIL
+                  : LetterTileDrawable.TYPE_DEFAULT;
+          letterTile.setCanonicalDialerLetterTileDetails(
+              primaryInfo.name,
+              primaryInfo.contactInfoLookupKey,
+              LetterTileDrawable.SHAPE_CIRCLE,
+              contactType);
+          avatarImageView.setBackground(letterTile);
+      }
+    }
+  }
+  }
+
+  /**
+   * Updates row 2. For example:
+   *
+   * <ul>
+   *   <li>Mobile +1 (650) 253-0000
+   *   <li>[HD icon] 00:15
+   *   <li>Call ended
+   *   <li>Hanging up
+   * </ul>
+   */
+  private void updateBottomRow() {
+    BottomRow.Info info = BottomRow.getInfo(context, primaryCallState, primaryInfo);
+
+    bottomTextView.setText(info.label);
+    bottomTextView.setAllCaps(info.isSpamIconVisible);
+    workIconImageView.setVisibility(info.isWorkIconVisible ? View.VISIBLE : View.GONE);
+    hdIconImageView.setVisibility(info.isHdIconVisible ? View.VISIBLE : View.GONE);
+    forwardIconImageView.setVisibility(info.isForwardIconVisible ? View.VISIBLE : View.GONE);
+    spamIconImageView.setVisibility(info.isSpamIconVisible ? View.VISIBLE : View.GONE);
+
+    if (info.isTimerVisible) {
+      bottomTextSwitcher.setDisplayedChild(1);
+      bottomTimerView.setBase(
+          primaryCallState.connectTimeMillis
+              - System.currentTimeMillis()
+              + SystemClock.elapsedRealtime());
+      bottomTimerView.start();
+    } else {
+      bottomTextSwitcher.setDisplayedChild(0);
+      bottomTimerView.stop();
+    }
+  }
+}
diff --git a/java/com/android/incallui/contactgrid/TopRow.java b/java/com/android/incallui/contactgrid/TopRow.java
new file mode 100644
index 0000000..a340fd0
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/TopRow.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2016 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.contactgrid;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import com.android.dialer.common.Assert;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+
+/**
+ * Gets the content of the top row. For example:
+ *
+ * <ul>
+ * <li>Captain Holt ON HOLD
+ * <li>Calling...
+ * <li>[Wi-Fi icon] Calling via Starbucks Wi-Fi
+ * <li>[Wi-Fi icon] Starbucks Wi-Fi
+ * <li>Call from
+ * </ul>
+ */
+public class TopRow {
+
+  /** Content of the top row. */
+  public static class Info {
+
+    @Nullable public final CharSequence label;
+    @Nullable public final Drawable icon;
+    public final boolean labelIsSingleLine;
+
+    public Info(@Nullable CharSequence label, @Nullable Drawable icon, boolean labelIsSingleLine) {
+      this.label = label;
+      this.icon = icon;
+      this.labelIsSingleLine = labelIsSingleLine;
+    }
+  }
+
+  private TopRow() {}
+
+  public static Info getInfo(Context context, PrimaryCallState state) {
+    CharSequence label = null;
+    Drawable icon = state.connectionIcon;
+    boolean labelIsSingleLine = true;
+
+    if (state.isWifi && icon == null) {
+      icon = context.getDrawable(R.drawable.quantum_ic_network_wifi_white_24);
+    }
+
+    if (state.state == State.INCOMING || state.state == State.CALL_WAITING) {
+      // Call from
+      // [Wi-Fi icon] Video call from
+      // Hey Jake, pick up!
+      if (!TextUtils.isEmpty(state.callSubject)) {
+        label = state.callSubject;
+        labelIsSingleLine = false;
+      } else {
+        label = getLabelForIncoming(context, state);
+      }
+    } else if (VideoUtils.hasSentVideoUpgradeRequest(state.sessionModificationState)
+        || VideoUtils.hasReceivedVideoUpgradeRequest(state.sessionModificationState)) {
+      label = getLabelForVideoRequest(context, state);
+    } else if (state.state == State.PULLING) {
+      label = context.getString(R.string.incall_transferring);
+    } else if (state.state == State.DIALING || state.state == State.CONNECTING) {
+      // [Wi-Fi icon] Calling via Google Guest
+      // Calling...
+      label = getLabelForDialing(context, state);
+    } else if (state.state == State.ACTIVE && state.isRemotelyHeld) {
+      label = context.getString(R.string.incall_remotely_held);
+    } else {
+      // Video calling...
+      // [Wi-Fi icon] Starbucks Wi-Fi
+      label = getConnectionLabel(state);
+    }
+
+    return new Info(label, icon, labelIsSingleLine);
+  }
+
+  private static CharSequence getLabelForIncoming(Context context, PrimaryCallState state) {
+    if (VideoUtils.isVideoCall(state.videoState)) {
+      return getLabelForIncomingVideo(context, state.isWifi);
+    } else if (state.isWifi && !TextUtils.isEmpty(state.connectionLabel)) {
+      return state.connectionLabel;
+    } else if (isAccount(state)) {
+      return context.getString(R.string.contact_grid_incoming_via_template, state.connectionLabel);
+    } else if (state.isWorkCall) {
+      return context.getString(R.string.contact_grid_incoming_work_call);
+    } else {
+      return context.getString(R.string.contact_grid_incoming_voice_call);
+    }
+  }
+
+  private static CharSequence getLabelForIncomingVideo(Context context, boolean isWifi) {
+    if (isWifi) {
+      return context.getString(R.string.contact_grid_incoming_wifi_video_call);
+    } else {
+      return context.getString(R.string.contact_grid_incoming_video_call);
+    }
+  }
+
+  private static CharSequence getLabelForDialing(Context context, PrimaryCallState state) {
+    if (!TextUtils.isEmpty(state.connectionLabel) && !state.isWifi) {
+      return context.getString(R.string.incall_calling_via_template, state.connectionLabel);
+    } else {
+      if (VideoUtils.isVideoCall(state.videoState)) {
+        if (state.isWifi) {
+          return context.getString(R.string.incall_wifi_video_call_requesting);
+        } else {
+          return context.getString(R.string.incall_video_call_requesting);
+        }
+      }
+      return context.getString(R.string.incall_connecting);
+    }
+  }
+
+  private static CharSequence getConnectionLabel(PrimaryCallState state) {
+    if (!TextUtils.isEmpty(state.connectionLabel)
+        && (isAccount(state) || state.isWifi || state.isConference)) {
+      // We normally don't show a "call state label" at all when active
+      // (but we can use the call state label to display the provider name).
+      return state.connectionLabel;
+    } else {
+      return null;
+    }
+  }
+
+  private static CharSequence getLabelForVideoRequest(Context context, PrimaryCallState state) {
+    switch (state.sessionModificationState) {
+      case DialerCall.SESSION_MODIFICATION_STATE_WAITING_FOR_UPGRADE_TO_VIDEO_RESPONSE:
+        return context.getString(R.string.incall_video_call_requesting);
+      case DialerCall.SESSION_MODIFICATION_STATE_REQUEST_FAILED:
+      case DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_FAILED:
+        return context.getString(R.string.incall_video_call_request_failed);
+      case DialerCall.SESSION_MODIFICATION_STATE_REQUEST_REJECTED:
+        return context.getString(R.string.incall_video_call_request_rejected);
+      case DialerCall.SESSION_MODIFICATION_STATE_UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT:
+        return context.getString(R.string.incall_video_call_request_timed_out);
+      case DialerCall.SESSION_MODIFICATION_STATE_RECEIVED_UPGRADE_TO_VIDEO_REQUEST:
+        return getLabelForIncomingVideo(context, state.isWifi);
+      case DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST:
+      default:
+        Assert.fail();
+        return null;
+    }
+  }
+
+  private static boolean isAccount(PrimaryCallState state) {
+    return !TextUtils.isEmpty(state.connectionLabel) && TextUtils.isEmpty(state.gatewayNumber);
+  }
+}
diff --git a/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_bottom_row.xml b/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_bottom_row.xml
new file mode 100644
index 0000000..3900be5
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_bottom_row.xml
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="wrap_content"
+  android:layout_height="wrap_content"
+  android:orientation="horizontal"
+  android:gravity="center_horizontal"
+  tools:showIn="@layout/incall_contact_grid">
+  <ImageView
+    android:id="@id/contactgrid_workIcon"
+    android:layout_width="24dp"
+    android:layout_height="24dp"
+    android:layout_marginEnd="8dp"
+    android:scaleType="fitCenter"
+    android:src="@drawable/ic_work_profile"
+    android:tint="#ffffff"
+    tools:visibility="gone"
+    />
+  <ImageView
+    android:id="@id/contactgrid_hdIcon"
+    android:layout_width="24dp"
+    android:layout_height="24dp"
+    android:layout_marginEnd="8dp"
+    android:scaleType="fitCenter"
+    android:src="@drawable/quantum_ic_hd_white_24"
+    tools:visibility="gone"
+    />
+  <ImageView
+    android:id="@id/contactgrid_forwardIcon"
+    android:layout_width="24dp"
+    android:layout_height="24dp"
+    android:layout_marginEnd="8dp"
+    android:scaleType="fitCenter"
+    android:src="@drawable/quantum_ic_forward_white_24"
+    tools:visibility="gone"
+    />
+  <ImageView
+    android:id="@+id/contactgrid_spamIcon"
+    android:layout_width="24dp"
+    android:layout_height="24dp"
+    android:layout_marginEnd="8dp"
+    android:scaleType="fitCenter"
+    android:src="@drawable/quantum_ic_report_white_18"
+    tools:visibility="gone"
+    />
+  <ViewAnimator
+    android:id="@+id/contactgrid_bottom_text_switcher"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_marginBottom="2dp"
+    android:measureAllChildren="false">
+    <TextView
+      android:id="@+id/contactgrid_bottom_text"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_gravity="center_horizontal"
+      android:singleLine="true"
+      android:textAppearance="@style/Dialer.Incall.TextAppearance"
+      tools:gravity="start"
+      tools:text="Mobile +1 (650) 253-0000"/>
+    <Chronometer
+      android:id="@+id/contactgrid_bottom_timer"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_gravity="center_horizontal"
+      android:singleLine="true"
+      android:textAppearance="@style/Dialer.Incall.TextAppearance"
+      tools:gravity="center"/>
+  </ViewAnimator>
+</LinearLayout>
diff --git a/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_top_row.xml b/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_top_row.xml
new file mode 100644
index 0000000..59359c9
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/res/layout/incall_contactgrid_top_row.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="wrap_content"
+  android:layout_height="wrap_content"
+  android:gravity="center"
+  android:orientation="horizontal"
+  tools:showIn="@layout/incall_contact_grid">
+  <ImageView
+    android:id="@id/contactgrid_connection_icon"
+    android:layout_width="24dp"
+    android:layout_height="24dp"
+    android:layout_marginEnd="10dp"
+    android:scaleType="fitCenter"
+    tools:src="@android:drawable/sym_def_app_icon"
+    tools:visibility="visible"
+    />
+  <TextView
+    android:id="@id/contactgrid_status_text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:singleLine="true"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance"
+    tools:text="Captain Holt"/>
+</LinearLayout>
diff --git a/java/com/android/incallui/contactgrid/res/values/ids.xml b/java/com/android/incallui/contactgrid/res/values/ids.xml
new file mode 100644
index 0000000..821dc9d
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/res/values/ids.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <item name="contactgrid_connection_icon" type="id"/>
+  <item name="contactgrid_status_text" type="id"/>
+  <item name="contactgrid_contact_name" type="id"/>
+  <item name="contactgrid_workIcon" type="id"/>
+  <item name="contactgrid_hdIcon" type="id"/>
+  <item name="contactgrid_forwardIcon" type="id"/>
+  <item name="contactgrid_spamIcon" type="id"/>
+  <item name="contactgrid_bottom_text" type="id"/>
+  <item name="contactgrid_bottom_timer" type="id"/>
+  <item name="contactgrid_avatar" type="id"/>
+  <item name="contactgrid_top_row" type="id"/>
+  <item name="contactgrid_bottom_row" type="id"/>
+</resources>
diff --git a/java/com/android/incallui/contactgrid/res/values/strings.xml b/java/com/android/incallui/contactgrid/res/values/strings.xml
new file mode 100644
index 0000000..385f843
--- /dev/null
+++ b/java/com/android/incallui/contactgrid/res/values/strings.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+  <!-- Title displayed in the overlay for outgoing calls which include the name of the provider.
+     [CHAR LIMIT=40] -->
+  <string name="incall_calling_via_template">Calling via <xliff:g id="provider_name">%s</xliff:g></string>
+
+  <!-- Displayed above the contact name during an outgoing phone call. Indicates that the call is
+       in the connecting stage. -->
+  <string name="incall_connecting">Calling…</string>
+
+  <!-- Displayed above the contact name when an external call is being pulled to the local
+       device. -->
+  <string name="incall_transferring">Transferring…</string>
+
+  <!-- Displayed above the contact name when the user requests an upgrade from a voice call to a
+       video call. -->
+  <string name="incall_video_call_requesting">Video calling…</string>
+
+  <!-- Displayed above the contact name when the user requests an upgrade from a voice call to a
+       Wi-Fi video call. -->
+  <string name="incall_wifi_video_call_requesting">Wi-Fi video calling…</string>
+
+  <!-- Displayed above the contact name when the user's video upgrade failed due to an unknown
+       reason. -->
+  <string name="incall_video_call_request_failed">Unable to connect</string>
+
+  <!-- Displayed above the contact name when the user's video upgrade was declined by the remote
+       party. -->
+  <string name="incall_video_call_request_rejected">Call declined</string>
+
+  <!-- Displayed above the contact name when no response was received for the user's upgrade
+       requests and we timed out. -->
+  <string name="incall_video_call_request_timed_out">Call timed out</string>
+
+  <!-- In-call screen: status label for a call that's in the process of hanging up
+       [CHAR LIMIT=25] -->
+  <string name="incall_hanging_up">Hanging up</string>
+
+  <!-- In-call screen: status label displayed briefly after a call ends [CHAR LIMIT=25] -->
+  <string name="incall_call_ended">Call ended</string>
+
+  <!-- In-call screen: label shown at the top of the screen when a call is on hold by the remote
+     party [CHAR LIMIT=25] -->
+  <string name="incall_remotely_held">On hold</string>
+
+  <!-- Displayed in the answer call screen for incoming video calls. -->
+  <string name="contact_grid_incoming_video_call">Video call from</string>
+
+  <!-- Displayed in the answer call screen for incoming video calls over Wi-F. -->
+  <string name="contact_grid_incoming_wifi_video_call">Wi-Fi video call from</string>
+
+  <!-- Displayed in the answer call screen for incoming voice calls. -->
+  <string name="contact_grid_incoming_voice_call">Call from</string>
+
+  <!-- Displayed in the answer call screen for incoming voice calls. -->
+  <string name="contact_grid_incoming_work_call">Work call from</string>
+
+  <!-- Displayed in the answer call screen for incoming calls via a phone account. -->
+  <string name="contact_grid_incoming_via_template">Incoming via <xliff:g id="provider_name">%s</xliff:g></string>
+
+  <!-- Displayed in the answer call screen for incoming spam calls. -->
+  <string name="contact_grid_incoming_suspected_spam">Suspected spam caller</string>
+
+  <!-- In-call screen: string shown to the user when their outgoing number is different than the
+     number reported by TelephonyManager#getLine1Number(). This is used for carriers like
+     Project Fi so that users can give their number to emergency responders. -->
+  <string name="contact_grid_callback_number">Callback number: <xliff:g id="dark_number">%1$s</xliff:g></string>
+</resources>
diff --git a/java/com/android/incallui/hold/AndroidManifest.xml b/java/com/android/incallui/hold/AndroidManifest.xml
new file mode 100644
index 0000000..2aedce9
--- /dev/null
+++ b/java/com/android/incallui/hold/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.hold">
+</manifest>
diff --git a/java/com/android/incallui/hold/OnHoldFragment.java b/java/com/android/incallui/hold/OnHoldFragment.java
new file mode 100644
index 0000000..c695213
--- /dev/null
+++ b/java/com/android/incallui/hold/OnHoldFragment.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2016 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.hold;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.telephony.PhoneNumberUtils;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.transition.TransitionManager;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+import com.android.dialer.common.Assert;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+
+/** Shows banner UI for background call */
+public class OnHoldFragment extends Fragment {
+
+  private static final String ARG_INFO = "info";
+  private boolean padTopInset = true;
+  private int topInset;
+
+  public static OnHoldFragment newInstance(@NonNull SecondaryInfo info) {
+    OnHoldFragment fragment = new OnHoldFragment();
+    Bundle args = new Bundle();
+    args.putParcelable(ARG_INFO, info);
+    fragment.setArguments(args);
+    return fragment;
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    final View view = layoutInflater.inflate(R.layout.incall_on_hold_banner, viewGroup, false);
+
+    SecondaryInfo secondaryInfo = getArguments().getParcelable(ARG_INFO);
+    secondaryInfo = Assert.isNotNull(secondaryInfo);
+
+    ((TextView) view.findViewById(R.id.hold_contact_name))
+        .setText(
+            secondaryInfo.nameIsNumber
+                ? PhoneNumberUtils.createTtsSpannable(
+                    BidiFormatter.getInstance()
+                        .unicodeWrap(secondaryInfo.name, TextDirectionHeuristics.LTR))
+                : secondaryInfo.name);
+    ((ImageView) view.findViewById(R.id.hold_phone_icon))
+        .setImageResource(
+            secondaryInfo.isVideoCall
+                ? R.drawable.quantum_ic_videocam_white_18
+                : R.drawable.quantum_ic_call_white_18);
+    view.addOnAttachStateChangeListener(
+        new OnAttachStateChangeListener() {
+          @Override
+          public void onViewAttachedToWindow(View v) {
+            topInset = v.getRootWindowInsets().getSystemWindowInsetTop();
+            applyInset();
+          }
+
+          @Override
+          public void onViewDetachedFromWindow(View v) {}
+        });
+    return view;
+  }
+
+  public void setPadTopInset(boolean padTopInset) {
+    this.padTopInset = padTopInset;
+    applyInset();
+  }
+
+  private void applyInset() {
+    if (getView() == null) {
+      return;
+    }
+
+    int newPadding = padTopInset ? topInset : 0;
+    if (newPadding != getView().getPaddingTop()) {
+      TransitionManager.beginDelayedTransition(((ViewGroup) getView().getParent()));
+      getView().setPadding(0, newPadding, 0, 0);
+    }
+  }
+}
diff --git a/java/com/android/incallui/hold/res/layout/incall_on_hold_banner.xml b/java/com/android/incallui/hold/res/layout/incall_on_hold_banner.xml
new file mode 100644
index 0000000..c213af5
--- /dev/null
+++ b/java/com/android/incallui/hold/res/layout/incall_on_hold_banner.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+  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:background="#CC212121"
+  android:fitsSystemWindows="true">
+  <LinearLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:paddingStart="24dp"
+    android:paddingEnd="24dp"
+    android:paddingTop="16dp"
+    android:paddingBottom="16dp"
+    android:gravity="center_vertical">
+
+    <ImageView
+      android:id="@+id/hold_phone_icon"
+      android:layout_width="18dp"
+      android:layout_height="18dp"
+      android:src="@drawable/quantum_ic_call_white_18"
+      android:contentDescription="@null"/>
+
+    <TextView
+      android:id="@+id/hold_contact_name"
+      style="@style/Dialer.Incall.TextAppearance"
+      android:layout_width="0dp"
+      android:layout_height="wrap_content"
+      android:layout_weight="1"
+      android:layout_marginStart="8dp"
+      android:layout_marginEnd="24dp"
+      android:ellipsize="end"
+      android:singleLine="true"
+      android:textColor="@android:color/white"
+      tools:text="Jake Peralta Really Longname"/>
+
+    <TextView
+      style="@style/Dialer.Incall.TextAppearance"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:textAllCaps="true"
+      android:textColor="@android:color/white"
+      android:text="@string/incall_on_hold"/>
+  </LinearLayout>
+</FrameLayout>
diff --git a/java/com/android/incallui/hold/res/values/strings.xml b/java/com/android/incallui/hold/res/values/strings.xml
new file mode 100644
index 0000000..2e66bcf
--- /dev/null
+++ b/java/com/android/incallui/hold/res/values/strings.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <string name="incall_on_hold">On hold</string>
+
+</resources>
diff --git a/java/com/android/incallui/incall/bindings/InCallBindings.java b/java/com/android/incallui/incall/bindings/InCallBindings.java
new file mode 100644
index 0000000..8bbbc68
--- /dev/null
+++ b/java/com/android/incallui/incall/bindings/InCallBindings.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 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.incall.bindings;
+
+import com.android.incallui.incall.impl.InCallFragment;
+import com.android.incallui.incall.protocol.InCallScreen;
+
+/** Bindings for the in call module. */
+public class InCallBindings {
+
+  public static InCallScreen createInCallScreen() {
+    return new InCallFragment();
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/AndroidManifest.xml b/java/com/android/incallui/incall/impl/AndroidManifest.xml
new file mode 100644
index 0000000..a0e3110
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incall.incall.impl">
+</manifest>
diff --git a/java/com/android/incallui/incall/impl/AutoValue_MappedButtonConfig_MappingInfo.java b/java/com/android/incallui/incall/impl/AutoValue_MappedButtonConfig_MappingInfo.java
new file mode 100644
index 0000000..addebc4
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/AutoValue_MappedButtonConfig_MappingInfo.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2017 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.incall.impl;
+
+import javax.annotation.Generated;
+
+@Generated("com.google.auto.value.processor.AutoValueProcessor")
+ final class AutoValue_MappedButtonConfig_MappingInfo extends MappedButtonConfig.MappingInfo {
+
+  private final int slot;
+  private final int slotOrder;
+  private final int conflictOrder;
+
+  private AutoValue_MappedButtonConfig_MappingInfo(
+      int slot,
+      int slotOrder,
+      int conflictOrder) {
+    this.slot = slot;
+    this.slotOrder = slotOrder;
+    this.conflictOrder = conflictOrder;
+  }
+
+  @Override
+  public int getSlot() {
+    return slot;
+  }
+
+  @Override
+  public int getSlotOrder() {
+    return slotOrder;
+  }
+
+  @Override
+  public int getConflictOrder() {
+    return conflictOrder;
+  }
+
+  @Override
+  public String toString() {
+    return "MappingInfo{"
+        + "slot=" + slot + ", "
+        + "slotOrder=" + slotOrder + ", "
+        + "conflictOrder=" + conflictOrder
+        + "}";
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    }
+    if (o instanceof MappedButtonConfig.MappingInfo) {
+      MappedButtonConfig.MappingInfo that = (MappedButtonConfig.MappingInfo) o;
+      return (this.slot == that.getSlot())
+           && (this.slotOrder == that.getSlotOrder())
+           && (this.conflictOrder == that.getConflictOrder());
+    }
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    int h = 1;
+    h *= 1000003;
+    h ^= this.slot;
+    h *= 1000003;
+    h ^= this.slotOrder;
+    h *= 1000003;
+    h ^= this.conflictOrder;
+    return h;
+  }
+
+  static final class Builder extends MappedButtonConfig.MappingInfo.Builder {
+    private Integer slot;
+    private Integer slotOrder;
+    private Integer conflictOrder;
+    Builder() {
+    }
+    private Builder(MappedButtonConfig.MappingInfo source) {
+      this.slot = source.getSlot();
+      this.slotOrder = source.getSlotOrder();
+      this.conflictOrder = source.getConflictOrder();
+    }
+    @Override
+    public MappedButtonConfig.MappingInfo.Builder setSlot(int slot) {
+      this.slot = slot;
+      return this;
+    }
+    @Override
+    public MappedButtonConfig.MappingInfo.Builder setSlotOrder(int slotOrder) {
+      this.slotOrder = slotOrder;
+      return this;
+    }
+    @Override
+    public MappedButtonConfig.MappingInfo.Builder setConflictOrder(int conflictOrder) {
+      this.conflictOrder = conflictOrder;
+      return this;
+    }
+    @Override
+    public MappedButtonConfig.MappingInfo build() {
+      String missing = "";
+      if (this.slot == null) {
+        missing += " slot";
+      }
+      if (this.slotOrder == null) {
+        missing += " slotOrder";
+      }
+      if (this.conflictOrder == null) {
+        missing += " conflictOrder";
+      }
+      if (!missing.isEmpty()) {
+        throw new IllegalStateException("Missing required properties:" + missing);
+      }
+      return new AutoValue_MappedButtonConfig_MappingInfo(
+          this.slot,
+          this.slotOrder,
+          this.conflictOrder);
+    }
+  }
+
+}
diff --git a/java/com/android/incallui/incall/impl/ButtonChooser.java b/java/com/android/incallui/incall/impl/ButtonChooser.java
new file mode 100644
index 0000000..55b82f0
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/ButtonChooser.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.support.annotation.NonNull;
+import com.android.dialer.common.Assert;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Determines where logical buttons should be placed in the {@link InCallFragment} based on the
+ * provided mapping.
+ *
+ * <p>The button placement returned by a call to {@link #getButtonPlacement(int, Set)} is created as
+ * follows: one button is placed at each UI slot, using the provided mapping to resolve conflicts.
+ * Any allowed buttons that were not chosen for their desired slot are filled in at the end of the
+ * list until it becomes the proper size.
+ */
+@Immutable
+final class ButtonChooser {
+
+  private final MappedButtonConfig config;
+
+  public ButtonChooser(@NonNull MappedButtonConfig config) {
+    this.config = Assert.isNotNull(config);
+  }
+
+  /**
+   * Returns the buttons that should be shown in the {@link InCallFragment}, ordered appropriately.
+   *
+   * @param numUiButtons the number of ui buttons available.
+   * @param allowedButtons the {@link InCallButtonIds} that can be shown.
+   * @param disabledButtons the {@link InCallButtonIds} that can be shown but in disabled stats.
+   * @return an immutable list whose size is at most {@code numUiButtons}, containing the buttons to
+   *     show.
+   */
+  @NonNull
+  public List<Integer> getButtonPlacement(
+      int numUiButtons,
+      @NonNull Set<Integer> allowedButtons,
+      @NonNull Set<Integer> disabledButtons) {
+    Assert.isNotNull(allowedButtons);
+    Assert.checkArgument(numUiButtons >= 0);
+
+    if (numUiButtons == 0 || allowedButtons.isEmpty()) {
+      return Collections.emptyList();
+    }
+
+    List<Integer> placedButtons = new ArrayList<>();
+    List<Integer> conflicts = new ArrayList<>();
+    placeButtonsInSlots(numUiButtons, allowedButtons, placedButtons, conflicts);
+    placeConflictsInOpenSlots(
+        numUiButtons, allowedButtons, disabledButtons, placedButtons, conflicts);
+    return Collections.unmodifiableList(placedButtons);
+  }
+
+  private void placeButtonsInSlots(
+      int numUiButtons,
+      @NonNull Set<Integer> allowedButtons,
+      @NonNull List<Integer> placedButtons,
+      @NonNull List<Integer> conflicts) {
+    List<Integer> configuredSlots = config.getOrderedMappedSlots();
+    for (int i = 0; i < configuredSlots.size() && placedButtons.size() < numUiButtons; ++i) {
+      int slotNumber = configuredSlots.get(i);
+      List<Integer> potentialButtons = config.getButtonsForSlot(slotNumber);
+      Collections.sort(potentialButtons, config.getSlotComparator());
+      for (int j = 0; j < potentialButtons.size(); ++j) {
+        if (allowedButtons.contains(potentialButtons.get(j))) {
+          placedButtons.add(potentialButtons.get(j));
+          conflicts.addAll(potentialButtons.subList(j + 1, potentialButtons.size()));
+          break;
+        }
+      }
+    }
+  }
+
+  private void placeConflictsInOpenSlots(
+      int numUiButtons,
+      @NonNull Set<Integer> allowedButtons,
+      @NonNull Set<Integer> disabledButtons,
+      @NonNull List<Integer> placedButtons,
+      @NonNull List<Integer> conflicts) {
+    Collections.sort(conflicts, config.getConflictComparator());
+    for (Integer conflict : conflicts) {
+      if (placedButtons.size() >= numUiButtons) {
+        return;
+      }
+      // If the conflict button is allowed but disabled, don't place it since it probably will
+      // move when it's enabled.
+      if (!allowedButtons.contains(conflict) || disabledButtons.contains(conflict)) {
+        continue;
+      }
+      placedButtons.add(conflict);
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/ButtonChooserFactory.java b/java/com/android/incallui/incall/impl/ButtonChooserFactory.java
new file mode 100644
index 0000000..1b168a6
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/ButtonChooserFactory.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.support.v4.util.ArrayMap;
+import android.telephony.TelephonyManager;
+import com.android.incallui.incall.impl.MappedButtonConfig.MappingInfo;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import java.util.Map;
+
+/**
+ * Creates {@link ButtonChooser} objects, based on the current network and phone type.
+ */
+class ButtonChooserFactory {
+
+  /**
+   * Creates the appropriate {@link ButtonChooser} based on the given information.
+   *
+   * @param voiceNetworkType the result of a call to {@link TelephonyManager#getVoiceNetworkType()}.
+   * @param isWiFi {@code true} if the call is made over WiFi, {@code false} otherwise.
+   * @param phoneType the result of a call to {@link TelephonyManager#getPhoneType()}.
+   * @return the ButtonChooser.
+   */
+  public static ButtonChooser newButtonChooser(
+      int voiceNetworkType, boolean isWiFi, int phoneType) {
+    if (voiceNetworkType == TelephonyManager.NETWORK_TYPE_LTE || isWiFi) {
+      return newImsAndWiFiButtonChooser();
+    }
+
+    if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) {
+      return newCdmaButtonChooser();
+    }
+
+    if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
+      return newGsmButtonChooser();
+    }
+
+    return newImsAndWiFiButtonChooser();
+  }
+
+  private static ButtonChooser newImsAndWiFiButtonChooser() {
+    Map<Integer, MappingInfo> mapping = createCommonMapping();
+    mapping.put(
+        InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
+        MappingInfo.builder(4).setSlotOrder(0).build());
+    mapping.put(
+        InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO, MappingInfo.builder(4).setSlotOrder(10).build());
+    mapping.put(
+        InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY, MappingInfo.builder(5).setSlotOrder(0).build());
+    mapping.put(InCallButtonIds.BUTTON_HOLD, MappingInfo.builder(5).setSlotOrder(10).build());
+
+    return new ButtonChooser(new MappedButtonConfig(mapping));
+  }
+
+  private static ButtonChooser newCdmaButtonChooser() {
+    Map<Integer, MappingInfo> mapping = createCommonMapping();
+    mapping.put(
+        InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
+        MappingInfo.builder(4).setSlotOrder(0).build());
+    mapping.put(InCallButtonIds.BUTTON_SWAP, MappingInfo.builder(5).setSlotOrder(0).build());
+
+    return new ButtonChooser(new MappedButtonConfig(mapping));
+  }
+
+  private static ButtonChooser newGsmButtonChooser() {
+    Map<Integer, MappingInfo> mapping = createCommonMapping();
+    mapping.put(
+        InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY, MappingInfo.builder(4).setSlotOrder(0).build());
+    mapping.put(
+        InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
+        MappingInfo.builder(4).setSlotOrder(10).build());
+    mapping.put(InCallButtonIds.BUTTON_HOLD, MappingInfo.builder(5).setSlotOrder(0).build());
+
+    return new ButtonChooser(new MappedButtonConfig(mapping));
+  }
+
+  private static Map<Integer, MappingInfo> createCommonMapping() {
+    Map<Integer, MappingInfo> mapping = new ArrayMap<>();
+    mapping.put(InCallButtonIds.BUTTON_MUTE, MappingInfo.builder(0).build());
+    mapping.put(InCallButtonIds.BUTTON_DIALPAD, MappingInfo.builder(1).build());
+    mapping.put(InCallButtonIds.BUTTON_AUDIO, MappingInfo.builder(2).build());
+    mapping.put(InCallButtonIds.BUTTON_MERGE, MappingInfo.builder(3).setSlotOrder(0).build());
+    mapping.put(InCallButtonIds.BUTTON_ADD_CALL, MappingInfo.builder(3).build());
+    return mapping;
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/ButtonController.java b/java/com/android/incallui/incall/impl/ButtonController.java
new file mode 100644
index 0000000..95a38be
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/ButtonController.java
@@ -0,0 +1,584 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.support.annotation.CallSuper;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.StringRes;
+import android.telecom.CallAudioState;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.View.OnClickListener;
+import com.android.dialer.common.Assert;
+import com.android.incallui.incall.impl.CheckableLabeledButton.OnCheckedChangeListener;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+
+/** Manages a single button. */
+interface ButtonController {
+
+  boolean isEnabled();
+
+  void setEnabled(boolean isEnabled);
+
+  boolean isAllowed();
+
+  void setAllowed(boolean isAllowed);
+
+  void setChecked(boolean isChecked);
+
+  @InCallButtonIds
+  int getInCallButtonId();
+
+  void setButton(CheckableLabeledButton button);
+
+  final class Controllers {
+
+    private static void resetButton(CheckableLabeledButton button) {
+      if (button != null) {
+        button.setOnCheckedChangeListener(null);
+        button.setOnClickListener(null);
+      }
+    }
+  }
+
+  abstract class CheckableButtonController implements ButtonController, OnCheckedChangeListener {
+
+    @NonNull protected final InCallButtonUiDelegate delegate;
+    @InCallButtonIds protected final int buttonId;
+    @StringRes protected final int checkedDescription;
+    @StringRes protected final int uncheckedDescription;
+    protected boolean isEnabled;
+    protected boolean isAllowed;
+    protected boolean isChecked;
+    protected CheckableLabeledButton button;
+
+    protected CheckableButtonController(
+        @NonNull InCallButtonUiDelegate delegate,
+        @InCallButtonIds int buttonId,
+        @StringRes int checkedContentDescription,
+        @StringRes int uncheckedContentDescription) {
+      Assert.isNotNull(delegate);
+      this.delegate = delegate;
+      this.buttonId = buttonId;
+      this.checkedDescription = checkedContentDescription;
+      this.uncheckedDescription = uncheckedContentDescription;
+    }
+
+    @Override
+    public boolean isEnabled() {
+      return isEnabled;
+    }
+
+    @Override
+    public void setEnabled(boolean isEnabled) {
+      this.isEnabled = isEnabled;
+      if (button != null) {
+        button.setEnabled(isEnabled);
+      }
+    }
+
+    @Override
+    public boolean isAllowed() {
+      return isAllowed;
+    }
+
+    @Override
+    public void setAllowed(boolean isAllowed) {
+      this.isAllowed = isAllowed;
+      if (button != null) {
+        button.setVisibility(isAllowed ? View.VISIBLE : View.INVISIBLE);
+      }
+    }
+
+    @Override
+    public void setChecked(boolean isChecked) {
+      this.isChecked = isChecked;
+      if (button != null) {
+        button.setChecked(isChecked);
+      }
+    }
+
+    @Override
+    @InCallButtonIds
+    public int getInCallButtonId() {
+      return buttonId;
+    }
+
+    @Override
+    @CallSuper
+    public void setButton(CheckableLabeledButton button) {
+      Controllers.resetButton(this.button);
+
+      this.button = button;
+      if (button != null) {
+        button.setEnabled(isEnabled);
+        button.setVisibility(isAllowed ? View.VISIBLE : View.INVISIBLE);
+        button.setChecked(isChecked);
+        button.setOnClickListener(null);
+        button.setOnCheckedChangeListener(this);
+        button.setContentDescription(
+            button.getContext().getText(isChecked ? checkedDescription : uncheckedDescription));
+        button.setShouldShowMoreIndicator(false);
+      }
+    }
+
+    @Override
+    public void onCheckedChanged(CheckableLabeledButton checkableLabeledButton, boolean isChecked) {
+      button.setContentDescription(
+          button.getContext().getText(isChecked ? checkedDescription : uncheckedDescription));
+      doCheckedChanged(isChecked);
+    }
+
+    protected abstract void doCheckedChanged(boolean isChecked);
+  }
+
+  abstract class SimpleCheckableButtonController extends CheckableButtonController {
+
+    @StringRes private final int label;
+    @DrawableRes private final int icon;
+
+    protected SimpleCheckableButtonController(
+        @NonNull InCallButtonUiDelegate delegate,
+        @InCallButtonIds int buttonId,
+        @StringRes int checkedContentDescription,
+        @StringRes int uncheckedContentDescription,
+        @StringRes int label,
+        @DrawableRes int icon) {
+      super(
+          delegate,
+          buttonId,
+          checkedContentDescription == 0 ? label : checkedContentDescription,
+          uncheckedContentDescription == 0 ? label : uncheckedContentDescription);
+      this.label = label;
+      this.icon = icon;
+    }
+
+    @Override
+    @CallSuper
+    public void setButton(CheckableLabeledButton button) {
+      super.setButton(button);
+      if (button != null) {
+        button.setLabelText(label);
+        button.setIconDrawable(icon);
+      }
+    }
+  }
+
+  abstract class NonCheckableButtonController implements ButtonController, OnClickListener {
+
+    protected final InCallButtonUiDelegate delegate;
+    @InCallButtonIds protected final int buttonId;
+    @StringRes protected final int contentDescription;
+    protected boolean isEnabled;
+    protected boolean isAllowed;
+    protected CheckableLabeledButton button;
+
+    protected NonCheckableButtonController(
+        InCallButtonUiDelegate delegate,
+        @InCallButtonIds int buttonId,
+        @StringRes int contentDescription) {
+      this.delegate = delegate;
+      this.buttonId = buttonId;
+      this.contentDescription = contentDescription;
+    }
+
+    @Override
+    public boolean isEnabled() {
+      return isEnabled;
+    }
+
+    @Override
+    public void setEnabled(boolean isEnabled) {
+      this.isEnabled = isEnabled;
+      if (button != null) {
+        button.setEnabled(isEnabled);
+      }
+    }
+
+    @Override
+    public boolean isAllowed() {
+      return isAllowed;
+    }
+
+    @Override
+    public void setAllowed(boolean isAllowed) {
+      this.isAllowed = isAllowed;
+      if (button != null) {
+        button.setVisibility(isAllowed ? View.VISIBLE : View.INVISIBLE);
+      }
+    }
+
+    @Override
+    public void setChecked(boolean isChecked) {
+      Assert.fail();
+    }
+
+    @Override
+    @InCallButtonIds
+    public int getInCallButtonId() {
+      return buttonId;
+    }
+
+    @Override
+    @CallSuper
+    public void setButton(CheckableLabeledButton button) {
+      Controllers.resetButton(this.button);
+
+      this.button = button;
+      if (button != null) {
+        button.setEnabled(isEnabled);
+        button.setVisibility(isAllowed ? View.VISIBLE : View.INVISIBLE);
+        button.setChecked(false);
+        button.setOnCheckedChangeListener(null);
+        button.setOnClickListener(this);
+        button.setContentDescription(button.getContext().getText(contentDescription));
+        button.setShouldShowMoreIndicator(false);
+      }
+    }
+  }
+
+  abstract class SimpleNonCheckableButtonController extends NonCheckableButtonController {
+
+    @StringRes private final int label;
+    @DrawableRes private final int icon;
+
+    protected SimpleNonCheckableButtonController(
+        InCallButtonUiDelegate delegate,
+        @InCallButtonIds int buttonId,
+        @StringRes int contentDescription,
+        @StringRes int label,
+        @DrawableRes int icon) {
+      super(delegate, buttonId, contentDescription == 0 ? label : contentDescription);
+      this.label = label;
+      this.icon = icon;
+    }
+
+    @Override
+    @CallSuper
+    public void setButton(CheckableLabeledButton button) {
+      super.setButton(button);
+      if (button != null) {
+        button.setLabelText(label);
+        button.setIconDrawable(icon);
+      }
+    }
+  }
+
+  class MuteButtonController extends SimpleCheckableButtonController {
+
+    public MuteButtonController(InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_MUTE,
+          R.string.incall_content_description_muted,
+          R.string.incall_content_description_unmuted,
+          R.string.incall_label_mute,
+          R.drawable.quantum_ic_mic_off_white_36);
+    }
+
+    @Override
+    public void doCheckedChanged(boolean isChecked) {
+      delegate.muteClicked(isChecked);
+    }
+  }
+
+  class SpeakerButtonController
+      implements ButtonController, OnCheckedChangeListener, OnClickListener {
+
+    @NonNull private final InCallButtonUiDelegate delegate;
+    private boolean isEnabled;
+    private boolean isAllowed;
+    private boolean isChecked;
+    private CheckableLabeledButton button;
+
+    @StringRes private int label = R.string.incall_label_speaker;
+    @DrawableRes private int icon = R.drawable.quantum_ic_volume_up_white_36;
+    private boolean checkable;
+    private CharSequence contentDescription;
+    private CharSequence checkedContentDescription;
+    private CharSequence uncheckedContentDescription;
+
+    public SpeakerButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public boolean isEnabled() {
+      return isEnabled;
+    }
+
+    @Override
+    public void setEnabled(boolean isEnabled) {
+      this.isEnabled = isEnabled;
+      if (button != null) {
+        button.setEnabled(isEnabled && isAllowed);
+      }
+    }
+
+    @Override
+    public boolean isAllowed() {
+      return isAllowed;
+    }
+
+    @Override
+    public void setAllowed(boolean isAllowed) {
+      this.isAllowed = isAllowed;
+      if (button != null) {
+        button.setEnabled(isEnabled && isAllowed);
+      }
+    }
+
+    @Override
+    public void setChecked(boolean isChecked) {
+      this.isChecked = isChecked;
+      if (button != null) {
+        button.setChecked(isChecked);
+      }
+    }
+
+    @Override
+    public int getInCallButtonId() {
+      return InCallButtonIds.BUTTON_AUDIO;
+    }
+
+    @Override
+    public void setButton(CheckableLabeledButton button) {
+      this.button = button;
+      if (button != null) {
+        button.setEnabled(isEnabled && isAllowed);
+        button.setVisibility(View.VISIBLE);
+        button.setChecked(isChecked);
+        button.setOnClickListener(checkable ? null : this);
+        button.setOnCheckedChangeListener(checkable ? this : null);
+        button.setLabelText(label);
+        button.setIconDrawable(icon);
+        button.setContentDescription(
+            isChecked ? checkedContentDescription : uncheckedContentDescription);
+        button.setShouldShowMoreIndicator(!checkable);
+      }
+    }
+
+    public void setAudioState(CallAudioState audioState) {
+      @StringRes int contentDescriptionResId;
+      if ((audioState.getSupportedRouteMask() & CallAudioState.ROUTE_BLUETOOTH)
+          == CallAudioState.ROUTE_BLUETOOTH) {
+        checkable = false;
+        isChecked = false;
+        label = R.string.incall_label_audio;
+
+        if ((audioState.getRoute() & CallAudioState.ROUTE_BLUETOOTH)
+            == CallAudioState.ROUTE_BLUETOOTH) {
+          icon = R.drawable.quantum_ic_bluetooth_audio_white_36;
+          contentDescriptionResId = R.string.incall_content_description_bluetooth;
+        } else if ((audioState.getRoute() & CallAudioState.ROUTE_SPEAKER)
+            == CallAudioState.ROUTE_SPEAKER) {
+          icon = R.drawable.quantum_ic_volume_up_white_36;
+          contentDescriptionResId = R.string.incall_content_description_speaker;
+        } else if ((audioState.getRoute() & CallAudioState.ROUTE_WIRED_HEADSET)
+            == CallAudioState.ROUTE_WIRED_HEADSET) {
+          icon = R.drawable.quantum_ic_headset_white_36;
+          contentDescriptionResId = R.string.incall_content_description_headset;
+        } else {
+          icon = R.drawable.ic_phone_audio_white_36dp;
+          contentDescriptionResId = R.string.incall_content_description_earpiece;
+        }
+      } else {
+        checkable = true;
+        isChecked = audioState.getRoute() == CallAudioState.ROUTE_SPEAKER;
+        label = R.string.incall_label_speaker;
+        icon = R.drawable.quantum_ic_volume_up_white_36;
+        contentDescriptionResId = R.string.incall_content_description_speaker;
+      }
+
+      contentDescription = delegate.getContext().getText(contentDescriptionResId);
+      checkedContentDescription =
+          TextUtils.concat(
+              contentDescription,
+              delegate.getContext().getText(R.string.incall_talkback_speaker_on));
+      uncheckedContentDescription =
+          TextUtils.concat(
+              contentDescription,
+              delegate.getContext().getText(R.string.incall_talkback_speaker_off));
+      setButton(button);
+    }
+
+    @Override
+    public void onClick(View v) {
+      delegate.showAudioRouteSelector();
+    }
+
+    @Override
+    public void onCheckedChanged(CheckableLabeledButton checkableLabeledButton, boolean isChecked) {
+      checkableLabeledButton.setContentDescription(
+          isChecked ? checkedContentDescription : uncheckedContentDescription);
+      delegate.toggleSpeakerphone();
+    }
+  }
+
+  class DialpadButtonController extends SimpleCheckableButtonController {
+
+    public DialpadButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_DIALPAD,
+          0,
+          0,
+          R.string.incall_label_dialpad,
+          R.drawable.quantum_ic_dialpad_white_36);
+    }
+
+    @Override
+    public void doCheckedChanged(boolean isChecked) {
+      delegate.showDialpadClicked(isChecked);
+    }
+  }
+
+  class HoldButtonController extends SimpleCheckableButtonController {
+
+    public HoldButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_HOLD,
+          R.string.incall_content_description_unhold,
+          R.string.incall_content_description_hold,
+          R.string.incall_label_hold,
+          R.drawable.quantum_ic_pause_white_36);
+    }
+
+    @Override
+    public void doCheckedChanged(boolean isChecked) {
+      delegate.holdClicked(isChecked);
+    }
+  }
+
+  class AddCallButtonController extends SimpleNonCheckableButtonController {
+
+    public AddCallButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_ADD_CALL,
+          0,
+          R.string.incall_label_add_call,
+          R.drawable.ic_addcall_white);
+      Assert.isNotNull(delegate);
+    }
+
+    @Override
+    public void onClick(View view) {
+      delegate.addCallClicked();
+    }
+  }
+
+  class SwapButtonController extends SimpleNonCheckableButtonController {
+
+    public SwapButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_SWAP,
+          R.string.incall_content_description_swap_calls,
+          R.string.incall_label_swap,
+          R.drawable.quantum_ic_swap_calls_white_36);
+      Assert.isNotNull(delegate);
+    }
+
+    @Override
+    public void onClick(View view) {
+      delegate.swapClicked();
+    }
+  }
+
+  class MergeButtonController extends SimpleNonCheckableButtonController {
+
+    public MergeButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_MERGE,
+          R.string.incall_content_description_merge_calls,
+          R.string.incall_label_merge,
+          R.drawable.quantum_ic_call_merge_white_36);
+      Assert.isNotNull(delegate);
+    }
+
+    @Override
+    public void onClick(View view) {
+      delegate.mergeClicked();
+    }
+  }
+
+  class UpgradeToVideoButtonController extends SimpleNonCheckableButtonController {
+
+    public UpgradeToVideoButtonController(@NonNull InCallButtonUiDelegate delegate) {
+      super(
+          delegate,
+          InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO,
+          0,
+          R.string.incall_label_videocall,
+          R.drawable.quantum_ic_videocam_white_36);
+      Assert.isNotNull(delegate);
+    }
+
+    @Override
+    public void onClick(View view) {
+      delegate.changeToVideoClicked();
+    }
+  }
+
+  class ManageConferenceButtonController extends SimpleNonCheckableButtonController {
+
+    private final InCallScreenDelegate inCallScreenDelegate;
+
+    public ManageConferenceButtonController(@NonNull InCallScreenDelegate inCallScreenDelegate) {
+      super(
+          null,
+          InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
+          R.string.a11y_description_incall_label_manage_content,
+          R.string.incall_label_manage,
+          R.drawable.quantum_ic_group_white_36);
+      Assert.isNotNull(inCallScreenDelegate);
+      this.inCallScreenDelegate = inCallScreenDelegate;
+    }
+
+    @Override
+    public void onClick(View view) {
+      inCallScreenDelegate.onManageConferenceClicked();
+    }
+  }
+
+  class SwitchToSecondaryButtonController extends SimpleNonCheckableButtonController {
+
+    private final InCallScreenDelegate inCallScreenDelegate;
+
+    public SwitchToSecondaryButtonController(InCallScreenDelegate inCallScreenDelegate) {
+      super(
+          null,
+          InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY,
+          R.string.incall_content_description_swap_calls,
+          R.string.incall_label_swap,
+          R.drawable.quantum_ic_swap_calls_white_36);
+      Assert.isNotNull(inCallScreenDelegate);
+      this.inCallScreenDelegate = inCallScreenDelegate;
+    }
+
+    @Override
+    public void onClick(View view) {
+      inCallScreenDelegate.onSecondaryInfoClicked();
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/CheckableLabeledButton.java b/java/com/android/incallui/incall/impl/CheckableLabeledButton.java
new file mode 100644
index 0000000..a681adc
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/CheckableLabeledButton.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.animation.AnimatorInflater;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.PorterDuff.Mode;
+import android.graphics.drawable.Drawable;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.StringRes;
+import android.text.TextUtils.TruncateAt;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.SoundEffectConstants;
+import android.widget.Checkable;
+import android.widget.ImageView;
+import android.widget.ImageView.ScaleType;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/** A button to show on the incall screen */
+public class CheckableLabeledButton extends LinearLayout implements Checkable {
+
+  private static final int[] CHECKED_STATE_SET = {android.R.attr.state_checked};
+  private static final float DISABLED_STATE_OPACITY = .3f;
+  private boolean broadcasting;
+  private boolean isChecked;
+  private OnCheckedChangeListener onCheckedChangeListener;
+  private ImageView iconView;
+  private TextView labelView;
+  private Drawable background;
+  private Drawable backgroundMore;
+
+  public CheckableLabeledButton(Context context, AttributeSet attrs) {
+    super(context, attrs);
+    init(context, attrs);
+  }
+
+  public CheckableLabeledButton(Context context) {
+    this(context, null);
+  }
+
+  private void init(Context context, AttributeSet attrs) {
+    setOrientation(VERTICAL);
+    setGravity(Gravity.CENTER_HORIZONTAL);
+    Drawable icon;
+    CharSequence labelText;
+    boolean enabled;
+
+    backgroundMore = getResources().getDrawable(R.drawable.incall_button_background_more, null);
+    background = getResources().getDrawable(R.drawable.incall_button_background, null);
+
+    TypedArray typedArray =
+        context.obtainStyledAttributes(attrs, R.styleable.CheckableLabeledButton);
+    icon = typedArray.getDrawable(R.styleable.CheckableLabeledButton_incall_icon);
+    labelText = typedArray.getString(R.styleable.CheckableLabeledButton_incall_labelText);
+    enabled = typedArray.getBoolean(R.styleable.CheckableLabeledButton_android_enabled, true);
+    typedArray.recycle();
+
+    int paddingSize = getResources().getDimensionPixelOffset(R.dimen.incall_button_padding);
+    setPadding(paddingSize, paddingSize, paddingSize, paddingSize);
+
+    int iconSize = getResources().getDimensionPixelSize(R.dimen.incall_labeled_button_size);
+
+    iconView = new ImageView(context, null, android.R.style.Widget_Material_Button_Colored);
+    LayoutParams iconParams = generateDefaultLayoutParams();
+    iconParams.width = iconSize;
+    iconParams.height = iconSize;
+    iconView.setLayoutParams(iconParams);
+    iconView.setScaleType(ScaleType.CENTER_INSIDE);
+    iconView.setImageDrawable(icon);
+    iconView.setImageTintMode(Mode.SRC_IN);
+    iconView.setImageTintList(getResources().getColorStateList(R.color.incall_button_icon, null));
+    iconView.setBackground(getResources().getDrawable(R.drawable.incall_button_background, null));
+    iconView.setDuplicateParentStateEnabled(true);
+    iconView.setElevation(getResources().getDimension(R.dimen.incall_button_elevation));
+    iconView.setStateListAnimator(
+        AnimatorInflater.loadStateListAnimator(context, R.animator.incall_button_elevation));
+    addView(iconView);
+
+    labelView = new TextView(context);
+    LayoutParams labelParams = generateDefaultLayoutParams();
+    labelParams.width = LayoutParams.WRAP_CONTENT;
+    labelParams.height = LayoutParams.WRAP_CONTENT;
+    labelParams.topMargin =
+        context.getResources().getDimensionPixelOffset(R.dimen.incall_button_label_margin);
+    labelView.setLayoutParams(labelParams);
+    labelView.setTextAppearance(R.style.Dialer_Incall_TextAppearance_Label);
+    labelView.setText(labelText);
+    labelView.setSingleLine();
+    labelView.setMaxEms(9);
+    labelView.setEllipsize(TruncateAt.END);
+    labelView.setGravity(Gravity.CENTER);
+    labelView.setDuplicateParentStateEnabled(true);
+    addView(labelView);
+
+    setFocusable(true);
+    setClickable(true);
+    setEnabled(enabled);
+    setOutlineProvider(null);
+  }
+
+  @Override
+  public void refreshDrawableState() {
+    super.refreshDrawableState();
+    iconView.setAlpha(isEnabled() ? 1f : DISABLED_STATE_OPACITY);
+    labelView.setAlpha(isEnabled() ? 1f : DISABLED_STATE_OPACITY);
+  }
+
+  public void setIconDrawable(@DrawableRes int drawableRes) {
+    iconView.setImageResource(drawableRes);
+  }
+
+  public void setLabelText(@StringRes int stringRes) {
+    labelView.setText(stringRes);
+  }
+
+  /** Shows or hides a little down arrow to indicate that the button will pop up a menu. */
+  public void setShouldShowMoreIndicator(boolean shouldShow) {
+    iconView.setBackground(shouldShow ? backgroundMore : background);
+  }
+
+  @Override
+  public boolean isChecked() {
+    return isChecked;
+  }
+
+  @Override
+  public void setChecked(boolean checked) {
+    performSetChecked(checked);
+  }
+
+  @Override
+  public void toggle() {
+    userRequestedSetChecked(!isChecked());
+  }
+
+  @Override
+  public int[] onCreateDrawableState(int extraSpace) {
+    final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
+    if (isChecked()) {
+      mergeDrawableStates(drawableState, CHECKED_STATE_SET);
+    }
+    return drawableState;
+  }
+
+  @Override
+  protected void drawableStateChanged() {
+    super.drawableStateChanged();
+    invalidate();
+  }
+
+  public void setOnCheckedChangeListener(OnCheckedChangeListener listener) {
+    this.onCheckedChangeListener = listener;
+  }
+
+  @Override
+  public boolean performClick() {
+    if (!isCheckable()) {
+      return super.performClick();
+    }
+
+    toggle();
+    final boolean handled = super.performClick();
+    if (!handled) {
+      // View only makes a sound effect if the onClickListener was
+      // called, so we'll need to make one here instead.
+      playSoundEffect(SoundEffectConstants.CLICK);
+    }
+    return handled;
+  }
+
+  private boolean isCheckable() {
+    return onCheckedChangeListener != null;
+  }
+
+  @Override
+  protected void onRestoreInstanceState(Parcelable state) {
+    SavedState savedState = (SavedState) state;
+    super.onRestoreInstanceState(savedState.getSuperState());
+    performSetChecked(savedState.isChecked);
+    requestLayout();
+  }
+
+  @Override
+  protected Parcelable onSaveInstanceState() {
+    return new SavedState(isChecked(), super.onSaveInstanceState());
+  }
+
+  /**
+   * Called when the state of the button should be updated, this should not be the result of user
+   * interaction.
+   *
+   * @param checked {@code true} if the button should be in the checked state, {@code false}
+   *     otherwise.
+   */
+  private void performSetChecked(boolean checked) {
+    if (isChecked() == checked) {
+      return;
+    }
+    isChecked = checked;
+    refreshDrawableState();
+  }
+
+  /**
+   * Called when the user interacts with a button. This should not result in the button updating
+   * state, rather the request should be propagated to the associated listener.
+   *
+   * @param checked {@code true} if the button should be in the checked state, {@code false}
+   *     otherwise.
+   */
+  private void userRequestedSetChecked(boolean checked) {
+    if (isChecked() == checked) {
+      return;
+    }
+    if (broadcasting) {
+      return;
+    }
+    broadcasting = true;
+    if (onCheckedChangeListener != null) {
+      onCheckedChangeListener.onCheckedChanged(this, checked);
+    }
+    broadcasting = false;
+  }
+
+  /** Callback interface to notify when the button's checked state has changed */
+  public interface OnCheckedChangeListener {
+
+    void onCheckedChanged(CheckableLabeledButton checkableLabeledButton, boolean isChecked);
+  }
+
+  private static class SavedState extends BaseSavedState {
+
+    public static final Creator<SavedState> CREATOR =
+        new Creator<SavedState>() {
+          @Override
+          public SavedState createFromParcel(Parcel in) {
+            return new SavedState(in);
+          }
+
+          @Override
+          public SavedState[] newArray(int size) {
+            return new SavedState[size];
+          }
+        };
+    public final boolean isChecked;
+
+    private SavedState(boolean isChecked, Parcelable superState) {
+      super(superState);
+      this.isChecked = isChecked;
+    }
+
+    protected SavedState(Parcel in) {
+      super(in);
+      isChecked = in.readByte() != 0;
+    }
+
+    @Override
+    public int describeContents() {
+      return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+      super.writeToParcel(dest, flags);
+      dest.writeByte((byte) (isChecked ? 1 : 0));
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/InCallButtonGridFragment.java b/java/com/android/incallui/incall/impl/InCallButtonGridFragment.java
new file mode 100644
index 0000000..db0b5b9
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/InCallButtonGridFragment.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.util.ArraySet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import java.util.List;
+import java.util.Set;
+
+/** Fragment for the in call buttons (mute, speaker, ect.). */
+public class InCallButtonGridFragment extends Fragment {
+
+  private static final int BUTTON_COUNT = 6;
+  private static final int BUTTONS_PER_ROW = 3;
+
+  private CheckableLabeledButton[] buttons = new CheckableLabeledButton[BUTTON_COUNT];
+  private OnButtonGridCreatedListener buttonGridListener;
+
+  public static Fragment newInstance() {
+    return new InCallButtonGridFragment();
+  }
+
+  @Override
+  public void onCreate(@Nullable Bundle bundle) {
+    super.onCreate(bundle);
+    buttonGridListener = FragmentUtils.getParent(this, OnButtonGridCreatedListener.class);
+    Assert.isNotNull(buttonGridListener);
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater inflater, @Nullable ViewGroup parent, @Nullable Bundle bundle) {
+    View view = inflater.inflate(R.layout.incall_button_grid, parent, false);
+
+    buttons[0] = ((CheckableLabeledButton) view.findViewById(R.id.incall_first_button));
+    buttons[1] = ((CheckableLabeledButton) view.findViewById(R.id.incall_second_button));
+    buttons[2] = ((CheckableLabeledButton) view.findViewById(R.id.incall_third_button));
+    buttons[3] = ((CheckableLabeledButton) view.findViewById(R.id.incall_fourth_button));
+    buttons[4] = ((CheckableLabeledButton) view.findViewById(R.id.incall_fifth_button));
+    buttons[5] = ((CheckableLabeledButton) view.findViewById(R.id.incall_sixth_button));
+
+    return view;
+  }
+
+  @Override
+  public void onViewCreated(View view, @Nullable Bundle bundle) {
+    super.onViewCreated(view, bundle);
+    buttonGridListener.onButtonGridCreated(this);
+  }
+
+  @Override
+  public void onDestroyView() {
+    super.onDestroyView();
+    buttonGridListener.onButtonGridDestroyed();
+  }
+
+  public void onInCallScreenDialpadVisibilityChange(boolean isShowing) {
+    for (CheckableLabeledButton button : buttons) {
+      button.setImportantForAccessibility(
+          isShowing
+              ? View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+              : View.IMPORTANT_FOR_ACCESSIBILITY_AUTO);
+    }
+  }
+
+  public int updateButtonStates(
+      List<ButtonController> buttonControllers,
+      @Nullable ButtonChooser buttonChooser,
+      int voiceNetworkType,
+      int phoneType) {
+    Set<Integer> allowedButtons = new ArraySet<>();
+    Set<Integer> disabledButtons = new ArraySet<>();
+    for (ButtonController controller : buttonControllers) {
+      if (controller.isAllowed()) {
+        allowedButtons.add(controller.getInCallButtonId());
+        if (!controller.isEnabled()) {
+          disabledButtons.add(controller.getInCallButtonId());
+        }
+      }
+    }
+
+    for (ButtonController controller : buttonControllers) {
+      controller.setButton(null);
+    }
+
+    if (buttonChooser == null) {
+      buttonChooser =
+          ButtonChooserFactory.newButtonChooser(voiceNetworkType, false /* isWiFi */, phoneType);
+    }
+
+    int numVisibleButtons = getResources().getInteger(R.integer.incall_num_rows) * BUTTONS_PER_ROW;
+    List<Integer> buttonsToPlace =
+        buttonChooser.getButtonPlacement(numVisibleButtons, allowedButtons, disabledButtons);
+
+    for (int i = 0; i < BUTTON_COUNT; ++i) {
+      if (i >= buttonsToPlace.size()) {
+        buttons[i].setVisibility(View.INVISIBLE);
+        continue;
+      }
+      @InCallButtonIds int button = buttonsToPlace.get(i);
+      buttonGridListener.getButtonController(button).setButton(buttons[i]);
+    }
+
+    return numVisibleButtons;
+  }
+
+  /** Interface to let the listener know the status of the button grid. */
+  public interface OnButtonGridCreatedListener {
+    void onButtonGridCreated(InCallButtonGridFragment inCallButtonGridFragment);
+    void onButtonGridDestroyed();
+
+    ButtonController getButtonController(@InCallButtonIds int id);
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/InCallFragment.java b/java/com/android/incallui/incall/impl/InCallFragment.java
new file mode 100644
index 0000000..ef8a1ed
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/InCallFragment.java
@@ -0,0 +1,501 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.Manifest.permission;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.Bundle;
+import android.os.Handler;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.design.widget.TabLayout;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.view.ViewPager;
+import android.telecom.CallAudioState;
+import android.telephony.TelephonyManager;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment;
+import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment.AudioRouteSelectorPresenter;
+import com.android.incallui.contactgrid.ContactGridManager;
+import com.android.incallui.hold.OnHoldFragment;
+import com.android.incallui.incall.impl.ButtonController.SpeakerButtonController;
+import com.android.incallui.incall.impl.InCallButtonGridFragment.OnButtonGridCreatedListener;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import com.android.incallui.incall.protocol.InCallButtonIdsExtension;
+import com.android.incallui.incall.protocol.InCallButtonUi;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegateFactory;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.InCallScreenDelegateFactory;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Fragment that shows UI for an ongoing voice call. */
+public class InCallFragment extends Fragment
+    implements InCallScreen,
+        InCallButtonUi,
+        OnClickListener,
+        AudioRouteSelectorPresenter,
+        OnButtonGridCreatedListener {
+
+  private List<ButtonController> buttonControllers = new ArrayList<>();
+  private View endCallButton;
+  private TabLayout tabLayout;
+  private ViewPager pager;
+  private InCallPagerAdapter adapter;
+  private ContactGridManager contactGridManager;
+  private InCallScreenDelegate inCallScreenDelegate;
+  private InCallButtonUiDelegate inCallButtonUiDelegate;
+  private InCallButtonGridFragment inCallButtonGridFragment;
+  @Nullable private ButtonChooser buttonChooser;
+  private SecondaryInfo savedSecondaryInfo;
+  private int voiceNetworkType;
+  private int phoneType;
+  private boolean stateRestored;
+
+  private static boolean isSupportedButton(@InCallButtonIds int id) {
+    return id == InCallButtonIds.BUTTON_AUDIO
+        || id == InCallButtonIds.BUTTON_MUTE
+        || id == InCallButtonIds.BUTTON_DIALPAD
+        || id == InCallButtonIds.BUTTON_HOLD
+        || id == InCallButtonIds.BUTTON_SWAP
+        || id == InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO
+        || id == InCallButtonIds.BUTTON_ADD_CALL
+        || id == InCallButtonIds.BUTTON_MERGE
+        || id == InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE;
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    if (savedSecondaryInfo != null) {
+      setSecondary(savedSecondaryInfo);
+    }
+  }
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    inCallButtonUiDelegate =
+        FragmentUtils.getParent(this, InCallButtonUiDelegateFactory.class)
+            .newInCallButtonUiDelegate();
+    if (savedInstanceState != null) {
+      inCallButtonUiDelegate.onRestoreInstanceState(savedInstanceState);
+      stateRestored = true;
+    }
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      @NonNull LayoutInflater layoutInflater,
+      @Nullable ViewGroup viewGroup,
+      @Nullable Bundle bundle) {
+    LogUtil.i("InCallFragment.onCreateView", null);
+    final View view = layoutInflater.inflate(R.layout.frag_incall_voice, viewGroup, false);
+    contactGridManager =
+        new ContactGridManager(
+            view,
+            (ImageView) view.findViewById(R.id.contactgrid_avatar),
+            getResources().getDimensionPixelSize(R.dimen.incall_avatar_size),
+            true /* showAnonymousAvatar */);
+
+    tabLayout = (TabLayout) view.findViewById(R.id.incall_tab_dots);
+    pager = (ViewPager) view.findViewById(R.id.incall_pager);
+
+    endCallButton = view.findViewById(R.id.incall_end_call);
+    endCallButton.setOnClickListener(this);
+
+    if (ContextCompat.checkSelfPermission(getContext(), permission.READ_PHONE_STATE)
+        != PackageManager.PERMISSION_GRANTED) {
+      voiceNetworkType = TelephonyManager.NETWORK_TYPE_UNKNOWN;
+    } else {
+
+      voiceNetworkType =
+          VERSION.SDK_INT >= VERSION_CODES.N
+              ? getContext().getSystemService(TelephonyManager.class).getVoiceNetworkType()
+              : TelephonyManager.NETWORK_TYPE_UNKNOWN;
+    }
+    phoneType = getContext().getSystemService(TelephonyManager.class).getPhoneType();
+    return view;
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    inCallButtonUiDelegate.refreshMuteState();
+    inCallScreenDelegate.onInCallScreenResumed();
+  }
+
+  @Override
+  public void onViewCreated(@NonNull View view, @Nullable Bundle bundle) {
+    LogUtil.i("InCallFragment.onViewCreated", null);
+    super.onViewCreated(view, bundle);
+    inCallScreenDelegate =
+        FragmentUtils.getParent(this, InCallScreenDelegateFactory.class).newInCallScreenDelegate();
+    Assert.isNotNull(inCallScreenDelegate);
+
+    buttonControllers.add(new ButtonController.MuteButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.SpeakerButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.DialpadButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.HoldButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.AddCallButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.SwapButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(new ButtonController.MergeButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(
+        new ButtonController.UpgradeToVideoButtonController(inCallButtonUiDelegate));
+    buttonControllers.add(
+        new ButtonController.ManageConferenceButtonController(inCallScreenDelegate));
+    buttonControllers.add(
+        new ButtonController.SwitchToSecondaryButtonController(inCallScreenDelegate));
+
+    inCallScreenDelegate.onInCallScreenDelegateInit(this);
+    inCallScreenDelegate.onInCallScreenReady();
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    inCallScreenDelegate.onInCallScreenUnready();
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    inCallButtonUiDelegate.onSaveInstanceState(outState);
+  }
+
+  @Override
+  public void onClick(View view) {
+    if (view == endCallButton) {
+      LogUtil.i("InCallFragment.onClick", "end call button clicked");
+      inCallScreenDelegate.onEndCallClicked();
+    } else {
+      LogUtil.e("InCallFragment.onClick", "unknown view: " + view);
+      Assert.fail();
+    }
+  }
+
+  @Override
+  public void setPrimary(@NonNull PrimaryInfo primaryInfo) {
+    LogUtil.i("InCallFragment.setPrimary", primaryInfo.toString());
+    if (adapter == null) {
+      initAdapter(primaryInfo.multimediaData);
+    }
+    contactGridManager.setPrimary(primaryInfo);
+
+    if (primaryInfo.shouldShowLocation) {
+      // Hide the avatar to make room for location
+      contactGridManager.setAvatarHidden(true);
+
+      // Need to widen the contact grid to fit location information
+      View contactGridView = getView().findViewById(R.id.incall_contact_grid);
+      ViewGroup.LayoutParams params = contactGridView.getLayoutParams();
+      if (params instanceof ViewGroup.MarginLayoutParams) {
+        ((ViewGroup.MarginLayoutParams) params).setMarginStart(0);
+        ((ViewGroup.MarginLayoutParams) params).setMarginEnd(0);
+      }
+      contactGridView.setLayoutParams(params);
+
+      // Need to let the dialpad move up a little further when location info is being shown
+      View dialpadView = getView().findViewById(R.id.incall_dialpad_container);
+      params = dialpadView.getLayoutParams();
+      if (params instanceof RelativeLayout.LayoutParams) {
+        ((RelativeLayout.LayoutParams) params).removeRule(RelativeLayout.BELOW);
+      }
+      dialpadView.setLayoutParams(params);
+    }
+  }
+
+  private void initAdapter(MultimediaData multimediaData) {
+    adapter = new InCallPagerAdapter(getChildFragmentManager(), multimediaData);
+    pager.setAdapter(adapter);
+
+    if (adapter.getCount() > 1) {
+      tabLayout.setVisibility(pager.getVisibility());
+      tabLayout.setupWithViewPager(pager, true);
+      if (!stateRestored) {
+        new Handler()
+            .postDelayed(
+                new Runnable() {
+                  @Override
+                  public void run() {
+                    // In order to prevent user confusion and educate the user on our UI, we animate
+                    // the view pager to the button grid after 2 seconds show them when the UI is
+                    // that they are more familiar with.
+                    pager.setCurrentItem(adapter.getButtonGridPosition());
+                  }
+                },
+                2000);
+      }
+    } else {
+      tabLayout.setVisibility(View.GONE);
+    }
+  }
+
+  @Override
+  public void setSecondary(@NonNull SecondaryInfo secondaryInfo) {
+    LogUtil.i("InCallFragment.setSecondary", secondaryInfo.toString());
+    getButtonController(InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY)
+        .setEnabled(secondaryInfo.shouldShow);
+    getButtonController(InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY)
+        .setAllowed(secondaryInfo.shouldShow);
+    updateButtonStates();
+
+    if (!isAdded()) {
+      savedSecondaryInfo = secondaryInfo;
+      return;
+    }
+    savedSecondaryInfo = null;
+    FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
+    Fragment oldBanner = getChildFragmentManager().findFragmentById(R.id.incall_on_hold_banner);
+    if (secondaryInfo.shouldShow) {
+      transaction.replace(R.id.incall_on_hold_banner, OnHoldFragment.newInstance(secondaryInfo));
+    } else {
+      if (oldBanner != null) {
+        transaction.remove(oldBanner);
+      }
+    }
+    transaction.setCustomAnimations(R.anim.abc_slide_in_top, R.anim.abc_slide_out_top);
+    transaction.commitAllowingStateLoss();
+  }
+
+  @Override
+  public void setCallState(@NonNull PrimaryCallState primaryCallState) {
+    LogUtil.i("InCallFragment.setCallState", primaryCallState.toString());
+    contactGridManager.setCallState(primaryCallState);
+    buttonChooser =
+        ButtonChooserFactory.newButtonChooser(voiceNetworkType, primaryCallState.isWifi, phoneType);
+    updateButtonStates();
+  }
+
+  @Override
+  public void setEndCallButtonEnabled(boolean enabled, boolean animate) {
+    if (endCallButton != null) {
+      endCallButton.setEnabled(enabled);
+    }
+  }
+
+  @Override
+  public void showManageConferenceCallButton(boolean visible) {
+    getButtonController(InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE).setAllowed(visible);
+    getButtonController(InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE).setEnabled(visible);
+    updateButtonStates();
+  }
+
+  @Override
+  public boolean isManageConferenceVisible() {
+    return getButtonController(InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE).isAllowed();
+  }
+
+  @Override
+  public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+    contactGridManager.dispatchPopulateAccessibilityEvent(event);
+  }
+
+  @Override
+  public void showNoteSentToast() {
+    LogUtil.i("InCallFragment.showNoteSentToast", null);
+    Toast.makeText(getContext(), R.string.incall_note_sent, Toast.LENGTH_LONG).show();
+  }
+
+  @Override
+  public void updateInCallScreenColors() {}
+
+  @Override
+  public void onInCallScreenDialpadVisibilityChange(boolean isShowing) {
+    LogUtil.i("InCallFragment.onInCallScreenDialpadVisibilityChange", "isShowing: " + isShowing);
+    // Take note that the dialpad button isShowing
+    getButtonController(InCallButtonIds.BUTTON_DIALPAD).setChecked(isShowing);
+
+    // This check is needed because there is a race condition where we attempt to update
+    // ButtonGridFragment before it is ready, so we check whether it is ready first and once it is
+    // ready, #onButtonGridCreated will mark the dialpad button as isShowing.
+    if (inCallButtonGridFragment != null) {
+      // Update the Android Button's state to isShowing.
+      inCallButtonGridFragment.onInCallScreenDialpadVisibilityChange(isShowing);
+    }
+  }
+
+  @Override
+  public int getAnswerAndDialpadContainerResourceId() {
+    return R.id.incall_dialpad_container;
+  }
+
+  @Override
+  public Fragment getInCallScreenFragment() {
+    return this;
+  }
+
+  @Override
+  public void showButton(@InCallButtonIds int buttonId, boolean show) {
+    LogUtil.v(
+        "InCallFragment.showButton",
+        "buttionId: %s, show: %b",
+        InCallButtonIdsExtension.toString(buttonId),
+        show);
+    if (isSupportedButton(buttonId)) {
+      getButtonController(buttonId).setAllowed(show);
+    }
+  }
+
+  @Override
+  public void enableButton(@InCallButtonIds int buttonId, boolean enable) {
+    LogUtil.v(
+        "InCallFragment.enableButton",
+        "buttonId: %s, enable: %b",
+        InCallButtonIdsExtension.toString(buttonId),
+        enable);
+    if (isSupportedButton(buttonId)) {
+      getButtonController(buttonId).setEnabled(enable);
+    }
+  }
+
+  @Override
+  public void setEnabled(boolean enabled) {
+    LogUtil.v("InCallFragment.setEnabled", "enabled: " + enabled);
+    for (ButtonController buttonController : buttonControllers) {
+      buttonController.setEnabled(enabled);
+    }
+  }
+
+  @Override
+  public void setHold(boolean value) {
+    getButtonController(InCallButtonIds.BUTTON_HOLD).setChecked(value);
+  }
+
+  @Override
+  public void setCameraSwitched(boolean isBackFacingCamera) {}
+
+  @Override
+  public void setVideoPaused(boolean isPaused) {}
+
+  @Override
+  public void setAudioState(CallAudioState audioState) {
+    LogUtil.i("InCallFragment.setAudioState", "audioState: " + audioState);
+    ((SpeakerButtonController) getButtonController(InCallButtonIds.BUTTON_AUDIO))
+        .setAudioState(audioState);
+    getButtonController(InCallButtonIds.BUTTON_MUTE).setChecked(audioState.isMuted());
+  }
+
+  @Override
+  public void updateButtonStates() {
+    // When the incall screen is ready, this method is called from #setSecondary, even though the
+    // incall button ui is not ready yet. This method is called again once the incall button ui is
+    // ready though, so this operation is safe and will be executed asap.
+    if (inCallButtonGridFragment == null) {
+      return;
+    }
+    int numVisibleButtons =
+        inCallButtonGridFragment.updateButtonStates(
+            buttonControllers, buttonChooser, voiceNetworkType, phoneType);
+
+    int visibility = numVisibleButtons == 0 ? View.GONE : View.VISIBLE;
+    pager.setVisibility(visibility);
+    if (adapter != null && adapter.getCount() > 1) {
+      tabLayout.setVisibility(visibility);
+    }
+  }
+
+  @Override
+  public void updateInCallButtonUiColors() {}
+
+  @Override
+  public Fragment getInCallButtonUiFragment() {
+    return this;
+  }
+
+  @Override
+  public void showAudioRouteSelector() {
+    AudioRouteSelectorDialogFragment.newInstance(inCallButtonUiDelegate.getCurrentAudioState())
+        .show(getChildFragmentManager(), null);
+  }
+
+  @Override
+  public void onAudioRouteSelected(int audioRoute) {
+    inCallButtonUiDelegate.setAudioRoute(audioRoute);
+  }
+
+  @NonNull
+  @Override
+  public ButtonController getButtonController(@InCallButtonIds int id) {
+    for (ButtonController buttonController : buttonControllers) {
+      if (buttonController.getInCallButtonId() == id) {
+        return buttonController;
+      }
+    }
+    Assert.fail();
+    return null;
+  }
+
+  @Override
+  public void onButtonGridCreated(InCallButtonGridFragment inCallButtonGridFragment) {
+    LogUtil.i("InCallFragment.onButtonGridCreated", "InCallUiReady");
+    this.inCallButtonGridFragment = inCallButtonGridFragment;
+    inCallButtonUiDelegate.onInCallButtonUiReady(this);
+    updateButtonStates();
+  }
+
+  @Override
+  public void onButtonGridDestroyed() {
+    LogUtil.i("InCallFragment.onButtonGridCreated", "InCallUiUnready");
+    inCallButtonUiDelegate.onInCallButtonUiUnready();
+    this.inCallButtonGridFragment = null;
+  }
+
+  @Override
+  public boolean isShowingLocationUi() {
+    Fragment fragment = getChildFragmentManager().findFragmentById(R.id.incall_location_holder);
+    return fragment != null && fragment.isVisible();
+  }
+
+  @Override
+  public void showLocationUi(@Nullable Fragment locationUi) {
+    boolean isShowing = isShowingLocationUi();
+    if (!isShowing && locationUi != null) {
+      // Show the location fragment.
+      getChildFragmentManager()
+          .beginTransaction()
+          .replace(R.id.incall_location_holder, locationUi)
+          .commitAllowingStateLoss();
+    } else if (isShowing && locationUi == null) {
+      // Hide the location fragment
+      Fragment fragment = getChildFragmentManager().findFragmentById(R.id.incall_location_holder);
+      getChildFragmentManager().beginTransaction().remove(fragment).commitAllowingStateLoss();
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/InCallPagerAdapter.java b/java/com/android/incallui/incall/impl/InCallPagerAdapter.java
new file mode 100644
index 0000000..50eb4c8
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/InCallPagerAdapter.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2017 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.incall.impl;
+
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentPagerAdapter;
+import android.text.TextUtils;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.incallui.sessiondata.MultimediaFragment;
+
+/** View pager adapter for in call ui. */
+public class InCallPagerAdapter extends FragmentPagerAdapter {
+
+  @Nullable private final MultimediaData attachments;
+
+  public InCallPagerAdapter(FragmentManager fragmentManager, MultimediaData attachments) {
+    super(fragmentManager);
+    this.attachments = attachments;
+  }
+
+  @Override
+  public Fragment getItem(int position) {
+    if (position == getButtonGridPosition()) {
+      return InCallButtonGridFragment.newInstance();
+    } else {
+      // TODO: handle fragment invalidation for when the data changes.
+      return MultimediaFragment.newInstance(attachments, true, false);
+    }
+  }
+
+  @Override
+  public int getCount() {
+    if (attachments != null
+        && (!TextUtils.isEmpty(attachments.getSubject()) || attachments.hasImageData())) {
+      return 2;
+    }
+    return 1;
+  }
+
+  public int getButtonGridPosition() {
+    return getCount() - 1;
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/MappedButtonConfig.java b/java/com/android/incallui/incall/impl/MappedButtonConfig.java
new file mode 100644
index 0000000..ecdb5df
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/MappedButtonConfig.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2016 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.incall.impl;
+
+import android.support.annotation.NonNull;
+import android.support.v4.util.ArrayMap;
+import android.util.ArraySet;
+import com.android.dialer.common.Assert;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import com.android.incallui.incall.protocol.InCallButtonIdsExtension;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Determines logical button slot and ordering based on a provided mapping.
+ *
+ * <p>The provided mapping is declared with the following pieces of information: key, the {@link
+ * InCallButtonIds} for which the mapping applies; {@link MappingInfo#getSlot()}, the arbitrarily
+ * indexed slot into which the InCallButtonId desires to be placed; {@link
+ * MappingInfo#getSlotOrder()}, the slotOrder, used to choose the correct InCallButtonId when
+ * multiple desire to be placed in the same slot; and {@link MappingInfo#getConflictOrder()}, the
+ * conflictOrder, used to determine the overall order for InCallButtonIds that weren't chosen for
+ * their desired slot.
+ */
+@Immutable
+final class MappedButtonConfig {
+
+  @NonNull private final Map<Integer, MappingInfo> mapping;
+  @NonNull private final List<Integer> orderedMappedSlots;
+
+  /**
+   * Creates this MappedButtonConfig with the given mapping of {@link InCallButtonIds} to their
+   * corresponding slots and order.
+   *
+   * @param mapping the mapping.
+   */
+  public MappedButtonConfig(@NonNull Map<Integer, MappingInfo> mapping) {
+    this.mapping = new ArrayMap<>();
+    this.mapping.putAll(Assert.isNotNull(mapping));
+    this.orderedMappedSlots = findOrderedMappedSlots();
+  }
+
+  private List<Integer> findOrderedMappedSlots() {
+    Set<Integer> slots = new ArraySet<>();
+    for (Entry<Integer, MappingInfo> entry : mapping.entrySet()) {
+      slots.add(entry.getValue().getSlot());
+    }
+    List<Integer> orderedSlots = new ArrayList<>(slots);
+    Collections.sort(orderedSlots);
+    return orderedSlots;
+  }
+
+  /** Returns an immutable list of the slots for which this class has button mapping. */
+  @NonNull
+  public List<Integer> getOrderedMappedSlots() {
+    if (mapping.isEmpty()) {
+      return Collections.emptyList();
+    }
+    return Collections.unmodifiableList(orderedMappedSlots);
+  }
+
+  /**
+   * Returns a list of {@link InCallButtonIds} that are configured to be placed in the given ui
+   * slot. The slot can be based from any index, as long as it matches the provided mapping.
+   */
+  @NonNull
+  public List<Integer> getButtonsForSlot(int slot) {
+    List<Integer> buttons = new ArrayList<>();
+    for (Entry<Integer, MappingInfo> entry : mapping.entrySet()) {
+      if (entry.getValue().getSlot() == slot) {
+        buttons.add(entry.getKey());
+      }
+    }
+    return buttons;
+  }
+
+  /**
+   * Returns a {@link Comparator} capable of ordering {@link InCallButtonIds} that are configured to
+   * be placed in the same slot. InCallButtonIds are sorted based on the natural ordering of {@link
+   * MappingInfo#getSlotOrder()}.
+   *
+   * <p>Note: the returned Comparator's compare method will throw an {@link
+   * IllegalArgumentException} if called with InCallButtonIds that have no configuration or are not
+   * to be placed in the same slot.
+   */
+  @NonNull
+  public Comparator<Integer> getSlotComparator() {
+    return new Comparator<Integer>() {
+      @Override
+      public int compare(Integer lhs, Integer rhs) {
+        MappingInfo lhsInfo = lookupMappingInfo(lhs);
+        MappingInfo rhsInfo = lookupMappingInfo(rhs);
+        if (lhsInfo.getSlot() != rhsInfo.getSlot()) {
+          throw new IllegalArgumentException("lhs and rhs don't go in the same slot");
+        }
+        return lhsInfo.getSlotOrder() - rhsInfo.getSlotOrder();
+      }
+    };
+  }
+
+  /**
+   * Returns a {@link Comparator} capable of ordering {@link InCallButtonIds} by their conflict
+   * score. This comparator should be used when multiple InCallButtonIds could have been shown in
+   * the same slot. InCallButtonIds are sorted based on the natural ordering of {@link
+   * MappingInfo#getConflictOrder()}.
+   *
+   * <p>Note: the returned Comparator's compare method will throw an {@link
+   * IllegalArgumentException} if called with InCallButtonIds that have no configuration.
+   */
+  @NonNull
+  public Comparator<Integer> getConflictComparator() {
+    return new Comparator<Integer>() {
+      @Override
+      public int compare(Integer lhs, Integer rhs) {
+        MappingInfo lhsInfo = lookupMappingInfo(lhs);
+        MappingInfo rhsInfo = lookupMappingInfo(rhs);
+        return lhsInfo.getConflictOrder() - rhsInfo.getConflictOrder();
+      }
+    };
+  }
+
+  @NonNull
+  private MappingInfo lookupMappingInfo(@InCallButtonIds int button) {
+    MappingInfo info = mapping.get(button);
+    if (info == null) {
+      throw new IllegalArgumentException(
+          "Unknown InCallButtonId: " + InCallButtonIdsExtension.toString(button));
+    }
+    return info;
+  }
+
+  /** Holds information about button mapping. */
+
+  abstract static class MappingInfo {
+
+    /** The Ui slot into which a given button desires to be placed. */
+    public abstract int getSlot();
+
+    /**
+     * Returns an integer used to determine which button is chosen for a slot when multiple buttons
+     * desire to be placed in the same slot. Follows from the natural ordering of integers, i.e. a
+     * lower slotOrder results in the button being chosen.
+     */
+    public abstract int getSlotOrder();
+
+    /**
+     * Returns an integer used to determine the order in which buttons that weren't chosen for their
+     * desired slot are placed into the Ui. Follows from the natural ordering of integers, i.e. a
+     * lower conflictOrder results in the button being chosen.
+     */
+    public abstract int getConflictOrder();
+
+    static Builder builder(int slot) {
+      return new AutoValue_MappedButtonConfig_MappingInfo.Builder()
+          .setSlot(slot)
+          .setSlotOrder(Integer.MAX_VALUE)
+          .setConflictOrder(Integer.MAX_VALUE);
+    }
+
+    /** Class used to build instances of {@link MappingInfo}. */
+
+    abstract static class Builder {
+      public abstract Builder setSlot(int slot);
+
+      public abstract Builder setSlotOrder(int slotOrder);
+
+      public abstract Builder setConflictOrder(int conflictOrder);
+
+      public abstract MappingInfo build();
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/impl/res/animator/incall_button_elevation.xml b/java/com/android/incallui/incall/impl/res/animator/incall_button_elevation.xml
new file mode 100644
index 0000000..69215ad
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/animator/incall_button_elevation.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+    android:state_enabled="true"
+    android:state_pressed="true">
+    <objectAnimator
+      android:duration="@android:integer/config_shortAnimTime"
+      android:propertyName="translationZ"
+      android:valueTo="8dp"
+      android:valueType="floatType"/>
+
+  </item>
+  <item
+    android:state_checked="true"
+    android:state_enabled="true"
+    android:state_pressed="false">
+    <objectAnimator
+      android:duration="@android:integer/config_shortAnimTime"
+      android:propertyName="translationZ"
+      android:valueTo="4dp"
+      android:valueType="floatType"/>
+
+  </item>
+  <item>
+    <objectAnimator
+      android:duration="@android:integer/config_shortAnimTime"
+      android:propertyName="translationZ"
+      android:valueTo="0dp"
+      android:valueType="floatType"/>
+  </item>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/color/incall_button_icon.xml b/java/com/android/incallui/incall/impl/res/color/incall_button_icon.xml
new file mode 100644
index 0000000..6d85567
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/color/incall_button_icon.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="#FF01579B" android:state_checked="true"/>
+  <item android:color="#FFFFFFFF"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable-mdpi/ic_addcall_white.png b/java/com/android/incallui/incall/impl/res/drawable-mdpi/ic_addcall_white.png
new file mode 100644
index 0000000..a608052
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable-mdpi/ic_addcall_white.png
Binary files differ
diff --git a/java/com/android/incallui/incall/impl/res/drawable-xhdpi/ic_addcall_white.png b/java/com/android/incallui/incall/impl/res/drawable-xhdpi/ic_addcall_white.png
new file mode 100644
index 0000000..d2a843c
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable-xhdpi/ic_addcall_white.png
Binary files differ
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_button_background.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background.xml
new file mode 100644
index 0000000..c8bd295
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item>
+    <selector>
+      <item
+        android:drawable="@drawable/incall_button_background_checked"
+        android:state_checked="true"/>
+      <item android:drawable="@drawable/incall_button_background_unchecked"/>
+    </selector>
+  </item>
+  <item>
+    <ripple android:color="@color/incall_button_ripple">
+      <item
+        android:id="@android:id/mask"
+        android:gravity="center">
+        <shape android:shape="oval">
+          <solid android:color="@android:color/white"/>
+        </shape>
+      </item>
+    </ripple>
+  </item>
+</layer-list>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_checked.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_checked.xml
new file mode 100644
index 0000000..73c6947
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_checked.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/incall_button_white"/>
+</shape>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_more.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_more.xml
new file mode 100644
index 0000000..6755f0f
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_more.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item>
+    <selector>
+      <item
+        android:drawable="@drawable/incall_button_background_checked"
+        android:state_checked="true"/>
+      <item android:drawable="@drawable/incall_button_background_unchecked"/>
+    </selector>
+  </item>
+  <item>
+    <ripple android:color="@color/incall_button_ripple">
+      <item
+        android:id="@android:id/mask"
+        android:gravity="center">
+        <shape android:shape="oval">
+          <solid android:color="@android:color/white"/>
+        </shape>
+      </item>
+    </ripple>
+  </item>
+
+  <!-- This adds a little down arrow to indicate that the button will pop up a menu. Use an explicit
+    <bitmap> to avoid scaling the icon up to the full size of the button. -->
+  <item>
+    <bitmap
+      android:gravity="end"
+      android:src="@drawable/quantum_ic_arrow_drop_down_white_18"/>
+  </item>
+</layer-list>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_unchecked.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_unchecked.xml
new file mode 100644
index 0000000..f7ffa4d
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_button_background_unchecked.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@android:color/transparent"/>
+</shape>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml
new file mode 100644
index 0000000..4daf052
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/ic_addcall_white"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml
new file mode 100644
index 0000000..091142b
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/quantum_ic_dialpad_white_36"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml
new file mode 100644
index 0000000..a48e4c4
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/quantum_ic_group_white_36"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml
new file mode 100644
index 0000000..61d7555
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/quantum_ic_call_merge_white_36"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml
new file mode 100644
index 0000000..6aa8ab8
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/quantum_ic_pause_white_36"/>
+</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml
new file mode 100644
index 0000000..6a55b35
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item>
+    <shape
+      android:innerRadius="0dp"
+      android:shape="ring"
+      android:thickness="2dp"
+      android:useLevel="false">
+      <solid android:color="@android:color/darker_gray"/>
+    </shape>
+  </item>
+</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml
new file mode 100644
index 0000000..fc673c6
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item>
+    <shape
+      android:innerRadius="0dp"
+      android:shape="ring"
+      android:thickness="4dp"
+      android:useLevel="false">
+      <solid android:color="@color/background_dialer_white"/>
+    </shape>
+  </item>
+</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml
new file mode 100644
index 0000000..303a49b
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@drawable/tab_indicator_selected"
+    android:state_selected="true"/>
+  <item android:drawable="@drawable/tab_indicator_default"/>
+</selector>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml b/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml
new file mode 100644
index 0000000..335ac8a
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+  <TextView
+    android:id="@+id/subject"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_margin="8dp"
+    android:padding="8dp"
+    android:textSize="24sp"
+    android:textColor="@color/primary_text_color"
+    android:background="@color/background_dialer_white"/>
+</FrameLayout>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/layout/frag_incall_voice.xml b/java/com/android/incallui/incall/impl/res/layout/frag_incall_voice.xml
new file mode 100644
index 0000000..9b95046
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/layout/frag_incall_voice.xml
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+
+  <RelativeLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <LinearLayout
+      android:id="@id/incall_contact_grid"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:layout_marginTop="12dp"
+      android:layout_marginStart="@dimen/incall_window_margin_horizontal"
+      android:layout_marginEnd="@dimen/incall_window_margin_horizontal"
+      android:gravity="center_horizontal"
+      android:orientation="vertical">
+
+      <ImageView
+        android:id="@id/contactgrid_avatar"
+        android:layout_width="@dimen/incall_avatar_size"
+        android:layout_height="@dimen/incall_avatar_size"
+        android:layout_marginBottom="8dp"
+        android:elevation="2dp"/>
+
+      <include
+        layout="@layout/incall_contactgrid_top_row"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"/>
+
+      <!-- We have to keep deprecated singleLine to allow long text being truncated with ellipses.
+                 b/31396406 -->
+      <com.android.incallui.autoresizetext.AutoResizeTextView
+        android:id="@id/contactgrid_contact_name"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="4dp"
+        android:singleLine="true"
+        android:textAppearance="@style/Dialer.Incall.TextAppearance.Large"
+        app:autoResizeText_minTextSize="28sp"
+        tools:text="Jake Peralta"
+        tools:ignore="Deprecated"/>
+
+      <include
+        layout="@layout/incall_contactgrid_bottom_row"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"/>
+
+      <FrameLayout
+        android:id="@+id/incall_location_holder"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+    </LinearLayout>
+
+    <android.support.v4.view.ViewPager
+      android:id="@+id/incall_pager"
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:layout_above="@+id/incall_tab_dots"
+      android:layout_below="@+id/incall_contact_grid"
+      android:layout_centerHorizontal="true"/>
+
+    <android.support.design.widget.TabLayout
+      android:id="@+id/incall_tab_dots"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:layout_above="@+id/incall_end_call"
+      android:visibility="gone"
+      app:tabBackground="@drawable/tab_selector"
+      app:tabGravity="center"
+      app:tabIndicatorHeight="0dp"/>
+
+    <FrameLayout
+      android:id="@+id/incall_dialpad_container"
+      style="@style/DialpadContainer"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:layout_alignParentBottom="true"
+      tools:background="@android:color/white"
+      tools:visibility="gone"/>
+    <ImageButton
+      android:id="@+id/incall_end_call"
+      style="@style/Incall.Button.End"
+      android:layout_marginTop="16dp"
+      android:layout_marginBottom="36dp"
+      android:layout_alignParentBottom="true"
+      android:layout_centerHorizontal="true"
+      android:contentDescription="@string/incall_content_description_end_call"/>
+  </RelativeLayout>
+
+  <FrameLayout
+    android:id="@id/incall_on_hold_banner"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_gravity="top"/>
+</FrameLayout>
diff --git a/java/com/android/incallui/incall/impl/res/layout/incall_button_grid.xml b/java/com/android/incallui/incall/impl/res/layout/incall_button_grid.xml
new file mode 100644
index 0000000..59e9944
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/layout/incall_button_grid.xml
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="wrap_content"
+  android:layout_marginStart="@dimen/incall_window_margin_horizontal"
+  android:layout_marginEnd="@dimen/incall_window_margin_horizontal"
+  tools:showIn="@layout/frag_incall_voice">
+  <GridLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:columnCount="3"
+    android:orientation="horizontal">
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_first_button"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:enabled="false"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_mute"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_second_button"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:enabled="false"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_dialpad"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_third_button"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:enabled="false"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_speaker"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_fourth_button"
+      android:layout_marginTop="@dimen/incall_button_vertical_padding"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_add_call"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_fifth_button"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:layout_marginTop="@dimen/incall_button_vertical_padding"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_hold"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+    <com.android.incallui.incall.impl.CheckableLabeledButton
+      android:id="@+id/incall_sixth_button"
+      android:layout_width="0dp"
+      android:layout_columnWeight="1"
+      android:layout_marginTop="@dimen/incall_button_vertical_padding"
+      android:gravity="center"
+      app:incall_labelText="@string/incall_label_videocall"
+      tools:background="#FFFF0000"
+      tools:layout_height="@dimen/tools_button_height"
+      tools:layout_width="@dimen/incall_labeled_button_size"/>
+  </GridLayout>
+</FrameLayout>
diff --git a/java/com/android/incallui/incall/impl/res/values-h320dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-h320dp/dimens.xml
new file mode 100644
index 0000000..1fe0c4d
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-h320dp/dimens.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <bool name="incall_dialpad_allowed">true</bool>
+  <integer name="incall_num_rows">1</integer>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml
new file mode 100644
index 0000000..aac42c5
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="incall_avatar_size">64dp</dimen>
+  <dimen name="incall_avatar_marginBottom">8dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-h480dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-h480dp/dimens.xml
new file mode 100644
index 0000000..ef1a800
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-h480dp/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <integer name="incall_num_rows">2</integer>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-h580dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-h580dp/dimens.xml
new file mode 100644
index 0000000..1f37cd5
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-h580dp/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="incall_avatar_size">88dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-h580dp/styles.xml b/java/com/android/incallui/incall/impl/res/values-h580dp/styles.xml
new file mode 100644
index 0000000..b58ef48
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-h580dp/styles.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+
+  <style name="DialpadContainer">
+    <item name="android:layout_below">@id/incall_contact_grid</item>
+    <item name="android:layout_marginTop">8dp</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-w260dp-h520dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-w260dp-h520dp/dimens.xml
new file mode 100644
index 0000000..e73eb93
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-w260dp-h520dp/dimens.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="incall_button_horizontal_padding">16dp</dimen>
+  <dimen name="incall_button_vertical_padding">16dp</dimen>
+  <dimen name="incall_labeled_button_size">64dp</dimen>
+  <dimen name="tools_button_height">92dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-w300dp-h540dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-w300dp-h540dp/dimens.xml
new file mode 100644
index 0000000..502ae72
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values-w300dp-h540dp/dimens.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="incall_button_horizontal_padding">32dp</dimen>
+  <dimen name="incall_button_vertical_padding">32dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values/attrs.xml b/java/com/android/incallui/incall/impl/res/values/attrs.xml
new file mode 100644
index 0000000..ed1b2a8
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values/attrs.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <declare-styleable name="CheckableLabeledButton">
+    <attr format="reference" name="incall_icon"/>
+    <attr format="string|reference" name="incall_labelText"/>
+    <attr name="android:enabled"/>
+  </declare-styleable>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values/dimens.xml b/java/com/android/incallui/incall/impl/res/values/dimens.xml
new file mode 100644
index 0000000..2497887
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values/dimens.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="incall_button_label_margin">8dp</dimen>
+  <dimen name="incall_button_elevation">0dp</dimen>
+  <dimen name="incall_end_call_spacing">116dp</dimen>
+  <dimen name="incall_button_padding">4dp</dimen>
+  <dimen name="incall_button_horizontal_padding">8dp</dimen>
+  <dimen name="incall_button_vertical_padding">8dp</dimen>
+  <dimen name="incall_avatar_size">0dp</dimen>
+  <dimen name="incall_avatar_marginBottom">0dp</dimen>
+  <dimen name="incall_labeled_button_size">48dp</dimen>
+  <dimen name="tools_button_height">76dp</dimen>
+  <dimen name="incall_window_margin_horizontal">24dp</dimen>
+
+  <bool name="incall_dialpad_allowed">false</bool>
+  <integer name="incall_num_rows">0</integer>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values/ids.xml b/java/com/android/incallui/incall/impl/res/values/ids.xml
new file mode 100644
index 0000000..e1368f9
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values/ids.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <item name="incall_on_hold_banner" type="id"/>
+  <item name="incall_button_grid" type="id"/>
+  <item name="incall_contact_grid" type="id"/>
+</resources>
diff --git a/java/com/android/incallui/incall/impl/res/values/strings.xml b/java/com/android/incallui/incall/impl/res/values/strings.xml
new file mode 100644
index 0000000..054ca96
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values/strings.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <!-- Button shown during a phone call to upgrade to video.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_videocall">Video call</string>
+
+  <!-- Button shown during a phone call to put the call on hold.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_hold">Hold</string>
+
+  <!-- Button shown during a phone call to add a new phone call.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_add_call">Add call</string>
+
+  <!-- Button shown during a phone call to mute the microphone.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_mute">Mute</string>
+
+  <!-- Button shown during a phone call to show the dialpad.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_dialpad">Keypad</string>
+
+  <!-- Button shown during a phone to route audio from earpiece to speaker phone.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_speaker">Speaker</string>
+
+  <!-- Talkback text for speaker button status. [CHAR LIMIT=12] -->
+  <string name="incall_talkback_speaker_on">, is on</string>
+
+  <!-- Talkback text for speaker button status. [CHAR LIMIT=12] -->
+  <string name="incall_talkback_speaker_off">, is Off</string>
+
+  <!-- Button shown during a phone to merge two ongoing calls.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_merge">Merge</string>
+
+  <!-- Button shown during a phone to show the manage conference call screen.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_manage">Manage</string>
+
+  <string name="a11y_description_incall_label_manage_content">Manage callers</string>
+
+  <!-- Button shown during a phone to swap from the foreground call to the background call.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_swap">Swap</string>
+
+  <!-- Button shown during a phone to switch the audio route.
+     [CHAR LIMIT=12] -->
+  <string name="incall_label_audio">Sound</string>
+
+  <!-- Used to inform the user that the note associated with an outgoing call has been sent.
+       [CHAR LIMIT=32] -->
+  <string name="incall_note_sent">Note sent</string>
+
+</resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/values/styles.xml b/java/com/android/incallui/incall/impl/res/values/styles.xml
new file mode 100644
index 0000000..2392574
--- /dev/null
+++ b/java/com/android/incallui/incall/impl/res/values/styles.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+
+  <style name="DialpadContainer">
+    <item name="android:layout_alignParentTop">true</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/incall/protocol/ContactPhotoType.java b/java/com/android/incallui/incall/protocol/ContactPhotoType.java
new file mode 100644
index 0000000..d79b755
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/ContactPhotoType.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.support.annotation.IntDef;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/** Types of contact photos we can have. */
+@Retention(RetentionPolicy.SOURCE)
+@IntDef({
+  ContactPhotoType.DEFAULT_PLACEHOLDER,
+  ContactPhotoType.BUSINESS,
+  ContactPhotoType.CONTACT,
+})
+public @interface ContactPhotoType {
+
+  int DEFAULT_PLACEHOLDER = 0;
+  int BUSINESS = 1;
+  int CONTACT = 2;
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallButtonIds.java b/java/com/android/incallui/incall/protocol/InCallButtonIds.java
new file mode 100644
index 0000000..50ebc64
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallButtonIds.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.incall.protocol;
+
+import android.support.annotation.IntDef;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/** Ids for buttons in the in call UI. */
+@Retention(RetentionPolicy.SOURCE)
+@IntDef({
+  InCallButtonIds.BUTTON_AUDIO,
+  InCallButtonIds.BUTTON_MUTE,
+  InCallButtonIds.BUTTON_DIALPAD,
+  InCallButtonIds.BUTTON_HOLD,
+  InCallButtonIds.BUTTON_SWAP,
+  InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO,
+  InCallButtonIds.BUTTON_SWITCH_CAMERA,
+  InCallButtonIds.BUTTON_DOWNGRADE_TO_AUDIO,
+  InCallButtonIds.BUTTON_ADD_CALL,
+  InCallButtonIds.BUTTON_MERGE,
+  InCallButtonIds.BUTTON_PAUSE_VIDEO,
+  InCallButtonIds.BUTTON_MANAGE_VIDEO_CONFERENCE,
+  InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
+  InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY,
+  InCallButtonIds.BUTTON_COUNT,
+})
+public @interface InCallButtonIds {
+
+  int BUTTON_AUDIO = 0;
+  int BUTTON_MUTE = 1;
+  int BUTTON_DIALPAD = 2;
+  int BUTTON_HOLD = 3;
+  int BUTTON_SWAP = 4;
+  int BUTTON_UPGRADE_TO_VIDEO = 5;
+  int BUTTON_SWITCH_CAMERA = 6;
+  int BUTTON_DOWNGRADE_TO_AUDIO = 7;
+  int BUTTON_ADD_CALL = 8;
+  int BUTTON_MERGE = 9;
+  int BUTTON_PAUSE_VIDEO = 10;
+  int BUTTON_MANAGE_VIDEO_CONFERENCE = 11;
+  int BUTTON_MANAGE_VOICE_CONFERENCE = 12;
+  int BUTTON_SWITCH_TO_SECONDARY = 13;
+  int BUTTON_COUNT = 14;
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallButtonIdsExtension.java b/java/com/android/incallui/incall/protocol/InCallButtonIdsExtension.java
new file mode 100644
index 0000000..6d802e3
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallButtonIdsExtension.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+/** Utility class for {@link InCallButtonIds}. */
+public class InCallButtonIdsExtension {
+
+  /**
+   * Converts the given {@link InCallButtonIds} to a human readable string.
+   *
+   * @param id the id to convert.
+   * @return the human readable string.
+   */
+  public static String toString(@InCallButtonIds int id) {
+    if (id == InCallButtonIds.BUTTON_AUDIO) {
+      return "AUDIO";
+    } else if (id == InCallButtonIds.BUTTON_MUTE) {
+      return "MUTE";
+    } else if (id == InCallButtonIds.BUTTON_DIALPAD) {
+      return "DIALPAD";
+    } else if (id == InCallButtonIds.BUTTON_HOLD) {
+      return "HOLD";
+    } else if (id == InCallButtonIds.BUTTON_SWAP) {
+      return "SWAP";
+    } else if (id == InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO) {
+      return "UPGRADE_TO_VIDEO";
+    } else if (id == InCallButtonIds.BUTTON_DOWNGRADE_TO_AUDIO) {
+      return "DOWNGRADE_TO_AUDIO";
+    } else if (id == InCallButtonIds.BUTTON_SWITCH_CAMERA) {
+      return "SWITCH_CAMERA";
+    } else if (id == InCallButtonIds.BUTTON_ADD_CALL) {
+      return "ADD_CALL";
+    } else if (id == InCallButtonIds.BUTTON_MERGE) {
+      return "MERGE";
+    } else if (id == InCallButtonIds.BUTTON_PAUSE_VIDEO) {
+      return "PAUSE_VIDEO";
+    } else if (id == InCallButtonIds.BUTTON_MANAGE_VIDEO_CONFERENCE) {
+      return "MANAGE_VIDEO_CONFERENCE";
+    } else if (id == InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE) {
+      return "MANAGE_VOICE_CONFERENCE";
+    } else if (id == InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY) {
+      return "SWITCH_TO_SECONDARY";
+    } else {
+      return "INVALID_BUTTON: " + id;
+    }
+  }
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallButtonUi.java b/java/com/android/incallui/incall/protocol/InCallButtonUi.java
new file mode 100644
index 0000000..96d741a
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallButtonUi.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.incall.protocol;
+
+import android.support.v4.app.Fragment;
+import android.telecom.CallAudioState;
+
+/** Interface for the call button UI. */
+public interface InCallButtonUi {
+
+  void showButton(@InCallButtonIds int buttonId, boolean show);
+
+  void enableButton(@InCallButtonIds int buttonId, boolean enable);
+
+  void setEnabled(boolean on);
+
+  void setHold(boolean on);
+
+  void setCameraSwitched(boolean isBackFacingCamera);
+
+  void setVideoPaused(boolean isPaused);
+
+  void setAudioState(CallAudioState audioState);
+
+  /**
+   * Once showButton() has been called on each of the individual buttons in the UI, call this to
+   * configure the overflow menu appropriately.
+   */
+  void updateButtonStates();
+
+  void updateInCallButtonUiColors();
+
+  Fragment getInCallButtonUiFragment();
+
+  void showAudioRouteSelector();
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallButtonUiDelegate.java b/java/com/android/incallui/incall/protocol/InCallButtonUiDelegate.java
new file mode 100644
index 0000000..5e69f0e
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallButtonUiDelegate.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.telecom.CallAudioState;
+
+/** Callbacks from the module out to the container. */
+public interface InCallButtonUiDelegate {
+
+  void onInCallButtonUiReady(InCallButtonUi inCallButtonUi);
+
+  void onInCallButtonUiUnready();
+
+  void onSaveInstanceState(Bundle outState);
+
+  void onRestoreInstanceState(Bundle savedInstanceState);
+
+  void refreshMuteState();
+
+  void addCallClicked();
+
+  void muteClicked(boolean checked);
+
+  void mergeClicked();
+
+  void holdClicked(boolean checked);
+
+  void swapClicked();
+
+  void showDialpadClicked(boolean checked);
+
+  void changeToVideoClicked();
+
+  void switchCameraClicked(boolean useFrontFacingCamera);
+
+  void toggleCameraClicked();
+
+  void pauseVideoClicked(boolean pause);
+
+  void toggleSpeakerphone();
+
+  CallAudioState getCurrentAudioState();
+
+  void setAudioRoute(int route);
+
+  void onEndCallClicked();
+
+  void showAudioRouteSelector();
+
+  Context getContext();
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallButtonUiDelegateFactory.java b/java/com/android/incallui/incall/protocol/InCallButtonUiDelegateFactory.java
new file mode 100644
index 0000000..ca7d119
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallButtonUiDelegateFactory.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+/** Callbacks from the module out to the container. */
+public interface InCallButtonUiDelegateFactory {
+
+  InCallButtonUiDelegate newInCallButtonUiDelegate();
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallScreen.java b/java/com/android/incallui/incall/protocol/InCallScreen.java
new file mode 100644
index 0000000..612ad26
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallScreen.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.incall.protocol;
+
+import android.support.annotation.NonNull;
+import android.support.v4.app.Fragment;
+import android.view.accessibility.AccessibilityEvent;
+
+/** Interface for the call card module. */
+public interface InCallScreen {
+
+  void setPrimary(@NonNull PrimaryInfo primaryInfo);
+
+  void setSecondary(@NonNull SecondaryInfo secondaryInfo);
+
+  void setCallState(@NonNull PrimaryCallState primaryCallState);
+
+  void setEndCallButtonEnabled(boolean enabled, boolean animate);
+
+  void showManageConferenceCallButton(boolean visible);
+
+  boolean isManageConferenceVisible();
+
+  void dispatchPopulateAccessibilityEvent(AccessibilityEvent event);
+
+  void showNoteSentToast();
+
+  void updateInCallScreenColors();
+
+  void onInCallScreenDialpadVisibilityChange(boolean isShowing);
+
+  int getAnswerAndDialpadContainerResourceId();
+
+  void showLocationUi(Fragment locationUi);
+
+  boolean isShowingLocationUi();
+
+  Fragment getInCallScreenFragment();
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallScreenDelegate.java b/java/com/android/incallui/incall/protocol/InCallScreenDelegate.java
new file mode 100644
index 0000000..b39f9f4
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallScreenDelegate.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.graphics.drawable.Drawable;
+
+/** Callbacks from the module out to the container. */
+public interface InCallScreenDelegate {
+
+  void onInCallScreenDelegateInit(InCallScreen inCallScreen);
+
+  void onInCallScreenReady();
+
+  void onInCallScreenUnready();
+
+  void onEndCallClicked();
+
+  void onSecondaryInfoClicked();
+
+  void onCallStateButtonClicked();
+
+  void onManageConferenceClicked();
+
+  void onShrinkAnimationComplete();
+
+  void onInCallScreenResumed();
+
+  Drawable getDefaultContactPhotoDrawable();
+}
diff --git a/java/com/android/incallui/incall/protocol/InCallScreenDelegateFactory.java b/java/com/android/incallui/incall/protocol/InCallScreenDelegateFactory.java
new file mode 100644
index 0000000..6706691
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/InCallScreenDelegateFactory.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+/** Callbacks from the module out to the container. */
+public interface InCallScreenDelegateFactory {
+
+  InCallScreenDelegate newInCallScreenDelegate();
+}
diff --git a/java/com/android/incallui/incall/protocol/PrimaryCallState.java b/java/com/android/incallui/incall/protocol/PrimaryCallState.java
new file mode 100644
index 0000000..7820908
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/PrimaryCallState.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.graphics.drawable.Drawable;
+import android.telecom.DisconnectCause;
+import android.telecom.VideoProfile;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import java.util.Locale;
+
+/** State of the primary call. */
+public class PrimaryCallState {
+  public final int state;
+  public final int videoState;
+  @SessionModificationState public final int sessionModificationState;
+  public final DisconnectCause disconnectCause;
+  public final String connectionLabel;
+  public final Drawable connectionIcon;
+  public final String gatewayNumber;
+  public final String callSubject;
+  public final String callbackNumber;
+  public final boolean isWifi;
+  public final boolean isConference;
+  public final boolean isWorkCall;
+  public final boolean isHdAudioCall;
+  public final boolean isForwardedNumber;
+  public final boolean shouldShowContactPhoto;
+  public final long connectTimeMillis;
+  public final boolean isVoiceMailNumber;
+  public final boolean isRemotelyHeld;
+
+  // TODO: Convert to autovalue. b/34502119
+  public static PrimaryCallState createEmptyPrimaryCallState() {
+    return new PrimaryCallState(
+        DialerCall.State.IDLE,
+        VideoProfile.STATE_AUDIO_ONLY,
+        DialerCall.SESSION_MODIFICATION_STATE_NO_REQUEST,
+        new DisconnectCause(DisconnectCause.UNKNOWN),
+        null, /* connectionLabel */
+        null, /* connectionIcon */
+        null, /* gatewayNumber */
+        null, /* callSubject */
+        null, /* callbackNumber */
+        false /* isWifi */,
+        false /* isConference */,
+        false /* isWorkCall */,
+        false /* isHdAudioCall */,
+        false /* isForwardedNumber */,
+        false /* shouldShowContactPhoto */,
+        0,
+        false /* isVoiceMailNumber */,
+        false /* isRemotelyHeld */);
+  }
+
+  public PrimaryCallState(
+      int state,
+      int videoState,
+      @SessionModificationState int sessionModificationState,
+      DisconnectCause disconnectCause,
+      String connectionLabel,
+      Drawable connectionIcon,
+      String gatewayNumber,
+      String callSubject,
+      String callbackNumber,
+      boolean isWifi,
+      boolean isConference,
+      boolean isWorkCall,
+      boolean isHdAudioCall,
+      boolean isForwardedNumber,
+      boolean shouldShowContactPhoto,
+      long connectTimeMillis,
+      boolean isVoiceMailNumber,
+      boolean isRemotelyHeld) {
+    this.state = state;
+    this.videoState = videoState;
+    this.sessionModificationState = sessionModificationState;
+    this.disconnectCause = disconnectCause;
+    this.connectionLabel = connectionLabel;
+    this.connectionIcon = connectionIcon;
+    this.gatewayNumber = gatewayNumber;
+    this.callSubject = callSubject;
+    this.callbackNumber = callbackNumber;
+    this.isWifi = isWifi;
+    this.isConference = isConference;
+    this.isWorkCall = isWorkCall;
+    this.isHdAudioCall = isHdAudioCall;
+    this.isForwardedNumber = isForwardedNumber;
+    this.shouldShowContactPhoto = shouldShowContactPhoto;
+    this.connectTimeMillis = connectTimeMillis;
+    this.isVoiceMailNumber = isVoiceMailNumber;
+    this.isRemotelyHeld = isRemotelyHeld;
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.US, "PrimaryCallState, state: %d, connectionLabel: %s", state, connectionLabel);
+  }
+}
diff --git a/java/com/android/incallui/incall/protocol/PrimaryInfo.java b/java/com/android/incallui/incall/protocol/PrimaryInfo.java
new file mode 100644
index 0000000..1833ed2
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/PrimaryInfo.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.graphics.drawable.Drawable;
+import android.support.annotation.Nullable;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.multimedia.MultimediaData;
+import java.util.Locale;
+
+/** Information about the primary call. */
+public class PrimaryInfo {
+  @Nullable public final String number;
+  @Nullable public final String name;
+  public final boolean nameIsNumber;
+  // This is from contacts and shows the type of number. For example, "Mobile".
+  @Nullable public final String label;
+  @Nullable public final String location;
+  @Nullable public final Drawable photo;
+  @ContactPhotoType public final int photoType;
+  public final boolean isSipCall;
+  public final boolean isContactPhotoShown;
+  public final boolean isWorkCall;
+  public final boolean isSpam;
+  public final boolean answeringDisconnectsOngoingCall;
+  public final boolean shouldShowLocation;
+  // Used for consistent LetterTile coloring.
+  @Nullable public final String contactInfoLookupKey;
+  @Nullable public final MultimediaData multimediaData;
+
+  // TODO: Convert to autovalue. b/34502119
+  public static PrimaryInfo createEmptyPrimaryInfo() {
+    return new PrimaryInfo(
+        null,
+        null,
+        false,
+        null,
+        null,
+        null,
+        ContactPhotoType.DEFAULT_PLACEHOLDER,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        null,
+        null);
+  }
+
+  public PrimaryInfo(
+      @Nullable String number,
+      @Nullable String name,
+      boolean nameIsNumber,
+      @Nullable String location,
+      @Nullable String label,
+      @Nullable Drawable photo,
+      @ContactPhotoType int phototType,
+      boolean isSipCall,
+      boolean isContactPhotoShown,
+      boolean isWorkCall,
+      boolean isSpam,
+      boolean answeringDisconnectsOngoingCall,
+      boolean shouldShowLocation,
+      @Nullable String contactInfoLookupKey,
+      @Nullable MultimediaData multimediaData) {
+    this.number = number;
+    this.name = name;
+    this.nameIsNumber = nameIsNumber;
+    this.location = location;
+    this.label = label;
+    this.photo = photo;
+    this.photoType = phototType;
+    this.isSipCall = isSipCall;
+    this.isContactPhotoShown = isContactPhotoShown;
+    this.isWorkCall = isWorkCall;
+    this.isSpam = isSpam;
+    this.answeringDisconnectsOngoingCall = answeringDisconnectsOngoingCall;
+    this.shouldShowLocation = shouldShowLocation;
+    this.contactInfoLookupKey = contactInfoLookupKey;
+    this.multimediaData = multimediaData;
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.US,
+        "PrimaryInfo, number: %s, name: %s, location: %s, label: %s, "
+            + "photo: %s, photoType: %d, isPhotoVisible: %b",
+        LogUtil.sanitizePhoneNumber(number),
+        LogUtil.sanitizePii(name),
+        LogUtil.sanitizePii(location),
+        label,
+        photo,
+        photoType,
+        isContactPhotoShown);
+  }
+}
diff --git a/java/com/android/incallui/incall/protocol/SecondaryInfo.java b/java/com/android/incallui/incall/protocol/SecondaryInfo.java
new file mode 100644
index 0000000..cadfca6
--- /dev/null
+++ b/java/com/android/incallui/incall/protocol/SecondaryInfo.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2016 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.incall.protocol;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.android.dialer.common.LogUtil;
+import java.util.Locale;
+
+/** Information about the secondary call. */
+public class SecondaryInfo implements Parcelable {
+  public final boolean shouldShow;
+  public final String name;
+  public final boolean nameIsNumber;
+  public final String label;
+  public final String providerLabel;
+  public final boolean isConference;
+  public final boolean isVideoCall;
+  public final boolean isFullscreen;
+
+  public static SecondaryInfo createEmptySecondaryInfo(boolean isFullScreen) {
+    return new SecondaryInfo(false, null, false, null, null, false, false, isFullScreen);
+  }
+
+  public SecondaryInfo(
+      boolean shouldShow,
+      String name,
+      boolean nameIsNumber,
+      String label,
+      String providerLabel,
+      boolean isConference,
+      boolean isVideoCall,
+      boolean isFullscreen) {
+    this.shouldShow = shouldShow;
+    this.name = name;
+    this.nameIsNumber = nameIsNumber;
+    this.label = label;
+    this.providerLabel = providerLabel;
+    this.isConference = isConference;
+    this.isVideoCall = isVideoCall;
+    this.isFullscreen = isFullscreen;
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.US,
+        "SecondaryInfo, show: %b, name: %s, label: %s, " + "providerLabel: %s",
+        shouldShow,
+        LogUtil.sanitizePii(name),
+        label,
+        providerLabel);
+  }
+
+  protected SecondaryInfo(Parcel in) {
+    shouldShow = in.readByte() != 0;
+    name = in.readString();
+    nameIsNumber = in.readByte() != 0;
+    label = in.readString();
+    providerLabel = in.readString();
+    isConference = in.readByte() != 0;
+    isVideoCall = in.readByte() != 0;
+    isFullscreen = in.readByte() != 0;
+  }
+
+  public static final Creator<SecondaryInfo> CREATOR =
+      new Creator<SecondaryInfo>() {
+        @Override
+        public SecondaryInfo createFromParcel(Parcel in) {
+          return new SecondaryInfo(in);
+        }
+
+        @Override
+        public SecondaryInfo[] newArray(int size) {
+          return new SecondaryInfo[size];
+        }
+      };
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeByte((byte) (shouldShow ? 1 : 0));
+    dest.writeString(name);
+    dest.writeByte((byte) (nameIsNumber ? 1 : 0));
+    dest.writeString(label);
+    dest.writeString(providerLabel);
+    dest.writeByte((byte) (isConference ? 1 : 0));
+    dest.writeByte((byte) (isVideoCall ? 1 : 0));
+    dest.writeByte((byte) (isFullscreen ? 1 : 0));
+  }
+}
diff --git a/java/com/android/incallui/latencyreport/LatencyReport.java b/java/com/android/incallui/latencyreport/LatencyReport.java
new file mode 100644
index 0000000..2e1fbd5
--- /dev/null
+++ b/java/com/android/incallui/latencyreport/LatencyReport.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2016 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.latencyreport;
+
+import android.os.Bundle;
+import android.os.SystemClock;
+
+/** Tracks latency information for a call. */
+public class LatencyReport {
+
+  public static final long INVALID_TIME = -1;
+  // The following are hidden constants from android.telecom.TelecomManager.
+  private static final String EXTRA_CALL_CREATED_TIME_MILLIS =
+      "android.telecom.extra.CALL_CREATED_TIME_MILLIS";
+  private static final String EXTRA_CALL_TELECOM_ROUTING_START_TIME_MILLIS =
+      "android.telecom.extra.CALL_TELECOM_ROUTING_START_TIME_MILLIS";
+  private static final String EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS =
+      "android.telecom.extra.CALL_TELECOM_ROUTING_END_TIME_MILLIS";
+  private final boolean mWasIncoming;
+
+  // Time elapsed since boot when the call was created by the connection service.
+  private final long mCreatedTimeMillis;
+
+  // Time elapsed since boot when telecom began processing the call.
+  private final long mTelecomRoutingStartTimeMillis;
+
+  // Time elapsed since boot when telecom finished processing the call. This includes things like
+  // looking up contact info and call blocking but before showing any UI.
+  private final long mTelecomRoutingEndTimeMillis;
+
+  // Time elapsed since boot when the call was added to the InCallUi.
+  private final long mCallAddedTimeMillis;
+
+  // Time elapsed since boot when the call was added and call blocking evaluation was completed.
+  private long mCallBlockingTimeMillis = INVALID_TIME;
+
+  // Time elapsed since boot when the call notification was shown.
+  private long mCallNotificationTimeMillis = INVALID_TIME;
+
+  // Time elapsed since boot when the InCallUI was shown.
+  private long mInCallUiShownTimeMillis = INVALID_TIME;
+
+  // Whether the call was shown to the user as a heads up notification instead of a full screen
+  // UI.
+  private boolean mDidDisplayHeadsUpNotification;
+
+  public LatencyReport() {
+    mWasIncoming = false;
+    mCreatedTimeMillis = INVALID_TIME;
+    mTelecomRoutingStartTimeMillis = INVALID_TIME;
+    mTelecomRoutingEndTimeMillis = INVALID_TIME;
+    mCallAddedTimeMillis = SystemClock.elapsedRealtime();
+  }
+
+  public LatencyReport(android.telecom.Call telecomCall) {
+    mWasIncoming = telecomCall.getState() == android.telecom.Call.STATE_RINGING;
+    Bundle extras = telecomCall.getDetails().getIntentExtras();
+    if (extras == null) {
+      mCreatedTimeMillis = INVALID_TIME;
+      mTelecomRoutingStartTimeMillis = INVALID_TIME;
+      mTelecomRoutingEndTimeMillis = INVALID_TIME;
+    } else {
+      mCreatedTimeMillis = extras.getLong(EXTRA_CALL_CREATED_TIME_MILLIS, INVALID_TIME);
+      mTelecomRoutingStartTimeMillis =
+          extras.getLong(EXTRA_CALL_TELECOM_ROUTING_START_TIME_MILLIS, INVALID_TIME);
+      mTelecomRoutingEndTimeMillis =
+          extras.getLong(EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS, INVALID_TIME);
+    }
+    mCallAddedTimeMillis = SystemClock.elapsedRealtime();
+  }
+
+  public boolean getWasIncoming() {
+    return mWasIncoming;
+  }
+
+  public long getCreatedTimeMillis() {
+    return mCreatedTimeMillis;
+  }
+
+  public long getTelecomRoutingStartTimeMillis() {
+    return mTelecomRoutingStartTimeMillis;
+  }
+
+  public long getTelecomRoutingEndTimeMillis() {
+    return mTelecomRoutingEndTimeMillis;
+  }
+
+  public long getCallAddedTimeMillis() {
+    return mCallAddedTimeMillis;
+  }
+
+  public long getCallBlockingTimeMillis() {
+    return mCallBlockingTimeMillis;
+  }
+
+  public void onCallBlockingDone() {
+    if (mCallBlockingTimeMillis == INVALID_TIME) {
+      mCallBlockingTimeMillis = SystemClock.elapsedRealtime();
+    }
+  }
+
+  public long getCallNotificationTimeMillis() {
+    return mCallNotificationTimeMillis;
+  }
+
+  public void onNotificationShown() {
+    if (mCallNotificationTimeMillis == INVALID_TIME) {
+      mCallNotificationTimeMillis = SystemClock.elapsedRealtime();
+    }
+  }
+
+  public long getInCallUiShownTimeMillis() {
+    return mInCallUiShownTimeMillis;
+  }
+
+  public void onInCallUiShown(boolean forFullScreenIntent) {
+    if (mInCallUiShownTimeMillis == INVALID_TIME) {
+      mInCallUiShownTimeMillis = SystemClock.elapsedRealtime();
+      mDidDisplayHeadsUpNotification = mWasIncoming && !forFullScreenIntent;
+    }
+  }
+
+  public boolean getDidDisplayHeadsUpNotification() {
+    return mDidDisplayHeadsUpNotification;
+  }
+}
diff --git a/java/com/android/incallui/legacyblocking/BlockedNumberContentObserver.java b/java/com/android/incallui/legacyblocking/BlockedNumberContentObserver.java
new file mode 100644
index 0000000..9b5335b
--- /dev/null
+++ b/java/com/android/incallui/legacyblocking/BlockedNumberContentObserver.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 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.legacyblocking;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.os.Handler;
+import android.provider.CallLog;
+import android.support.annotation.NonNull;
+import com.android.dialer.common.AsyncTaskExecutor;
+import com.android.dialer.common.AsyncTaskExecutors;
+import com.android.dialer.common.LogUtil;
+import java.util.Objects;
+
+/**
+ * Observes the {@link CallLog} to delete the CallLog entry for a blocked call after it is added.
+ * Automatically de-registers itself {@link #TIMEOUT_MS} ms after registration or if the entry is
+ * found and deleted.
+ */
+public class BlockedNumberContentObserver extends ContentObserver
+    implements DeleteBlockedCallTask.Listener {
+
+  /**
+   * The time after which a {@link BlockedNumberContentObserver} will be automatically unregistered.
+   */
+  public static final int TIMEOUT_MS = 5000;
+
+  @NonNull private final Context context;
+  @NonNull private final Handler handler;
+  private final String number;
+  private final long timeAddedMillis;
+  private final Runnable timeoutRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          unregister();
+        }
+      };
+
+  private final AsyncTaskExecutor asyncTaskExecutor = AsyncTaskExecutors.createThreadPoolExecutor();
+
+  /**
+   * Creates the BlockedNumberContentObserver to delete the new {@link CallLog} entry from the given
+   * blocked number.
+   *
+   * @param number The blocked number.
+   * @param timeAddedMillis The time at which the call from the blocked number was placed.
+   */
+  public BlockedNumberContentObserver(
+      @NonNull Context context, @NonNull Handler handler, String number, long timeAddedMillis) {
+    super(handler);
+    this.context = Objects.requireNonNull(context, "context").getApplicationContext();
+    this.handler = Objects.requireNonNull(handler);
+    this.number = number;
+    this.timeAddedMillis = timeAddedMillis;
+  }
+
+  @Override
+  public void onChange(boolean selfChange) {
+    LogUtil.i(
+        "BlockedNumberContentObserver.onChange",
+        "attempting to remove call log entry from blocked number");
+    asyncTaskExecutor.submit(
+        DeleteBlockedCallTask.IDENTIFIER,
+        new DeleteBlockedCallTask(context, this, number, timeAddedMillis));
+  }
+
+  @Override
+  public void onDeleteBlockedCallTaskComplete(boolean didFindEntry) {
+    if (didFindEntry) {
+      unregister();
+    }
+  }
+
+  /**
+   * Registers this {@link ContentObserver} to listen for changes to the {@link CallLog}. If the
+   * CallLog entry is not found before {@link #TIMEOUT_MS}, this ContentObserver automatically
+   * un-registers itself.
+   */
+  public void register() {
+    LogUtil.i("BlockedNumberContentObserver.register", null);
+    context.getContentResolver().registerContentObserver(CallLog.CONTENT_URI, true, this);
+    handler.postDelayed(timeoutRunnable, TIMEOUT_MS);
+  }
+
+  private void unregister() {
+    LogUtil.i("BlockedNumberContentObserver.unregister", null);
+    handler.removeCallbacks(timeoutRunnable);
+    context.getContentResolver().unregisterContentObserver(this);
+  }
+}
diff --git a/java/com/android/incallui/legacyblocking/DeleteBlockedCallTask.java b/java/com/android/incallui/legacyblocking/DeleteBlockedCallTask.java
new file mode 100644
index 0000000..a3f2dfa
--- /dev/null
+++ b/java/com/android/incallui/legacyblocking/DeleteBlockedCallTask.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2016 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.legacyblocking;
+
+import android.Manifest.permission;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.Build.VERSION_CODES;
+import android.provider.CallLog;
+import android.support.v4.content.ContextCompat;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.telecom.TelecomUtil;
+import java.util.Objects;
+
+/**
+ * Deletes a blocked call from the call log. This is only used on Android Marshmallow. On later
+ * versions of the OS, call blocking is implemented in the system and there's no need to mess with
+ * the call log.
+ */
+@TargetApi(VERSION_CODES.M)
+public class DeleteBlockedCallTask extends AsyncTask<Void, Void, Long> {
+
+  public static final String IDENTIFIER = "DeleteBlockedCallTask";
+
+  // Try to identify if a call log entry corresponds to a number which was blocked. We match by
+  // by comparing its creation time to the time it was added in the InCallUi and seeing if they
+  // fall within a certain threshold.
+  private static final int MATCH_BLOCKED_CALL_THRESHOLD_MS = 3000;
+
+  private final Context context;
+  private final Listener listener;
+  private final String number;
+  private final long timeAddedMillis;
+
+  /**
+   * Creates the task to delete the new {@link CallLog} entry from the given blocked number.
+   *
+   * @param number The blocked number.
+   * @param timeAddedMillis The time at which the call from the blocked number was placed.
+   */
+  public DeleteBlockedCallTask(
+      Context context, Listener listener, String number, long timeAddedMillis) {
+    this.context = Objects.requireNonNull(context);
+    this.listener = Objects.requireNonNull(listener);
+    this.number = number;
+    this.timeAddedMillis = timeAddedMillis;
+  }
+
+  @Override
+  public Long doInBackground(Void... params) {
+    if (ContextCompat.checkSelfPermission(context, permission.READ_CALL_LOG)
+            != PackageManager.PERMISSION_GRANTED
+        || ContextCompat.checkSelfPermission(context, permission.WRITE_CALL_LOG)
+            != PackageManager.PERMISSION_GRANTED) {
+      LogUtil.i("DeleteBlockedCallTask.doInBackground", "missing call log permissions");
+      return -1L;
+    }
+
+    // First, lookup the call log entry of the most recent call with this number.
+    try (Cursor cursor =
+        context
+            .getContentResolver()
+            .query(
+                TelecomUtil.getCallLogUri(context),
+                CallLogDeleteBlockedCallQuery.PROJECTION,
+                CallLog.Calls.NUMBER + "= ?",
+                new String[] {number},
+                CallLog.Calls.DATE + " DESC LIMIT 1")) {
+
+      // If match is found, delete this call log entry and return the call log entry id.
+      if (cursor != null && cursor.moveToFirst()) {
+        long creationTime = cursor.getLong(CallLogDeleteBlockedCallQuery.DATE_COLUMN_INDEX);
+        if (timeAddedMillis > creationTime
+            && timeAddedMillis - creationTime < MATCH_BLOCKED_CALL_THRESHOLD_MS) {
+          long callLogEntryId = cursor.getLong(CallLogDeleteBlockedCallQuery.ID_COLUMN_INDEX);
+          context
+              .getContentResolver()
+              .delete(
+                  TelecomUtil.getCallLogUri(context),
+                  CallLog.Calls._ID + " IN (" + callLogEntryId + ")",
+                  null);
+          return callLogEntryId;
+        }
+      }
+    }
+    return -1L;
+  }
+
+  @Override
+  public void onPostExecute(Long callLogEntryId) {
+    listener.onDeleteBlockedCallTaskComplete(callLogEntryId >= 0);
+  }
+
+  /** Callback invoked when delete is complete. */
+  public interface Listener {
+
+    void onDeleteBlockedCallTaskComplete(boolean didFindEntry);
+  }
+
+  private static class CallLogDeleteBlockedCallQuery {
+
+    static final String[] PROJECTION = new String[] {CallLog.Calls._ID, CallLog.Calls.DATE};
+
+    static final int ID_COLUMN_INDEX = 0;
+    static final int DATE_COLUMN_INDEX = 1;
+  }
+}
diff --git a/java/com/android/incallui/maps/StaticMapBinding.java b/java/com/android/incallui/maps/StaticMapBinding.java
new file mode 100644
index 0000000..9d24ef2
--- /dev/null
+++ b/java/com/android/incallui/maps/StaticMapBinding.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 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.maps;
+
+import android.app.Application;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+
+/** Utility for getting a {@link StaticMapFactory} */
+public class StaticMapBinding {
+
+  @Nullable
+  public static StaticMapFactory get(@NonNull Application application) {
+    if (useTestingInstance) {
+      return testingInstance;
+    }
+    if (application instanceof StaticMapFactory) {
+      return ((StaticMapFactory) application);
+    }
+    return null;
+  }
+
+  private static StaticMapFactory testingInstance;
+  private static boolean useTestingInstance;
+
+  @VisibleForTesting
+  public static void setForTesting(@Nullable StaticMapFactory staticMapFactory) {
+    testingInstance = staticMapFactory;
+    useTestingInstance = true;
+  }
+
+  @VisibleForTesting
+  public static void clearForTesting() {
+    useTestingInstance = false;
+  }
+}
diff --git a/java/com/android/incallui/maps/StaticMapFactory.java b/java/com/android/incallui/maps/StaticMapFactory.java
new file mode 100644
index 0000000..a350138
--- /dev/null
+++ b/java/com/android/incallui/maps/StaticMapFactory.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 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.maps;
+
+import android.location.Location;
+import android.support.annotation.NonNull;
+import android.support.v4.app.Fragment;
+
+/** A Factory that can create Fragments for showing a static map */
+public interface StaticMapFactory {
+
+  @NonNull
+  Fragment getStaticMap(@NonNull Location location);
+}
diff --git a/java/com/android/incallui/res/anim/activity_open_enter.xml b/java/com/android/incallui/res/anim/activity_open_enter.xml
new file mode 100644
index 0000000..71cc096
--- /dev/null
+++ b/java/com/android/incallui/res/anim/activity_open_enter.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, 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.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shareInterpolator="false"
+  android:zAdjustment="top">
+  <alpha
+    android:duration="300"
+    android:fillAfter="true"
+    android:fillBefore="false"
+    android:fillEnabled="true"
+    android:fromAlpha="0.0"
+    android:interpolator="@anim/decelerate_cubic"
+    android:toAlpha="1.0"/>
+  <scale
+    android:duration="300"
+    android:fillAfter="true"
+    android:fillBefore="false"
+    android:fillEnabled="true"
+    android:fromXScale=".8"
+    android:fromYScale=".8"
+    android:interpolator="@anim/decelerate_cubic"
+    android:pivotX="50%p"
+    android:pivotY="50%p"
+    android:toXScale="1.0"
+    android:toYScale="1.0"/>
+</set>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/anim/activity_open_exit.xml b/java/com/android/incallui/res/anim/activity_open_exit.xml
new file mode 100644
index 0000000..9b36bb3
--- /dev/null
+++ b/java/com/android/incallui/res/anim/activity_open_exit.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, 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.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+  android:background="#ff000000"
+  android:zAdjustment="normal">
+  <alpha
+    android:duration="300"
+    android:fillAfter="true"
+    android:fillBefore="false"
+    android:fillEnabled="true"
+    android:fromAlpha="1.0"
+    android:interpolator="@anim/decelerate_quint"
+    android:toAlpha="0.0"/>
+</set>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/anim/decelerate_cubic.xml b/java/com/android/incallui/res/anim/decelerate_cubic.xml
new file mode 100644
index 0000000..c2f4159
--- /dev/null
+++ b/java/com/android/incallui/res/anim/decelerate_cubic.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2010, 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.
+*/
+-->
+
+<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
+  android:factor="1.5"/>
diff --git a/java/com/android/incallui/res/anim/decelerate_quint.xml b/java/com/android/incallui/res/anim/decelerate_quint.xml
new file mode 100644
index 0000000..e55e99c
--- /dev/null
+++ b/java/com/android/incallui/res/anim/decelerate_quint.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2010, 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.
+*/
+-->
+
+<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
+  android:factor="2.5"/>
diff --git a/java/com/android/incallui/res/anim/on_going_call.xml b/java/com/android/incallui/res/anim/on_going_call.xml
new file mode 100644
index 0000000..3a2e2ba
--- /dev/null
+++ b/java/com/android/incallui/res/anim/on_going_call.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
+  android:oneshot="false">
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_01"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_02"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_03"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_04"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_05"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_06"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_07"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_08"
+    android:duration="200"/>
+  <item
+    android:drawable="@drawable/ic_ongoing_phone_24px_09"
+    android:duration="200"/>
+</animation-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/color/ota_title_color.xml b/java/com/android/incallui/res/color/ota_title_color.xml
new file mode 100644
index 0000000..bf36f56
--- /dev/null
+++ b/java/com/android/incallui/res/color/ota_title_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="#FFA6C839"/>
+</selector>
+
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_block_grey600_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_block_grey600_24dp.png
new file mode 100644
index 0000000..1e9294c
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_block_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_call_end_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..757d339
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_call_split_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..4e3dbf5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_close_grey600_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_close_grey600_24dp.png
new file mode 100644
index 0000000..9ab350e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_close_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..7c281c3
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_01.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_01.png
new file mode 100644
index 0000000..e4ff6db
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_01.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_02.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_02.png
new file mode 100644
index 0000000..bc2b3d2
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_02.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_03.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_03.png
new file mode 100644
index 0000000..fa936cb
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_03.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_04.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_04.png
new file mode 100644
index 0000000..ef51379
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_04.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_05.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_05.png
new file mode 100644
index 0000000..3712d16
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_05.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_06.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_06.png
new file mode 100644
index 0000000..c6a4216
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_06.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_07.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_07.png
new file mode 100644
index 0000000..e4ff6db
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_07.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_08.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_08.png
new file mode 100644
index 0000000..e4ff6db
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_08.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_09.png b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_09.png
new file mode 100644
index 0000000..e4ff6db
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_ongoing_phone_24px_09.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_person_add_grey600_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_person_add_grey600_24dp.png
new file mode 100644
index 0000000..185d033
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_person_add_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_phone_paused_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..a2177f5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png
new file mode 100644
index 0000000..bd9489c
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..f3581d1
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/img_business.png b/java/com/android/incallui/res/drawable-hdpi/img_business.png
new file mode 100644
index 0000000..f706342
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/img_business.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/img_conference.png b/java/com/android/incallui/res/drawable-hdpi/img_conference.png
new file mode 100644
index 0000000..3d9f683
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/img_conference.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/img_no_image.png b/java/com/android/incallui/res/drawable-hdpi/img_no_image.png
new file mode 100644
index 0000000..fd0ab32
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/img_no_image.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/img_phone.png b/java/com/android/incallui/res/drawable-hdpi/img_phone.png
new file mode 100644
index 0000000..748312e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-hdpi/img_phone.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_block_grey600_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_block_grey600_24dp.png
new file mode 100644
index 0000000..edd666b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_block_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_call_end_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..17eb482
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_call_split_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..cb7ee1f
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_close_grey600_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_close_grey600_24dp.png
new file mode 100644
index 0000000..73faf52
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_close_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..933eb51
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_01.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_01.png
new file mode 100644
index 0000000..ae31e04
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_01.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_02.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_02.png
new file mode 100644
index 0000000..67b2b16
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_02.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_03.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_03.png
new file mode 100644
index 0000000..46abea3
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_03.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_04.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_04.png
new file mode 100644
index 0000000..0d787ff
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_04.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_05.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_05.png
new file mode 100644
index 0000000..2da4b40
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_05.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_06.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_06.png
new file mode 100644
index 0000000..a34cf4d
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_06.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_07.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_07.png
new file mode 100644
index 0000000..ae31e04
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_07.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_08.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_08.png
new file mode 100644
index 0000000..ae31e04
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_08.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_09.png b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_09.png
new file mode 100644
index 0000000..ae31e04
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_ongoing_phone_24px_09.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_person_add_grey600_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_person_add_grey600_24dp.png
new file mode 100644
index 0000000..ec32370
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_person_add_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_phone_paused_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..7dc920b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png
new file mode 100644
index 0000000..594d0b9
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..501ee84
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/img_business.png b/java/com/android/incallui/res/drawable-mdpi/img_business.png
new file mode 100644
index 0000000..90738a7
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/img_business.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/img_conference.png b/java/com/android/incallui/res/drawable-mdpi/img_conference.png
new file mode 100644
index 0000000..0694dbd
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/img_conference.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/img_no_image.png b/java/com/android/incallui/res/drawable-mdpi/img_no_image.png
new file mode 100644
index 0000000..014a1c4
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/img_no_image.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/img_phone.png b/java/com/android/incallui/res/drawable-mdpi/img_phone.png
new file mode 100644
index 0000000..41a1d33
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-mdpi/img_phone.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_block_grey600_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_block_grey600_24dp.png
new file mode 100644
index 0000000..36210a8
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_block_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_call_end_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..b00d82e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_call_split_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..218cb12
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_close_grey600_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_close_grey600_24dp.png
new file mode 100644
index 0000000..a3896c5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_close_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..814ca8d
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_01.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_01.png
new file mode 100644
index 0000000..80ad50b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_01.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_02.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_02.png
new file mode 100644
index 0000000..1fb69a4
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_02.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_03.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_03.png
new file mode 100644
index 0000000..2578be1
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_03.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_04.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_04.png
new file mode 100644
index 0000000..9a5b91f
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_04.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_05.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_05.png
new file mode 100644
index 0000000..69b472b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_05.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_06.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_06.png
new file mode 100644
index 0000000..118ea33
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_06.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_07.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_07.png
new file mode 100644
index 0000000..80ad50b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_07.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_08.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_08.png
new file mode 100644
index 0000000..80ad50b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_08.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_09.png b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_09.png
new file mode 100644
index 0000000..80ad50b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_ongoing_phone_24px_09.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_person_add_grey600_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_person_add_grey600_24dp.png
new file mode 100644
index 0000000..e56481e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_person_add_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_phone_paused_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..a8becf4
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png
new file mode 100644
index 0000000..ec915f6
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..2e27936
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/img_business.png b/java/com/android/incallui/res/drawable-xhdpi/img_business.png
new file mode 100644
index 0000000..7b04d95
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/img_business.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/img_conference.png b/java/com/android/incallui/res/drawable-xhdpi/img_conference.png
new file mode 100644
index 0000000..b0dbcc2
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/img_conference.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/img_no_image.png b/java/com/android/incallui/res/drawable-xhdpi/img_no_image.png
new file mode 100644
index 0000000..4022207
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/img_no_image.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/img_phone.png b/java/com/android/incallui/res/drawable-xhdpi/img_phone.png
new file mode 100644
index 0000000..2e0ceec
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xhdpi/img_phone.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_block_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_block_grey600_24dp.png
new file mode 100644
index 0000000..9f51203
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_block_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_call_end_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..aeabe4a
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_call_split_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..5ea5777
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_close_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_close_grey600_24dp.png
new file mode 100644
index 0000000..22d7aa5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_close_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..078b10d
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_01.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_01.png
new file mode 100644
index 0000000..871a1ee
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_01.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_02.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_02.png
new file mode 100644
index 0000000..028e43b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_02.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_03.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_03.png
new file mode 100644
index 0000000..b7dd070
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_03.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_04.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_04.png
new file mode 100644
index 0000000..887c803
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_04.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_05.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_05.png
new file mode 100644
index 0000000..c6ec168
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_05.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_06.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_06.png
new file mode 100644
index 0000000..d0b1e86
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_06.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_07.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_07.png
new file mode 100644
index 0000000..871a1ee
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_07.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_08.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_08.png
new file mode 100644
index 0000000..871a1ee
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_08.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_09.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_09.png
new file mode 100644
index 0000000..871a1ee
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_ongoing_phone_24px_09.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_person_add_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_person_add_grey600_24dp.png
new file mode 100644
index 0000000..c17dfe0
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_person_add_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..baf0cf2
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png
new file mode 100644
index 0000000..e3f6d28
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..bfc7273
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/img_business.png b/java/com/android/incallui/res/drawable-xxhdpi/img_business.png
new file mode 100644
index 0000000..c17e4c9
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/img_business.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/img_conference.png b/java/com/android/incallui/res/drawable-xxhdpi/img_conference.png
new file mode 100644
index 0000000..a8dba5e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/img_conference.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/img_no_image.png b/java/com/android/incallui/res/drawable-xxhdpi/img_no_image.png
new file mode 100644
index 0000000..2cf7f23
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/img_no_image.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/img_phone.png b/java/com/android/incallui/res/drawable-xxhdpi/img_phone.png
new file mode 100644
index 0000000..4eaaba5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxhdpi/img_phone.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_block_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_block_grey600_24dp.png
new file mode 100644
index 0000000..01df2b5
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_block_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_end_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..a6e8a7b
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_split_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..600cec8
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_close_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_close_grey600_24dp.png
new file mode 100644
index 0000000..7d1c061
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_close_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..8bcb6f6
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_person_add_grey600_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_person_add_grey600_24dp.png
new file mode 100644
index 0000000..e249197
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_person_add_grey600_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png
new file mode 100644
index 0000000..1a6bf1e
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..b94f4df
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/img_business.png b/java/com/android/incallui/res/drawable-xxxhdpi/img_business.png
new file mode 100644
index 0000000..88f14e9
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/img_business.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/img_conference.png b/java/com/android/incallui/res/drawable-xxxhdpi/img_conference.png
new file mode 100644
index 0000000..eb42b55
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/img_conference.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/img_no_image.png b/java/com/android/incallui/res/drawable-xxxhdpi/img_no_image.png
new file mode 100644
index 0000000..2165742
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/img_no_image.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/img_phone.png b/java/com/android/incallui/res/drawable-xxxhdpi/img_phone.png
new file mode 100644
index 0000000..7cbfbd7
--- /dev/null
+++ b/java/com/android/incallui/res/drawable-xxxhdpi/img_phone.png
Binary files differ
diff --git a/java/com/android/incallui/res/drawable/img_conference_automirrored.xml b/java/com/android/incallui/res/drawable/img_conference_automirrored.xml
new file mode 100644
index 0000000..78b2876
--- /dev/null
+++ b/java/com/android/incallui/res/drawable/img_conference_automirrored.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2014 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
+  -->
+
+<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
+  android:autoMirrored="true"
+  android:src="@drawable/img_conference"/>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/drawable/img_no_image_automirrored.xml b/java/com/android/incallui/res/drawable/img_no_image_automirrored.xml
new file mode 100644
index 0000000..9a9ec97
--- /dev/null
+++ b/java/com/android/incallui/res/drawable/img_no_image_automirrored.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2014 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
+  -->
+
+<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
+  android:autoMirrored="true"
+  android:src="@drawable/img_no_image"/>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/drawable/incall_background_gradient.xml b/java/com/android/incallui/res/drawable/incall_background_gradient.xml
new file mode 100644
index 0000000..5dd927f
--- /dev/null
+++ b/java/com/android/incallui/res/drawable/incall_background_gradient.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+  <gradient
+    android:angle="270"
+    android:startColor="@color/incall_background_gradient_top"
+    android:centerColor="@color/incall_background_gradient_middle"
+    android:endColor="@color/incall_background_gradient_bottom"/>
+</shape>
diff --git a/java/com/android/incallui/res/drawable/spam_notification_icon.xml b/java/com/android/incallui/res/drawable/spam_notification_icon.xml
new file mode 100644
index 0000000..2668978
--- /dev/null
+++ b/java/com/android/incallui/res/drawable/spam_notification_icon.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <item>
+    <shape android:shape="oval">
+      <solid android:color="@color/incall_call_spam_background_color"/>
+      <size
+        android:height="@dimen/notification_large_icon_height"
+        android:width="@dimen/notification_large_icon_width"/>
+    </shape>
+  </item>
+
+  <item
+    android:drawable="@drawable/ic_report_white_36dp"
+    android:gravity="center"/>
+
+</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/drawable/unknown_notification_icon.xml b/java/com/android/incallui/res/drawable/unknown_notification_icon.xml
new file mode 100644
index 0000000..5ab07ec
--- /dev/null
+++ b/java/com/android/incallui/res/drawable/unknown_notification_icon.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <item>
+    <shape android:shape="oval">
+      <solid android:color="@color/unknown_number_color"/>
+      <size
+        android:height="@dimen/notification_large_icon_height"
+        android:width="@dimen/notification_large_icon_width"/>
+    </shape>
+  </item>
+
+  <item
+    android:drawable="@drawable/ic_question_mark"
+    android:gravity="center"/>
+
+</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/layout/activity_manage_conference.xml b/java/com/android/incallui/res/layout/activity_manage_conference.xml
new file mode 100644
index 0000000..6051293
--- /dev/null
+++ b/java/com/android/incallui/res/layout/activity_manage_conference.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/manageConferencePanel"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+</FrameLayout>
diff --git a/java/com/android/incallui/res/layout/caller_in_conference.xml b/java/com/android/incallui/res/layout/caller_in_conference.xml
new file mode 100644
index 0000000..3a6773d
--- /dev/null
+++ b/java/com/android/incallui/res/layout/caller_in_conference.xml
@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 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.
+-->
+
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="64dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="8dp"
+  android:gravity="center_vertical"
+  android:orientation="horizontal">
+
+  <!-- Caller information -->
+  <LinearLayout
+    android:layout_width="0dp"
+    android:layout_height="match_parent"
+    android:layout_weight="1"
+    android:gravity="center_vertical"
+    android:orientation="horizontal">
+
+    <ImageView
+      android:id="@+id/callerPhoto"
+      android:layout_width="@dimen/contact_browser_list_item_photo_size"
+      android:layout_height="@dimen/contact_browser_list_item_photo_size"/>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:layout_marginStart="16dp"
+      android:paddingBottom="2dp"
+      android:gravity="center_vertical"
+      android:orientation="vertical">
+
+      <!-- Name or number of this caller -->
+      <TextView
+        android:id="@+id/conferenceCallerName"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        android:layout_marginEnd="2dp"
+        android:singleLine="true"
+        android:textAppearance="?android:attr/textAppearanceLarge"
+        android:textColor="@color/conference_call_manager_caller_name_text_color"
+        android:textSize="16sp"/>
+
+      <!-- Number of this caller if name is supplied above -->
+      <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        android:gravity="bottom"
+        android:orientation="horizontal">
+
+        <!-- Number -->
+        <TextView
+          android:id="@+id/conferenceCallerNumber"
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:layout_marginEnd="8dp"
+          android:ellipsize="marquee"
+          android:singleLine="true"
+          android:textColor="@color/conference_call_manager_secondary_text_color"
+          android:textSize="14sp"/>
+
+        <!-- Number type -->
+        <TextView
+          android:id="@+id/conferenceCallerNumberType"
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:ellipsize="marquee"
+          android:gravity="start"
+          android:singleLine="true"
+          android:textAllCaps="true"
+          android:textColor="@color/conference_call_manager_secondary_text_color"
+          android:textSize="12sp"/>
+
+      </LinearLayout>  <!-- End of caller number -->
+
+    </LinearLayout>  <!-- End of caller information -->
+
+  </LinearLayout>
+
+  <!-- "Separate" (i.e. "go private") button for this caller -->
+  <ImageView
+    android:id="@+id/conferenceCallerSeparate"
+    android:layout_width="@dimen/conference_call_manager_button_dimension"
+    android:layout_height="@dimen/conference_call_manager_button_dimension"
+    android:background="?android:selectableItemBackgroundBorderless"
+    android:clickable="true"
+    android:contentDescription="@string/goPrivate"
+    android:scaleType="center"
+    android:src="@drawable/ic_call_split_white_24dp"
+    android:tint="@color/conference_call_manager_icon_color"/>
+
+  <!-- "Disconnect" button which terminates the connection with this caller. -->
+  <ImageButton
+    android:id="@+id/conferenceCallerDisconnect"
+    android:layout_width="@dimen/conference_call_manager_button_dimension"
+    android:layout_height="@dimen/conference_call_manager_button_dimension"
+    android:layout_marginStart="8dp"
+    android:background="?android:selectableItemBackgroundBorderless"
+    android:clickable="true"
+    android:contentDescription="@string/conference_caller_disconnect_content_description"
+    android:scaleType="center"
+    android:src="@drawable/ic_call_end_white_24dp"
+    android:tint="@color/conference_call_manager_icon_color"/>
+
+</LinearLayout>  <!-- End of single list element -->
diff --git a/java/com/android/incallui/res/layout/conference_manager_fragment.xml b/java/com/android/incallui/res/layout/conference_manager_fragment.xml
new file mode 100644
index 0000000..c0cc4cd
--- /dev/null
+++ b/java/com/android/incallui/res/layout/conference_manager_fragment.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+
+<!-- The "Manage conference" UI.  This panel is displayed (instead of
+     the inCallPanel) when the user clicks the "Manage conference"
+     button while on a conference call. -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/manageConferencePanel"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+  <!-- List of conference participants. -->
+  <ListView
+    android:id="@+id/participantList"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:divider="@null"
+    android:focusable="true"
+    android:focusableInTouchMode="true"
+    android:listSelector="@null"/>
+</FrameLayout>
diff --git a/java/com/android/incallui/res/layout/incall_dialpad_fragment.xml b/java/com/android/incallui/res/layout/incall_dialpad_fragment.xml
new file mode 100644
index 0000000..0621d48
--- /dev/null
+++ b/java/com/android/incallui/res/layout/incall_dialpad_fragment.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2006 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.
+-->
+
+<view xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/dtmf_twelve_key_dialer_view"
+  class="com.android.incallui.DialpadFragment$DialpadSlidingLinearLayout"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:orientation="vertical">
+  <include layout="@layout/dialpad_view"/>
+</view>
diff --git a/java/com/android/incallui/res/layout/incall_screen.xml b/java/com/android/incallui/res/layout/incall_screen.xml
new file mode 100644
index 0000000..9090fb2
--- /dev/null
+++ b/java/com/android/incallui/res/layout/incall_screen.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2007 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.
+-->
+
+<!-- In-call Phone UI; see InCallActivity.java. -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+  <FrameLayout
+    android:id="@+id/main"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"/>
+
+  <View
+    android:id="@+id/psuedo_black_screen_overlay"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="#000000"
+    android:visibility="gone"
+    android:keepScreenOn="true"/>
+</FrameLayout>
diff --git a/java/com/android/incallui/res/layout/video_call_lte_to_wifi_failed.xml b/java/com/android/incallui/res/layout/video_call_lte_to_wifi_failed.xml
new file mode 100644
index 0000000..bdc4eaf
--- /dev/null
+++ b/java/com/android/incallui/res/layout/video_call_lte_to_wifi_failed.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="wrap_content"
+  android:layout_height="wrap_content"
+  android:padding="25dp"
+  android:orientation="vertical">
+
+  <CheckBox
+    android:id="@+id/video_call_lte_to_wifi_failed_checkbox"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:text="@string/video_call_lte_to_wifi_failed_do_not_show"
+    android:textSize="@dimen/video_call_lte_to_wifi_failed_do_not_show_text_size"/>
+</LinearLayout>
diff --git a/java/com/android/incallui/res/values-sw360dp/dimens.xml b/java/com/android/incallui/res/values-sw360dp/dimens.xml
new file mode 100644
index 0000000..ad782e8
--- /dev/null
+++ b/java/com/android/incallui/res/values-sw360dp/dimens.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+
+  <!-- The InCallUI dialpad will sometimes want digits sizes that are different from dialer. -->
+  <dimen name="incall_dialpad_key_number_margin_bottom">
+    @dimen/dialpad_key_number_default_margin_bottom
+  </dimen>
+  <!-- Zero key should have less space between self and text because "+" is smaller -->
+  <dimen name="incall_dialpad_zero_key_number_margin_bottom">
+    @dimen/dialpad_zero_key_number_default_margin_bottom
+  </dimen>
+  <dimen name="incall_dialpad_digits_adjustable_text_size">@dimen/dialpad_digits_text_size</dimen>
+  <dimen name="incall_dialpad_digits_adjustable_height">@dimen/dialpad_digits_height</dimen>
+  <dimen name="incall_dialpad_key_numbers_size">@dimen/dialpad_key_numbers_default_size</dimen>
+
+</resources>
diff --git a/java/com/android/incallui/res/values-w500dp-land/colors.xml b/java/com/android/incallui/res/values-w500dp-land/colors.xml
new file mode 100644
index 0000000..4b0e33e
--- /dev/null
+++ b/java/com/android/incallui/res/values-w500dp-land/colors.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+  <!-- Background color for status bar. For portrait this will be ignored. -->
+  <color name="statusbar_background_color">#000000</color>
+</resources>
diff --git a/java/com/android/incallui/res/values-w500dp-land/dimens.xml b/java/com/android/incallui/res/values-w500dp-land/dimens.xml
new file mode 100644
index 0000000..81090fc
--- /dev/null
+++ b/java/com/android/incallui/res/values-w500dp-land/dimens.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+
+  <!-- Whether or not the landscape mode layout is currently being used -->
+  <bool name="is_layout_landscape">true</bool>
+
+</resources>
diff --git a/java/com/android/incallui/res/values/animation_constants.xml b/java/com/android/incallui/res/values/animation_constants.xml
new file mode 100644
index 0000000..ac50db2
--- /dev/null
+++ b/java/com/android/incallui/res/values/animation_constants.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2014 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
+  -->
+<resources>
+  <integer name="reveal_animation_duration">333</integer>
+</resources>
diff --git a/java/com/android/incallui/res/values/colors.xml b/java/com/android/incallui/res/values/colors.xml
new file mode 100644
index 0000000..0c73cdb
--- /dev/null
+++ b/java/com/android/incallui/res/values/colors.xml
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+
+  <color name="incall_action_bar_background_color">@color/dialer_theme_color</color>
+  <color name="incall_action_bar_text_color">#ffffff</color>
+
+  <!-- Put on top of each photo, implying 80% darker than usual. -->
+  <color name="on_hold_dim_effect">#cc000000</color>
+
+  <color name="conference_call_manager_caller_name_text_color">#4d4d4d</color>
+  <color name="conference_call_manager_icon_color">#999999</color>
+  <!-- Used with some smaller texts in manage conference screen. -->
+  <color name="conference_call_manager_secondary_text_color">#999999</color>
+
+  <color name="incall_dialpad_background">#ffffff</color>
+  <color name="incall_dialpad_background_pressed">#ccaaaaaa</color>
+  <color name="incall_window_scrim">#b2000000</color>
+
+  <!-- Background color for status bar. For portrait this will be ignored. -->
+  <color name="statusbar_background_color">@color/dialer_theme_color</color>
+
+  <color name="translucent_shadow">#33999999</color>
+
+  <!-- 20% opacity, theme color. -->
+  <color name="incall_dialpad_touch_tint">@color/dialer_theme_color_20pct</color>
+
+  <!-- Background colors for InCallUI. This is a set of colors which pass WCAG
+       AA and all have a contrast ratio over 5:1.
+
+      These colors are also used by InCallUIMaterialColorMapUtils to generate
+      primary activity colors.
+
+  -->
+  <array name="background_colors">
+    <item>#00796B</item>
+    <item>#3367D6</item>
+    <item>#303F9F</item>
+    <item>#7B1FA2</item>
+    <item>#C2185B</item>
+    <item>#C53929</item>
+    <item>#A52714</item>
+  </array>
+
+  <!-- Darker versions of background_colors, two shades darker. These colors are used for the
+       status bar. -->
+  <array name="background_colors_dark">
+    <item>#00695C</item>
+    <item>#2A56C6</item>
+    <item>#283593</item>
+    <item>#6A1B9A</item>
+    <item>#AD1457</item>
+    <item>#B93221</item>
+    <item>#841F10</item>
+  </array>
+
+  <!-- Background color for spam. This color must match one of background_colors above. -->
+  <color name="incall_call_spam_background_color">@color/blocked_contact_background</color>
+
+  <!-- Ripple color used over light backgrounds. -->
+  <color name="ripple_light">#40000000</color>
+
+  <!-- Background color for large notification icon in after call from unknown numbers -->
+  <color name="unknown_number_color">#F4B400</color>
+
+  <color name="incall_background_gradient_top">#E91141BB</color>
+  <color name="incall_background_gradient_middle">#E91141BB</color>
+  <color name="incall_background_gradient_bottom">#CC229FEB</color>
+
+  <color name="incall_background_multiwindow">#E91141BB</color>
+
+  <color name="incall_background_gradient_spam_top">#E5A30B0B</color>
+  <color name="incall_background_gradient_spam_middle">#D6C01111</color>
+  <color name="incall_background_gradient_spam_bottom">#B8E55135</color>
+
+  <color name="incall_background_multiwindow_spam">#E9C22E2E</color>
+</resources>
diff --git a/java/com/android/incallui/res/values/config.xml b/java/com/android/incallui/res/values/config.xml
new file mode 100644
index 0000000..0f3c983
--- /dev/null
+++ b/java/com/android/incallui/res/values/config.xml
@@ -0,0 +1,23 @@
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <!-- Determines video calls will automatically enter fullscreen mode after the start of the
+       call. -->
+  <bool name="video_call_auto_fullscreen">true</bool>
+  <!-- The number of milliseconds after which a video call will automatically enter fullscreen
+       mode (requires video_call_auto_fullscreen to be true). -->
+  <integer name="video_call_auto_fullscreen_timeout">5000</integer>
+</resources>
diff --git a/java/com/android/incallui/res/values/dimens.xml b/java/com/android/incallui/res/values/dimens.xml
new file mode 100644
index 0000000..18816f6
--- /dev/null
+++ b/java/com/android/incallui/res/values/dimens.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+  <dimen name="incall_action_bar_elevation">3dp</dimen>
+
+  <!-- Margin between the bottom of the "call card" photo
+       and the top of the in-call button cluster. -->
+  <dimen name="in_call_touch_ui_upper_margin">2dp</dimen>
+
+  <!-- Padding at the top and bottom edges of the "provider information" -->
+  <dimen name="provider_info_top_bottom_padding">8dp</dimen>
+
+  <!-- Right padding for name and number fields in the call banner.
+       This padding is used to ensure that ultra-long names or
+       numbers won't overlap the elapsed time indication. -->
+  <dimen name="call_banner_name_number_right_padding">50sp</dimen>
+
+  <!-- The InCallUI dialpad will sometimes want digits sizes that are different
+       from dialer. Note, these are the default sizes for small devices. Larger
+       screen sizes apply the values in values-sw360dp/dimens.xml. -->
+  <dimen name="incall_dialpad_key_number_margin_bottom">1dp</dimen>
+  <!-- Zero key should have less space between self and text because "+" is smaller -->
+  <dimen name="incall_dialpad_zero_key_number_margin_bottom">0dp</dimen>
+  <dimen name="incall_dialpad_digits_adjustable_text_size">20sp</dimen>
+  <dimen name="incall_dialpad_digits_adjustable_height">50dp</dimen>
+  <dimen name="incall_dialpad_key_numbers_size">36sp</dimen>
+
+  <!-- Dimensions for OTA Call Card -->
+  <dimen name="otaactivate_layout_marginTop">10dp</dimen>
+  <dimen name="otalistenprogress_layout_marginTop">5dp</dimen>
+  <dimen name="otasuccessfail_layout_marginTop">10dp</dimen>
+
+  <!-- Dimension used to possibly down-scale high-res photo into what is suitable
+       for notification's large icon. -->
+  <dimen name="notification_icon_size">64dp</dimen>
+
+  <!-- Height of translucent shadow effect -->
+  <dimen name="translucent_shadow_height">2dp</dimen>
+
+  <!-- The smaller dimension of the video preview.  When in portrait orientation this is the
+       width of the preview.  When in landscape, this is the height. -->
+  <dimen name="video_preview_small_dimension">90dp</dimen>
+
+  <dimen name="conference_call_manager_button_dimension">48dp</dimen>
+
+  <!-- Whether or not the landscape mode layout is currently being used -->
+  <bool name="is_layout_landscape">false</bool>
+
+  <dimen name="video_call_lte_to_wifi_failed_do_not_show_text_size">16sp</dimen>
+
+</resources>
diff --git a/java/com/android/incallui/res/values/strings.xml b/java/com/android/incallui/res/values/strings.xml
new file mode 100644
index 0000000..252d131
--- /dev/null
+++ b/java/com/android/incallui/res/values/strings.xml
@@ -0,0 +1,367 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+  <!-- Official label of the phone app, as seen in "Manage Applications"
+       and other settings UIs. -->
+  <string name="phoneAppLabel" product="default">Phone</string>
+
+  <!-- Official label for the in-call UI. DO NOT TRANSLATE. -->
+  <string name="inCallLabel" translate="false">InCallUI</string>
+
+  <!-- In-call screen: status label for a conference call -->
+  <string name="confCall">Conference call</string>
+  <!-- In-call screen: call lost dialog text -->
+  <string name="call_lost">Call dropped</string>
+
+  <!-- MMI dialog strings -->
+  <!-- Dialog label when an MMI code starts running -->
+
+  <!-- post dial -->
+  <!-- In-call screen: body text of the dialog that appears when we encounter
+       the "wait" character in a phone number to be dialed; this dialog asks the
+       user if it's OK to send the numbers following the "wait". -->
+  <string name="wait_prompt_str">Send the following tones?\n</string>
+  <!-- In-call screen: body text of the dialog that appears when we encounter
+       the "PAUSE" character in a phone number to be dialed; this dialog gives
+       informative message to the user to show the sending numbers following the "Pause". -->
+  <string name="pause_prompt_str">Sending tones\n</string>
+  <!-- In-call screen: button label on the "wait" prompt dialog -->
+  <string name="send_button">Send</string>
+  <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
+  <string name="pause_prompt_yes">Yes</string>
+  <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
+  <string name="pause_prompt_no">No</string>
+  <!-- In-call screen: on the "wild" character dialog, this is the label
+       for a text widget that lets the user enter the digits that should
+       replace the "wild" character. -->
+  <string name="wild_prompt_str">Replace wild character with</string>
+
+  <!-- In-call screen: status label for a conference call -->
+  <string name="caller_manage_header">Conference call <xliff:g id="conf_call_time">%s</xliff:g></string>
+
+  <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+  <string name="fake_phone_activity_phoneNumber_text" translatable="false">(650) 555-1234</string>
+  <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+  <string name="fake_phone_activity_infoText_text" translatable="false">Incoming phone number</string>
+  <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+  <string name="fake_phone_activity_placeCall_text" translatable="false">Fake Incoming Call</string>
+
+  <!-- Call settings screen, Set voicemail dialog title -->
+  <string name="voicemail_settings_number_label">Voicemail number</string>
+
+  <!-- Notification strings -->
+  <!-- The "label" of the in-call Notification for a dialing call, used
+       as the format string for a Chronometer widget. [CHAR LIMIT=60] -->
+  <string name="notification_dialing">Dialing</string>
+  <!-- Missed call notification message used for a single missed call, including
+       the caller-id info from the missed call -->
+  <string name="notification_missedCallTicker">Missed call from <xliff:g id="missed_call_from">%s</xliff:g></string>
+  <!-- The "label" of the in-call Notification for an ongoing call. [CHAR LIMIT=60] -->
+  <string name="notification_ongoing_call">Ongoing call</string>
+  <!-- The "label" of the in-call Notification for an ongoing work call. [CHAR LIMIT=60] -->
+  <string name="notification_ongoing_work_call">Ongoing work call</string>
+  <!-- The "label" of the in-call Notification for an ongoing call, which is being made over
+       Wi-Fi. [CHAR LIMIT=60] -->
+  <string name="notification_ongoing_call_wifi">Ongoing Wi-Fi call</string>
+  <!-- The "label" of the in-call Notification for an ongoing work call, which is being made
+       over Wi-Fi. [CHAR LIMIT=60] -->
+  <string name="notification_ongoing_work_call_wifi">Ongoing Wi-Fi work call</string>
+  <!-- The "label" of the in-call Notification for a call that's on hold -->
+  <string name="notification_on_hold">On hold</string>
+  <!-- The "label" of the in-call Notification for an incoming ringing call. [CHAR LIMIT=60] -->
+  <string name="notification_incoming_call">Incoming call</string>
+  <!-- The "label" of the in-call Notification for an incoming ringing call. [CHAR LIMIT=60] -->
+  <string name="notification_incoming_work_call">Incoming work call</string>
+  <!-- The "label" of the in-call Notification for an incoming ringing call,
+       which is being made over Wi-Fi. [CHAR LIMIT=60] -->
+  <string name="notification_incoming_call_wifi">Incoming Wi-Fi call</string>
+  <!-- The "label" of the in-call Notification for an incoming ringing work call,
+       which is being made over Wi-Fi. [CHAR LIMIT=60] -->
+  <string name="notification_incoming_work_call_wifi">Incoming Wi-Fi work call</string>
+  <!-- The "label" of the in-call Notification for an incoming ringing spam call. -->
+  <string name="notification_incoming_spam_call">Incoming suspected spam call</string>
+  <!-- The "label" of the in-call Notification for upgrading an existing call to a video call. -->
+  <string name="notification_requesting_video_call">Incoming video request</string>
+  <!-- Label for the "Voicemail" notification item, when expanded. -->
+  <string name="notification_voicemail_title">New voicemail</string>
+  <!-- Label for the expanded "Voicemail" notification item,
+       including a count of messages. -->
+  <string name="notification_voicemail_title_count">New voicemail (<xliff:g id="count">%d</xliff:g>)</string>
+  <!-- Message displayed in the "Voicemail" notification item, allowing the user
+       to dial the indicated number. -->
+  <string name="notification_voicemail_text_format">Dial <xliff:g id="voicemail_number">%s</xliff:g></string>
+  <!-- Message displayed in the "Voicemail" notification item,
+       indicating that there's no voicemail number available -->
+  <string name="notification_voicemail_no_vm_number">Voicemail number unknown</string>
+  <!-- Label for the "No service" notification item, when expanded. -->
+  <string name="notification_network_selection_title">No service</string>
+  <!-- Label for the expanded "No service" notification item, including the
+       operator name set by user -->
+  <string name="notification_network_selection_text">Selected network (<xliff:g id="operator_name">%s</xliff:g>) unavailable</string>
+  <!-- Label for the "Answer call" action. This is the displayed label for the action that answers
+       an incoming call. [CHAR LIMIT=12] -->
+  <string name="notification_action_answer">Answer</string>
+  <!-- Label for "end call" Action.
+       It is displayed in the "Ongoing call" notification, which is shown
+       when the user is outside the in-call screen while the phone call is still
+       active. [CHAR LIMIT=12] -->
+  <string name="notification_action_end_call">Hang up</string>
+  <!-- Label for "Video Call" notification action. This is a displayed on the notification for an
+       incoming video call, and answers the call as a video call. [CHAR LIMIT=12] -->
+  <string name="notification_action_answer_video">Video</string>
+  <!-- Label for "Voice" notification action. This is a displayed on the notification for an
+       incoming video call, and answers the call as an audio call. [CHAR LIMIT=12] -->
+  <string name="notification_action_answer_voice">Voice</string>
+  <!-- Label for "Accept" notification action. This is somewhat generic, and may refer to
+       scenarios such as accepting an incoming call or accepting a video call request.
+       [CHAR LIMIT=12] -->
+  <string name="notification_action_accept">Accept</string>
+  <!-- Label for "Dismiss" notification action. This is somewhat generic, and may refer to
+       scenarios such as declining an incoming call or declining a video call request.
+       [CHAR LIMIT=12] -->
+  <string name="notification_action_dismiss">Decline</string>
+
+  <!-- The "label" of the in-call Notification for an ongoing external call.
+       External calls are a representation of a call which is in progress on the user's other
+       device (e.g. another phone or a watch).
+       [CHAR LIMIT=60] -->
+  <string name="notification_external_call">Ongoing call on another device</string>
+  <!-- The "label" of the in-call Notification for an ongoing external video call.
+       External calls are a representation of a call which is in progress on the user's other
+       device (e.g. another phone or a watch).
+       [CHAR LIMIT=60] -->
+  <string name="notification_external_video_call">Ongoing video call on another device</string>
+  <!-- Notification action displayed for external call notifications.  External calls are a
+       representation of a call which is in progress on the user's other device (e.g. another
+       phone or a watch).  The "take call" action initiates the process of pulling an external
+       call to the current device.
+       [CHAR LIMIT=30] -->
+  <string name="notification_take_call">Take Call</string>
+  <!-- Notification action displayed for external call notifications.  External calls are a
+       representation of a call which is in progress on the user's other device (e.g. another
+       phone or a watch).  The "take video call" action initiates the process of pulling an external
+       video call to the current device.
+       [CHAR LIMIT=30] -->
+  <string name="notification_take_video_call">Take Video Call</string>
+  <!-- In-call screen: call failure message displayed in an error dialog -->
+  <string name="incall_error_power_off">To place a call, first turn off Airplane mode.</string>
+  <!-- In-call screen: call failure message displayed in an error dialog.
+       This string is currently unused (see comments in InCallActivity.java.) -->
+  <string name="incall_error_emergency_only">Not registered on network.</string>
+  <!-- In-call screen: call failure message displayed in an error dialog -->
+  <string name="incall_error_out_of_service">Cellular network not available.</string>
+  <!-- In-call screen: call failure message displayed in an error dialog -->
+  <string name="incall_error_no_phone_number_supplied">To place a call, enter a valid number.</string>
+  <!-- In-call screen: call failure message displayed in an error dialog -->
+  <string name="incall_error_call_failed">Can\'t call.</string>
+  <!-- In-call screen: status message displayed in a dialog when starting an MMI -->
+  <string name="incall_status_dialed_mmi">Starting MMI sequence\u2026</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_unknown">Service not supported.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_switch">Can\'t switch calls.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_separate">Can\'t separate call.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_transfer">Can\'t transfer.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_conference">Can\'t conference.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_reject">Can\'t reject call.</string>
+  <!-- In-call screen: message displayed in an error dialog -->
+  <string name="incall_error_supp_service_hangup">Can\'t release call(s).</string>
+
+  <!-- Dialog title for the "radio enable" UI for emergency calls -->
+  <string name="emergency_enable_radio_dialog_title">Emergency call</string>
+  <!-- Status message for the "radio enable" UI for emergency calls -->
+  <string name="emergency_enable_radio_dialog_message">Turning on radio\u2026</string>
+  <!-- Status message for the "radio enable" UI for emergency calls -->
+  <string name="emergency_enable_radio_dialog_retry">No service. Trying again\u2026</string>
+
+  <!-- Dialer text on Emergency Dialer -->
+  <!-- Emergency dialer: message displayed in an error dialog -->
+  <string name="dial_emergency_error">Can\'t call. <xliff:g id="non_emergency_number">%s</xliff:g> is not an emergency number.</string>
+  <!-- Emergency dialer: message displayed in an error dialog -->
+  <string name="dial_emergency_empty_error">Can\'t call. Dial an emergency number.</string>
+
+  <!-- Displayed in the text entry box in the dialer when in landscape mode to guide the user
+       to dial using the physical keyboard -->
+  <string name="dialerKeyboardHintText">Use keyboard to dial</string>
+
+  <!-- Message indicating that Video Started flowing for IMS-VT calls -->
+  <string name="player_started">Player Started</string>
+  <!-- Message indicating that Video Stopped flowing for IMS-VT calls -->
+  <string name="player_stopped">Player Stopped</string>
+  <!-- Message indicating that camera failure has occurred for the selected camera and
+       as result camera is not ready -->
+  <string name="camera_not_ready">Camera not ready</string>
+  <!-- Message indicating that camera is ready/available -->
+  <string name="camera_ready">Camera ready</string>
+  <!-- Message indicating unknown call session event -->
+  <string name="unknown_call_session_event">"Unkown call session event"</string>
+
+  <!-- For incoming calls, this is a string we can get from a CDMA network instead of
+       the actual phone number, to indicate there's no number present.  DO NOT TRANSLATE. -->
+  <string-array name="absent_num" translatable="false">
+    <item>ABSENT NUMBER</item>
+    <item>ABSENTNUMBER</item>
+  </string-array>
+
+  <!-- Preference for Voicemail service provider under "Voicemail" settings.
+       [CHAR LIMIT=40] -->
+  <string name="voicemail_provider">Service</string>
+
+  <!-- Preference for Voicemail setting of each provider.
+       [CHAR LIMIT=40] -->
+  <string name="voicemail_settings">Setup</string>
+
+  <!-- String to display in voicemail number summary when no voicemail num is set -->
+  <string name="voicemail_number_not_set">&lt;Not set&gt;</string>
+
+  <!-- Title displayed above settings coming after voicemail in the call features screen -->
+  <string name="other_settings">Other call settings</string>
+
+  <!-- Use this to describe the separate conference call button; currently for screen readers through accessibility. -->
+  <string name="goPrivate">go private</string>
+  <!--  Use this to describe the select contact button in EditPhoneNumberPreference; currently for screen readers through accessibility. -->
+  <string name="selectContact">select contact</string>
+
+  <!-- Dialog title for the vibration settings for voicemail notifications [CHAR LIMIT=40] -->
+  <string msgid="8731372580674292759" name="voicemail_notification_vibrate_when_title">Vibrate</string>
+  <!-- Dialog title for the vibration settings for voice mail notifications [CHAR LIMIT=40]-->
+  <string msgid="8995274609647451109" name="voicemail_notification_vibarte_when_dialog_title">Vibrate</string>
+
+  <!-- Voicemail ringtone title. The user clicks on this preference to select
+       which sound to play when a voicemail notification is received.
+       [CHAR LIMIT=30] -->
+  <string name="voicemail_notification_ringtone_title">Sound</string>
+
+  <!-- The default value value for voicemail notification. -->
+  <string name="voicemail_notification_vibrate_when_default" translatable="false">never</string>
+
+  <!-- Actual values used in our code for voicemail notifications. DO NOT TRANSLATE -->
+  <string-array name="voicemail_notification_vibrate_when_values" translatable="false">
+    <item>always</item>
+    <item>silent</item>
+    <item>never</item>
+  </string-array>
+
+  <!-- Title for the category "ringtone", which is shown above ringtone and vibration
+       related settings.
+       [CHAR LIMIT=30] -->
+  <string name="preference_category_ringtone">Ringtone &amp; Vibrate</string>
+
+  <!-- Label for "Manage conference call" panel [CHAR LIMIT=40] -->
+  <string name="manageConferenceLabel">Manage conference call</string>
+
+  <!-- This can be used in any application wanting to disable the text "Emergency number" -->
+  <string name="emergency_call_dialog_number_for_display">Emergency number</string>
+
+  <!-- Used to inform the user that a call was received via a number other than the primary
+      phone number associated with their device. [CHAR LIMIT=16] -->
+  <string name="child_number">via <xliff:g example="650-555-1212" id="child_number">%s</xliff:g></string>
+
+  <!-- Title for the call context with a person-type contact. [CHAR LIMIT=40] -->
+  <string name="person_contact_context_title">Recent messages</string>
+
+  <!-- Title for the call context with a business-type contact. [CHAR LIMIT=40] -->
+  <string name="business_contact_context_title">Business info</string>
+
+  <!-- Distance strings for business caller ID context. -->
+
+  <!-- Used to inform the user how far away a location is in miles. [CHAR LIMIT=NONE] -->
+  <string name="distance_imperial_away"><xliff:g id="distance">%.1f</xliff:g> mi away</string>
+  <!-- Used to inform the user how far away a location is in kilometers. [CHAR LIMIT=NONE] -->
+  <string name="distance_metric_away"><xliff:g id="distance">%.1f</xliff:g> km away</string>
+  <!-- A shortened way to display a business address. Formatted [street address], [city/locality]. -->
+  <string name="display_address"><xliff:g id="street_address">%1$s</xliff:g>, <xliff:g id="locality">%2$s</xliff:g></string>
+  <!-- Used to indicate hours of operation for a location as a time span. e.g. "11 am - 9 pm" [CHAR LIMIT=NONE] -->
+  <string name="open_time_span"><xliff:g id="open_time">%1$s</xliff:g> - <xliff:g id="close_time">%2$s</xliff:g></string>
+  <!-- Used to indicate a series of opening hours for a location.
+       This first argument may be one or more time spans. e.g. "11 am - 9 pm, 9 pm - 11 pm"
+       The second argument is an additional time span. e.g. "11 pm - 1 am"
+       The string is used to build a list of opening hours.
+       [CHAR LIMIT=NONE] -->
+  <string name="opening_hours"><xliff:g id="earlier_times">%1$s</xliff:g>, <xliff:g id="later_time">%2$s</xliff:g></string>
+  <!-- Used to express when a location will open the next day. [CHAR LIMIT=NONE] -->
+  <string name="opens_tomorrow_at">Opens tomorrow at <xliff:g id="open_time">%s</xliff:g></string>
+  <!-- Used to express the next time at which a location will be open today. [CHAR LIMIT=NONE] -->
+  <string name="opens_today_at">Opens today at <xliff:g id="open_time">%s</xliff:g></string>
+  <!-- Used to express the next time at which a location will close today. [CHAR LIMIT=NONE] -->
+  <string name="closes_today_at">Closes at <xliff:g id="close_time">%s</xliff:g></string>
+  <!-- Used to express the next time at which a location closed today if it is already closed. [CHAR LIMIT=NONE] -->
+  <string name="closed_today_at">Closed today at <xliff:g id="close_time">%s</xliff:g></string>
+  <!-- Displayed when a place is open. -->
+  <string name="open_now">Open now</string>
+  <!-- Displayed when a place is closed. -->
+  <string name="closed_now">Closed now</string>
+
+  <!-- Title for the notification to the user after a call from an unknown number ends. [CHAR LIMIT=100] -->
+  <string name="non_spam_notification_title">Know <xliff:g id="number">%1$s</xliff:g>?</string>
+  <!-- Title for the notification to the user after a call from an spammer ends. [CHAR LIMIT=100] -->
+  <string name="spam_notification_title">Is <xliff:g id="number">%1$s</xliff:g> spam?</string>
+  <!-- Text for the toast shown after the user presses block/report spam. [CHAR LIMIT=100] -->
+  <string name="spam_notification_block_report_toast_text"><xliff:g id="number">%1$s</xliff:g> blocked and call was reported as spam.</string>
+  <!-- Text for the toast shown after the user presses not spam. [CHAR LIMIT=100] -->
+  <string name="spam_notification_not_spam_toast_text">Call from <xliff:g id="number">%1$s</xliff:g> reported as not spam.</string>
+  <!-- Text displayed in the collapsed notification to the user after a non-spam call ends. [CHAR LIMIT=100] -->
+  <string name="spam_notification_non_spam_call_collapsed_text">Tap to add to contacts or block spam number.</string>
+  <!-- Text displayed in the expanded notification to the user after a non-spam call ends. [CHAR LIMIT=NONE] -->
+  <string name="spam_notification_non_spam_call_expanded_text">This is the first time this number called you. If this call was spam, you can block this number and report it.</string>
+  <!-- Text displayed in the collapsed notification to the user after a spam call ends. [CHAR LIMIT=100] -->
+  <string name="spam_notification_spam_call_collapsed_text">Tap to report as NOT SPAM, or block it.</string>
+  <!-- Text displayed in the expanded notification to the user after a spam call ends. [CHAR LIMIT=NONE] -->
+  <string name="spam_notification_spam_call_expanded_text">We suspected this to be a spammer. If this call wasn\'t spam, tap "NOT SPAM" to report our mistake.</string>
+  <!-- Text for the reporting spam action in the after call prompt. [CHAR LIMIT=20] -->
+  <string name="spam_notification_report_spam_action_text">Block &amp; report</string>
+  <!-- Text for the adding to contacts action in the after call prompt. [CHAR LIMIT=20] -->
+  <string name="spam_notification_add_contact_action_text">Add contact</string>
+  <!-- Text for the reporting as not spam action in the after call prompt. [CHAR LIMIT=20] -->
+  <string name="spam_notification_not_spam_action_text">Not spam</string>
+  <!-- Text for the blocking spam action in the after call prompt. [CHAR LIMIT=20] -->
+  <string name="spam_notification_block_spam_action_text">Block number</string>
+  <!-- Text for the adding to contacts action in the after call dialog. [CHAR LIMIT=40] -->
+  <string name="spam_notification_dialog_add_contact_action_text">Add to contacts</string>
+  <!-- Text for the blocking and reporting spam action in the after call dialog. [CHAR LIMIT=40] -->
+  <string name="spam_notification_dialog_block_report_spam_action_text">Block &amp; report spam</string>
+  <!-- Text for the marking a call as not spam in the after call dialog. [CHAR LIMIT=40] -->
+  <string name="spam_notification_dialog_was_not_spam_action_text">Not spam</string>
+
+  <string name="callFailed_simError">No SIM or SIM error</string>
+
+  <string name="conference_caller_disconnect_content_description">End call</string>
+
+  <!-- Name for a conference call. Shown in the in call UI and in notifications. -->
+  <string name="conference_call_name">Conference call</string>
+
+  <!-- Name for a generic conference call. Shown in the in call UI. This is used in CDMA where we
+       don't know the precise state of participants in the conference.  -->
+  <string name="generic_conference_call_name">In call</string>
+
+  <!-- Displayed when handover from WiFi to Lte occurs during a video call -->
+  <string name="video_call_wifi_to_lte_handover_toast">Continuing call using cellular data…</string>
+
+  <!-- Displayed when WiFi handover from LTE fails during a video call. -->
+  <string name="video_call_lte_to_wifi_failed_title">Couldn\'t switch to Wi-Fi network</string>
+  <string name="video_call_lte_to_wifi_failed_message">Video call will remain on cellular network. Standard
+    data charges may apply.
+  </string>
+  <string name="video_call_lte_to_wifi_failed_do_not_show">Do not show this again</string>
+
+</resources>
diff --git a/java/com/android/incallui/res/values/styles.xml b/java/com/android/incallui/res/values/styles.xml
new file mode 100644
index 0000000..96e3d4d
--- /dev/null
+++ b/java/com/android/incallui/res/values/styles.xml
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2013 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+  <drawable name="grayBg">#FF333333</drawable>
+
+  <!-- Theme for the InCallActivity activity. Should have a transparent background for the
+       circular reveal animation for a new outgoing call to work correctly. We don't just use
+       Theme.Black.NoTitleBar directly, since we want any popups or dialogs from the
+       InCallActivity to have the correct Material style. -->
+  <style name="Theme.InCallScreen" parent="@style/Theme.AppCompat.NoActionBar">
+    <item name="android:textColorPrimary">#ffffff</item>
+    <item name="android:textColorSecondary">#DDFFFFFF</item>
+    <item name="android:colorPrimary">@color/dialer_theme_color</item>
+    <item name="android:colorPrimaryDark">@color/dialer_theme_color_dark</item>
+
+    <item name="android:statusBarColor">@android:color/transparent</item>
+    <item name="android:navigationBarColor">@android:color/transparent</item>
+    <item name="android:windowDrawsSystemBarBackgrounds">true</item>
+
+    <item name="dialpad_key_button_touch_tint">@color/incall_dialpad_touch_tint</item>
+    <item name="dialpad_style">@style/InCallDialpad</item>
+    <item name="android:windowAnimationStyle">@null</item>
+    <item name="android:alertDialogTheme">@style/AlertDialogTheme</item>
+
+    <item name="android:windowBackground">@drawable/incall_background_gradient</item>
+    <item name="android:windowShowWallpaper">true</item>
+  </style>
+
+  <style name="Theme.InCallScreen.ManageConference" parent="DialerThemeBase">
+  </style>
+
+  <style name="InCallDialpad" parent="Dialpad.Light">
+    <item name="dialpad_key_number_margin_bottom">
+      @dimen/incall_dialpad_key_number_margin_bottom
+    </item>
+    <item name="dialpad_zero_key_number_margin_bottom">
+      @dimen/incall_dialpad_zero_key_number_margin_bottom
+    </item>
+    <item name="dialpad_digits_adjustable_text_size">
+      @dimen/incall_dialpad_digits_adjustable_text_size
+    </item>
+    <item name="dialpad_digits_adjustable_height">
+      @dimen/incall_dialpad_digits_adjustable_height
+    </item>
+    <item name="dialpad_key_numbers_size">
+      @dimen/incall_dialpad_key_numbers_size
+    </item>
+    <item name="dialpad_end_key_spacing">
+      @dimen/incall_end_call_spacing
+    </item>
+  </style>
+
+  <style name="AfterCallNotificationTheme" parent="@style/Theme.AppCompat.Light.Dialog.MinWidth">
+    <!-- This colorAccent is to style checkboxes in the dialogs -->
+    <item name="colorAccent">@color/dialer_theme_color</item>
+    <!-- This is needed to make any alert dialogs in this activity take up minimum space -->
+    <item name="android:alertDialogTheme">@style/AfterCallDialogStyle</item>
+  </style>
+
+  <style name="AfterCallDialogStyle" parent="@style/Theme.AppCompat.Light.Dialog.MinWidth">
+    <!-- This colorAccent is to style text in the dialogs -->
+    <item name="android:colorAccent">@color/dialer_theme_color</item>
+  </style>
+
+</resources>
diff --git a/java/com/android/incallui/ringtone/DialerRingtoneManager.java b/java/com/android/incallui/ringtone/DialerRingtoneManager.java
new file mode 100644
index 0000000..5ebd933
--- /dev/null
+++ b/java/com/android/incallui/ringtone/DialerRingtoneManager.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2016 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.ringtone;
+
+import android.content.ContentResolver;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.provider.Settings;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall.State;
+import java.util.Objects;
+
+/**
+ * Class that determines when ringtones should be played and can play the call waiting tone when
+ * necessary.
+ */
+public class DialerRingtoneManager {
+
+  /*
+   * Flag used to determine if the Dialer is responsible for playing ringtones for incoming calls.
+   * Once we're ready to enable Dialer Ringing, these flags should be removed.
+   */
+  private static final boolean IS_DIALER_RINGING_ENABLED = false;
+  private final InCallTonePlayer mInCallTonePlayer;
+  private final CallList mCallList;
+  private Boolean mIsDialerRingingEnabledForTesting;
+
+  /**
+   * 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}
+   * @throws NullPointerException if inCallTonePlayer or callList are null
+   */
+  public DialerRingtoneManager(
+      @NonNull InCallTonePlayer inCallTonePlayer, @NonNull CallList callList) {
+    mInCallTonePlayer = Objects.requireNonNull(inCallTonePlayer);
+    mCallList = Objects.requireNonNull(callList);
+  }
+
+  /**
+   * Determines if a ringtone should be played for the given call state (see {@link State}) and
+   * {@link Uri}.
+   *
+   * @param callState the call state for the call being checked.
+   * @param ringtoneUri the ringtone to potentially play.
+   * @return {@code true} if the ringtone should be played, {@code false} otherwise.
+   */
+  public boolean shouldPlayRingtone(int callState, @Nullable Uri ringtoneUri) {
+    return isDialerRingingEnabled()
+        && translateCallStateForCallWaiting(callState) == State.INCOMING
+        && ringtoneUri != null;
+  }
+
+  /**
+   * Determines if an incoming call should vibrate as well as ring.
+   *
+   * @param resolver {@link ContentResolver} used to look up the {@link
+   *     Settings.System#VIBRATE_WHEN_RINGING} setting.
+   * @return {@code true} if the call should vibrate, {@code false} otherwise.
+   */
+  public boolean shouldVibrate(ContentResolver resolver) {
+    return Settings.System.getInt(resolver, Settings.System.VIBRATE_WHEN_RINGING, 0) != 0;
+  }
+
+  /**
+   * The incoming callState is never set as {@link State#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) {
+      return callState;
+    }
+    return mCallList.getActiveCall() == null ? State.INCOMING : State.CALL_WAITING;
+  }
+
+  private boolean isDialerRingingEnabled() {
+    boolean enabledFlag =
+        mIsDialerRingingEnabledForTesting != null
+            ? mIsDialerRingingEnabledForTesting
+            : IS_DIALER_RINGING_ENABLED;
+    return VERSION.SDK_INT >= VERSION_CODES.N && enabledFlag;
+  }
+
+  /**
+   * Determines if a call waiting tone should be played for the the given call state (see {@link
+   * State}).
+   *
+   * @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
+        && !mInCallTonePlayer.isPlayingTone();
+  }
+
+  /** Plays the call waiting tone. */
+  public void playCallWaitingTone() {
+    if (!isDialerRingingEnabled()) {
+      return;
+    }
+    mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+  }
+
+  /** Stops playing the call waiting tone. */
+  public void stopCallWaitingTone() {
+    if (!isDialerRingingEnabled()) {
+      return;
+    }
+    mInCallTonePlayer.stop();
+  }
+
+  void setDialerRingingEnabledForTesting(boolean status) {
+    mIsDialerRingingEnabledForTesting = status;
+  }
+}
diff --git a/java/com/android/incallui/ringtone/InCallTonePlayer.java b/java/com/android/incallui/ringtone/InCallTonePlayer.java
new file mode 100644
index 0000000..c76b41d
--- /dev/null
+++ b/java/com/android/incallui/ringtone/InCallTonePlayer.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2016 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.ringtone;
+
+import android.media.AudioManager;
+import android.media.ToneGenerator;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import com.android.incallui.Log;
+import com.android.incallui.async.PausableExecutor;
+import java.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Class responsible for playing in-call related tones in a background thread. This class only
+ * allows one tone to be played at a time.
+ */
+public class InCallTonePlayer {
+
+  public static final int TONE_CALL_WAITING = 4;
+
+  public static final int VOLUME_RELATIVE_HIGH_PRIORITY = 80;
+
+  @NonNull private final ToneGeneratorFactory mToneGeneratorFactory;
+  @NonNull private final PausableExecutor mExecutor;
+  private @Nullable CountDownLatch mNumPlayingTones;
+
+  /**
+   * Creates a new InCallTonePlayer.
+   *
+   * @param toneGeneratorFactory the {@link ToneGeneratorFactory} used to create {@link
+   *     ToneGenerator}s.
+   * @param executor the {@link PausableExecutor} used to play tones in a background thread.
+   * @throws NullPointerException if audioModeProvider, toneGeneratorFactory, or executor are {@code
+   *     null}.
+   */
+  public InCallTonePlayer(
+      @NonNull ToneGeneratorFactory toneGeneratorFactory, @NonNull PausableExecutor executor) {
+    mToneGeneratorFactory = Objects.requireNonNull(toneGeneratorFactory);
+    mExecutor = Objects.requireNonNull(executor);
+  }
+
+  /** @return {@code true} if a tone is currently playing, {@code false} otherwise. */
+  public boolean isPlayingTone() {
+    return mNumPlayingTones != null && mNumPlayingTones.getCount() > 0;
+  }
+
+  /**
+   * Plays the given tone in a background thread.
+   *
+   * @param tone the tone to play.
+   * @throws IllegalStateException if a tone is already playing.
+   * @throws IllegalArgumentException if the tone is invalid.
+   */
+  public void play(int tone) {
+    if (isPlayingTone()) {
+      throw new IllegalStateException("Tone already playing");
+    }
+    final ToneGeneratorInfo info = getToneGeneratorInfo(tone);
+    mNumPlayingTones = new CountDownLatch(1);
+    mExecutor.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            playOnBackgroundThread(info);
+          }
+        });
+  }
+
+  private ToneGeneratorInfo getToneGeneratorInfo(int tone) {
+    switch (tone) {
+      case TONE_CALL_WAITING:
+        /*
+         * DialerCall waiting tones play until they're stopped either by the user accepting or
+         * declining the call so the tone length is set at what's effectively forever. The
+         * tone is played at a high priority volume and through STREAM_VOICE_CALL since it's
+         * call related and using that stream will route it through bluetooth devices
+         * appropriately.
+         */
+        return new ToneGeneratorInfo(
+            ToneGenerator.TONE_SUP_CALL_WAITING,
+            VOLUME_RELATIVE_HIGH_PRIORITY,
+            Integer.MAX_VALUE,
+            AudioManager.STREAM_VOICE_CALL);
+      default:
+        throw new IllegalArgumentException("Bad tone: " + tone);
+    }
+  }
+
+  private void playOnBackgroundThread(ToneGeneratorInfo info) {
+    ToneGenerator toneGenerator = null;
+    try {
+      Log.v(this, "Starting tone " + info);
+      toneGenerator = mToneGeneratorFactory.newInCallToneGenerator(info.stream, info.volume);
+      toneGenerator.startTone(info.tone);
+      /*
+       * During tests, this will block until the tests call mExecutor.ackMilestone. This call
+       * allows for synchronization to the point where the tone has started playing.
+       */
+      mExecutor.milestone();
+      if (mNumPlayingTones != null) {
+        mNumPlayingTones.await(info.toneLengthMillis, TimeUnit.MILLISECONDS);
+        // Allows for synchronization to the point where the tone has completed playing.
+        mExecutor.milestone();
+      }
+    } catch (InterruptedException e) {
+      Log.w(this, "Interrupted while playing in-call tone.");
+    } finally {
+      if (toneGenerator != null) {
+        toneGenerator.release();
+      }
+      if (mNumPlayingTones != null) {
+        mNumPlayingTones.countDown();
+      }
+      // Allows for synchronization to the point where this background thread has cleaned up.
+      mExecutor.milestone();
+    }
+  }
+
+  /** Stops playback of the current tone. */
+  public void stop() {
+    if (mNumPlayingTones != null) {
+      mNumPlayingTones.countDown();
+    }
+  }
+
+  private static class ToneGeneratorInfo {
+
+    public final int tone;
+    public final int volume;
+    public final int toneLengthMillis;
+    public final int stream;
+
+    public ToneGeneratorInfo(int toneGeneratorType, int volume, int toneLengthMillis, int stream) {
+      this.tone = toneGeneratorType;
+      this.volume = volume;
+      this.toneLengthMillis = toneLengthMillis;
+      this.stream = stream;
+    }
+
+    @Override
+    public String toString() {
+      return "ToneGeneratorInfo{"
+          + "toneLengthMillis="
+          + toneLengthMillis
+          + ", tone="
+          + tone
+          + ", volume="
+          + volume
+          + '}';
+    }
+  }
+}
diff --git a/java/com/android/incallui/ringtone/ToneGeneratorFactory.java b/java/com/android/incallui/ringtone/ToneGeneratorFactory.java
new file mode 100644
index 0000000..cd7b11a
--- /dev/null
+++ b/java/com/android/incallui/ringtone/ToneGeneratorFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2016 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.ringtone;
+
+import android.media.ToneGenerator;
+
+/** Factory used to create {@link ToneGenerator}s. */
+public class ToneGeneratorFactory {
+
+  /**
+   * Creates a new {@link ToneGenerator} to use while in a call.
+   *
+   * @param stream the stream through which to play tones.
+   * @param volume the volume at which to play tones.
+   * @return a new ToneGenerator.
+   */
+  public ToneGenerator newInCallToneGenerator(int stream, int volume) {
+    return new ToneGenerator(stream, volume);
+  }
+}
diff --git a/java/com/android/incallui/sessiondata/AndroidManifest.xml b/java/com/android/incallui/sessiondata/AndroidManifest.xml
new file mode 100644
index 0000000..11babd9
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/AndroidManifest.xml
@@ -0,0 +1,18 @@
+<!--
+ ~ Copyright (C) 2016 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
+ -->
+<manifest
+  package="com.android.incallui.sessiondata">
+</manifest>
diff --git a/java/com/android/incallui/sessiondata/AvatarPresenter.java b/java/com/android/incallui/sessiondata/AvatarPresenter.java
new file mode 100644
index 0000000..e7303b9
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/AvatarPresenter.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 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.sessiondata;
+
+import android.support.annotation.Nullable;
+import android.widget.ImageView;
+
+/** Interface for interacting with Fragments that can be put in the data container */
+public interface AvatarPresenter {
+
+  @Nullable
+  ImageView getAvatarImageView();
+
+  int getAvatarSize();
+
+  boolean shouldShowAnonymousAvatar();
+}
diff --git a/java/com/android/incallui/sessiondata/MultimediaFragment.java b/java/com/android/incallui/sessiondata/MultimediaFragment.java
new file mode 100644
index 0000000..d6f671d
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/MultimediaFragment.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2016 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.sessiondata;
+
+import android.graphics.drawable.Drawable;
+import android.location.Location;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import android.support.v4.app.Fragment;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.TextView;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.multimedia.MultimediaData;
+import com.android.incallui.maps.StaticMapBinding;
+import com.android.incallui.maps.StaticMapFactory;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.target.Target;
+
+/**
+ * Displays info from {@link MultimediaData MultimediaData}.
+ *
+ * <p>Currently displays image, location (as a map), and message that come bundled with
+ * MultimediaData when calling {@link #newInstance(MultimediaData, boolean, boolean)}.
+ */
+public class MultimediaFragment extends Fragment implements AvatarPresenter {
+
+  private static final String ARG_SUBJECT = "subject";
+  private static final String ARG_IMAGE = "image";
+  private static final String ARG_LOCATION = "location";
+  private static final String ARG_INTERACTIVE = "interactive";
+  private static final String ARG_SHOW_AVATAR = "show_avatar";
+  private ImageView avatarImageView;
+  // TODO: add click listeners
+  @SuppressWarnings("unused")
+  private boolean isInteractive;
+
+  private boolean showAvatar;
+  private StaticMapFactory mapFactory;
+
+  public static MultimediaFragment newInstance(
+      @NonNull MultimediaData multimediaData, boolean isInteractive, boolean showAvatar) {
+    return newInstance(
+        multimediaData.getSubject(),
+        multimediaData.getImageUri(),
+        multimediaData.getLocation(),
+        isInteractive,
+        showAvatar);
+  }
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  public static MultimediaFragment newInstance(
+      @Nullable String subject,
+      @Nullable Uri imageUri,
+      @Nullable Location location,
+      boolean isInteractive,
+      boolean showAvatar) {
+    Bundle args = new Bundle();
+    args.putString(ARG_SUBJECT, subject);
+    args.putParcelable(ARG_IMAGE, imageUri);
+    args.putParcelable(ARG_LOCATION, location);
+    args.putBoolean(ARG_INTERACTIVE, isInteractive);
+    args.putBoolean(ARG_SHOW_AVATAR, showAvatar);
+    MultimediaFragment fragment = new MultimediaFragment();
+    fragment.setArguments(args);
+    return fragment;
+  }
+
+  @Override
+  public void onCreate(@Nullable Bundle bundle) {
+    super.onCreate(bundle);
+    isInteractive = getArguments().getBoolean(ARG_INTERACTIVE);
+    showAvatar = getArguments().getBoolean(ARG_SHOW_AVATAR);
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    boolean hasImage = getImageUri() != null;
+    boolean hasSubject = !TextUtils.isEmpty(getSubject());
+    boolean hasMap = getLocation() != null;
+    if (hasMap) {
+      mapFactory = StaticMapBinding.get(getActivity().getApplication());
+    }
+    if (mapFactory != null) {
+      if (hasImage) {
+        if (hasSubject) {
+          return layoutInflater.inflate(
+              R.layout.fragment_composer_text_image_frag, viewGroup, false);
+        } else {
+          return layoutInflater.inflate(R.layout.fragment_composer_image_frag, viewGroup, false);
+        }
+      } else if (hasSubject) {
+        return layoutInflater.inflate(R.layout.fragment_composer_text_frag, viewGroup, false);
+      } else {
+        return layoutInflater.inflate(R.layout.fragment_composer_frag, viewGroup, false);
+      }
+    } else if (hasImage) {
+      if (hasSubject) {
+        return layoutInflater.inflate(R.layout.fragment_composer_text_image, viewGroup, false);
+      } else {
+        return layoutInflater.inflate(R.layout.fragment_composer_image, viewGroup, false);
+      }
+    } else {
+      return layoutInflater.inflate(R.layout.fragment_composer_text, viewGroup, false);
+    }
+  }
+
+  @Override
+  public void onViewCreated(View view, @Nullable Bundle bundle) {
+    super.onViewCreated(view, bundle);
+    TextView messageText = (TextView) view.findViewById(R.id.answer_message_text);
+    if (messageText != null) {
+      messageText.setText(getSubject());
+    }
+    ImageView mainImage = (ImageView) view.findViewById(R.id.answer_message_image);
+    if (mainImage != null) {
+      Glide.with(this)
+          .load(getImageUri())
+          .transition(DrawableTransitionOptions.withCrossFade())
+          .listener(
+              new RequestListener<Drawable>() {
+                @Override
+                public boolean onLoadFailed(
+                    @Nullable GlideException e,
+                    Object model,
+                    Target<Drawable> target,
+                    boolean isFirstResource) {
+                  view.findViewById(R.id.loading_spinner).setVisibility(View.GONE);
+                  LogUtil.e("MultimediaFragment.onLoadFailed", null, e);
+                  // TODO(b/34720074) handle error cases nicely
+                  return false; // Let Glide handle the rest
+                }
+
+                @Override
+                public boolean onResourceReady(
+                    Drawable drawable,
+                    Object model,
+                    Target<Drawable> target,
+                    DataSource dataSource,
+                    boolean isFirstResource) {
+                  view.findViewById(R.id.loading_spinner).setVisibility(View.GONE);
+                  return false;
+                }
+              })
+          .into(mainImage);
+      mainImage.setClipToOutline(true);
+    }
+    FrameLayout fragmentHolder = (FrameLayout) view.findViewById(R.id.answer_message_frag);
+    if (fragmentHolder != null) {
+      fragmentHolder.setClipToOutline(true);
+      Fragment mapFragment =
+          Assert.isNotNull(mapFactory).getStaticMap(Assert.isNotNull(getLocation()));
+      getChildFragmentManager()
+          .beginTransaction()
+          .replace(R.id.answer_message_frag, mapFragment)
+          .commitNow();
+    }
+    avatarImageView = ((ImageView) view.findViewById(R.id.answer_message_avatar));
+    avatarImageView.setVisibility(showAvatar ? View.VISIBLE : View.GONE);
+
+    Holder parent = FragmentUtils.getParent(this, Holder.class);
+    if (parent != null) {
+      parent.updateAvatar(this);
+    }
+  }
+
+  @Nullable
+  @Override
+  public ImageView getAvatarImageView() {
+    return avatarImageView;
+  }
+
+  @Override
+  public int getAvatarSize() {
+    return getResources().getDimensionPixelSize(R.dimen.answer_message_avatar_size);
+  }
+
+  @Override
+  public boolean shouldShowAnonymousAvatar() {
+    return showAvatar;
+  }
+
+  @Nullable
+  public String getSubject() {
+    return getArguments().getString(ARG_SUBJECT);
+  }
+
+  @Nullable
+  public Uri getImageUri() {
+    return getArguments().getParcelable(ARG_IMAGE);
+  }
+
+  @Nullable
+  public Location getLocation() {
+    return getArguments().getParcelable(ARG_LOCATION);
+  }
+
+  /** Interface for notifying the fragment parent of changes. */
+  public interface Holder {
+    void updateAvatar(AvatarPresenter sessionDataScreen);
+  }
+}
diff --git a/java/com/android/incallui/sessiondata/res/drawable/answer_data_background.xml b/java/com/android/incallui/sessiondata/res/drawable/answer_data_background.xml
new file mode 100644
index 0000000..8826f90
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/drawable/answer_data_background.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <corners android:radius="16dp"/>
+  <solid android:color="@android:color/white"/>
+</shape>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_frag.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_frag.xml
new file mode 100644
index 0000000..ed2bee0
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_frag.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="wrap_content"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <FrameLayout
+    android:id="@id/answer_message_frag"
+    android:layout_width="0dp"
+    android:layout_height="wrap_content"
+    android:layout_weight="1"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"/>
+</LinearLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image.xml
new file mode 100644
index 0000000..7000f83
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="wrap_content"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <ImageView
+    android:id="@id/answer_message_image"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_centerInParent="true"
+    android:layout_toEndOf="@+id/answer_message_avatar"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"
+    android:adjustViewBounds="true"
+    android:scaleType="fitXY"/>
+
+  <ProgressBar
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:id="@+id/loading_spinner"
+    android:layout_centerInParent="true"/>
+</RelativeLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image_frag.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image_frag.xml
new file mode 100644
index 0000000..9959f4d
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_image_frag.xml
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:layout_rowSpan="2"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <ImageView
+    android:id="@id/answer_message_image"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginStart="8dp"
+    android:layout_columnWeight="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"
+    android:scaleType="centerCrop"/>
+
+  <FrameLayout
+    android:id="@id/answer_message_frag"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_column="1"
+    android:layout_columnWeight="1"
+    android:layout_row="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"/>
+</GridLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml
new file mode 100644
index 0000000..c699730
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="wrap_content"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <TextView
+    android:id="@id/answer_message_text"
+    android:layout_width="0dp"
+    android:layout_height="wrap_content"
+    android:layout_weight="1"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:padding="18dp"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"/>
+</LinearLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_frag.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_frag.xml
new file mode 100644
index 0000000..5a1cf72
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_frag.xml
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:layout_rowSpan="2"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <TextView
+    android:id="@id/answer_message_text"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginStart="8dp"
+    android:layout_columnWeight="1"
+    android:layout_rowWeight="1"
+    android:padding="18dp"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:gravity="center_vertical"
+    android:maxLines="2"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"/>
+
+  <FrameLayout
+    android:id="@id/answer_message_frag"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_column="1"
+    android:layout_columnWeight="1"
+    android:layout_row="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"/>
+</GridLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image.xml
new file mode 100644
index 0000000..9955654
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:layout_rowSpan="2"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <TextView
+    android:id="@id/answer_message_text"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginStart="8dp"
+    android:layout_columnWeight="1"
+    android:layout_rowWeight="1"
+    android:padding="18dp"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:gravity="center_vertical"
+    android:maxLines="2"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"/>
+
+  <ImageView
+    android:id="@id/answer_message_image"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_column="1"
+    android:layout_columnWeight="1"
+    android:layout_row="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"
+    android:scaleType="centerCrop"/>
+</GridLayout>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image_frag.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image_frag.xml
new file mode 100644
index 0000000..387c5cf
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text_image_frag.xml
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:paddingTop="16dp"
+  android:paddingStart="16dp"
+  android:paddingEnd="24dp"
+  android:orientation="horizontal">
+
+  <ImageView
+    android:id="@id/answer_message_avatar"
+    android:layout_width="@dimen/answer_message_avatar_size"
+    android:layout_height="@dimen/answer_message_avatar_size"
+    android:layout_rowSpan="2"
+    android:elevation="@dimen/answer_data_elevation"/>
+
+  <TextView
+    android:id="@id/answer_message_text"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginStart="8dp"
+    android:layout_columnWeight="2"
+    android:layout_columnSpan="2"
+    android:layout_rowWeight="1"
+    android:padding="18dp"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:gravity="center_vertical"
+    android:maxLines="2"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"/>
+
+  <ImageView
+    android:id="@id/answer_message_image"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_column="1"
+    android:layout_columnWeight="1"
+    android:layout_row="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"
+    android:scaleType="centerCrop"/>
+
+  <FrameLayout
+    android:id="@id/answer_message_frag"
+    android:layout_width="0dp"
+    android:layout_height="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    android:layout_marginStart="8dp"
+    android:layout_column="2"
+    android:layout_columnWeight="1"
+    android:layout_row="1"
+    android:layout_rowWeight="1"
+    android:background="@drawable/answer_data_background"
+    android:elevation="@dimen/answer_data_elevation"
+    android:outlineProvider="background"/>
+</GridLayout>
diff --git a/java/com/android/incallui/sessiondata/res/values/dimens.xml b/java/com/android/incallui/sessiondata/res/values/dimens.xml
new file mode 100644
index 0000000..76c7edb
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/values/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <dimen name="answer_message_avatar_size">40dp</dimen>
+  <dimen name="answer_data_elevation">2dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/sessiondata/res/values/ids.xml b/java/com/android/incallui/sessiondata/res/values/ids.xml
new file mode 100644
index 0000000..077474c
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/values/ids.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <item name="answer_message_avatar" type="id"/>
+  <item name="answer_message_text" type="id"/>
+  <item name="answer_message_image" type="id"/>
+  <item name="answer_message_frag" type="id"/>
+</resources>
diff --git a/java/com/android/incallui/sessiondata/res/values/styles.xml b/java/com/android/incallui/sessiondata/res/values/styles.xml
new file mode 100644
index 0000000..dd898a4
--- /dev/null
+++ b/java/com/android/incallui/sessiondata/res/values/styles.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+
+<resources>
+  <style name="Dialer.Incall.TextAppearance.Message" parent="Dialer.Incall.TextAppearance">
+    <item name="android:fontFamily">sans-serif</item>
+    <item name="android:textColor">@android:color/black</item>
+    <item name="android:textSize">24sp</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/spam/NumberInCallHistoryTask.java b/java/com/android/incallui/spam/NumberInCallHistoryTask.java
new file mode 100644
index 0000000..a225606
--- /dev/null
+++ b/java/com/android/incallui/spam/NumberInCallHistoryTask.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2016 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.spam;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteException;
+import android.os.AsyncTask;
+import android.os.Build.VERSION_CODES;
+import android.provider.CallLog;
+import android.provider.CallLog.Calls;
+import android.support.annotation.NonNull;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import com.android.dialer.common.AsyncTaskExecutor;
+import com.android.dialer.common.AsyncTaskExecutors;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.telecom.TelecomUtil;
+import com.android.dialer.util.PermissionsUtil;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.CallHistoryStatus;
+import java.util.Objects;
+
+/** Checks if the number is in the call history. */
+@TargetApi(VERSION_CODES.M)
+public class NumberInCallHistoryTask extends AsyncTask<Void, Void, Integer> {
+
+  public static final String TASK_ID = "number_in_call_history_status";
+
+  private final Context context;
+  private final Listener listener;
+  private final String number;
+  private final String countryIso;
+
+  public NumberInCallHistoryTask(
+      @NonNull Context context, @NonNull Listener listener, String number, String countryIso) {
+    this.context = Objects.requireNonNull(context);
+    this.listener = Objects.requireNonNull(listener);
+    this.number = number;
+    this.countryIso = countryIso;
+  }
+
+  public void submitTask() {
+    if (!PermissionsUtil.hasPhonePermissions(context)) {
+      return;
+    }
+    AsyncTaskExecutor asyncTaskExecutor = AsyncTaskExecutors.createThreadPoolExecutor();
+    asyncTaskExecutor.submit(TASK_ID, this);
+  }
+
+  @Override
+  @CallHistoryStatus
+  public Integer doInBackground(Void... params) {
+    String numberToQuery = number;
+    String fieldToQuery = Calls.NUMBER;
+    String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);
+
+    // If we can normalize the number successfully, look in "normalized_number"
+    // field instead. Otherwise, look for number in "number" field.
+    if (!TextUtils.isEmpty(normalizedNumber)) {
+      numberToQuery = normalizedNumber;
+      fieldToQuery = Calls.CACHED_NORMALIZED_NUMBER;
+    }
+    try (Cursor cursor =
+        context
+            .getContentResolver()
+            .query(
+                TelecomUtil.getCallLogUri(context),
+                new String[] {CallLog.Calls._ID},
+                fieldToQuery + " = ?",
+                new String[] {numberToQuery},
+                null)) {
+      return cursor != null && cursor.getCount() > 0
+          ? DialerCall.CALL_HISTORY_STATUS_PRESENT
+          : DialerCall.CALL_HISTORY_STATUS_NOT_PRESENT;
+    } catch (SQLiteException e) {
+      LogUtil.e("NumberInCallHistoryTask.doInBackground", "query call log error", e);
+      return DialerCall.CALL_HISTORY_STATUS_UNKNOWN;
+    }
+  }
+
+  @Override
+  public void onPostExecute(@CallHistoryStatus Integer callHistoryStatus) {
+    listener.onComplete(callHistoryStatus);
+  }
+
+  /** Callback for the async task. */
+  public interface Listener {
+
+    void onComplete(@CallHistoryStatus int callHistoryStatus);
+  }
+}
diff --git a/java/com/android/incallui/spam/SpamCallListListener.java b/java/com/android/incallui/spam/SpamCallListListener.java
new file mode 100644
index 0000000..0897842
--- /dev/null
+++ b/java/com/android/incallui/spam/SpamCallListListener.java
@@ -0,0 +1,364 @@
+/*
+ * Copyright (C) 2016 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.spam;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.drawable.Icon;
+import android.telecom.DisconnectCause;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.dialer.blocking.FilteredNumberCompat;
+import com.android.dialer.blocking.FilteredNumbersUtil;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.ContactLookupResult;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.dialer.spam.Spam;
+import com.android.incallui.R;
+import com.android.incallui.call.CallList;
+import com.android.incallui.call.DialerCall;
+import com.android.incallui.call.DialerCall.CallHistoryStatus;
+import com.android.incallui.call.DialerCall.SessionModificationState;
+import java.util.Random;
+
+/**
+ * Creates notifications after a call ends if the call matched the criteria (incoming, accepted,
+ * etc).
+ */
+public class SpamCallListListener implements CallList.Listener {
+
+  static final int NOTIFICATION_ID = 1;
+  private static final String TAG = "SpamCallListListener";
+  private final Context context;
+  private final Random random;
+
+  public SpamCallListListener(Context context) {
+    this.context = context;
+    this.random = new Random();
+  }
+
+  public SpamCallListListener(Context context, Random rand) {
+    this.context = context;
+    this.random = rand;
+  }
+
+  private static String pii(String pii) {
+    return com.android.incallui.Log.pii(pii);
+  }
+
+  @Override
+  public void onIncomingCall(final DialerCall call) {
+    String number = call.getNumber();
+    if (TextUtils.isEmpty(number)) {
+      return;
+    }
+    NumberInCallHistoryTask.Listener listener =
+        new NumberInCallHistoryTask.Listener() {
+          @Override
+          public void onComplete(@CallHistoryStatus int callHistoryStatus) {
+            call.setCallHistoryStatus(callHistoryStatus);
+          }
+        };
+    new NumberInCallHistoryTask(context, listener, number, GeoUtil.getCurrentCountryIso(context))
+        .submitTask();
+  }
+
+  @Override
+  public void onUpgradeToVideo(DialerCall call) {}
+
+  @Override
+  public void onSessionModificationStateChange(@SessionModificationState int newState) {}
+
+  @Override
+  public void onCallListChange(CallList callList) {}
+
+  @Override
+  public void onWiFiToLteHandover(DialerCall call) {}
+
+  @Override
+  public void onHandoverToWifiFailed(DialerCall call) {}
+
+  @Override
+  public void onDisconnect(DialerCall call) {
+    if (!shouldShowAfterCallNotification(call)) {
+      return;
+    }
+    String e164Number =
+        PhoneNumberUtils.formatNumberToE164(
+            call.getNumber(), GeoUtil.getCurrentCountryIso(context));
+    if (!FilteredNumbersUtil.canBlockNumber(context, e164Number, call.getNumber())
+        || !FilteredNumberCompat.canAttemptBlockOperations(context)) {
+      return;
+    }
+    if (e164Number == null) {
+      return;
+    }
+    showNotification(call);
+  }
+
+  /** Posts the intent for displaying the after call spam notification to the user. */
+  private void showNotification(DialerCall call) {
+    if (call.isSpam()) {
+      maybeShowSpamCallNotification(call);
+    } else {
+      LogUtil.d(TAG, "Showing not spam notification for number=" + pii(call.getNumber()));
+      maybeShowNonSpamCallNotification(call);
+    }
+  }
+
+  /** Determines if the after call notification should be shown for the specified call. */
+  private boolean shouldShowAfterCallNotification(DialerCall call) {
+    if (!Spam.get(context).isSpamNotificationEnabled()) {
+      return false;
+    }
+
+    String number = call.getNumber();
+    if (TextUtils.isEmpty(number)) {
+      return false;
+    }
+
+    DialerCall.LogState logState = call.getLogState();
+    if (!logState.isIncoming) {
+      return false;
+    }
+
+    if (logState.duration <= 0) {
+      return false;
+    }
+
+    if (logState.contactLookupResult != ContactLookupResult.Type.NOT_FOUND
+        && logState.contactLookupResult != ContactLookupResult.Type.UNKNOWN_LOOKUP_RESULT_TYPE) {
+      return false;
+    }
+
+    int callHistoryStatus = call.getCallHistoryStatus();
+    if (callHistoryStatus == DialerCall.CALL_HISTORY_STATUS_PRESENT) {
+      return false;
+    } else if (callHistoryStatus == DialerCall.CALL_HISTORY_STATUS_UNKNOWN) {
+      LogUtil.i(TAG, "DialerCall history status is unknown, returning false");
+      return false;
+    }
+
+    // Check if call disconnected because of either user hanging up
+    int disconnectCause = call.getDisconnectCause().getCode();
+    if (disconnectCause != DisconnectCause.LOCAL && disconnectCause != DisconnectCause.REMOTE) {
+      return false;
+    }
+
+    LogUtil.i(TAG, "shouldShowAfterCallNotification, returning true");
+    return true;
+  }
+
+  /**
+   * Creates a notification builder with properties common among the two after call notifications.
+   */
+  private Notification.Builder createAfterCallNotificationBuilder(DialerCall call) {
+    return new Notification.Builder(context)
+        .setContentIntent(
+            createActivityPendingIntent(call, SpamNotificationActivity.ACTION_SHOW_DIALOG))
+        .setCategory(Notification.CATEGORY_STATUS)
+        .setPriority(Notification.PRIORITY_DEFAULT)
+        .setColor(context.getColor(R.color.dialer_theme_color))
+        .setSmallIcon(R.drawable.ic_call_end_white_24dp);
+  }
+
+  private CharSequence getDisplayNumber(DialerCall call) {
+    String formattedNumber =
+        PhoneNumberUtils.formatNumber(call.getNumber(), GeoUtil.getCurrentCountryIso(context));
+    return PhoneNumberUtilsCompat.createTtsSpannable(formattedNumber);
+  }
+
+  /** Display a notification with two actions: "add contact" and "report spam". */
+  private void showNonSpamCallNotification(DialerCall call) {
+    Notification.Builder notificationBuilder =
+        createAfterCallNotificationBuilder(call)
+            .setLargeIcon(Icon.createWithResource(context, R.drawable.unknown_notification_icon))
+            .setContentText(
+                context.getString(R.string.spam_notification_non_spam_call_collapsed_text))
+            .setStyle(
+                new Notification.BigTextStyle()
+                    .bigText(
+                        context.getString(R.string.spam_notification_non_spam_call_expanded_text)))
+            // Add contact
+            .addAction(
+                new Notification.Action.Builder(
+                        R.drawable.ic_person_add_grey600_24dp,
+                        context.getString(R.string.spam_notification_add_contact_action_text),
+                        createActivityPendingIntent(
+                            call, SpamNotificationActivity.ACTION_ADD_TO_CONTACTS))
+                    .build())
+            // Block/report spam
+            .addAction(
+                new Notification.Action.Builder(
+                        R.drawable.ic_block_grey600_24dp,
+                        context.getString(R.string.spam_notification_report_spam_action_text),
+                        createBlockReportSpamPendingIntent(call))
+                    .build())
+            .setContentTitle(
+                context.getString(R.string.non_spam_notification_title, getDisplayNumber(call)));
+    ((NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE))
+        .notify(call.getNumber(), NOTIFICATION_ID, notificationBuilder.build());
+  }
+
+  private boolean shouldThrottleSpamNotification() {
+    int randomNumber = random.nextInt(100);
+    int thresholdForShowing = Spam.get(context).percentOfSpamNotificationsToShow();
+    if (thresholdForShowing == 0) {
+      LogUtil.d(
+          TAG,
+          "shouldThrottleSpamNotification, not showing - percentOfSpamNotificationsToShow is 0");
+      return true;
+    } else if (randomNumber < thresholdForShowing) {
+      LogUtil.d(
+          TAG,
+          "shouldThrottleSpamNotification, showing " + randomNumber + " < " + thresholdForShowing);
+      return false;
+    } else {
+      LogUtil.d(
+          TAG,
+          "shouldThrottleSpamNotification, not showing "
+              + randomNumber
+              + " >= "
+              + thresholdForShowing);
+      return true;
+    }
+  }
+
+  private boolean shouldThrottleNonSpamNotification() {
+    int randomNumber = random.nextInt(100);
+    int thresholdForShowing = Spam.get(context).percentOfNonSpamNotificationsToShow();
+    if (thresholdForShowing == 0) {
+      LogUtil.d(TAG, "Not showing non spam notification: percentOfNonSpamNotificationsToShow is 0");
+      return true;
+    } else if (randomNumber < thresholdForShowing) {
+      LogUtil.d(
+          TAG, "Showing non spam notification: " + randomNumber + " < " + thresholdForShowing);
+      return false;
+    } else {
+      LogUtil.d(
+          TAG, "Not showing non spam notification:" + randomNumber + " >= " + thresholdForShowing);
+      return true;
+    }
+  }
+
+  private void maybeShowSpamCallNotification(DialerCall call) {
+    if (shouldThrottleSpamNotification()) {
+      Logger.get(context)
+          .logCallImpression(
+              DialerImpression.Type.SPAM_NOTIFICATION_NOT_SHOWN_AFTER_THROTTLE,
+              call.getUniqueCallId(),
+              call.getTimeAddedMs());
+    } else {
+      Logger.get(context)
+          .logCallImpression(
+              DialerImpression.Type.SPAM_NOTIFICATION_SHOWN_AFTER_THROTTLE,
+              call.getUniqueCallId(),
+              call.getTimeAddedMs());
+      showSpamCallNotification(call);
+    }
+  }
+
+  private void maybeShowNonSpamCallNotification(DialerCall call) {
+    if (shouldThrottleNonSpamNotification()) {
+      Logger.get(context)
+          .logCallImpression(
+              DialerImpression.Type.NON_SPAM_NOTIFICATION_NOT_SHOWN_AFTER_THROTTLE,
+              call.getUniqueCallId(),
+              call.getTimeAddedMs());
+    } else {
+      Logger.get(context)
+          .logCallImpression(
+              DialerImpression.Type.NON_SPAM_NOTIFICATION_SHOWN_AFTER_THROTTLE,
+              call.getUniqueCallId(),
+              call.getTimeAddedMs());
+      showNonSpamCallNotification(call);
+    }
+  }
+
+  /** Display a notification with the action "not spam". */
+  private void showSpamCallNotification(DialerCall call) {
+    Notification.Builder notificationBuilder =
+        createAfterCallNotificationBuilder(call)
+            .setLargeIcon(Icon.createWithResource(context, R.drawable.spam_notification_icon))
+            .setContentText(context.getString(R.string.spam_notification_spam_call_collapsed_text))
+            .setStyle(
+                new Notification.BigTextStyle()
+                    .bigText(context.getString(R.string.spam_notification_spam_call_expanded_text)))
+            // Not spam
+            .addAction(
+                new Notification.Action.Builder(
+                        R.drawable.ic_close_grey600_24dp,
+                        context.getString(R.string.spam_notification_not_spam_action_text),
+                        createNotSpamPendingIntent(call))
+                    .build())
+            // Block/report spam
+            .addAction(
+                new Notification.Action.Builder(
+                        R.drawable.ic_block_grey600_24dp,
+                        context.getString(R.string.spam_notification_block_spam_action_text),
+                        createBlockReportSpamPendingIntent(call))
+                    .build())
+            .setContentTitle(
+                context.getString(R.string.spam_notification_title, getDisplayNumber(call)));
+    ((NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE))
+        .notify(call.getNumber(), NOTIFICATION_ID, notificationBuilder.build());
+  }
+
+  /**
+   * Creates a pending intent for block/report spam action. If enabled, this intent is forwarded to
+   * the {@link SpamNotificationActivity}, otherwise to the {@link SpamNotificationService}.
+   */
+  private PendingIntent createBlockReportSpamPendingIntent(DialerCall call) {
+    String action = SpamNotificationActivity.ACTION_MARK_NUMBER_AS_SPAM;
+    return Spam.get(context).isDialogEnabledForSpamNotification()
+        ? createActivityPendingIntent(call, action)
+        : createServicePendingIntent(call, action);
+  }
+
+  /**
+   * Creates a pending intent for not spam action. If enabled, this intent is forwarded to the
+   * {@link SpamNotificationActivity}, otherwise to the {@link SpamNotificationService}.
+   */
+  private PendingIntent createNotSpamPendingIntent(DialerCall call) {
+    String action = SpamNotificationActivity.ACTION_MARK_NUMBER_AS_NOT_SPAM;
+    return Spam.get(context).isDialogEnabledForSpamNotification()
+        ? createActivityPendingIntent(call, action)
+        : createServicePendingIntent(call, action);
+  }
+
+  /** Creates a pending intent for {@link SpamNotificationService}. */
+  private PendingIntent createServicePendingIntent(DialerCall call, String action) {
+    Intent intent =
+        SpamNotificationService.createServiceIntent(context, call, action, NOTIFICATION_ID);
+    return PendingIntent.getService(
+        context, (int) System.currentTimeMillis(), intent, PendingIntent.FLAG_ONE_SHOT);
+  }
+
+  /** Creates a pending intent for {@link SpamNotificationActivity}. */
+  private PendingIntent createActivityPendingIntent(DialerCall call, String action) {
+    Intent intent =
+        SpamNotificationActivity.createActivityIntent(context, call, action, NOTIFICATION_ID);
+    return PendingIntent.getActivity(
+        context, (int) System.currentTimeMillis(), intent, PendingIntent.FLAG_ONE_SHOT);
+  }
+}
diff --git a/java/com/android/incallui/spam/SpamNotificationActivity.java b/java/com/android/incallui/spam/SpamNotificationActivity.java
new file mode 100644
index 0000000..88d6bdf
--- /dev/null
+++ b/java/com/android/incallui/spam/SpamNotificationActivity.java
@@ -0,0 +1,483 @@
+/*
+ * Copyright (C) 2016 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.spam;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.provider.CallLog;
+import android.provider.ContactsContract;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.dialer.blocking.BlockReportSpamDialogs;
+import com.android.dialer.blocking.BlockedNumbersMigrator;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.blocking.FilteredNumberCompat;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.dialer.logging.nano.ReportingLocation;
+import com.android.dialer.spam.Spam;
+import com.android.incallui.R;
+import com.android.incallui.call.DialerCall;
+
+/** Creates the after call notification dialogs. */
+public class SpamNotificationActivity extends FragmentActivity {
+
+  /** Action to add number to contacts. */
+  static final String ACTION_ADD_TO_CONTACTS = "com.android.incallui.spam.ACTION_ADD_TO_CONTACTS";
+  /** Action to show dialog. */
+  static final String ACTION_SHOW_DIALOG = "com.android.incallui.spam.ACTION_SHOW_DIALOG";
+  /** Action to mark a number as spam. */
+  static final String ACTION_MARK_NUMBER_AS_SPAM =
+      "com.android.incallui.spam.ACTION_MARK_NUMBER_AS_SPAM";
+  /** Action to mark a number as not spam. */
+  static final String ACTION_MARK_NUMBER_AS_NOT_SPAM =
+      "com.android.incallui.spam.ACTION_MARK_NUMBER_AS_NOT_SPAM";
+
+  private static final String TAG = "SpamNotifications";
+  private static final String EXTRA_NOTIFICATION_ID = "notification_id";
+  private static final String EXTRA_CALL_INFO = "call_info";
+
+  private static final String CALL_INFO_KEY_PHONE_NUMBER = "phone_number";
+  private static final String CALL_INFO_KEY_IS_SPAM = "is_spam";
+  private static final String CALL_INFO_KEY_CALL_ID = "call_id";
+  private static final String CALL_INFO_KEY_START_TIME_MILLIS = "call_start_time_millis";
+  private static final String CALL_INFO_CONTACT_LOOKUP_RESULT_TYPE = "contact_lookup_result_type";
+  private final DialogInterface.OnDismissListener dismissListener =
+      new DialogInterface.OnDismissListener() {
+        @Override
+        public void onDismiss(DialogInterface dialog) {
+          if (!isFinishing()) {
+            finish();
+          }
+        }
+      };
+  private FilteredNumberAsyncQueryHandler filteredNumberAsyncQueryHandler;
+
+  /**
+   * Creates an intent to start this activity.
+   *
+   * @return Intent intent that starts this activity.
+   */
+  public static Intent createActivityIntent(
+      Context context, DialerCall call, String action, int notificationId) {
+    Intent intent = new Intent(context, SpamNotificationActivity.class);
+    intent.setAction(action);
+    // This ensures only one activity of this kind exists at a time.
+    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    intent.putExtra(EXTRA_NOTIFICATION_ID, notificationId);
+    intent.putExtra(EXTRA_CALL_INFO, newCallInfoBundle(call));
+    return intent;
+  }
+
+  /** Creates the intent to insert a contact. */
+  private static Intent createInsertContactsIntent(String number) {
+    Intent intent = new Intent(ContactsContract.Intents.Insert.ACTION);
+    // This ensures that the edit contact number field gets updated if called more than once.
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+    intent.setType(ContactsContract.RawContacts.CONTENT_TYPE);
+    intent.putExtra(ContactsContract.Intents.Insert.PHONE, number);
+    return intent;
+  }
+
+  /** Returns the formatted version of the given number. */
+  private static String getFormattedNumber(String number) {
+    return PhoneNumberUtilsCompat.createTtsSpannable(number).toString();
+  }
+
+  private static void logCallImpression(Context context, Bundle bundle, int impression) {
+    Logger.get(context)
+        .logCallImpression(
+            impression,
+            bundle.getString(CALL_INFO_KEY_CALL_ID),
+            bundle.getLong(CALL_INFO_KEY_START_TIME_MILLIS, 0));
+  }
+
+  private static Bundle newCallInfoBundle(DialerCall call) {
+    Bundle bundle = new Bundle();
+    bundle.putString(CALL_INFO_KEY_PHONE_NUMBER, call.getNumber());
+    bundle.putBoolean(CALL_INFO_KEY_IS_SPAM, call.isSpam());
+    bundle.putString(CALL_INFO_KEY_CALL_ID, call.getUniqueCallId());
+    bundle.putLong(CALL_INFO_KEY_START_TIME_MILLIS, call.getTimeAddedMs());
+    bundle.putInt(CALL_INFO_CONTACT_LOOKUP_RESULT_TYPE, call.getLogState().contactLookupResult);
+    return bundle;
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    LogUtil.i(TAG, "onCreate");
+    super.onCreate(savedInstanceState);
+    setFinishOnTouchOutside(true);
+    filteredNumberAsyncQueryHandler = new FilteredNumberAsyncQueryHandler(this);
+    cancelNotification();
+  }
+
+  @Override
+  protected void onResume() {
+    LogUtil.i(TAG, "onResume");
+    super.onResume();
+    Intent intent = getIntent();
+    String number = getCallInfo().getString(CALL_INFO_KEY_PHONE_NUMBER);
+    boolean isSpam = getCallInfo().getBoolean(CALL_INFO_KEY_IS_SPAM);
+    int contactLookupResultType = getCallInfo().getInt(CALL_INFO_CONTACT_LOOKUP_RESULT_TYPE, 0);
+    switch (intent.getAction()) {
+      case ACTION_ADD_TO_CONTACTS:
+        logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_ADD_TO_CONTACTS);
+        startActivity(createInsertContactsIntent(number));
+        finish();
+        break;
+      case ACTION_MARK_NUMBER_AS_SPAM:
+        assertDialogsEnabled();
+        maybeShowBlockReportSpamDialog(number, contactLookupResultType);
+        break;
+      case ACTION_MARK_NUMBER_AS_NOT_SPAM:
+        assertDialogsEnabled();
+        maybeShowNotSpamDialog(number, contactLookupResultType);
+        break;
+      case ACTION_SHOW_DIALOG:
+        if (isSpam) {
+          showSpamFullDialog();
+        } else {
+          showNonSpamDialog();
+        }
+        break;
+    }
+  }
+
+  @Override
+  protected void onPause() {
+    LogUtil.d(TAG, "onPause");
+    // Finish activity on pause (e.g: orientation change or back button pressed)
+    filteredNumberAsyncQueryHandler = null;
+    if (!isFinishing()) {
+      finish();
+    }
+    super.onPause();
+  }
+
+  /** Creates and displays the dialog for whitelisting a number. */
+  private void maybeShowNotSpamDialog(final String number, final int contactLookupResultType) {
+    if (Spam.get(this).isDialogEnabledForSpamNotification()) {
+      BlockReportSpamDialogs.ReportNotSpamDialogFragment.newInstance(
+              getFormattedNumber(number),
+              new BlockReportSpamDialogs.OnConfirmListener() {
+                @Override
+                public void onClick() {
+                  reportNotSpamAndFinish(number, contactLookupResultType);
+                }
+              },
+              dismissListener)
+          .show(getFragmentManager(), BlockReportSpamDialogs.NOT_SPAM_DIALOG_TAG);
+    } else {
+      reportNotSpamAndFinish(number, contactLookupResultType);
+    }
+  }
+
+  /** Creates and displays the dialog for blocking/reporting a number as spam. */
+  private void maybeShowBlockReportSpamDialog(
+      final String number, final int contactLookupResultType) {
+    if (Spam.get(this).isDialogEnabledForSpamNotification()) {
+      maybeShowBlockNumberMigrationDialog(
+          new BlockedNumbersMigrator.Listener() {
+            @Override
+            public void onComplete() {
+              BlockReportSpamDialogs.BlockReportSpamDialogFragment.newInstance(
+                      getFormattedNumber(number),
+                      Spam.get(SpamNotificationActivity.this).isDialogReportSpamCheckedByDefault(),
+                      new BlockReportSpamDialogs.OnSpamDialogClickListener() {
+                        @Override
+                        public void onClick(boolean isSpamChecked) {
+                          blockReportNumberAndFinish(
+                              number, isSpamChecked, contactLookupResultType);
+                        }
+                      },
+                      dismissListener)
+                  .show(getFragmentManager(), BlockReportSpamDialogs.BLOCK_REPORT_SPAM_DIALOG_TAG);
+            }
+          });
+    } else {
+      blockReportNumberAndFinish(number, true, contactLookupResultType);
+    }
+  }
+
+  /**
+   * Displays the dialog for the first time unknown calls with actions "Add contact", "Block/report
+   * spam", and "Dismiss".
+   */
+  private void showNonSpamDialog() {
+    logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_SHOW_NON_SPAM_DIALOG);
+    FirstTimeNonSpamCallDialogFragment.newInstance(getCallInfo())
+        .show(getSupportFragmentManager(), FirstTimeNonSpamCallDialogFragment.TAG);
+  }
+
+  /**
+   * Displays the dialog for first time spam calls with actions "Not spam", "Block", and "Dismiss".
+   */
+  private void showSpamFullDialog() {
+    logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_SHOW_SPAM_DIALOG);
+    FirstTimeSpamCallDialogFragment.newInstance(getCallInfo())
+        .show(getSupportFragmentManager(), FirstTimeSpamCallDialogFragment.TAG);
+  }
+
+  /** Checks if the user has migrated to the new blocking and display a dialog if necessary. */
+  private void maybeShowBlockNumberMigrationDialog(BlockedNumbersMigrator.Listener listener) {
+    if (!FilteredNumberCompat.maybeShowBlockNumberMigrationDialog(
+        this, getFragmentManager(), listener)) {
+      listener.onComplete();
+    }
+  }
+
+  /** Block and report the number as spam. */
+  private void blockReportNumberAndFinish(
+      String number, boolean reportAsSpam, int contactLookupResultType) {
+    if (reportAsSpam) {
+      logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_MARKED_NUMBER_AS_SPAM);
+      Spam.get(this)
+          .reportSpamFromAfterCallNotification(
+              number,
+              getCountryIso(),
+              CallLog.Calls.INCOMING_TYPE,
+              ReportingLocation.Type.FEEDBACK_PROMPT,
+              contactLookupResultType);
+    }
+
+    logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_BLOCK_NUMBER);
+    filteredNumberAsyncQueryHandler.blockNumber(null, number, getCountryIso());
+    // TODO: DialerCall finish() after block/reporting async tasks complete (b/28441936)
+    finish();
+  }
+
+  /** Report the number as not spam. */
+  private void reportNotSpamAndFinish(String number, int contactLookupResultType) {
+    logCallImpression(DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_REPORT_NUMBER_AS_NOT_SPAM);
+    Spam.get(this)
+        .reportNotSpamFromAfterCallNotification(
+            number,
+            getCountryIso(),
+            CallLog.Calls.INCOMING_TYPE,
+            ReportingLocation.Type.FEEDBACK_PROMPT,
+            contactLookupResultType);
+    // TODO: DialerCall finish() after async task completes (b/28441936)
+    finish();
+  }
+
+  /** Cancels the notification associated with the number. */
+  private void cancelNotification() {
+    int notificationId = getIntent().getIntExtra(EXTRA_NOTIFICATION_ID, 1);
+    String number = getCallInfo().getString(CALL_INFO_KEY_PHONE_NUMBER);
+    ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE))
+        .cancel(number, notificationId);
+  }
+
+  private String getCountryIso() {
+    return GeoUtil.getCurrentCountryIso(this);
+  }
+
+  private void assertDialogsEnabled() {
+    if (!Spam.get(this).isDialogEnabledForSpamNotification()) {
+      throw new IllegalStateException(
+          "Cannot start this activity with given action because dialogs are not enabled.");
+    }
+  }
+
+  private Bundle getCallInfo() {
+    return getIntent().getBundleExtra(EXTRA_CALL_INFO);
+  }
+
+  private void logCallImpression(int impression) {
+    logCallImpression(this, getCallInfo(), impression);
+  }
+
+  /** Dialog that displays "Not spam", "Block/report spam" and "Dismiss". */
+  public static class FirstTimeSpamCallDialogFragment extends DialogFragment {
+
+    public static final String TAG = "FirstTimeSpamDialog";
+
+    private boolean dismissed;
+    private Context applicationContext;
+
+    private static DialogFragment newInstance(Bundle bundle) {
+      FirstTimeSpamCallDialogFragment fragment = new FirstTimeSpamCallDialogFragment();
+      fragment.setArguments(bundle);
+      return fragment;
+    }
+
+    @Override
+    public void onPause() {
+      dismiss();
+      super.onPause();
+    }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+      logCallImpression(
+          applicationContext,
+          getArguments(),
+          DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_ON_DISMISS_SPAM_DIALOG);
+      super.onDismiss(dialog);
+      // If dialog was not dismissed by user pressing one of the buttons, finish activity
+      if (!dismissed && getActivity() != null && !getActivity().isFinishing()) {
+        getActivity().finish();
+      }
+    }
+
+    @Override
+    public void onAttach(Context context) {
+      super.onAttach(context);
+      applicationContext = context.getApplicationContext();
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+      super.onCreateDialog(savedInstanceState);
+      final SpamNotificationActivity spamNotificationActivity =
+          (SpamNotificationActivity) getActivity();
+      final String number = getArguments().getString(CALL_INFO_KEY_PHONE_NUMBER);
+      final int contactLookupResultType =
+          getArguments().getInt(CALL_INFO_CONTACT_LOOKUP_RESULT_TYPE, 0);
+
+      return new AlertDialog.Builder(getActivity())
+          .setCancelable(false)
+          .setTitle(getString(R.string.spam_notification_title, getFormattedNumber(number)))
+          .setMessage(getString(R.string.spam_notification_spam_call_expanded_text))
+          .setNeutralButton(
+              getString(R.string.notification_action_dismiss),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismiss();
+                }
+              })
+          .setPositiveButton(
+              getString(R.string.spam_notification_dialog_was_not_spam_action_text),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismissed = true;
+                  dismiss();
+                  spamNotificationActivity.maybeShowNotSpamDialog(number, contactLookupResultType);
+                }
+              })
+          .setNegativeButton(
+              getString(R.string.spam_notification_block_spam_action_text),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismissed = true;
+                  dismiss();
+                  spamNotificationActivity.maybeShowBlockReportSpamDialog(
+                      number, contactLookupResultType);
+                }
+              })
+          .create();
+    }
+  }
+
+  /** Dialog that displays "Add contact", "Block/report spam" and "Dismiss". */
+  public static class FirstTimeNonSpamCallDialogFragment extends DialogFragment {
+
+    public static final String TAG = "FirstTimeNonSpamDialog";
+
+    private boolean dismissed;
+    private Context context;
+
+    private static DialogFragment newInstance(Bundle bundle) {
+      FirstTimeNonSpamCallDialogFragment fragment = new FirstTimeNonSpamCallDialogFragment();
+      fragment.setArguments(bundle);
+      return fragment;
+    }
+
+    @Override
+    public void onPause() {
+      // Dismiss on pause e.g: orientation change
+      dismiss();
+      super.onPause();
+    }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+      super.onDismiss(dialog);
+      logCallImpression(
+          context,
+          getArguments(),
+          DialerImpression.Type.SPAM_AFTER_CALL_NOTIFICATION_ON_DISMISS_NON_SPAM_DIALOG);
+      // If dialog was not dismissed by user pressing one of the buttons, finish activity
+      if (!dismissed && getActivity() != null && !getActivity().isFinishing()) {
+        getActivity().finish();
+      }
+    }
+
+    @Override
+    public void onAttach(Context context) {
+      super.onAttach(context);
+      this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+      super.onCreateDialog(savedInstanceState);
+      final SpamNotificationActivity spamNotificationActivity =
+          (SpamNotificationActivity) getActivity();
+      final String number = getArguments().getString(CALL_INFO_KEY_PHONE_NUMBER);
+      final int contactLookupResultType =
+          getArguments().getInt(CALL_INFO_CONTACT_LOOKUP_RESULT_TYPE, 0);
+      return new AlertDialog.Builder(getActivity())
+          .setTitle(getString(R.string.non_spam_notification_title, getFormattedNumber(number)))
+          .setCancelable(false)
+          .setMessage(getString(R.string.spam_notification_non_spam_call_expanded_text))
+          .setNeutralButton(
+              getString(R.string.notification_action_dismiss),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismiss();
+                }
+              })
+          .setPositiveButton(
+              getString(R.string.spam_notification_dialog_add_contact_action_text),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismissed = true;
+                  dismiss();
+                  startActivity(createInsertContactsIntent(number));
+                }
+              })
+          .setNegativeButton(
+              getString(R.string.spam_notification_dialog_block_report_spam_action_text),
+              new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  dismissed = true;
+                  dismiss();
+                  spamNotificationActivity.maybeShowBlockReportSpamDialog(
+                      number, contactLookupResultType);
+                }
+              })
+          .create();
+    }
+  }
+}
diff --git a/java/com/android/incallui/spam/SpamNotificationService.java b/java/com/android/incallui/spam/SpamNotificationService.java
new file mode 100644
index 0000000..bf107f7
--- /dev/null
+++ b/java/com/android/incallui/spam/SpamNotificationService.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2016 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.spam;
+
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.provider.CallLog;
+import android.support.annotation.Nullable;
+import com.android.contacts.common.GeoUtil;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.nano.DialerImpression;
+import com.android.dialer.logging.nano.ReportingLocation;
+import com.android.dialer.spam.Spam;
+import com.android.incallui.call.DialerCall;
+
+/**
+ * This service determines if the device is locked/unlocked and takes an action based on the state.
+ * A service is used to to determine this, as opposed to an activity, because the user must unlock
+ * the device before a notification can start an activity. This is not the case for a service, and
+ * intents can be sent to this service even from the lock screen. This allows users to quickly
+ * report a number as spam or not spam from their lock screen.
+ */
+public class SpamNotificationService extends Service {
+
+  private static final String TAG = "SpamNotificationSvc";
+
+  private static final String EXTRA_PHONE_NUMBER = "service_phone_number";
+  private static final String EXTRA_CALL_ID = "service_call_id";
+  private static final String EXTRA_CALL_START_TIME_MILLIS = "service_call_start_time_millis";
+  private static final String EXTRA_NOTIFICATION_ID = "service_notification_id";
+  private static final String EXTRA_CONTACT_LOOKUP_RESULT_TYPE =
+      "service_contact_lookup_result_type";
+  /** Creates an intent to start this service. */
+  public static Intent createServiceIntent(
+      Context context, DialerCall call, String action, int notificationId) {
+    Intent intent = new Intent(context, SpamNotificationService.class);
+    intent.setAction(action);
+    intent.putExtra(EXTRA_PHONE_NUMBER, call.getNumber());
+    intent.putExtra(EXTRA_CALL_ID, call.getUniqueCallId());
+    intent.putExtra(EXTRA_CALL_START_TIME_MILLIS, call.getTimeAddedMs());
+    intent.putExtra(EXTRA_NOTIFICATION_ID, notificationId);
+    intent.putExtra(EXTRA_CONTACT_LOOKUP_RESULT_TYPE, call.getLogState().contactLookupResult);
+    return intent;
+  }
+
+  @Nullable
+  @Override
+  public IBinder onBind(Intent intent) {
+    // Return null because clients cannot bind to this service
+    return null;
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    LogUtil.d(TAG, "onStartCommand");
+    if (intent == null) {
+      LogUtil.d(TAG, "Null intent");
+      stopSelf();
+      // Return {@link #START_NOT_STICKY} so service is not restarted.
+      return START_NOT_STICKY;
+    }
+    String number = intent.getStringExtra(EXTRA_PHONE_NUMBER);
+    int notificationId = intent.getIntExtra(EXTRA_NOTIFICATION_ID, 1);
+    String countryIso = GeoUtil.getCurrentCountryIso(this);
+    int contactLookupResultType = intent.getIntExtra(EXTRA_CONTACT_LOOKUP_RESULT_TYPE, 0);
+
+    ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE))
+        .cancel(number, notificationId);
+
+    switch (intent.getAction()) {
+      case SpamNotificationActivity.ACTION_MARK_NUMBER_AS_SPAM:
+        logCallImpression(
+            intent, DialerImpression.Type.SPAM_NOTIFICATION_SERVICE_ACTION_MARK_NUMBER_AS_SPAM);
+        Spam.get(this)
+            .reportSpamFromAfterCallNotification(
+                number,
+                countryIso,
+                CallLog.Calls.INCOMING_TYPE,
+                ReportingLocation.Type.FEEDBACK_PROMPT,
+                contactLookupResultType);
+        new FilteredNumberAsyncQueryHandler(this).blockNumber(null, number, countryIso);
+        break;
+      case SpamNotificationActivity.ACTION_MARK_NUMBER_AS_NOT_SPAM:
+        logCallImpression(
+            intent, DialerImpression.Type.SPAM_NOTIFICATION_SERVICE_ACTION_MARK_NUMBER_AS_NOT_SPAM);
+        Spam.get(this)
+            .reportNotSpamFromAfterCallNotification(
+                number,
+                countryIso,
+                CallLog.Calls.INCOMING_TYPE,
+                ReportingLocation.Type.FEEDBACK_PROMPT,
+                contactLookupResultType);
+        break;
+    }
+    // TODO: call stopSelf() after async tasks complete (b/28441936)
+    stopSelf();
+    return START_NOT_STICKY;
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    LogUtil.d(TAG, "onDestroy");
+  }
+
+  private void logCallImpression(Intent intent, int impression) {
+    Logger.get(this)
+        .logCallImpression(
+            impression,
+            intent.getStringExtra(EXTRA_CALL_ID),
+            intent.getLongExtra(EXTRA_CALL_START_TIME_MILLIS, 0));
+  }
+}
diff --git a/java/com/android/incallui/util/AccessibilityUtil.java b/java/com/android/incallui/util/AccessibilityUtil.java
new file mode 100644
index 0000000..6575348
--- /dev/null
+++ b/java/com/android/incallui/util/AccessibilityUtil.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.util;
+
+import android.content.Context;
+import android.view.accessibility.AccessibilityManager;
+
+public class AccessibilityUtil {
+
+  public static boolean isAccessibilityEnabled(Context context) {
+    AccessibilityManager accessibilityManager =
+        context.getSystemService(AccessibilityManager.class);
+    return accessibilityManager.isEnabled();
+  }
+
+  public static boolean isTouchExplorationEnabled(Context context) {
+    AccessibilityManager accessibilityManager =
+        context.getSystemService(AccessibilityManager.class);
+    return accessibilityManager.isTouchExplorationEnabled();
+  }
+}
diff --git a/java/com/android/incallui/util/TelecomCallUtil.java b/java/com/android/incallui/util/TelecomCallUtil.java
new file mode 100644
index 0000000..8855543
--- /dev/null
+++ b/java/com/android/incallui/util/TelecomCallUtil.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.util;
+
+import android.net.Uri;
+import android.telecom.Call;
+import android.telephony.PhoneNumberUtils;
+
+/**
+ * Class to provide a standard interface for obtaining information from the underlying
+ * android.telecom.Call. Much of this should be obtained through the incall.Call, but on occasion we
+ * need to interact with the telecom.Call directly (eg. call blocking, before the incall.Call has
+ * been created).
+ */
+public class TelecomCallUtil {
+
+  // Whether the call handle is an emergency number.
+  public static boolean isEmergencyCall(Call call) {
+    Uri handle = call.getDetails().getHandle();
+    return PhoneNumberUtils.isEmergencyNumber(handle == null ? "" : handle.getSchemeSpecificPart());
+  }
+
+  public static String getNumber(Call call) {
+    if (call == null) {
+      return null;
+    }
+    if (call.getDetails().getGatewayInfo() != null) {
+      return call.getDetails().getGatewayInfo().getOriginalAddress().getSchemeSpecificPart();
+    }
+    Uri handle = getHandle(call);
+    return handle == null ? null : handle.getSchemeSpecificPart();
+  }
+
+  public static Uri getHandle(Call call) {
+    return call == null ? null : call.getDetails().getHandle();
+  }
+}
diff --git a/java/com/android/incallui/video/bindings/VideoBindings.java b/java/com/android/incallui/video/bindings/VideoBindings.java
new file mode 100644
index 0000000..934ff07
--- /dev/null
+++ b/java/com/android/incallui/video/bindings/VideoBindings.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 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.video.bindings;
+
+import com.android.incallui.video.impl.VideoCallFragment;
+import com.android.incallui.video.protocol.VideoCallScreen;
+
+/** Bindings for video module. */
+public class VideoBindings {
+
+  public static VideoCallScreen createVideoCallScreen() {
+    return new VideoCallFragment();
+  }
+}
diff --git a/java/com/android/incallui/video/impl/AndroidManifest.xml b/java/com/android/incallui/video/impl/AndroidManifest.xml
new file mode 100644
index 0000000..a36828e
--- /dev/null
+++ b/java/com/android/incallui/video/impl/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.video.impl">
+</manifest>
diff --git a/java/com/android/incallui/video/impl/CameraPermissionDialogFragment.java b/java/com/android/incallui/video/impl/CameraPermissionDialogFragment.java
new file mode 100644
index 0000000..291fce4
--- /dev/null
+++ b/java/com/android/incallui/video/impl/CameraPermissionDialogFragment.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 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.video.impl;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import com.android.dialer.common.FragmentUtils;
+
+/** Dialog fragment to ask for camera permission from user. */
+public class CameraPermissionDialogFragment extends DialogFragment {
+
+  static CameraPermissionDialogFragment newInstance() {
+    CameraPermissionDialogFragment fragment = new CameraPermissionDialogFragment();
+    return fragment;
+  }
+
+  @NonNull
+  @Override
+  public Dialog onCreateDialog(Bundle bundle) {
+    return new AlertDialog.Builder(getContext())
+        .setTitle(R.string.camera_permission_dialog_title)
+        .setMessage(R.string.camera_permission_dialog_message)
+        .setPositiveButton(
+            R.string.camera_permission_dialog_positive_button,
+            new DialogInterface.OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialog, int which) {
+                VideoCallFragment fragment =
+                    FragmentUtils.getParentUnsafe(
+                        CameraPermissionDialogFragment.this, VideoCallFragment.class);
+                fragment.onCameraPermissionGranted();
+              }
+            })
+        .setNegativeButton(
+            R.string.camera_permission_dialog_negative_button,
+            new DialogInterface.OnClickListener() {
+              @Override
+              public void onClick(DialogInterface dialog, int which) {
+                dialog.dismiss();
+              }
+            })
+        .create();
+  }
+}
diff --git a/java/com/android/incallui/video/impl/CheckableImageButton.java b/java/com/android/incallui/video/impl/CheckableImageButton.java
new file mode 100644
index 0000000..320f057
--- /dev/null
+++ b/java/com/android/incallui/video/impl/CheckableImageButton.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2016 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.video.impl;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.SoundEffectConstants;
+import android.widget.Checkable;
+import android.widget.ImageButton;
+
+/** Image button that maintains a checked state. */
+public class CheckableImageButton extends ImageButton implements Checkable {
+
+  private static final int[] CHECKED_STATE_SET = {android.R.attr.state_checked};
+
+  /** Callback interface to notify when the button's checked state has changed */
+  public interface OnCheckedChangeListener {
+
+    void onCheckedChanged(CheckableImageButton button, boolean isChecked);
+  }
+
+  private boolean broadcasting;
+  private boolean isChecked;
+  private OnCheckedChangeListener onCheckedChangeListener;
+  private CharSequence contentDescriptionChecked;
+  private CharSequence contentDescriptionUnchecked;
+
+  public CheckableImageButton(Context context) {
+    this(context, null);
+  }
+
+  public CheckableImageButton(Context context, AttributeSet attrs) {
+    this(context, attrs, 0);
+  }
+
+  public CheckableImageButton(Context context, AttributeSet attrs, int defStyleAttr) {
+    super(context, attrs, defStyleAttr);
+    init(context, attrs);
+  }
+
+  private void init(Context context, AttributeSet attrs) {
+    TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.CheckableImageButton);
+    setChecked(typedArray.getBoolean(R.styleable.CheckableImageButton_android_checked, false));
+    contentDescriptionChecked =
+        typedArray.getText(R.styleable.CheckableImageButton_contentDescriptionChecked);
+    contentDescriptionUnchecked =
+        typedArray.getText(R.styleable.CheckableImageButton_contentDescriptionUnchecked);
+    typedArray.recycle();
+
+    updateContentDescription();
+    setClickable(true);
+    setFocusable(true);
+  }
+
+  @Override
+  public void setChecked(boolean checked) {
+    performSetChecked(checked);
+  }
+
+  /**
+   * Called when the state of the button should be updated, this should not be the result of user
+   * interaction.
+   *
+   * @param checked {@code true} if the button should be in the checked state, {@code false}
+   *     otherwise.
+   */
+  private void performSetChecked(boolean checked) {
+    if (isChecked() == checked) {
+      return;
+    }
+    isChecked = checked;
+    CharSequence contentDescription = updateContentDescription();
+    announceForAccessibility(contentDescription);
+    refreshDrawableState();
+  }
+
+  private CharSequence updateContentDescription() {
+    CharSequence contentDescription =
+        isChecked ? contentDescriptionChecked : contentDescriptionUnchecked;
+    setContentDescription(contentDescription);
+    return contentDescription;
+  }
+
+  /**
+   * Called when the user interacts with a button. This should not result in the button updating
+   * state, rather the request should be propagated to the associated listener.
+   *
+   * @param checked {@code true} if the button should be in the checked state, {@code false}
+   *     otherwise.
+   */
+  private void userRequestedSetChecked(boolean checked) {
+    if (isChecked() == checked) {
+      return;
+    }
+    if (broadcasting) {
+      return;
+    }
+    broadcasting = true;
+    if (onCheckedChangeListener != null) {
+      onCheckedChangeListener.onCheckedChanged(this, checked);
+    }
+    broadcasting = false;
+  }
+
+  @Override
+  public boolean isChecked() {
+    return isChecked;
+  }
+
+  @Override
+  public void toggle() {
+    userRequestedSetChecked(!isChecked());
+  }
+
+  @Override
+  public int[] onCreateDrawableState(int extraSpace) {
+    final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
+    if (isChecked()) {
+      mergeDrawableStates(drawableState, CHECKED_STATE_SET);
+    }
+    return drawableState;
+  }
+
+  @Override
+  protected void drawableStateChanged() {
+    super.drawableStateChanged();
+    invalidate();
+  }
+
+  public void setOnCheckedChangeListener(OnCheckedChangeListener listener) {
+    this.onCheckedChangeListener = listener;
+  }
+
+  @Override
+  public boolean performClick() {
+    if (!isCheckable()) {
+      return super.performClick();
+    }
+
+    toggle();
+    final boolean handled = super.performClick();
+    if (!handled) {
+      // View only makes a sound effect if the onClickListener was
+      // called, so we'll need to make one here instead.
+      playSoundEffect(SoundEffectConstants.CLICK);
+    }
+    return handled;
+  }
+
+  private boolean isCheckable() {
+    return onCheckedChangeListener != null;
+  }
+
+  @Override
+  protected void onRestoreInstanceState(Parcelable state) {
+    SavedState savedState = (SavedState) state;
+    super.onRestoreInstanceState(savedState.getSuperState());
+    performSetChecked(savedState.isChecked);
+    requestLayout();
+  }
+
+  @Override
+  protected Parcelable onSaveInstanceState() {
+    return new SavedState(isChecked(), super.onSaveInstanceState());
+  }
+
+  private static class SavedState extends BaseSavedState {
+
+    public final boolean isChecked;
+
+    private SavedState(boolean isChecked, Parcelable superState) {
+      super(superState);
+      this.isChecked = isChecked;
+    }
+
+    protected SavedState(Parcel in) {
+      super(in);
+      isChecked = in.readByte() != 0;
+    }
+
+    public static final Creator<SavedState> CREATOR =
+        new Creator<SavedState>() {
+          @Override
+          public SavedState createFromParcel(Parcel in) {
+            return new SavedState(in);
+          }
+
+          @Override
+          public SavedState[] newArray(int size) {
+            return new SavedState[size];
+          }
+        };
+
+    @Override
+    public int describeContents() {
+      return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+      super.writeToParcel(dest, flags);
+      dest.writeByte((byte) (isChecked ? 1 : 0));
+    }
+  }
+}
diff --git a/java/com/android/incallui/video/impl/SpeakerButtonController.java b/java/com/android/incallui/video/impl/SpeakerButtonController.java
new file mode 100644
index 0000000..e12032a
--- /dev/null
+++ b/java/com/android/incallui/video/impl/SpeakerButtonController.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 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.video.impl;
+
+import android.support.annotation.DrawableRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.StringRes;
+import android.telecom.CallAudioState;
+import android.view.View;
+import android.view.View.OnClickListener;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+import com.android.incallui.video.impl.CheckableImageButton.OnCheckedChangeListener;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+
+/** Manages a single button. */
+public class SpeakerButtonController implements OnCheckedChangeListener, OnClickListener {
+
+  @NonNull private final InCallButtonUiDelegate inCallButtonUiDelegate;
+  @NonNull private final VideoCallScreenDelegate videoCallScreenDelegate;
+
+  @NonNull private CheckableImageButton button;
+
+  @DrawableRes private int icon = R.drawable.quantum_ic_volume_up_white_36;
+
+  private boolean isChecked;
+  private boolean checkable;
+  private boolean isEnabled;
+  private CharSequence contentDescription;
+
+  public SpeakerButtonController(
+      @NonNull CheckableImageButton button,
+      @NonNull InCallButtonUiDelegate inCallButtonUiDelegate,
+      @NonNull VideoCallScreenDelegate videoCallScreenDelegate) {
+    this.inCallButtonUiDelegate = Assert.isNotNull(inCallButtonUiDelegate);
+    this.videoCallScreenDelegate = Assert.isNotNull(videoCallScreenDelegate);
+    this.button = Assert.isNotNull(button);
+  }
+
+  public void setEnabled(boolean isEnabled) {
+    this.isEnabled = isEnabled;
+  }
+
+  public void updateButtonState() {
+    button.setVisibility(View.VISIBLE);
+    button.setEnabled(isEnabled);
+    button.setChecked(isChecked);
+    button.setOnClickListener(checkable ? null : this);
+    button.setOnCheckedChangeListener(checkable ? this : null);
+    button.setImageResource(icon);
+    button.setContentDescription(contentDescription);
+  }
+
+  public void setAudioState(CallAudioState audioState) {
+    LogUtil.i("SpeakerButtonController.setSupportedAudio", "audioState: " + audioState);
+
+    @StringRes int contentDescriptionResId;
+    if ((audioState.getSupportedRouteMask() & CallAudioState.ROUTE_BLUETOOTH)
+        == CallAudioState.ROUTE_BLUETOOTH) {
+      checkable = false;
+      isChecked = false;
+
+      if ((audioState.getRoute() & CallAudioState.ROUTE_BLUETOOTH)
+          == CallAudioState.ROUTE_BLUETOOTH) {
+        icon = R.drawable.quantum_ic_bluetooth_audio_white_36;
+        contentDescriptionResId = R.string.incall_content_description_bluetooth;
+      } else if ((audioState.getRoute() & CallAudioState.ROUTE_SPEAKER)
+          == CallAudioState.ROUTE_SPEAKER) {
+        icon = R.drawable.quantum_ic_volume_up_white_36;
+        contentDescriptionResId = R.string.incall_content_description_speaker;
+      } else if ((audioState.getRoute() & CallAudioState.ROUTE_WIRED_HEADSET)
+          == CallAudioState.ROUTE_WIRED_HEADSET) {
+        icon = R.drawable.quantum_ic_headset_white_36;
+        contentDescriptionResId = R.string.incall_content_description_headset;
+      } else {
+        icon = R.drawable.ic_phone_audio_white_36dp;
+        contentDescriptionResId = R.string.incall_content_description_earpiece;
+      }
+    } else {
+      checkable = true;
+      isChecked = audioState.getRoute() == CallAudioState.ROUTE_SPEAKER;
+      icon = R.drawable.quantum_ic_volume_up_white_36;
+      contentDescriptionResId = R.string.incall_content_description_speaker;
+    }
+
+    contentDescription = button.getContext().getText(contentDescriptionResId);
+    updateButtonState();
+  }
+
+  @Override
+  public void onCheckedChanged(CheckableImageButton button, boolean isChecked) {
+    LogUtil.i("SpeakerButtonController.onCheckedChanged", null);
+    inCallButtonUiDelegate.toggleSpeakerphone();
+    videoCallScreenDelegate.resetAutoFullscreenTimer();
+  }
+
+  @Override
+  public void onClick(View view) {
+    LogUtil.i("SpeakerButtonController.onClick", null);
+    inCallButtonUiDelegate.showAudioRouteSelector();
+    videoCallScreenDelegate.resetAutoFullscreenTimer();
+  }
+}
diff --git a/java/com/android/incallui/video/impl/SwitchOnHoldCallController.java b/java/com/android/incallui/video/impl/SwitchOnHoldCallController.java
new file mode 100644
index 0000000..372b56b
--- /dev/null
+++ b/java/com/android/incallui/video/impl/SwitchOnHoldCallController.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2016 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.video.impl;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.View;
+import android.view.View.OnClickListener;
+import com.android.dialer.common.Assert;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+
+/** Manages the swap button and on hold banner. */
+public class SwitchOnHoldCallController implements OnClickListener {
+
+  @NonNull private InCallScreenDelegate inCallScreenDelegate;
+  @NonNull private VideoCallScreenDelegate videoCallScreenDelegate;
+
+  @NonNull private View switchOnHoldButton;
+
+  @NonNull private View onHoldBanner;
+
+  private boolean isVisible;
+
+  private boolean isEnabled;
+
+  @Nullable private SecondaryInfo secondaryInfo;
+
+  public SwitchOnHoldCallController(
+      @NonNull View switchOnHoldButton,
+      @NonNull View onHoldBanner,
+      @NonNull InCallScreenDelegate inCallScreenDelegate,
+      @NonNull VideoCallScreenDelegate videoCallScreenDelegate) {
+    this.switchOnHoldButton = Assert.isNotNull(switchOnHoldButton);
+    switchOnHoldButton.setOnClickListener(this);
+    this.onHoldBanner = Assert.isNotNull(onHoldBanner);
+    this.inCallScreenDelegate = Assert.isNotNull(inCallScreenDelegate);
+    this.videoCallScreenDelegate = Assert.isNotNull(videoCallScreenDelegate);
+  }
+
+  public void setEnabled(boolean isEnabled) {
+    this.isEnabled = isEnabled;
+    updateButtonState();
+  }
+
+  public void setVisible(boolean isVisible) {
+    this.isVisible = isVisible;
+    updateButtonState();
+  }
+
+  public void setOnScreen() {
+    isVisible = hasSecondaryInfo();
+    updateButtonState();
+  }
+
+  public void setSecondaryInfo(@Nullable SecondaryInfo secondaryInfo) {
+    this.secondaryInfo = secondaryInfo;
+    isVisible = hasSecondaryInfo();
+  }
+
+  private boolean hasSecondaryInfo() {
+    return secondaryInfo != null && secondaryInfo.shouldShow;
+  }
+
+  public void updateButtonState() {
+    switchOnHoldButton.setEnabled(isEnabled);
+    switchOnHoldButton.setVisibility(isVisible ? View.VISIBLE : View.INVISIBLE);
+    onHoldBanner.setVisibility(isVisible ? View.VISIBLE : View.INVISIBLE);
+  }
+
+  @Override
+  public void onClick(View view) {
+    inCallScreenDelegate.onSecondaryInfoClicked();
+    videoCallScreenDelegate.resetAutoFullscreenTimer();
+  }
+}
diff --git a/java/com/android/incallui/video/impl/VideoCallFragment.java b/java/com/android/incallui/video/impl/VideoCallFragment.java
new file mode 100644
index 0000000..77a67d0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/VideoCallFragment.java
@@ -0,0 +1,1215 @@
+/*
+ * Copyright (C) 2016 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.video.impl;
+
+import android.Manifest.permission;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Outline;
+import android.graphics.Point;
+import android.graphics.drawable.Animatable;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.ScriptIntrinsicBlur;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.view.animation.FastOutLinearInInterpolator;
+import android.support.v4.view.animation.LinearOutSlowInInterpolator;
+import android.telecom.CallAudioState;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.Surface;
+import android.view.TextureView;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnSystemUiVisibilityChangeListener;
+import android.view.ViewGroup;
+import android.view.ViewGroup.MarginLayoutParams;
+import android.view.ViewOutlineProvider;
+import android.view.ViewTreeObserver;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.FragmentUtils;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.compat.ActivityCompat;
+import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment;
+import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment.AudioRouteSelectorPresenter;
+import com.android.incallui.call.VideoUtils;
+import com.android.incallui.contactgrid.ContactGridManager;
+import com.android.incallui.hold.OnHoldFragment;
+import com.android.incallui.incall.protocol.InCallButtonIds;
+import com.android.incallui.incall.protocol.InCallButtonIdsExtension;
+import com.android.incallui.incall.protocol.InCallButtonUi;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
+import com.android.incallui.incall.protocol.InCallButtonUiDelegateFactory;
+import com.android.incallui.incall.protocol.InCallScreen;
+import com.android.incallui.incall.protocol.InCallScreenDelegate;
+import com.android.incallui.incall.protocol.InCallScreenDelegateFactory;
+import com.android.incallui.incall.protocol.PrimaryCallState;
+import com.android.incallui.incall.protocol.PrimaryInfo;
+import com.android.incallui.incall.protocol.SecondaryInfo;
+import com.android.incallui.video.impl.CheckableImageButton.OnCheckedChangeListener;
+import com.android.incallui.video.protocol.VideoCallScreen;
+import com.android.incallui.video.protocol.VideoCallScreenDelegate;
+import com.android.incallui.video.protocol.VideoCallScreenDelegateFactory;
+import com.android.incallui.videosurface.bindings.VideoSurfaceBindings;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+
+/** Contains UI elements for a video call. */
+public class VideoCallFragment extends Fragment
+    implements InCallScreen,
+        InCallButtonUi,
+        VideoCallScreen,
+        OnClickListener,
+        OnCheckedChangeListener,
+        AudioRouteSelectorPresenter,
+        OnSystemUiVisibilityChangeListener {
+
+  private static final float BLUR_PREVIEW_RADIUS = 16.0f;
+  private static final float BLUR_PREVIEW_SCALE_FACTOR = 1.0f;
+  private static final float BLUR_REMOTE_RADIUS = 25.0f;
+  private static final float BLUR_REMOTE_SCALE_FACTOR = 0.25f;
+  private static final float ASPECT_RATIO_MATCH_THRESHOLD = 0.2f;
+
+  private static final int CAMERA_PERMISSION_REQUEST_CODE = 1;
+  private static final String CAMERA_PERMISSION_DIALOG_FRAMENT_TAG =
+      "CameraPermissionDialogFragment";
+  private static final long CAMERA_PERMISSION_DIALOG_DELAY_IN_MILLIS = 2000L;
+  private static final long VIDEO_OFF_VIEW_FADE_OUT_DELAY_IN_MILLIS = 2000L;
+
+  private final ViewOutlineProvider circleOutlineProvider =
+      new ViewOutlineProvider() {
+        @Override
+        public void getOutline(View view, Outline outline) {
+          int x = view.getWidth() / 2;
+          int y = view.getHeight() / 2;
+          int radius = Math.min(x, y);
+          outline.setOval(x - radius, y - radius, x + radius, y + radius);
+        }
+      };
+  private InCallScreenDelegate inCallScreenDelegate;
+  private VideoCallScreenDelegate videoCallScreenDelegate;
+  private InCallButtonUiDelegate inCallButtonUiDelegate;
+  private View endCallButton;
+  private CheckableImageButton speakerButton;
+  private SpeakerButtonController speakerButtonController;
+  private CheckableImageButton muteButton;
+  private CheckableImageButton cameraOffButton;
+  private ImageButton swapCameraButton;
+  private View switchOnHoldButton;
+  private View onHoldContainer;
+  private SwitchOnHoldCallController switchOnHoldCallController;
+  private TextView remoteVideoOff;
+  private ImageView remoteOffBlurredImageView;
+  private View mutePreviewOverlay;
+  private View previewOffOverlay;
+  private ImageView previewOffBlurredImageView;
+  private View controls;
+  private View controlsContainer;
+  private TextureView previewTextureView;
+  private TextureView remoteTextureView;
+  private View greenScreenBackgroundView;
+  private View fullscreenBackgroundView;
+  private boolean shouldShowRemote;
+  private boolean shouldShowPreview;
+  private boolean isInFullscreenMode;
+  private boolean isInGreenScreenMode;
+  private boolean hasInitializedScreenModes;
+  private boolean isRemotelyHeld;
+  private ContactGridManager contactGridManager;
+  private SecondaryInfo savedSecondaryInfo;
+  private final Runnable cameraPermissionDialogRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          if (videoCallScreenDelegate.shouldShowCameraPermissionDialog()) {
+            LogUtil.i("VideoCallFragment.cameraPermissionDialogRunnable", "showing dialog");
+            checkCameraPermission();
+          }
+        }
+      };
+
+  @Override
+  public void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    LogUtil.i("VideoCallFragment.onCreate", null);
+
+    inCallButtonUiDelegate =
+        FragmentUtils.getParent(this, InCallButtonUiDelegateFactory.class)
+            .newInCallButtonUiDelegate();
+    if (savedInstanceState != null) {
+      inCallButtonUiDelegate.onRestoreInstanceState(savedInstanceState);
+    }
+  }
+
+  @Override
+  public void onRequestPermissionsResult(
+      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    if (requestCode == CAMERA_PERMISSION_REQUEST_CODE) {
+      if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+        LogUtil.i("VideoCallFragment.onRequestPermissionsResult", "Camera permission granted.");
+        videoCallScreenDelegate.onCameraPermissionGranted();
+      } else {
+        LogUtil.i("VideoCallFragment.onRequestPermissionsResult", "Camera permission denied.");
+      }
+    }
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+  }
+
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+    LogUtil.i("VideoCallFragment.onCreateView", null);
+
+    View view =
+        layoutInflater.inflate(
+            isLandscape() ? R.layout.frag_videocall_land : R.layout.frag_videocall,
+            viewGroup,
+            false);
+    contactGridManager =
+        new ContactGridManager(view, null /* no avatar */, 0, false /* showAnonymousAvatar */);
+
+    controls = view.findViewById(R.id.videocall_video_controls);
+    controls.setVisibility(
+        ActivityCompat.isInMultiWindowMode(getActivity()) ? View.GONE : View.VISIBLE);
+    controlsContainer = view.findViewById(R.id.videocall_video_controls_container);
+    speakerButton = (CheckableImageButton) view.findViewById(R.id.videocall_speaker_button);
+    muteButton = (CheckableImageButton) view.findViewById(R.id.videocall_mute_button);
+    muteButton.setOnCheckedChangeListener(this);
+    mutePreviewOverlay = view.findViewById(R.id.videocall_video_preview_mute_overlay);
+    cameraOffButton = (CheckableImageButton) view.findViewById(R.id.videocall_mute_video);
+    cameraOffButton.setOnCheckedChangeListener(this);
+    previewOffOverlay = view.findViewById(R.id.videocall_video_preview_off_overlay);
+    previewOffBlurredImageView =
+        (ImageView) view.findViewById(R.id.videocall_preview_off_blurred_image_view);
+    swapCameraButton = (ImageButton) view.findViewById(R.id.videocall_switch_video);
+    swapCameraButton.setOnClickListener(this);
+    view.findViewById(R.id.videocall_switch_controls)
+        .setVisibility(
+            ActivityCompat.isInMultiWindowMode(getActivity()) ? View.GONE : View.VISIBLE);
+    switchOnHoldButton = view.findViewById(R.id.videocall_switch_on_hold);
+    onHoldContainer = view.findViewById(R.id.videocall_on_hold_banner);
+    remoteVideoOff = (TextView) view.findViewById(R.id.videocall_remote_video_off);
+    remoteVideoOff.setAccessibilityLiveRegion(View.ACCESSIBILITY_LIVE_REGION_POLITE);
+    remoteOffBlurredImageView =
+        (ImageView) view.findViewById(R.id.videocall_remote_off_blurred_image_view);
+    endCallButton = view.findViewById(R.id.videocall_end_call);
+    endCallButton.setOnClickListener(this);
+    previewTextureView = (TextureView) view.findViewById(R.id.videocall_video_preview);
+    previewTextureView.setClipToOutline(true);
+    previewOffOverlay.setOnClickListener(
+        new OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            checkCameraPermission();
+          }
+        });
+    remoteTextureView = (TextureView) view.findViewById(R.id.videocall_video_remote);
+    greenScreenBackgroundView = view.findViewById(R.id.videocall_green_screen_background);
+    fullscreenBackgroundView = view.findViewById(R.id.videocall_fullscreen_background);
+
+    // We need the texture view size to be able to scale the remote video. At this point the view
+    // layout won't be complete so add a layout listener.
+    ViewTreeObserver observer = remoteTextureView.getViewTreeObserver();
+    observer.addOnGlobalLayoutListener(
+        new ViewTreeObserver.OnGlobalLayoutListener() {
+          @Override
+          public void onGlobalLayout() {
+            LogUtil.i("VideoCallFragment.onGlobalLayout", null);
+            updateRemoteVideoScaling();
+            updatePreviewVideoScaling();
+            updateVideoOffViews();
+            // Remove the listener so we don't continually re-layout.
+            ViewTreeObserver observer = remoteTextureView.getViewTreeObserver();
+            if (observer.isAlive()) {
+              observer.removeOnGlobalLayoutListener(this);
+            }
+          }
+        });
+
+    return view;
+  }
+
+  @Override
+  public void onViewCreated(View view, @Nullable Bundle bundle) {
+    super.onViewCreated(view, bundle);
+    LogUtil.i("VideoCallFragment.onViewCreated", null);
+
+    inCallScreenDelegate =
+        FragmentUtils.getParentUnsafe(this, InCallScreenDelegateFactory.class)
+            .newInCallScreenDelegate();
+    videoCallScreenDelegate =
+        FragmentUtils.getParentUnsafe(this, VideoCallScreenDelegateFactory.class)
+            .newVideoCallScreenDelegate();
+
+    speakerButtonController =
+        new SpeakerButtonController(speakerButton, inCallButtonUiDelegate, videoCallScreenDelegate);
+    switchOnHoldCallController =
+        new SwitchOnHoldCallController(
+            switchOnHoldButton, onHoldContainer, inCallScreenDelegate, videoCallScreenDelegate);
+
+    videoCallScreenDelegate.initVideoCallScreenDelegate(getContext(), this);
+
+    inCallScreenDelegate.onInCallScreenDelegateInit(this);
+    inCallScreenDelegate.onInCallScreenReady();
+    inCallButtonUiDelegate.onInCallButtonUiReady(this);
+
+    view.setOnSystemUiVisibilityChangeListener(this);
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    inCallButtonUiDelegate.onSaveInstanceState(outState);
+  }
+
+  @Override
+  public void onDestroyView() {
+    super.onDestroyView();
+    LogUtil.i("VideoCallFragment.onDestroyView", null);
+    inCallButtonUiDelegate.onInCallButtonUiUnready();
+    inCallScreenDelegate.onInCallScreenUnready();
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    if (savedSecondaryInfo != null) {
+      setSecondary(savedSecondaryInfo);
+    }
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    LogUtil.i("VideoCallFragment.onResume", null);
+    inCallScreenDelegate.onInCallScreenResumed();
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    LogUtil.i("VideoCallFragment.onStart", null);
+    inCallButtonUiDelegate.refreshMuteState();
+    videoCallScreenDelegate.onVideoCallScreenUiReady();
+    getView().postDelayed(cameraPermissionDialogRunnable, CAMERA_PERMISSION_DIALOG_DELAY_IN_MILLIS);
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    LogUtil.i("VideoCallFragment.onPause", null);
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    LogUtil.i("VideoCallFragment.onStop", null);
+    getView().removeCallbacks(cameraPermissionDialogRunnable);
+    videoCallScreenDelegate.onVideoCallScreenUiUnready();
+  }
+
+  private void exitFullscreenMode() {
+    LogUtil.i("VideoCallFragment.exitFullscreenMode", null);
+
+    if (!getView().isAttachedToWindow()) {
+      LogUtil.i("VideoCallFragment.exitFullscreenMode", "not attached");
+      return;
+    }
+
+    showSystemUI();
+
+    LinearOutSlowInInterpolator linearOutSlowInInterpolator = new LinearOutSlowInInterpolator();
+
+    // Animate the controls to the shown state.
+    controls
+        .animate()
+        .translationX(0)
+        .translationY(0)
+        .setInterpolator(linearOutSlowInInterpolator)
+        .alpha(1)
+        .start();
+
+    // Animate onHold to the shown state.
+    switchOnHoldButton
+        .animate()
+        .translationX(0)
+        .translationY(0)
+        .setInterpolator(linearOutSlowInInterpolator)
+        .alpha(1)
+        .withStartAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                switchOnHoldCallController.setOnScreen();
+              }
+            });
+
+    View contactGridView = contactGridManager.getContainerView();
+    // Animate contact grid to the shown state.
+    contactGridView
+        .animate()
+        .translationX(0)
+        .translationY(0)
+        .setInterpolator(linearOutSlowInInterpolator)
+        .alpha(1)
+        .withStartAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                contactGridManager.show();
+              }
+            });
+
+    endCallButton
+        .animate()
+        .translationX(0)
+        .translationY(0)
+        .setInterpolator(linearOutSlowInInterpolator)
+        .alpha(1)
+        .withStartAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                endCallButton.setVisibility(View.VISIBLE);
+              }
+            })
+        .start();
+
+    // Animate all the preview controls up to make room for the navigation bar.
+    // In green screen mode we don't need this because the preview takes up the whole screen and has
+    // a fixed position.
+    if (!isInGreenScreenMode) {
+      Point previewOffsetStartShown = getPreviewOffsetStartShown();
+      for (View view : getAllPreviewRelatedViews()) {
+        // Animate up with the preview offset above the navigation bar.
+        view.animate()
+            .translationX(previewOffsetStartShown.x)
+            .translationY(previewOffsetStartShown.y)
+            .setInterpolator(new AccelerateDecelerateInterpolator())
+            .start();
+      }
+    }
+
+    updateOverlayBackground();
+  }
+
+  private void showSystemUI() {
+    View view = getView();
+    if (view != null) {
+      // Code is more expressive with all flags present, even though some may be combined
+      //noinspection PointlessBitwiseExpression
+      view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+    }
+  }
+
+  /** Set view flags to hide the system UI. System UI will return on any touch event */
+  private void hideSystemUI() {
+    View view = getView();
+    if (view != null) {
+      view.setSystemUiVisibility(
+          View.SYSTEM_UI_FLAG_FULLSCREEN
+              | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+              | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+    }
+  }
+
+  private Point getControlsOffsetEndHidden(View controls) {
+    if (isLandscape()) {
+      return new Point(0, getOffsetBottom(controls));
+    } else {
+      return new Point(getOffsetStart(controls), 0);
+    }
+  }
+
+  private Point getSwitchOnHoldOffsetEndHidden(View swapCallButton) {
+    if (isLandscape()) {
+      return new Point(0, getOffsetTop(swapCallButton));
+    } else {
+      return new Point(getOffsetEnd(swapCallButton), 0);
+    }
+  }
+
+  private Point getContactGridOffsetEndHidden(View view) {
+    return new Point(0, getOffsetTop(view));
+  }
+
+  private Point getEndCallOffsetEndHidden(View endCallButton) {
+    if (isLandscape()) {
+      return new Point(getOffsetEnd(endCallButton), 0);
+    } else {
+      return new Point(0, ((MarginLayoutParams) endCallButton.getLayoutParams()).bottomMargin);
+    }
+  }
+
+  private Point getPreviewOffsetStartShown() {
+    // No insets in multiwindow mode, and rootWindowInsets will get the display's insets.
+    if (ActivityCompat.isInMultiWindowMode(getActivity())) {
+      return new Point();
+    }
+    if (isLandscape()) {
+      int stableInsetEnd =
+          getView().getLayoutDirection() == View.LAYOUT_DIRECTION_RTL
+              ? getView().getRootWindowInsets().getStableInsetLeft()
+              : -getView().getRootWindowInsets().getStableInsetRight();
+      return new Point(stableInsetEnd, 0);
+    } else {
+      return new Point(0, -getView().getRootWindowInsets().getStableInsetBottom());
+    }
+  }
+
+  private View[] getAllPreviewRelatedViews() {
+    return new View[] {
+      previewTextureView, previewOffOverlay, previewOffBlurredImageView, mutePreviewOverlay,
+    };
+  }
+
+  private int getOffsetTop(View view) {
+    return -(view.getHeight() + ((MarginLayoutParams) view.getLayoutParams()).topMargin);
+  }
+
+  private int getOffsetBottom(View view) {
+    return view.getHeight() + ((MarginLayoutParams) view.getLayoutParams()).bottomMargin;
+  }
+
+  private int getOffsetStart(View view) {
+    int offset = view.getWidth() + ((MarginLayoutParams) view.getLayoutParams()).getMarginStart();
+    if (view.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) {
+      offset = -offset;
+    }
+    return -offset;
+  }
+
+  private int getOffsetEnd(View view) {
+    int offset = view.getWidth() + ((MarginLayoutParams) view.getLayoutParams()).getMarginEnd();
+    if (view.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) {
+      offset = -offset;
+    }
+    return offset;
+  }
+
+  private void enterFullscreenMode() {
+    LogUtil.i("VideoCallFragment.enterFullscreenMode", null);
+
+    hideSystemUI();
+
+    Interpolator fastOutLinearInInterpolator = new FastOutLinearInInterpolator();
+
+    // Animate controls to the hidden state.
+    Point offset = getControlsOffsetEndHidden(controls);
+    controls
+        .animate()
+        .translationX(offset.x)
+        .translationY(offset.y)
+        .setInterpolator(fastOutLinearInInterpolator)
+        .alpha(0)
+        .start();
+
+    // Animate onHold to the hidden state.
+    offset = getSwitchOnHoldOffsetEndHidden(switchOnHoldButton);
+    switchOnHoldButton
+        .animate()
+        .translationX(offset.x)
+        .translationY(offset.y)
+        .setInterpolator(fastOutLinearInInterpolator)
+        .alpha(0);
+
+    View contactGridView = contactGridManager.getContainerView();
+    // Animate contact grid to the hidden state.
+    offset = getContactGridOffsetEndHidden(contactGridView);
+    contactGridView
+        .animate()
+        .translationX(offset.x)
+        .translationY(offset.y)
+        .setInterpolator(fastOutLinearInInterpolator)
+        .alpha(0);
+
+    offset = getEndCallOffsetEndHidden(endCallButton);
+    // Use a fast out interpolator to quickly fade out the button. This is important because the
+    // button can't draw under the navigation bar which means that it'll look weird if it just
+    // abruptly disappears when it reaches the edge of the naivgation bar.
+    endCallButton
+        .animate()
+        .translationX(offset.x)
+        .translationY(offset.y)
+        .setInterpolator(fastOutLinearInInterpolator)
+        .alpha(0)
+        .withEndAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                endCallButton.setVisibility(View.INVISIBLE);
+              }
+            })
+        .setInterpolator(new FastOutLinearInInterpolator())
+        .start();
+
+    // Animate all the preview controls down now that the navigation bar is hidden.
+    // In green screen mode we don't need this because the preview takes up the whole screen and has
+    // a fixed position.
+    if (!isInGreenScreenMode) {
+      for (View view : getAllPreviewRelatedViews()) {
+        // Animate down with the navigation bar hidden.
+        view.animate()
+            .translationX(0)
+            .translationY(0)
+            .setInterpolator(new AccelerateDecelerateInterpolator())
+            .start();
+      }
+    }
+    updateOverlayBackground();
+  }
+
+  @Override
+  public void onClick(View v) {
+    if (v == endCallButton) {
+      LogUtil.i("VideoCallFragment.onClick", "end call button clicked");
+      inCallButtonUiDelegate.onEndCallClicked();
+      videoCallScreenDelegate.resetAutoFullscreenTimer();
+    } else if (v == swapCameraButton) {
+      if (swapCameraButton.getDrawable() instanceof Animatable) {
+        ((Animatable) swapCameraButton.getDrawable()).start();
+      }
+      inCallButtonUiDelegate.toggleCameraClicked();
+      videoCallScreenDelegate.resetAutoFullscreenTimer();
+    }
+  }
+
+  @Override
+  public void onCheckedChanged(CheckableImageButton button, boolean isChecked) {
+    if (button == cameraOffButton) {
+      if (!isChecked && !VideoUtils.hasCameraPermissionAndAllowedByUser(getContext())) {
+        LogUtil.i("VideoCallFragment.onCheckedChanged", "show camera permission dialog");
+        checkCameraPermission();
+      } else {
+        inCallButtonUiDelegate.pauseVideoClicked(isChecked);
+        videoCallScreenDelegate.resetAutoFullscreenTimer();
+      }
+    } else if (button == muteButton) {
+      inCallButtonUiDelegate.muteClicked(isChecked);
+      videoCallScreenDelegate.resetAutoFullscreenTimer();
+    }
+  }
+
+  @Override
+  public void showVideoViews(
+      boolean shouldShowPreview, boolean shouldShowRemote, boolean isRemotelyHeld) {
+    LogUtil.i(
+        "VideoCallFragment.showVideoViews",
+        "showPreview: %b, shouldShowRemote: %b",
+        shouldShowPreview,
+        shouldShowRemote);
+    this.shouldShowPreview = shouldShowPreview;
+    this.shouldShowRemote = shouldShowRemote;
+    this.isRemotelyHeld = isRemotelyHeld;
+
+    videoCallScreenDelegate.getLocalVideoSurfaceTexture().attachToTextureView(previewTextureView);
+    videoCallScreenDelegate.getRemoteVideoSurfaceTexture().attachToTextureView(remoteTextureView);
+
+    updateVideoOffViews();
+    updateRemoteVideoScaling();
+  }
+
+  /**
+   * This method scales the video feed inside the texture view, it doesn't change the texture view's
+   * size. In the old UI we would change the view size to match the aspect ratio of the video. In
+   * the new UI the view is always square (with the circular clip) so we have to do additional work
+   * to make sure the non-square video doesn't look squished.
+   */
+  @Override
+  public void onLocalVideoDimensionsChanged() {
+    LogUtil.i("VideoCallFragment.onLocalVideoDimensionsChanged", null);
+    updatePreviewVideoScaling();
+  }
+
+  @Override
+  public void onLocalVideoOrientationChanged() {
+    LogUtil.i("VideoCallFragment.onLocalVideoOrientationChanged", null);
+    updatePreviewVideoScaling();
+  }
+
+  /** Called when the remote video's dimensions change. */
+  @Override
+  public void onRemoteVideoDimensionsChanged() {
+    LogUtil.i("VideoCallFragment.onRemoteVideoDimensionsChanged", null);
+    updateRemoteVideoScaling();
+  }
+
+  @Override
+  public void updateFullscreenAndGreenScreenMode(
+      boolean shouldShowFullscreen, boolean shouldShowGreenScreen) {
+    LogUtil.i(
+        "VideoCallFragment.updateFullscreenAndGreenScreenMode",
+        "shouldShowFullscreen: %b, shouldShowGreenScreen: %b",
+        shouldShowFullscreen,
+        shouldShowGreenScreen);
+
+    if (getActivity() == null) {
+      LogUtil.i("VideoCallFragment.updateFullscreenAndGreenScreenMode", "not attached to activity");
+      return;
+    }
+
+    // Check if anything is actually going to change. The first time this function is called we
+    // force a change by checking the hasInitializedScreenModes flag. We also force both fullscreen
+    // and green screen modes to update even if only one has changed. That's because they both
+    // depend on each other.
+    if (hasInitializedScreenModes
+        && shouldShowGreenScreen == isInGreenScreenMode
+        && shouldShowFullscreen == isInFullscreenMode) {
+      LogUtil.i(
+          "VideoCallFragment.updateFullscreenAndGreenScreenMode", "no change to screen modes");
+      return;
+    }
+    hasInitializedScreenModes = true;
+    isInGreenScreenMode = shouldShowGreenScreen;
+    isInFullscreenMode = shouldShowFullscreen;
+
+    if (getView().isAttachedToWindow() && !ActivityCompat.isInMultiWindowMode(getActivity())) {
+      controlsContainer.onApplyWindowInsets(getView().getRootWindowInsets());
+    }
+    if (shouldShowGreenScreen) {
+      enterGreenScreenMode();
+    } else {
+      exitGreenScreenMode();
+    }
+    if (shouldShowFullscreen) {
+      enterFullscreenMode();
+    } else {
+      exitFullscreenMode();
+    }
+    updateVideoOffViews();
+
+    OnHoldFragment onHoldFragment =
+        ((OnHoldFragment)
+            getChildFragmentManager().findFragmentById(R.id.videocall_on_hold_banner));
+    if (onHoldFragment != null) {
+      onHoldFragment.setPadTopInset(!isInFullscreenMode);
+    }
+  }
+
+  @Override
+  public Fragment getVideoCallScreenFragment() {
+    return this;
+  }
+
+  @Override
+  public void showButton(@InCallButtonIds int buttonId, boolean show) {
+    LogUtil.v(
+        "VideoCallFragment.showButton",
+        "buttonId: %s, show: %b",
+        InCallButtonIdsExtension.toString(buttonId),
+        show);
+    if (buttonId == InCallButtonIds.BUTTON_AUDIO) {
+      speakerButtonController.setEnabled(show);
+    } else if (buttonId == InCallButtonIds.BUTTON_MUTE) {
+      muteButton.setEnabled(show);
+    } else if (buttonId == InCallButtonIds.BUTTON_PAUSE_VIDEO) {
+      cameraOffButton.setEnabled(show);
+    } else if (buttonId == InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY) {
+      switchOnHoldCallController.setVisible(show);
+    } else if (buttonId == InCallButtonIds.BUTTON_SWITCH_CAMERA) {
+      swapCameraButton.setEnabled(show);
+    }
+  }
+
+  @Override
+  public void enableButton(@InCallButtonIds int buttonId, boolean enable) {
+    LogUtil.v(
+        "VideoCallFragment.setEnabled",
+        "buttonId: %s, enable: %b",
+        InCallButtonIdsExtension.toString(buttonId),
+        enable);
+    if (buttonId == InCallButtonIds.BUTTON_AUDIO) {
+      speakerButtonController.setEnabled(enable);
+    } else if (buttonId == InCallButtonIds.BUTTON_MUTE) {
+      muteButton.setEnabled(enable);
+    } else if (buttonId == InCallButtonIds.BUTTON_PAUSE_VIDEO) {
+      cameraOffButton.setEnabled(enable);
+    } else if (buttonId == InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY) {
+      switchOnHoldCallController.setEnabled(enable);
+    }
+  }
+
+  @Override
+  public void setEnabled(boolean enabled) {
+    LogUtil.v("VideoCallFragment.setEnabled", "enabled: " + enabled);
+    speakerButtonController.setEnabled(enabled);
+    muteButton.setEnabled(enabled);
+    cameraOffButton.setEnabled(enabled);
+    switchOnHoldCallController.setEnabled(enabled);
+  }
+
+  @Override
+  public void setHold(boolean value) {
+    LogUtil.i("VideoCallFragment.setHold", "value: " + value);
+  }
+
+  @Override
+  public void setCameraSwitched(boolean isBackFacingCamera) {
+    LogUtil.i("VideoCallFragment.setCameraSwitched", "isBackFacingCamera: " + isBackFacingCamera);
+  }
+
+  @Override
+  public void setVideoPaused(boolean isPaused) {
+    LogUtil.i("VideoCallFragment.setVideoPaused", "isPaused: " + isPaused);
+    cameraOffButton.setChecked(isPaused);
+  }
+
+  @Override
+  public void setAudioState(CallAudioState audioState) {
+    LogUtil.i("VideoCallFragment.setAudioState", "audioState: " + audioState);
+    speakerButtonController.setAudioState(audioState);
+    muteButton.setChecked(audioState.isMuted());
+    updateMutePreviewOverlayVisibility();
+  }
+
+  @Override
+  public void updateButtonStates() {
+    LogUtil.i("VideoCallFragment.updateButtonState", null);
+    speakerButtonController.updateButtonState();
+    switchOnHoldCallController.updateButtonState();
+  }
+
+  @Override
+  public void updateInCallButtonUiColors() {}
+
+  @Override
+  public Fragment getInCallButtonUiFragment() {
+    return this;
+  }
+
+  @Override
+  public void showAudioRouteSelector() {
+    LogUtil.i("VideoCallFragment.showAudioRouteSelector", null);
+    AudioRouteSelectorDialogFragment.newInstance(inCallButtonUiDelegate.getCurrentAudioState())
+        .show(getChildFragmentManager(), null);
+  }
+
+  @Override
+  public void onAudioRouteSelected(int audioRoute) {
+    LogUtil.i("VideoCallFragment.onAudioRouteSelected", "audioRoute: " + audioRoute);
+    inCallButtonUiDelegate.setAudioRoute(audioRoute);
+  }
+
+  @Override
+  public void setPrimary(@NonNull PrimaryInfo primaryInfo) {
+    LogUtil.i("VideoCallFragment.setPrimary", primaryInfo.toString());
+    contactGridManager.setPrimary(primaryInfo);
+  }
+
+  @Override
+  public void setSecondary(@NonNull SecondaryInfo secondaryInfo) {
+    LogUtil.i("VideoCallFragment.setSecondary", secondaryInfo.toString());
+    if (!isAdded()) {
+      savedSecondaryInfo = secondaryInfo;
+      return;
+    }
+    savedSecondaryInfo = null;
+    switchOnHoldCallController.setSecondaryInfo(secondaryInfo);
+    updateButtonStates();
+    FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
+    Fragment oldBanner = getChildFragmentManager().findFragmentById(R.id.videocall_on_hold_banner);
+    if (secondaryInfo.shouldShow) {
+      OnHoldFragment onHoldFragment = OnHoldFragment.newInstance(secondaryInfo);
+      onHoldFragment.setPadTopInset(!isInFullscreenMode);
+      transaction.replace(R.id.videocall_on_hold_banner, onHoldFragment);
+    } else {
+      if (oldBanner != null) {
+        transaction.remove(oldBanner);
+      }
+    }
+    transaction.setCustomAnimations(R.anim.abc_slide_in_top, R.anim.abc_slide_out_top);
+    transaction.commitAllowingStateLoss();
+  }
+
+  @Override
+  public void setCallState(@NonNull PrimaryCallState primaryCallState) {
+    LogUtil.i("VideoCallFragment.setCallState", primaryCallState.toString());
+    contactGridManager.setCallState(primaryCallState);
+  }
+
+  @Override
+  public void setEndCallButtonEnabled(boolean enabled, boolean animate) {
+    LogUtil.i("VideoCallFragment.setEndCallButtonEnabled", "enabled: " + enabled);
+  }
+
+  @Override
+  public void showManageConferenceCallButton(boolean visible) {
+    LogUtil.i("VideoCallFragment.showManageConferenceCallButton", "visible: " + visible);
+  }
+
+  @Override
+  public boolean isManageConferenceVisible() {
+    LogUtil.i("VideoCallFragment.isManageConferenceVisible", null);
+    return false;
+  }
+
+  @Override
+  public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+    contactGridManager.dispatchPopulateAccessibilityEvent(event);
+  }
+
+  @Override
+  public void showNoteSentToast() {
+    LogUtil.i("VideoCallFragment.showNoteSentToast", null);
+  }
+
+  @Override
+  public void updateInCallScreenColors() {
+    LogUtil.i("VideoCallFragment.updateColors", null);
+  }
+
+  @Override
+  public void onInCallScreenDialpadVisibilityChange(boolean isShowing) {
+    LogUtil.i("VideoCallFragment.onInCallScreenDialpadVisibilityChange", null);
+  }
+
+  @Override
+  public int getAnswerAndDialpadContainerResourceId() {
+    return 0;
+  }
+
+  @Override
+  public Fragment getInCallScreenFragment() {
+    return this;
+  }
+
+  @Override
+  public boolean isShowingLocationUi() {
+    return false;
+  }
+
+  @Override
+  public void showLocationUi(Fragment locationUi) {
+    LogUtil.e("VideoCallFragment.showLocationUi", "Emergency video calling not supported");
+    // Do nothing
+  }
+
+  private void updatePreviewVideoScaling() {
+    if (previewTextureView.getWidth() == 0 || previewTextureView.getHeight() == 0) {
+      LogUtil.i("VideoCallFragment.updatePreviewVideoScaling", "view layout hasn't finished yet");
+      return;
+    }
+    VideoSurfaceTexture localVideoSurfaceTexture =
+        videoCallScreenDelegate.getLocalVideoSurfaceTexture();
+    Point cameraDimensions = localVideoSurfaceTexture.getSurfaceDimensions();
+    if (cameraDimensions == null) {
+      LogUtil.i(
+          "VideoCallFragment.updatePreviewVideoScaling", "camera dimensions haven't been set");
+      return;
+    }
+    if (isLandscape()) {
+      VideoSurfaceBindings.scaleVideoAndFillView(
+          previewTextureView,
+          cameraDimensions.x,
+          cameraDimensions.y,
+          videoCallScreenDelegate.getDeviceOrientation());
+    } else {
+      VideoSurfaceBindings.scaleVideoAndFillView(
+          previewTextureView,
+          cameraDimensions.y,
+          cameraDimensions.x,
+          videoCallScreenDelegate.getDeviceOrientation());
+    }
+  }
+
+  private void updateRemoteVideoScaling() {
+    VideoSurfaceTexture remoteVideoSurfaceTexture =
+        videoCallScreenDelegate.getRemoteVideoSurfaceTexture();
+    Point videoSize = remoteVideoSurfaceTexture.getSourceVideoDimensions();
+    if (videoSize == null) {
+      LogUtil.i("VideoCallFragment.updateRemoteVideoScaling", "video size is null");
+      return;
+    }
+    if (remoteTextureView.getWidth() == 0 || remoteTextureView.getHeight() == 0) {
+      LogUtil.i("VideoCallFragment.updateRemoteVideoScaling", "view layout hasn't finished yet");
+      return;
+    }
+
+    // If the video and display aspect ratio's are close then scale video to fill display
+    float videoAspectRatio = ((float) videoSize.x) / videoSize.y;
+    float displayAspectRatio =
+        ((float) remoteTextureView.getWidth()) / remoteTextureView.getHeight();
+    float delta = Math.abs(videoAspectRatio - displayAspectRatio);
+    float sum = videoAspectRatio + displayAspectRatio;
+    if (delta / sum < ASPECT_RATIO_MATCH_THRESHOLD) {
+      VideoSurfaceBindings.scaleVideoAndFillView(remoteTextureView, videoSize.x, videoSize.y, 0);
+    } else {
+      VideoSurfaceBindings.scaleVideoMaintainingAspectRatio(
+          remoteTextureView, videoSize.x, videoSize.y);
+    }
+  }
+
+  private boolean isLandscape() {
+    // Choose orientation based on display orientation, not window orientation
+    int rotation = getActivity().getWindowManager().getDefaultDisplay().getRotation();
+    return rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270;
+  }
+
+  private void enterGreenScreenMode() {
+    LogUtil.i("VideoCallFragment.enterGreenScreenMode", null);
+    RelativeLayout.LayoutParams params =
+        new RelativeLayout.LayoutParams(
+            RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT);
+    params.addRule(RelativeLayout.ALIGN_PARENT_START);
+    params.addRule(RelativeLayout.ALIGN_PARENT_TOP);
+    previewTextureView.setLayoutParams(params);
+    previewTextureView.setOutlineProvider(null);
+    updatePreviewVideoScaling();
+    updateOverlayBackground();
+    contactGridManager.setIsMiddleRowVisible(true);
+    updateMutePreviewOverlayVisibility();
+
+    previewOffBlurredImageView.setLayoutParams(params);
+    previewOffBlurredImageView.setOutlineProvider(null);
+    previewOffBlurredImageView.setClipToOutline(false);
+  }
+
+  private void exitGreenScreenMode() {
+    LogUtil.i("VideoCallFragment.exitGreenScreenMode", null);
+    Resources resources = getResources();
+    RelativeLayout.LayoutParams params =
+        new RelativeLayout.LayoutParams(
+            (int) resources.getDimension(R.dimen.videocall_preview_width),
+            (int) resources.getDimension(R.dimen.videocall_preview_height));
+    params.setMargins(
+        0, 0, 0, (int) resources.getDimension(R.dimen.videocall_preview_margin_bottom));
+    if (isLandscape()) {
+      params.addRule(RelativeLayout.ALIGN_PARENT_END);
+      params.setMarginEnd((int) resources.getDimension(R.dimen.videocall_preview_margin_end));
+    } else {
+      params.addRule(RelativeLayout.ALIGN_PARENT_START);
+      params.setMarginStart((int) resources.getDimension(R.dimen.videocall_preview_margin_start));
+    }
+    params.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
+    previewTextureView.setLayoutParams(params);
+    previewTextureView.setOutlineProvider(circleOutlineProvider);
+    updatePreviewVideoScaling();
+    updateOverlayBackground();
+    contactGridManager.setIsMiddleRowVisible(false);
+    updateMutePreviewOverlayVisibility();
+
+    previewOffBlurredImageView.setLayoutParams(params);
+    previewOffBlurredImageView.setOutlineProvider(circleOutlineProvider);
+    previewOffBlurredImageView.setClipToOutline(true);
+  }
+
+  private void updateVideoOffViews() {
+    // Always hide the preview off and remote off views in green screen mode.
+    boolean previewEnabled = isInGreenScreenMode || shouldShowPreview;
+    previewOffOverlay.setVisibility(previewEnabled ? View.GONE : View.VISIBLE);
+    updateBlurredImageView(
+        previewTextureView,
+        previewOffBlurredImageView,
+        shouldShowPreview,
+        BLUR_PREVIEW_RADIUS,
+        BLUR_PREVIEW_SCALE_FACTOR);
+
+    boolean remoteEnabled = isInGreenScreenMode || shouldShowRemote;
+    boolean isResumed = remoteEnabled && !isRemotelyHeld;
+    if (isResumed) {
+      boolean wasRemoteVideoOff =
+          TextUtils.equals(
+              remoteVideoOff.getText(),
+              remoteVideoOff.getResources().getString(R.string.videocall_remote_video_off));
+      // The text needs to be updated and hidden after enough delay in order to be announced by
+      // talkback.
+      remoteVideoOff.setText(
+          wasRemoteVideoOff
+              ? R.string.videocall_remote_video_on
+              : R.string.videocall_remotely_resumed);
+      remoteVideoOff.postDelayed(
+          new Runnable() {
+            @Override
+            public void run() {
+              remoteVideoOff.setVisibility(View.GONE);
+            }
+          },
+          VIDEO_OFF_VIEW_FADE_OUT_DELAY_IN_MILLIS);
+    } else {
+      remoteVideoOff.setText(
+          isRemotelyHeld ? R.string.videocall_remotely_held : R.string.videocall_remote_video_off);
+      remoteVideoOff.setVisibility(View.VISIBLE);
+    }
+    LogUtil.i("VideoCallFragment.updateVideoOffViews", "calling updateBlurredImageView");
+    updateBlurredImageView(
+        remoteTextureView,
+        remoteOffBlurredImageView,
+        shouldShowRemote,
+        BLUR_REMOTE_RADIUS,
+        BLUR_REMOTE_SCALE_FACTOR);
+  }
+
+  private void updateBlurredImageView(
+      TextureView textureView,
+      ImageView blurredImageView,
+      boolean isVideoEnabled,
+      float blurRadius,
+      float scaleFactor) {
+    boolean didBlur = false;
+    long startTimeMillis = SystemClock.elapsedRealtime();
+    if (!isVideoEnabled) {
+      int width = Math.round(textureView.getWidth() * scaleFactor);
+      int height = Math.round(textureView.getHeight() * scaleFactor);
+      // This call takes less than 10 milliseconds.
+      Bitmap bitmap = textureView.getBitmap(width, height);
+      if (bitmap != null) {
+        // TODO: When the view is first displayed after a rotation the bitmap is empty
+        // and thus this blur has no effect.
+        // This call can take 100 milliseconds.
+        blur(getContext(), bitmap, blurRadius);
+
+        // TODO: Figure out why only have to apply the transform in landscape mode
+        if (width > height) {
+          bitmap =
+              Bitmap.createBitmap(
+                  bitmap,
+                  0,
+                  0,
+                  bitmap.getWidth(),
+                  bitmap.getHeight(),
+                  textureView.getTransform(null),
+                  true);
+        }
+
+        blurredImageView.setImageBitmap(bitmap);
+        blurredImageView.setVisibility(View.VISIBLE);
+        didBlur = true;
+      }
+    }
+    if (!didBlur) {
+      blurredImageView.setImageBitmap(null);
+      blurredImageView.setVisibility(View.GONE);
+    }
+
+    LogUtil.i(
+        "VideoCallFragment.updateBlurredImageView",
+        "didBlur: %b, took %d millis",
+        didBlur,
+        (SystemClock.elapsedRealtime() - startTimeMillis));
+  }
+
+  private void updateOverlayBackground() {
+    if (isInGreenScreenMode) {
+      // We want to darken the preview view to make text and buttons readable. The fullscreen
+      // background is below the preview view so use the green screen background instead.
+      animateSetVisibility(greenScreenBackgroundView, View.VISIBLE);
+      animateSetVisibility(fullscreenBackgroundView, View.GONE);
+    } else if (!isInFullscreenMode) {
+      // We want to darken the remote view to make text and buttons readable. The green screen
+      // background is above the preview view so it would darken the preview too. Use the fullscreen
+      // background instead.
+      animateSetVisibility(greenScreenBackgroundView, View.GONE);
+      animateSetVisibility(fullscreenBackgroundView, View.VISIBLE);
+    } else {
+      animateSetVisibility(greenScreenBackgroundView, View.GONE);
+      animateSetVisibility(fullscreenBackgroundView, View.GONE);
+    }
+  }
+
+  private void updateMutePreviewOverlayVisibility() {
+    // Normally the mute overlay shows on the bottom right of the preview bubble. In green screen
+    // mode the preview is fullscreen so there's no where to anchor it.
+    mutePreviewOverlay.setVisibility(
+        muteButton.isChecked() && !isInGreenScreenMode ? View.VISIBLE : View.GONE);
+  }
+
+  private static void animateSetVisibility(final View view, final int visibility) {
+    if (view.getVisibility() == visibility) {
+      return;
+    }
+
+    int startAlpha;
+    int endAlpha;
+    if (visibility == View.GONE) {
+      startAlpha = 1;
+      endAlpha = 0;
+    } else if (visibility == View.VISIBLE) {
+      startAlpha = 0;
+      endAlpha = 1;
+    } else {
+      Assert.fail();
+      return;
+    }
+
+    view.setAlpha(startAlpha);
+    view.setVisibility(View.VISIBLE);
+    view.animate()
+        .alpha(endAlpha)
+        .withEndAction(
+            new Runnable() {
+              @Override
+              public void run() {
+                view.setVisibility(visibility);
+              }
+            })
+        .start();
+  }
+
+  private static void blur(Context context, Bitmap image, float blurRadius) {
+    RenderScript renderScript = RenderScript.create(context);
+    ScriptIntrinsicBlur blurScript =
+        ScriptIntrinsicBlur.create(renderScript, Element.U8_4(renderScript));
+    Allocation allocationIn = Allocation.createFromBitmap(renderScript, image);
+    Allocation allocationOut = Allocation.createFromBitmap(renderScript, image);
+    blurScript.setRadius(blurRadius);
+    blurScript.setInput(allocationIn);
+    blurScript.forEach(allocationOut);
+    allocationOut.copyTo(image);
+  }
+
+  @Override
+  public void onSystemUiVisibilityChange(int visibility) {
+    boolean navBarVisible = (visibility & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0;
+    videoCallScreenDelegate.onSystemUiVisibilityChange(navBarVisible);
+  }
+
+  protected void onCameraPermissionGranted() {
+    videoCallScreenDelegate.onCameraPermissionGranted();
+  }
+
+  private void checkCameraPermission() {
+    // Checks if user has consent of camera permission and the permission is granted.
+    // If camera permission is revoked, shows system permission dialog.
+    // If camera permission is granted but user doesn't have consent of camera permission
+    // (which means it's first time making video call), shows custom dialog instead. This
+    // will only be shown to user once.
+    if (!VideoUtils.hasCameraPermissionAndAllowedByUser(getContext())) {
+      videoCallScreenDelegate.onCameraPermissionDialogShown();
+      if (!VideoUtils.hasCameraPermission(getContext())) {
+        requestPermissions(new String[] {permission.CAMERA}, CAMERA_PERMISSION_REQUEST_CODE);
+      } else {
+        CameraPermissionDialogFragment.newInstance()
+            .show(getChildFragmentManager(), CAMERA_PERMISSION_DIALOG_FRAMENT_TAG);
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/video/impl/res/color/videocall_button_icon_tint.xml b/java/com/android/incallui/video/impl/res/color/videocall_button_icon_tint.xml
new file mode 100644
index 0000000..b46607b
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/color/videocall_button_icon_tint.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="#ff000000" android:state_checked="true"/>
+  <item android:color="#ffffffff"/>
+</selector>
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/ic_switch_camera.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/ic_switch_camera.png
new file mode 100644
index 0000000..b5c6f0a
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/ic_switch_camera.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked.png
new file mode 100644
index 0000000..2ab2f21
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png
new file mode 100644
index 0000000..2deaadd
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_pressed.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_pressed.png
new file mode 100644
index 0000000..c4147fa
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_default.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_default.png
new file mode 100644
index 0000000..c59e215
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_default.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png
new file mode 100644
index 0000000..95d6824
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_pressed.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_pressed.png
new file mode 100644
index 0000000..9a525a3
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/ic_switch_camera.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/ic_switch_camera.png
new file mode 100644
index 0000000..f3427a0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/ic_switch_camera.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked.png
new file mode 100644
index 0000000..c3ff7b2
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png
new file mode 100644
index 0000000..c752813
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_pressed.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_pressed.png
new file mode 100644
index 0000000..fd16bae
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_default.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_default.png
new file mode 100644
index 0000000..3fe2446
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_default.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png
new file mode 100644
index 0000000..1ff3e7c
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_pressed.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_pressed.png
new file mode 100644
index 0000000..aa7289a
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/ic_switch_camera.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/ic_switch_camera.png
new file mode 100644
index 0000000..4915471
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/ic_switch_camera.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked.png
new file mode 100644
index 0000000..799a78e
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png
new file mode 100644
index 0000000..4d5e033
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_pressed.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_pressed.png
new file mode 100644
index 0000000..62cd1a4
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_default.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_default.png
new file mode 100644
index 0000000..c68ad90
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_default.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png
new file mode 100644
index 0000000..e5c3fc4
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_pressed.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_pressed.png
new file mode 100644
index 0000000..583c3de
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/ic_switch_camera.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/ic_switch_camera.png
new file mode 100644
index 0000000..19a9344
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/ic_switch_camera.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked.png
new file mode 100644
index 0000000..5a7702b
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png
new file mode 100644
index 0000000..a0be8d1
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_pressed.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_pressed.png
new file mode 100644
index 0000000..5671bfa
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_default.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_default.png
new file mode 100644
index 0000000..527b3c4
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_default.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png
new file mode 100644
index 0000000..9961858
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_pressed.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_pressed.png
new file mode 100644
index 0000000..56295b1
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_pressed.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxxhdpi/ic_switch_camera.png b/java/com/android/incallui/video/impl/res/drawable-xxxhdpi/ic_switch_camera.png
new file mode 100644
index 0000000..529c0a4
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable-xxxhdpi/ic_switch_camera.png
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable/videocall_background_circle_white.xml b/java/com/android/incallui/video/impl/res/drawable/videocall_background_circle_white.xml
new file mode 100644
index 0000000..ee514c7
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable/videocall_background_circle_white.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="#80888888">
+  <item>
+    <shape
+      android:shape="oval">
+      <solid android:color="@color/incall_button_white"/>
+    </shape>
+  </item>
+</ripple>
diff --git a/java/com/android/incallui/video/impl/res/drawable/videocall_video_button_background.xml b/java/com/android/incallui/video/impl/res/drawable/videocall_video_button_background.xml
new file mode 100644
index 0000000..5e48413
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/drawable/videocall_video_button_background.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="@color/incall_button_ripple">
+  <item android:id="@android:id/mask">
+    <inset android:inset="5dp">
+      <shape android:shape="oval">
+        <solid android:color="@android:color/white"/>
+      </shape>
+    </inset>
+  </item>
+  <item>
+    <selector>
+      <item
+        android:drawable="@drawable/video_button_bg_checked_pressed"
+        android:state_checked="true"
+        android:state_pressed="true"/>
+      <item
+        android:drawable="@drawable/video_button_bg_checked"
+        android:state_checked="true"/>
+      <item
+        android:drawable="@drawable/video_button_bg_pressed"
+        android:state_pressed="true"/>
+      <item
+        android:drawable="@drawable/video_button_bg_default"/>
+    </selector>
+  </item>
+</ripple>
diff --git a/java/com/android/incallui/video/impl/res/layout-v21/switch_camera_button.xml b/java/com/android/incallui/video/impl/res/layout-v21/switch_camera_button.xml
new file mode 100644
index 0000000..1fb1bb0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout-v21/switch_camera_button.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/videocall_switch_video"
+  style="@style/Incall.Button.VideoCall"
+  android:contentDescription="@string/incall_content_description_swap_video"
+  android:src="@drawable/front_back_switch_button_animation"/>
diff --git a/java/com/android/incallui/video/impl/res/layout/frag_videocall.xml b/java/com/android/incallui/video/impl/res/layout/frag_videocall.xml
new file mode 100644
index 0000000..dc663dd
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/frag_videocall.xml
@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:background="@android:color/black"
+  android:orientation="vertical">
+
+  <TextureView
+    android:id="@+id/videocall_video_remote"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentStart="true"
+    android:layout_alignParentTop="true"
+    android:importantForAccessibility="no"/>
+
+  <ImageView
+    android:id="@+id/videocall_remote_off_blurred_image_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentStart="true"
+    android:layout_alignParentTop="true"
+    android:scaleType="fitCenter"/>
+
+  <TextView
+    android:gravity="center"
+    android:id="@+id/videocall_remote_video_off"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_centerInParent="true"
+    android:accessibilityTraversalBefore="@+id/videocall_speaker_button"
+    android:drawablePadding="8dp"
+    android:drawableTop="@drawable/quantum_ic_videocam_off_white_36"
+    android:padding="64dp"
+    android:text="@string/videocall_remote_video_off"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance"
+    android:visibility="gone"
+    tools:visibility="visible"/>
+
+  <View
+    android:id="@+id/videocall_fullscreen_background"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:background="@color/videocall_overlay_background_color"/>
+
+  <TextureView
+    android:id="@+id/videocall_video_preview"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginBottom="@dimen/videocall_preview_margin_bottom"
+    android:layout_marginStart="@dimen/videocall_preview_margin_start"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:importantForAccessibility="no"/>
+
+  <ImageView
+    android:id="@+id/videocall_preview_off_blurred_image_view"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginBottom="@dimen/videocall_preview_margin_bottom"
+    android:layout_marginStart="@dimen/videocall_preview_margin_start"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:scaleType="center"/>
+
+  <View
+    android:id="@+id/videocall_green_screen_background"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:background="@color/videocall_overlay_background_color"/>
+
+  <ImageView
+    android:id="@+id/videocall_video_preview_off_overlay"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_alignBottom="@+id/videocall_video_preview"
+    android:layout_alignLeft="@+id/videocall_video_preview"
+    android:layout_alignRight="@+id/videocall_video_preview"
+    android:layout_alignTop="@+id/videocall_video_preview"
+    android:scaleType="center"
+    android:src="@drawable/quantum_ic_videocam_off_white_36"
+    android:visibility="gone"
+    android:importantForAccessibility="no"
+    tools:visibility="visible"/>
+
+  <ImageView
+    android:id="@+id/videocall_video_preview_mute_overlay"
+    android:layout_width="32dp"
+    android:layout_height="32dp"
+    android:layout_alignBottom="@+id/videocall_video_preview"
+    android:layout_alignRight="@+id/videocall_video_preview"
+    android:background="@drawable/videocall_background_circle_white"
+    android:contentDescription="@string/incall_content_description_muted"
+    android:scaleType="center"
+    android:src="@drawable/quantum_ic_mic_off_black_24"
+    android:visibility="gone"
+    tools:visibility="visible"/>
+
+  <include
+    layout="@layout/videocall_controls"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"/>
+
+  <FrameLayout
+    android:id="@+id/videocall_on_hold_banner"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_alignParentTop="true"/>
+
+</RelativeLayout>
diff --git a/java/com/android/incallui/video/impl/res/layout/frag_videocall_land.xml b/java/com/android/incallui/video/impl/res/layout/frag_videocall_land.xml
new file mode 100644
index 0000000..2353dee
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/frag_videocall_land.xml
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:background="@android:color/black">
+
+  <TextureView
+    android:id="@+id/videocall_video_remote"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentStart="true"
+    android:layout_alignParentTop="true"
+    android:importantForAccessibility="no"/>
+
+  <ImageView
+    android:id="@+id/videocall_remote_off_blurred_image_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentStart="true"
+    android:layout_alignParentTop="true"
+    android:scaleType="fitCenter"/>
+
+  <TextView
+    android:gravity="center"
+    android:id="@+id/videocall_remote_video_off"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_centerInParent="true"
+    android:accessibilityTraversalBefore="@+id/videocall_speaker_button"
+    android:drawablePadding="8dp"
+    android:drawableTop="@drawable/quantum_ic_videocam_off_white_36"
+    android:padding="64dp"
+    android:text="@string/videocall_remote_video_off"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance"
+    android:visibility="gone"
+    tools:visibility="visible"/>
+
+  <View
+    android:id="@+id/videocall_fullscreen_background"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:background="@color/videocall_overlay_background_color"/>
+
+  <TextureView
+    android:id="@+id/videocall_video_preview"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginEnd="@dimen/videocall_preview_margin_end"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentEnd="true"
+    android:importantForAccessibility="no"/>
+
+  <ImageView
+    android:id="@+id/videocall_preview_off_blurred_image_view"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginEnd="@dimen/videocall_preview_margin_end"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentEnd="true"
+    android:scaleType="center"/>
+
+  <View
+    android:id="@+id/videocall_green_screen_background"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:background="@color/videocall_overlay_background_color"/>
+
+  <ImageView
+    android:id="@+id/videocall_video_preview_off_overlay"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_alignBottom="@+id/videocall_video_preview"
+    android:layout_alignLeft="@+id/videocall_video_preview"
+    android:layout_alignRight="@+id/videocall_video_preview"
+    android:layout_alignTop="@+id/videocall_video_preview"
+    android:scaleType="center"
+    android:src="@drawable/quantum_ic_videocam_off_white_36"
+    android:visibility="gone"
+    android:importantForAccessibility="no"
+    tools:visibility="visible"/>
+
+  <ImageView
+    android:id="@+id/videocall_video_preview_mute_overlay"
+    android:layout_width="32dp"
+    android:layout_height="32dp"
+    android:layout_alignBottom="@+id/videocall_video_preview"
+    android:layout_alignRight="@+id/videocall_video_preview"
+    android:background="@drawable/videocall_background_circle_white"
+    android:contentDescription="@string/incall_content_description_muted"
+    android:scaleType="center"
+    android:src="@drawable/quantum_ic_mic_off_black_24"
+    android:visibility="gone"
+    tools:visibility="visible"/>
+
+  <include
+    layout="@layout/videocall_controls_land"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"/>
+
+  <FrameLayout
+    android:id="@+id/videocall_on_hold_banner"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_alignParentTop="true"/>
+
+</RelativeLayout>
diff --git a/java/com/android/incallui/video/impl/res/layout/switch_camera_button.xml b/java/com/android/incallui/video/impl/res/layout/switch_camera_button.xml
new file mode 100644
index 0000000..87c2e1b
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/switch_camera_button.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/videocall_switch_video"
+  style="@style/Incall.Button.VideoCall"
+  android:contentDescription="@string/incall_content_description_swap_video"
+  android:src="@drawable/ic_switch_camera"/>
diff --git a/java/com/android/incallui/video/impl/res/layout/video_contact_grid.xml b/java/com/android/incallui/video/impl/res/layout/video_contact_grid.xml
new file mode 100644
index 0000000..ad984f3
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/video_contact_grid.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="wrap_content"
+  android:gravity="center_horizontal"
+  android:paddingTop="16dp"
+  android:orientation="vertical">
+
+  <include
+    layout="@layout/incall_contactgrid_top_row"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"/>
+
+  <!-- We have to keep deprecated singleLine to allow long text being truncated with ellipses.
+       b/31396406 -->
+  <com.android.incallui.autoresizetext.AutoResizeTextView
+    android:id="@id/contactgrid_contact_name"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:singleLine="true"
+    android:textAppearance="@style/Dialer.Incall.TextAppearance.Large"
+    app:autoResizeText_minTextSize="28sp"
+    tools:text="Jake Peralta"
+    tools:ignore="Deprecated"/>
+
+  <include
+    layout="@layout/incall_contactgrid_bottom_row"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"/>
+</LinearLayout>
diff --git a/java/com/android/incallui/video/impl/res/layout/videocall_controls.xml b/java/com/android/incallui/video/impl/res/layout/videocall_controls.xml
new file mode 100644
index 0000000..b3141bd
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/videocall_controls.xml
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:id="@+id/videocall_video_controls_container"
+  android:fitsSystemWindows="true"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:orientation="vertical">
+
+  <include
+    android:id="@+id/incall_contact_grid"
+    layout="@layout/video_contact_grid"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_marginTop="16dp"
+    android:layout_marginStart="24dp"
+    android:layout_marginEnd="24dp"/>
+
+  <!-- This placeholder matches the position of the preview UI and is used to
+     anchor video buttons. This is needed in greenscreen mode when the
+     preview is fullscreen but we want the controls to be positioned as
+     normal.  -->
+  <Space
+    android:id="@+id/videocall_video_preview_placeholder"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginBottom="@dimen/videocall_preview_margin_bottom"
+    android:layout_marginStart="@dimen/videocall_preview_margin_start"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentStart="true"
+    android:visibility="invisible"/>
+
+  <LinearLayout
+    android:id="@+id/videocall_video_controls"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_above="@+id/videocall_video_preview_placeholder"
+    android:layout_alignEnd="@+id/videocall_video_preview_placeholder"
+    android:layout_alignStart="@+id/videocall_video_preview_placeholder"
+    android:gravity="center_horizontal"
+    android:orientation="vertical"
+    android:visibility="invisible"
+    tools:visibility="visible">
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_speaker_button"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginBottom="@dimen/videocall_button_spacing"
+      android:checked="true"
+      android:src="@drawable/quantum_ic_volume_up_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_speaker"
+      app:contentDescriptionUnchecked="@string/incall_content_description_earpiece"
+      />
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_mute_button"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginBottom="@dimen/videocall_button_spacing"
+      android:src="@drawable/quantum_ic_mic_off_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_muted"
+      app:contentDescriptionUnchecked="@string/incall_content_description_unmuted"
+      />
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_mute_video"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginBottom="@dimen/videocall_button_spacing"
+      android:src="@drawable/quantum_ic_videocam_off_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_video_off"
+      app:contentDescriptionUnchecked="@string/incall_content_description_video_on"
+      />
+    <include
+      layout="@layout/switch_camera_button"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginBottom="@dimen/videocall_button_spacing"/>
+  </LinearLayout>
+
+  <FrameLayout
+    android:id="@+id/videocall_switch_controls"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_marginBottom="36dp"
+    android:layout_marginEnd="24dp"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentEnd="true">
+    <ImageButton
+      android:id="@+id/videocall_switch_on_hold"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:contentDescription="@string/incall_content_description_swap_calls"
+      android:src="@drawable/quantum_ic_swap_calls_white_36"
+      android:visibility="gone"
+      tools:visibility="visible"
+      />
+  </FrameLayout>
+
+  <ImageButton
+    android:id="@+id/videocall_end_call"
+    style="@style/Incall.Button.End"
+    android:layout_marginBottom="36dp"
+    android:layout_alignParentBottom="true"
+    android:layout_centerHorizontal="true"
+    android:contentDescription="@string/incall_content_description_end_call"
+    android:visibility="visible"/>
+
+</RelativeLayout>
diff --git a/java/com/android/incallui/video/impl/res/layout/videocall_controls_land.xml b/java/com/android/incallui/video/impl/res/layout/videocall_controls_land.xml
new file mode 100644
index 0000000..d71b3c0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/layout/videocall_controls_land.xml
@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:id="@+id/videocall_video_controls_container"
+  android:fitsSystemWindows="true"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:orientation="vertical">
+
+  <include
+    android:id="@+id/incall_contact_grid"
+    layout="@layout/video_contact_grid"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_marginTop="16dp"
+    android:layout_marginStart="24dp"
+    android:layout_marginEnd="24dp"/>
+
+  <!-- This placeholder matches the position of the preview UI and is used to
+     anchor video buttons. This is needed in greenscreen mode when the
+     preview is fullscreen but we want the controls to be positioned as
+     normal.  -->
+  <Space
+    android:id="@+id/videocall_video_preview_placeholder"
+    android:layout_width="@dimen/videocall_preview_width"
+    android:layout_height="@dimen/videocall_preview_height"
+    android:layout_marginEnd="@dimen/videocall_preview_margin_end"
+    android:layout_alignParentBottom="true"
+    android:layout_alignParentEnd="true"
+    android:visibility="invisible"/>
+
+  <LinearLayout
+    android:id="@+id/videocall_video_controls"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_alignBottom="@+id/videocall_video_preview_placeholder"
+    android:layout_alignTop="@+id/videocall_video_preview_placeholder"
+    android:layout_toStartOf="@+id/videocall_video_preview_placeholder"
+    android:gravity="center_horizontal"
+    android:orientation="horizontal"
+    android:visibility="invisible"
+    tools:visibility="visible">
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_speaker_button"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginEnd="24dp"
+      android:checked="true"
+      android:src="@drawable/quantum_ic_volume_up_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_speaker"
+      app:contentDescriptionUnchecked="@string/incall_content_description_earpiece"
+      />
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_mute_button"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginEnd="24dp"
+      android:scaleType="center"
+      android:src="@drawable/quantum_ic_mic_off_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_muted"
+      app:contentDescriptionUnchecked="@string/incall_content_description_unmuted"
+      />
+    <com.android.incallui.video.impl.CheckableImageButton
+      android:id="@+id/videocall_mute_video"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginEnd="24dp"
+      android:scaleType="center"
+      android:src="@drawable/quantum_ic_videocam_off_white_36"
+      app:contentDescriptionChecked="@string/incall_content_description_video_off"
+      app:contentDescriptionUnchecked="@string/incall_content_description_video_on"
+      />
+    <include
+      layout="@layout/switch_camera_button"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:layout_marginEnd="24dp"/>
+  </LinearLayout>
+
+  <FrameLayout
+    android:id="@+id/videocall_switch_controls"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_marginTop="36dp"
+    android:layout_marginEnd="36dp"
+    android:layout_alignParentEnd="true"
+    android:layout_alignParentTop="true">
+    <ImageButton
+      android:id="@+id/videocall_switch_on_hold"
+      style="@style/Incall.Button.VideoCall"
+      android:layout_width="@dimen/videocall_button_size"
+      android:layout_height="@dimen/videocall_button_size"
+      android:contentDescription="@string/incall_content_description_swap_calls"
+      android:src="@drawable/quantum_ic_swap_calls_white_36"
+      android:visibility="gone"
+      tools:visibility="visible"
+      />
+  </FrameLayout>
+
+  <ImageButton
+    android:id="@+id/videocall_end_call"
+    style="@style/Incall.Button.End"
+    android:layout_marginEnd="36dp"
+    android:layout_alignParentEnd="true"
+    android:layout_centerVertical="true"
+    android:contentDescription="@string/incall_content_description_end_call"
+    android:visibility="visible"
+    tools:visibility="visible"/>
+
+</RelativeLayout>
diff --git a/java/com/android/incallui/video/impl/res/values-h580dp/dimens.xml b/java/com/android/incallui/video/impl/res/values-h580dp/dimens.xml
new file mode 100644
index 0000000..b1a86a0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values-h580dp/dimens.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="videocall_button_spacing">16dp</dimen>
+  <dimen name="videocall_button_size">72dp</dimen>
+  <dimen name="videocall_preview_width">88dp</dimen>
+  <dimen name="videocall_preview_height">88dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/video/impl/res/values-w460dp/dimens.xml b/java/com/android/incallui/video/impl/res/values-w460dp/dimens.xml
new file mode 100644
index 0000000..b1a86a0
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values-w460dp/dimens.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="videocall_button_spacing">16dp</dimen>
+  <dimen name="videocall_button_size">72dp</dimen>
+  <dimen name="videocall_preview_width">88dp</dimen>
+  <dimen name="videocall_preview_height">88dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/video/impl/res/values/attrs.xml b/java/com/android/incallui/video/impl/res/values/attrs.xml
new file mode 100644
index 0000000..e4cd8af
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values/attrs.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <declare-styleable name="CheckableImageButton">
+    <attr name="android:checked"/>
+    <attr name="contentDescriptionChecked" format="reference|string"/>
+    <attr name="contentDescriptionUnchecked" format="reference|string"/>
+  </declare-styleable>
+</resources>
diff --git a/java/com/android/incallui/video/impl/res/values/dimens.xml b/java/com/android/incallui/video/impl/res/values/dimens.xml
new file mode 100644
index 0000000..4586003
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values/dimens.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <dimen name="videocall_preview_width">72dp</dimen>
+  <dimen name="videocall_preview_height">72dp</dimen>
+  <dimen name="videocall_preview_margin_bottom">24dp</dimen>
+  <dimen name="videocall_preview_margin_start">24dp</dimen>
+  <dimen name="videocall_preview_margin_end">24dp</dimen>
+  <dimen name="videocall_button_spacing">8dp</dimen>
+  <dimen name="videocall_button_size">60dp</dimen>
+</resources>
diff --git a/java/com/android/incallui/video/impl/res/values/strings.xml b/java/com/android/incallui/video/impl/res/values/strings.xml
new file mode 100644
index 0000000..2b72b80
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <!-- Text indicates the video from remote party is off. [CHAR LIMIT=40] -->
+  <string name="videocall_remote_video_off">Their video is off</string>
+
+  <!-- Text indicates the video from remote party is on. [CHAR LIMIT=40] -->
+  <string name="videocall_remote_video_on">Their video is on</string>
+
+  <!-- Text indicates the call is held by remote party. [CHAR LIMIT=20] -->
+  <string name="videocall_remotely_held">Call on hold</string>
+
+  <!-- Text indicates the call is resumed from held by remote party. [CHAR LIMIT=20] -->
+  <string name="videocall_remotely_resumed">Call resumed</string>
+
+  <!-- Title of dialog to ask user for camera permission. [CHAR LIMIT=30] -->
+  <string name="camera_permission_dialog_title">Allow video?</string>
+
+  <!-- Message of dialog to ask user for camera permission. [CHAR LIMIT=100] -->
+  <string name="camera_permission_dialog_message">The Phone app wants to use your camera for video calls.</string>
+
+  <!-- Text of button to be confirmed for camera permission by user. [CHAR LIMIT=20] -->
+  <string name="camera_permission_dialog_positive_button">Allow</string>
+
+  <!-- Text of button to be declined for camera permission by user. [CHAR LIMIT=20] -->
+  <string name="camera_permission_dialog_negative_button">Deny</string>
+
+</resources>
diff --git a/java/com/android/incallui/video/impl/res/values/styles.xml b/java/com/android/incallui/video/impl/res/values/styles.xml
new file mode 100644
index 0000000..b944008
--- /dev/null
+++ b/java/com/android/incallui/video/impl/res/values/styles.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+  <style name="Incall.Button.VideoCall" parent="Widget.AppCompat.ImageButton">
+    <item name="android:background">@drawable/videocall_video_button_background</item>
+    <item name="android:scaleType">center</item>
+    <item name="android:tint">@color/videocall_button_icon_tint</item>
+    <item name="android:tintMode">src_atop</item>
+    <item name="android:stateListAnimator">@animator/disabled_alpha</item>
+  </style>
+</resources>
diff --git a/java/com/android/incallui/video/protocol/VideoCallScreen.java b/java/com/android/incallui/video/protocol/VideoCallScreen.java
new file mode 100644
index 0000000..0eaf692
--- /dev/null
+++ b/java/com/android/incallui/video/protocol/VideoCallScreen.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 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.video.protocol;
+
+import android.support.v4.app.Fragment;
+
+/** Interface for call video call module. */
+public interface VideoCallScreen {
+
+  void showVideoViews(boolean shouldShowPreview, boolean shouldShowRemote, boolean isRemotelyHeld);
+
+  void onLocalVideoDimensionsChanged();
+
+  void onLocalVideoOrientationChanged();
+
+  void onRemoteVideoDimensionsChanged();
+
+  void updateFullscreenAndGreenScreenMode(
+      boolean shouldShowFullscreen, boolean shouldShowGreenScreen);
+
+  Fragment getVideoCallScreenFragment();
+}
diff --git a/java/com/android/incallui/video/protocol/VideoCallScreenDelegate.java b/java/com/android/incallui/video/protocol/VideoCallScreenDelegate.java
new file mode 100644
index 0000000..bbd86ee
--- /dev/null
+++ b/java/com/android/incallui/video/protocol/VideoCallScreenDelegate.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 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.video.protocol;
+
+import android.content.Context;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+
+/** Callbacks from the module out to the container. */
+public interface VideoCallScreenDelegate {
+
+  void initVideoCallScreenDelegate(Context context, VideoCallScreen videoCallScreen);
+
+  void onVideoCallScreenUiReady();
+
+  void onVideoCallScreenUiUnready();
+
+  void cancelAutoFullScreen();
+
+  void resetAutoFullscreenTimer();
+
+  void onSystemUiVisibilityChange(boolean visible);
+
+  void onCameraPermissionGranted();
+
+  boolean shouldShowCameraPermissionDialog();
+
+  void onCameraPermissionDialogShown();
+
+  VideoSurfaceTexture getLocalVideoSurfaceTexture();
+
+  VideoSurfaceTexture getRemoteVideoSurfaceTexture();
+
+  int getDeviceOrientation();
+}
diff --git a/java/com/android/incallui/video/protocol/VideoCallScreenDelegateFactory.java b/java/com/android/incallui/video/protocol/VideoCallScreenDelegateFactory.java
new file mode 100644
index 0000000..285857a
--- /dev/null
+++ b/java/com/android/incallui/video/protocol/VideoCallScreenDelegateFactory.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 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.video.protocol;
+
+/** Callbacks from the module out to the container. */
+public interface VideoCallScreenDelegateFactory {
+
+  VideoCallScreenDelegate newVideoCallScreenDelegate();
+}
diff --git a/java/com/android/incallui/videosurface/bindings/VideoSurfaceBindings.java b/java/com/android/incallui/videosurface/bindings/VideoSurfaceBindings.java
new file mode 100644
index 0000000..96fccb4
--- /dev/null
+++ b/java/com/android/incallui/videosurface/bindings/VideoSurfaceBindings.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 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.videosurface.bindings;
+
+import android.view.TextureView;
+import com.android.incallui.videosurface.impl.VideoScale;
+import com.android.incallui.videosurface.impl.VideoSurfaceTextureImpl;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+
+/** Bindings for video surface module. */
+public class VideoSurfaceBindings {
+
+  public static VideoSurfaceTexture createLocalVideoSurfaceTexture() {
+    return new VideoSurfaceTextureImpl(VideoSurfaceTexture.SURFACE_TYPE_LOCAL);
+  }
+
+  public static VideoSurfaceTexture createRemoteVideoSurfaceTexture() {
+    return new VideoSurfaceTextureImpl(VideoSurfaceTexture.SURFACE_TYPE_REMOTE);
+  }
+
+  public static void scaleVideoAndFillView(
+      TextureView textureView, float videoWidth, float videoHeight, float rotationDegrees) {
+    VideoScale.scaleVideoAndFillView(textureView, videoWidth, videoHeight, rotationDegrees);
+  }
+
+  public static void scaleVideoMaintainingAspectRatio(
+      TextureView textureView, int videoWidth, int videoHeight) {
+    VideoScale.scaleVideoMaintainingAspectRatio(textureView, videoWidth, videoHeight);
+  }
+}
diff --git a/java/com/android/incallui/videosurface/impl/VideoScale.java b/java/com/android/incallui/videosurface/impl/VideoScale.java
new file mode 100644
index 0000000..1444f59
--- /dev/null
+++ b/java/com/android/incallui/videosurface/impl/VideoScale.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2016 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.videosurface.impl;
+
+import android.graphics.Matrix;
+import android.view.TextureView;
+import com.android.dialer.common.LogUtil;
+
+/** Utilities to scale the preview and remote video. */
+public class VideoScale {
+  /**
+   * Scales the video in the given view such that the video takes up the entire view. To maintain
+   * aspect ratio the video will be scaled to be larger than the view.
+   */
+  public static void scaleVideoAndFillView(
+      TextureView textureView, float videoWidth, float videoHeight, float rotationDegrees) {
+    float viewWidth = textureView.getWidth();
+    float viewHeight = textureView.getHeight();
+    float viewAspectRatio = viewWidth / viewHeight;
+    float videoAspectRatio = videoWidth / videoHeight;
+    float scaleWidth = 1.0f;
+    float scaleHeight = 1.0f;
+
+    if (viewAspectRatio > videoAspectRatio) {
+      // Scale to exactly fit the width of the video. The top and bottom will be cropped.
+      float scaleFactor = viewWidth / videoWidth;
+      float desiredScaledHeight = videoHeight * scaleFactor;
+      scaleHeight = desiredScaledHeight / viewHeight;
+    } else {
+      // Scale to exactly fit the height of the video. The sides will be cropped.
+      float scaleFactor = viewHeight / videoHeight;
+      float desiredScaledWidth = videoWidth * scaleFactor;
+      scaleWidth = desiredScaledWidth / viewWidth;
+    }
+
+    if (rotationDegrees == 90.0f || rotationDegrees == 270.0f) {
+      // We're in landscape mode but the camera feed is still drawing in portrait mode. Normally,
+      // scale of 1.0 means that the video feed stretches to fit the view. In this case the X axis
+      // is scaled to fit the height and the Y axis is scaled to fit the width.
+      float scaleX = scaleWidth;
+      float scaleY = scaleHeight;
+      scaleWidth = viewHeight / viewWidth * scaleY;
+      scaleHeight = viewWidth / viewHeight * scaleX;
+
+      // This flips the view vertically. Without this the camera feed would be upside down.
+      scaleWidth = scaleWidth * -1.0f;
+      // This flips the view horizontally. Without this the camera feed would be mirrored (left
+      // side would appear on right).
+      scaleHeight = scaleHeight * -1.0f;
+    }
+
+    LogUtil.i(
+        "VideoScale.scaleVideoAndFillView",
+        "view: %f x %f, video: %f x %f scale: %f x %f, rotation: %f",
+        viewWidth,
+        viewHeight,
+        videoWidth,
+        videoHeight,
+        scaleWidth,
+        scaleHeight,
+        rotationDegrees);
+
+    Matrix transform = new Matrix();
+    transform.setScale(
+        scaleWidth,
+        scaleHeight,
+        // This performs the scaling from the horizontal middle of the view.
+        viewWidth / 2.0f,
+        // This perform the scaling from vertical middle of the view.
+        viewHeight / 2.0f);
+    if (rotationDegrees != 0) {
+      transform.postRotate(rotationDegrees, viewWidth / 2.0f, viewHeight / 2.0f);
+    }
+    textureView.setTransform(transform);
+  }
+
+  /**
+   * Scales the video in the given view such that all of the video is visible. This will result in
+   * black bars on the top and bottom or the sides of the video.
+   */
+  public static void scaleVideoMaintainingAspectRatio(
+      TextureView textureView, int videoWidth, int videoHeight) {
+    int viewWidth = textureView.getWidth();
+    int viewHeight = textureView.getHeight();
+    float scaleWidth = 1.0f;
+    float scaleHeight = 1.0f;
+
+    if (viewWidth > viewHeight) {
+      // Landscape layout.
+      if (viewHeight * videoWidth > viewWidth * videoHeight) {
+        // Current display height is too much. Correct it.
+        int desiredHeight = viewWidth * videoHeight / videoWidth;
+        scaleWidth = (float) desiredHeight / (float) viewHeight;
+      } else if (viewHeight * videoWidth < viewWidth * videoHeight) {
+        // Current display width is too much. Correct it.
+        int desiredWidth = viewHeight * videoWidth / videoHeight;
+        scaleWidth = (float) desiredWidth / (float) viewWidth;
+      }
+    } else {
+      // Portrait layout.
+      if (viewHeight * videoWidth > viewWidth * videoHeight) {
+        // Current display height is too much. Correct it.
+        int desiredHeight = viewWidth * videoHeight / videoWidth;
+        scaleHeight = (float) desiredHeight / (float) viewHeight;
+      } else if (viewHeight * videoWidth < viewWidth * videoHeight) {
+        // Current display width is too much. Correct it.
+        int desiredWidth = viewHeight * videoWidth / videoHeight;
+        scaleHeight = (float) desiredWidth / (float) viewWidth;
+      }
+    }
+
+    LogUtil.i(
+        "VideoScale.scaleVideoMaintainingAspectRatio",
+        "view: %d x %d, video: %d x %d scale: %f x %f",
+        viewWidth,
+        viewHeight,
+        videoWidth,
+        videoHeight,
+        scaleWidth,
+        scaleHeight);
+    Matrix transform = new Matrix();
+    transform.setScale(
+        scaleWidth,
+        scaleHeight,
+        // This performs the scaling from the horizontal middle of the view.
+        viewWidth / 2.0f,
+        // This perform the scaling from vertical middle of the view.
+        viewHeight / 2.0f);
+    textureView.setTransform(transform);
+  }
+
+  private VideoScale() {}
+}
diff --git a/java/com/android/incallui/videosurface/impl/VideoSurfaceTextureImpl.java b/java/com/android/incallui/videosurface/impl/VideoSurfaceTextureImpl.java
new file mode 100644
index 0000000..21160ca
--- /dev/null
+++ b/java/com/android/incallui/videosurface/impl/VideoSurfaceTextureImpl.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2014 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.videosurface.impl;
+
+import android.graphics.Point;
+import android.graphics.SurfaceTexture;
+import android.view.Surface;
+import android.view.TextureView;
+import android.view.View;
+import com.android.dialer.common.LogUtil;
+import com.android.incallui.videosurface.protocol.VideoSurfaceDelegate;
+import com.android.incallui.videosurface.protocol.VideoSurfaceTexture;
+import java.util.Locale;
+import java.util.Objects;
+
+/**
+ * Represents a {@link TextureView} and its associated {@link SurfaceTexture} and {@link Surface}.
+ * Used to manage the lifecycle of these objects across device orientation changes.
+ */
+public class VideoSurfaceTextureImpl implements VideoSurfaceTexture {
+  @SurfaceType private final int surfaceType;
+  private VideoSurfaceDelegate delegate;
+  private TextureView textureView;
+  private Surface savedSurface;
+  private SurfaceTexture savedSurfaceTexture;
+  private Point surfaceDimensions;
+  private Point sourceVideoDimensions;
+  private boolean isDoneWithSurface;
+
+  public VideoSurfaceTextureImpl(@SurfaceType int surfaceType) {
+    this.surfaceType = surfaceType;
+  }
+
+  @Override
+  public void setDelegate(VideoSurfaceDelegate delegate) {
+    LogUtil.i("VideoSurfaceTextureImpl.setDelegate", "delegate: " + delegate + " " + toString());
+    this.delegate = delegate;
+  }
+
+  @Override
+  public int getSurfaceType() {
+    return surfaceType;
+  }
+
+  @Override
+  public Surface getSavedSurface() {
+    return savedSurface;
+  }
+
+  @Override
+  public void setSurfaceDimensions(Point surfaceDimensions) {
+    LogUtil.i(
+        "VideoSurfaceTextureImpl.setSurfaceDimensions",
+        "surfaceDimensions: " + surfaceDimensions + " " + toString());
+    this.surfaceDimensions = surfaceDimensions;
+    if (surfaceDimensions != null && savedSurfaceTexture != null) {
+      savedSurfaceTexture.setDefaultBufferSize(surfaceDimensions.x, surfaceDimensions.y);
+    }
+  }
+
+  @Override
+  public Point getSurfaceDimensions() {
+    return surfaceDimensions;
+  }
+
+  @Override
+  public void setSourceVideoDimensions(Point sourceVideoDimensions) {
+    this.sourceVideoDimensions = sourceVideoDimensions;
+  }
+
+  @Override
+  public Point getSourceVideoDimensions() {
+    return sourceVideoDimensions;
+  }
+
+  @Override
+  public void attachToTextureView(TextureView textureView) {
+    if (this.textureView == textureView) {
+      return;
+    }
+    LogUtil.i("VideoSurfaceTextureImpl.attachToTextureView", toString());
+
+    if (this.textureView != null) {
+      this.textureView.setOnClickListener(null);
+      // Don't clear the surface texture listener. This is important because our listener prevents
+      // the surface from being released so that it can be reused later.
+    }
+
+    this.textureView = textureView;
+    textureView.setSurfaceTextureListener(new SurfaceTextureListener());
+    textureView.setOnClickListener(new OnClickListener());
+
+    boolean areSameSurfaces = Objects.equals(savedSurfaceTexture, textureView.getSurfaceTexture());
+    LogUtil.i("VideoSurfaceTextureImpl.attachToTextureView", "areSameSurfaces: " + areSameSurfaces);
+    if (savedSurfaceTexture != null && !areSameSurfaces) {
+      textureView.setSurfaceTexture(savedSurfaceTexture);
+      if (surfaceDimensions != null && createSurface(surfaceDimensions.x, surfaceDimensions.y)) {
+        onSurfaceCreated();
+      }
+    }
+    isDoneWithSurface = false;
+  }
+
+  @Override
+  public void setDoneWithSurface() {
+    LogUtil.i("VideoSurfaceTextureImpl.setDoneWithSurface", toString());
+    isDoneWithSurface = true;
+    if (textureView != null && textureView.isAvailable()) {
+      return;
+    }
+    if (savedSurface != null) {
+      onSurfaceReleased();
+      savedSurface.release();
+      savedSurface = null;
+    }
+    if (savedSurfaceTexture != null) {
+      savedSurfaceTexture.release();
+      savedSurfaceTexture = null;
+    }
+  }
+
+  private boolean createSurface(int width, int height) {
+    LogUtil.i(
+        "VideoSurfaceTextureImpl.createSurface",
+        "width: " + width + ", height: " + height + " " + toString());
+    if (savedSurfaceTexture != null) {
+      savedSurfaceTexture.setDefaultBufferSize(width, height);
+      savedSurface = new Surface(savedSurfaceTexture);
+      return true;
+    }
+    return false;
+  }
+
+  private void onSurfaceCreated() {
+    if (delegate != null) {
+      delegate.onSurfaceCreated(this);
+    } else {
+      LogUtil.e("VideoSurfaceTextureImpl.onSurfaceCreated", "delegate is null. " + toString());
+    }
+  }
+
+  private void onSurfaceReleased() {
+    if (delegate != null) {
+      delegate.onSurfaceReleased(this);
+    } else {
+      LogUtil.e("VideoSurfaceTextureImpl.onSurfaceReleased", "delegate is null. " + toString());
+    }
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.US,
+        "VideoSurfaceTextureImpl<%s%s%s%s>",
+        (surfaceType == SURFACE_TYPE_LOCAL ? "local, " : "remote, "),
+        (savedSurface == null ? "no-surface, " : ""),
+        (savedSurfaceTexture == null ? "no-texture, " : ""),
+        (surfaceDimensions == null
+            ? "(-1 x -1)"
+            : (surfaceDimensions.x + " x " + surfaceDimensions.y)));
+  }
+
+  private class SurfaceTextureListener implements TextureView.SurfaceTextureListener {
+    @Override
+    public void onSurfaceTextureAvailable(SurfaceTexture newSurfaceTexture, int width, int height) {
+      LogUtil.i(
+          "SurfaceTextureListener.onSurfaceTextureAvailable",
+          "newSurfaceTexture: "
+              + newSurfaceTexture
+              + " "
+              + VideoSurfaceTextureImpl.this.toString());
+
+      // Where there is no saved {@link SurfaceTexture} available, use the newly created one.
+      // If a saved {@link SurfaceTexture} is available, we are re-creating after an
+      // orientation change.
+      boolean surfaceCreated;
+      if (savedSurfaceTexture == null) {
+        savedSurfaceTexture = newSurfaceTexture;
+        surfaceCreated = createSurface(width, height);
+      } else {
+        // A saved SurfaceTexture was found.
+        LogUtil.i(
+            "SurfaceTextureListener.onSurfaceTextureAvailable", "replacing with cached surface...");
+        textureView.setSurfaceTexture(savedSurfaceTexture);
+        surfaceCreated = true;
+      }
+
+      // Inform the delegate that the surface is available.
+      if (surfaceCreated) {
+        onSurfaceCreated();
+      }
+    }
+
+    @Override
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture destroyedSurfaceTexture) {
+      LogUtil.i(
+          "SurfaceTextureListener.onSurfaceTextureDestroyed",
+          "destroyedSurfaceTexture: "
+              + destroyedSurfaceTexture
+              + " "
+              + VideoSurfaceTextureImpl.this.toString());
+      if (delegate != null) {
+        delegate.onSurfaceDestroyed(VideoSurfaceTextureImpl.this);
+      } else {
+        LogUtil.e("SurfaceTextureListener.onSurfaceTextureDestroyed", "delegate is null");
+      }
+
+      if (isDoneWithSurface) {
+        onSurfaceReleased();
+        if (savedSurface != null) {
+          savedSurface.release();
+          savedSurface = null;
+        }
+      }
+      return isDoneWithSurface;
+    }
+
+    @Override
+    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {}
+
+    @Override
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {}
+  }
+
+  private class OnClickListener implements View.OnClickListener {
+    @Override
+    public void onClick(View view) {
+      if (delegate != null) {
+        delegate.onSurfaceClick(VideoSurfaceTextureImpl.this);
+      } else {
+        LogUtil.e("OnClickListener.onClick", "delegate is null");
+      }
+    }
+  }
+}
diff --git a/java/com/android/incallui/videosurface/protocol/VideoSurfaceDelegate.java b/java/com/android/incallui/videosurface/protocol/VideoSurfaceDelegate.java
new file mode 100644
index 0000000..8fa585a
--- /dev/null
+++ b/java/com/android/incallui/videosurface/protocol/VideoSurfaceDelegate.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 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.videosurface.protocol;
+
+/** Callbacks from the video surface. */
+public interface VideoSurfaceDelegate {
+
+  void onSurfaceCreated(VideoSurfaceTexture videoCallSurface);
+
+  void onSurfaceReleased(VideoSurfaceTexture videoCallSurface);
+
+  void onSurfaceDestroyed(VideoSurfaceTexture videoCallSurface);
+
+  void onSurfaceClick(VideoSurfaceTexture videoCallSurface);
+}
diff --git a/java/com/android/incallui/videosurface/protocol/VideoSurfaceTexture.java b/java/com/android/incallui/videosurface/protocol/VideoSurfaceTexture.java
new file mode 100644
index 0000000..411b45f
--- /dev/null
+++ b/java/com/android/incallui/videosurface/protocol/VideoSurfaceTexture.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 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.videosurface.protocol;
+
+import android.graphics.Point;
+import android.support.annotation.IntDef;
+import android.view.Surface;
+import android.view.TextureView;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/** Represents a surface texture for a video feed. */
+public interface VideoSurfaceTexture {
+
+  /** Whether this represents the preview or remote display. */
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({
+    SURFACE_TYPE_LOCAL,
+    SURFACE_TYPE_REMOTE,
+  })
+  @interface SurfaceType {}
+
+  int SURFACE_TYPE_LOCAL = 1;
+  int SURFACE_TYPE_REMOTE = 2;
+
+  void setDelegate(VideoSurfaceDelegate delegate);
+
+  int getSurfaceType();
+
+  Surface getSavedSurface();
+
+  void setSurfaceDimensions(Point surfaceDimensions);
+
+  Point getSurfaceDimensions();
+
+  void setSourceVideoDimensions(Point sourceVideoDimensions);
+
+  Point getSourceVideoDimensions();
+
+  void attachToTextureView(TextureView textureView);
+
+  void setDoneWithSurface();
+}
diff --git a/java/com/android/incallui/wifi/AndroidManifest.xml b/java/com/android/incallui/wifi/AndroidManifest.xml
new file mode 100644
index 0000000..843f8f3
--- /dev/null
+++ b/java/com/android/incallui/wifi/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<manifest
+  package="com.android.incallui.wifi">
+</manifest>
diff --git a/java/com/android/incallui/wifi/EnableWifiCallingPrompt.java b/java/com/android/incallui/wifi/EnableWifiCallingPrompt.java
new file mode 100644
index 0000000..85603bf
--- /dev/null
+++ b/java/com/android/incallui/wifi/EnableWifiCallingPrompt.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2017 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.wifi;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.support.annotation.NonNull;
+import android.telecom.DisconnectCause;
+import android.util.Pair;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+
+/** Prompts the user to enable Wi-Fi calling. */
+public class EnableWifiCallingPrompt {
+  // This is a hidden constant in android.telecom.DisconnectCause. Telecom sets this as a disconnect
+  // reason if it wants us to prompt the user to enable Wi-Fi calling. In Android-O we might
+  // consider using a more explicit way to signal this.
+  private static final String REASON_WIFI_ON_BUT_WFC_OFF = "REASON_WIFI_ON_BUT_WFC_OFF";
+  private static final String ACTION_WIFI_CALLING_SETTINGS =
+      "android.settings.WIFI_CALLING_SETTINGS";
+  private static final String ANDROID_SETTINGS_PACKAGE = "com.android.settings";
+
+  public static boolean shouldShowPrompt(@NonNull DisconnectCause cause) {
+    Assert.isNotNull(cause);
+    if (cause.getReason() != null && cause.getReason().startsWith(REASON_WIFI_ON_BUT_WFC_OFF)) {
+      LogUtil.i(
+          "EnableWifiCallingPrompt.shouldShowPrompt",
+          "showing prompt for disconnect cause: %s",
+          cause);
+      return true;
+    }
+    return false;
+  }
+
+  @NonNull
+  public static Pair<Dialog, CharSequence> createDialog(
+      final @NonNull Context context, @NonNull DisconnectCause cause) {
+    Assert.isNotNull(context);
+    Assert.isNotNull(cause);
+    CharSequence message = cause.getDescription();
+    Dialog dialog =
+        new AlertDialog.Builder(context)
+            .setMessage(message)
+            .setPositiveButton(
+                R.string.incall_enable_wifi_calling_button,
+                new OnClickListener() {
+                  @Override
+                  public void onClick(DialogInterface dialog, int which) {
+                    openWifiCallingSettings(context);
+                  }
+                })
+            .setNegativeButton(android.R.string.cancel, null)
+            .create();
+    return new Pair<Dialog, CharSequence>(dialog, message);
+  }
+
+  private static void openWifiCallingSettings(@NonNull Context context) {
+    LogUtil.i("EnableWifiCallingPrompt.openWifiCallingSettings", "opening settings");
+    context.startActivity(
+        new Intent(ACTION_WIFI_CALLING_SETTINGS).setPackage(ANDROID_SETTINGS_PACKAGE));
+  }
+
+  private EnableWifiCallingPrompt() {}
+}
diff --git a/java/com/android/incallui/wifi/res/values/strings.xml b/java/com/android/incallui/wifi/res/values/strings.xml
new file mode 100644
index 0000000..1b52b9f
--- /dev/null
+++ b/java/com/android/incallui/wifi/res/values/strings.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+  <!-- Button to enable Wi-Fi calling. This is displayed in a dialog after a phone call disconnects
+      because there is no cellular service.
+      [CHAR LIMIT=20] -->
+  <string name="incall_enable_wifi_calling_button">Enable</string>
+
+</resources>