diff --git a/InCallUI/res/layout/call_button_fragment.xml b/InCallUI/res/layout/call_button_fragment.xml
index 6dbfbf7..802e3de 100644
--- a/InCallUI/res/layout/call_button_fragment.xml
+++ b/InCallUI/res/layout/call_button_fragment.xml
@@ -126,7 +126,7 @@
         <ToggleButton android:id="@+id/pauseVideoButton"
             style="@style/InCallCompoundButton"
             android:background="@drawable/btn_compound_video_off"
-            android:contentDescription="@string/onscreenPauseVideoText"
+            android:contentDescription="@string/onscreenTurnOffCameraText"
             android:visibility="gone" />
 
         <!-- "Change to audio call" for video calls. -->
diff --git a/InCallUI/res/values/strings.xml b/InCallUI/res/values/strings.xml
index 57a1b53..84eb14c 100644
--- a/InCallUI/res/values/strings.xml
+++ b/InCallUI/res/values/strings.xml
@@ -218,6 +218,17 @@
          The user will be able to send text messages using the phone number.
          [CHAR LIMIT=12] -->
     <string name="notification_missedCall_message">Message</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>
+    <!-- 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 "transfer call" action initiates the process of transferring an
+         external call to the current device.
+         [CHAR LIMIT=30] -->
+    <string name="notification_transfer_call">Transfer 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>
@@ -313,8 +324,10 @@
     <!-- Text for the onscreen "Switch camera" button. When clicked, this switches the user's camera
          for video calling between the front-facing camera and the back-facing camera. -->
     <string name="onscreenSwitchCameraText">Switch camera</string>
-    <!-- Text for the onscreen "Pause video" button. -->
-    <string name="onscreenPauseVideoText">Pause video</string>
+    <!-- Text for the onscreen "turn on camera" button. -->
+    <string name="onscreenTurnOnCameraText">Turn on camera</string>
+    <!-- Text for the onscreen "turn off camera" button. -->
+    <string name="onscreenTurnOffCameraText">Turn off camera</string>
     <!-- Text for the onscreen overflow button, to see additional actions which can be done. -->
     <string name="onscreenOverflowText">More options</string>
 
diff --git a/InCallUI/src/com/android/incallui/AnswerPresenter.java b/InCallUI/src/com/android/incallui/AnswerPresenter.java
index 6757268..883b54f 100644
--- a/InCallUI/src/com/android/incallui/AnswerPresenter.java
+++ b/InCallUI/src/com/android/incallui/AnswerPresenter.java
@@ -128,10 +128,7 @@
     @Override
     public void onUpgradeToVideo(Call call) {
         Log.d(this, "onUpgradeToVideo: " + this + " call=" + call);
-        if (getUi() == null) {
-            Log.d(this, "onUpgradeToVideo ui is null");
-            return;
-        }
+        showAnswerUi(true);
         boolean isUpgradePending = isVideoUpgradePending(call);
         InCallPresenter inCallPresenter = InCallPresenter.getInstance();
         if (isUpgradePending
diff --git a/InCallUI/src/com/android/incallui/Call.java b/InCallUI/src/com/android/incallui/Call.java
index 447c34c..d552ecf 100644
--- a/InCallUI/src/com/android/incallui/Call.java
+++ b/InCallUI/src/com/android/incallui/Call.java
@@ -33,6 +33,8 @@
 import android.text.TextUtils;
 
 import com.android.contacts.common.CallUtil;
+import com.android.contacts.common.compat.CallSdkCompat;
+import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.common.compat.SdkVersionOverride;
 import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
 import com.android.contacts.common.testing.NeededForTesting;
@@ -400,13 +402,30 @@
         setState(state);
     }
 
+    /**
+     * Creates a new instance of a {@link Call}.  Registers a callback for
+     * {@link android.telecom.Call} events.
+     */
     public Call(android.telecom.Call telecomCall) {
+        this(telecomCall, true /* registerCallback */);
+    }
+
+    /**
+     * Creates a new instance of a {@link Call}.  Optionally registers a callback for
+     * {@link android.telecom.Call} events.
+     *
+     * Intended for use when creating a {@link Call} instance for use with the
+     * {@link ContactInfoCache}, where we do not want to register callbacks for the new call.
+     */
+    public Call(android.telecom.Call telecomCall, boolean registerCallback) {
         mTelecomCall = telecomCall;
         mId = ID_PREFIX + Integer.toString(sIdCounter++);
 
-        updateFromTelecomCall();
+        updateFromTelecomCall(registerCallback);
 
-        mTelecomCall.registerCallback(mTelecomCallCallback);
+        if (registerCallback) {
+            mTelecomCall.registerCallback(mTelecomCallCallback);
+        }
 
         mTimeAddedMs = System.currentTimeMillis();
     }
@@ -426,7 +445,8 @@
     private void update() {
         Trace.beginSection("Update");
         int oldState = getState();
-        updateFromTelecomCall();
+        // We want to potentially register a video call callback here.
+        updateFromTelecomCall(true /* registerCallback */);
         if (oldState != getState() && getState() == Call.State.DISCONNECTED) {
             CallList.getInstance().onDisconnect(this);
         } else {
@@ -435,7 +455,7 @@
         Trace.endSection();
     }
 
-    private void updateFromTelecomCall() {
+    private void updateFromTelecomCall(boolean registerCallback) {
         Log.d(this, "updateFromTelecomCall: " + mTelecomCall.toString());
         final int translatedState = translateState(mTelecomCall.getState());
         if (mState != State.BLOCKED) {
@@ -444,7 +464,7 @@
             maybeCancelVideoUpgrade(mTelecomCall.getDetails().getVideoState());
         }
 
-        if (mTelecomCall.getVideoCall() != null) {
+        if (registerCallback && mTelecomCall.getVideoCall() != null) {
             if (mVideoCallCallback == null) {
                 mVideoCallCallback = new InCallVideoCallCallback(this);
             }
@@ -883,9 +903,46 @@
     }
 
     /**
+     * Determines if the call is an external call.
+     *
+     * An external call is one which does not exist locally for the
+     * {@link android.telecom.ConnectionService} it is associated with.
+     *
+     * 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 CompatUtils.isNCompatible() &&
+                hasProperty(CallSdkCompat.Details.PROPERTY_IS_EXTERNAL_CALL);
+    }
+
+    /**
+     * Determines if the external call is pullable.
+     *
+     * 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.
+     *
+     * 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 CompatUtils.isNCompatible() &&
+                (mTelecomCall.getDetails().getCallCapabilities()
+                        & CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL)
+                        == CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL;
+    }
+
+    /**
      * Logging utility methods
      */
     public void logCallInitiationType() {
+        if (isExternalCall()) {
+            return;
+        }
+
         if (getState() == State.INCOMING) {
             getLogState().callInitiationMethod = LogState.INITIATION_INCOMING;
         } else if (getIntentExtras() != null) {
@@ -903,11 +960,12 @@
             return String.valueOf(mId);
         }
 
-        return String.format(Locale.US, "[%s, %s, %s, children:%s, parent:%s, conferenceable:%s, " +
-                "videoState:%s, mSessionModificationState:%d, VideoSettings:%s]",
+        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(),
diff --git a/InCallUI/src/com/android/incallui/CallButtonFragment.java b/InCallUI/src/com/android/incallui/CallButtonFragment.java
index 5a25b6a..6b633ea 100644
--- a/InCallUI/src/com/android/incallui/CallButtonFragment.java
+++ b/InCallUI/src/com/android/incallui/CallButtonFragment.java
@@ -65,7 +65,6 @@
         implements CallButtonPresenter.CallButtonUi, OnMenuItemClickListener, OnDismissListener,
         View.OnClickListener {
 
-    private static final int INVALID_INDEX = -1;
     private int mButtonMaxVisible;
     // The button is currently visible in the UI
     private static final int BUTTON_VISIBLE = 1;
@@ -182,7 +181,7 @@
         super.onActivityCreated(savedInstanceState);
 
         // set the buttons
-        updateAudioButtons(getPresenter().getSupportedAudio());
+        updateAudioButtons();
     }
 
     @Override
@@ -425,8 +424,14 @@
     }
 
     @Override
-    public void setVideoPaused(boolean isPaused) {
-        mPauseVideoButton.setSelected(isPaused);
+    public void setVideoPaused(boolean isVideoPaused) {
+        mPauseVideoButton.setSelected(isVideoPaused);
+
+        if (isVideoPaused) {
+            mPauseVideoButton.setContentDescription(getText(R.string.onscreenTurnOnCameraText));
+        } else {
+            mPauseVideoButton.setContentDescription(getText(R.string.onscreenTurnOffCameraText));
+        }
     }
 
     @Override
@@ -505,7 +510,7 @@
 
     @Override
     public void setAudio(int mode) {
-        updateAudioButtons(getPresenter().getSupportedAudio());
+        updateAudioButtons();
         refreshAudioModePopup();
 
         if (mPrevAudioMode != mode) {
@@ -516,7 +521,7 @@
 
     @Override
     public void setSupportedAudio(int modeMask) {
-        updateAudioButtons(modeMask);
+        updateAudioButtons();
         refreshAudioModePopup();
     }
 
@@ -555,7 +560,7 @@
     public void onDismiss(PopupMenu menu) {
         Log.d(this, "- onDismiss: " + menu);
         mAudioModePopupVisible = false;
-        updateAudioButtons(getPresenter().getSupportedAudio());
+        updateAudioButtons();
     }
 
     /**
@@ -600,7 +605,7 @@
      * Updates the audio button so that the appriopriate visual layers
      * are visible based on the supported audio formats.
      */
-    private void updateAudioButtons(int supportedModes) {
+    private void updateAudioButtons() {
         final boolean bluetoothSupported = isSupported(CallAudioState.ROUTE_BLUETOOTH);
         final boolean speakerSupported = isSupported(CallAudioState.ROUTE_SPEAKER);
 
diff --git a/InCallUI/src/com/android/incallui/CallButtonPresenter.java b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
index e8c2d4b..df1cd66 100644
--- a/InCallUI/src/com/android/incallui/CallButtonPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
@@ -366,7 +366,6 @@
     private void updateButtonsState(Call call) {
         Log.v(this, "updateButtonsState");
         final CallButtonUi ui = getUi();
-
         final boolean isVideo = VideoUtils.isVideoCall(call);
 
         // Common functionality (audio, hold, etc).
@@ -398,6 +397,9 @@
         ui.showButton(BUTTON_DOWNGRADE_TO_AUDIO, showDowngradeToAudio);
         ui.showButton(BUTTON_SWITCH_CAMERA, isVideo);
         ui.showButton(BUTTON_PAUSE_VIDEO, isVideo);
+        if (isVideo) {
+            getUi().setVideoPaused(!VideoUtils.isTransmissionEnabled(call));
+        }
         ui.showButton(BUTTON_DIALPAD, true);
         ui.showButton(BUTTON_MERGE, showMerge);
 
diff --git a/InCallUI/src/com/android/incallui/ExternalCallList.java b/InCallUI/src/com/android/incallui/ExternalCallList.java
new file mode 100644
index 0000000..06e0bb9
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ExternalCallList.java
@@ -0,0 +1,105 @@
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import com.android.contacts.common.compat.CallSdkCompat;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.telecom.Call;
+import android.util.ArraySet;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Tracks the external calls known to the InCall UI.
+ *
+ * External calls are those with {@link android.telecom.Call.Details#PROPERTY_IS_EXTERNAL_CALL}.
+ */
+public class ExternalCallList {
+
+    public interface ExternalCallListener {
+        void onExternalCallAdded(Call call);
+        void onExternalCallRemoved(Call call);
+        void onExternalCallUpdated(Call call);
+    }
+
+    /**
+     * 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);
+        }
+    };
+
+    private final Set<Call> mExternalCalls = new ArraySet<>();
+    private final Set<ExternalCallListener> mExternalCallListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<ExternalCallListener, Boolean>(8, 0.9f, 1));
+
+    /**
+     * Begins tracking an external call and notifies listeners of the new call.
+     */
+    public void onCallAdded(Call telecomCall) {
+        Preconditions.checkArgument(telecomCall.getDetails()
+                .hasProperty(CallSdkCompat.Details.PROPERTY_IS_EXTERNAL_CALL));
+        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) {
+        Preconditions.checkArgument(mExternalCalls.contains(telecomCall));
+        mExternalCalls.remove(telecomCall);
+        telecomCall.unregisterCallback(mTelecomCallCallback);
+        notifyExternalCallRemoved(telecomCall);
+    }
+
+    /**
+     * Adds a new listener to external call events.
+     */
+    public void addExternalCallListener(ExternalCallListener listener) {
+        mExternalCallListeners.add(Preconditions.checkNotNull(listener));
+    }
+
+    /**
+     * Removes a listener to external call events.
+     */
+    public void removeExternalCallListener(ExternalCallListener listener) {
+        Preconditions.checkArgument(mExternalCallListeners.contains(listener));
+        mExternalCallListeners.remove(Preconditions.checkNotNull(listener));
+    }
+
+    /**
+     * 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) {
+        for (ExternalCallListener listener : mExternalCallListeners) {
+            listener.onExternalCallUpdated(call);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ExternalCallNotifier.java b/InCallUI/src/com/android/incallui/ExternalCallNotifier.java
new file mode 100644
index 0000000..40a2e02
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ExternalCallNotifier.java
@@ -0,0 +1,406 @@
+/*
+ * 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 com.google.common.base.Preconditions;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.compat.CallSdkCompat;
+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.R;
+import com.android.incallui.util.TelecomCallUtil;
+
+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.support.annotation.Nullable;
+import android.telecom.Call;
+import android.telecom.PhoneAccount;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.util.ArrayMap;
+
+import java.util.Map;
+
+/**
+ * Handles the display of notifications for "external calls".
+ *
+ * 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";
+
+    /**
+     * Represents a call and associated cached notification data.
+     */
+    private static class NotificationInfo {
+        private final Call mCall;
+        private final int mNotificationId;
+        @Nullable private String mContentTitle;
+        @Nullable private Bitmap mLargeIcon;
+        @Nullable private String mPersonReference;
+
+        public NotificationInfo(Call call, int notificationId) {
+            Preconditions.checkNotNull(call);
+            mCall = call;
+            mNotificationId = notificationId;
+        }
+
+        public Call getCall() {
+            return mCall;
+        }
+
+        public int getNotificationId() {
+            return mNotificationId;
+        }
+
+        public @Nullable String getContentTitle() {
+            return mContentTitle;
+        }
+
+        public @Nullable Bitmap getLargeIcon() {
+            return mLargeIcon;
+        }
+
+        public @Nullable String getPersonReference() {
+            return mPersonReference;
+        }
+
+        public void setContentTitle(@Nullable String contentTitle) {
+            mContentTitle = contentTitle;
+        }
+
+        public void setLargeIcon(@Nullable Bitmap largeIcon) {
+            mLargeIcon = largeIcon;
+        }
+
+        public void setPersonReference(@Nullable String personReference) {
+            mPersonReference = personReference;
+        }
+    }
+
+    private final Context mContext;
+    private final ContactInfoCache mContactInfoCache;
+    private Map<Call, NotificationInfo> mNotifications = new ArrayMap<>();
+    private int mNextUniqueNotificationId;
+    private ContactsPreferences mContactsPreferences;
+
+    /**
+     * Initializes a new instance of the external call notifier.
+     */
+    public ExternalCallNotifier(Context context, ContactInfoCache contactInfoCache) {
+        mContext = Preconditions.checkNotNull(context);
+        mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+        mContactInfoCache = Preconditions.checkNotNull(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);
+        Preconditions.checkArgument(!mNotifications.containsKey(call));
+        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) {
+        Preconditions.checkArgument(mNotifications.containsKey(call));
+        postNotification(mNotifications.get(call));
+    }
+
+    /**
+     * Initiates a call pull given a notification ID.
+     *
+     * @param notificationId The notification ID associated with the external call which is to be
+     *                       pulled.
+     */
+    public void pullExternalCall(int notificationId) {
+        for (NotificationInfo info : mNotifications.values()) {
+            if (info.getNotificationId() == notificationId) {
+                CallSdkCompat.pullExternalCall(info.getCall());
+                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.
+        com.android.incallui.Call incallCall = new com.android.incallui.Call(info.getCall(),
+                false /* registerCallback */);
+
+        mContactInfoCache.findInfo(incallCall, 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);
+                        }
+                    }
+
+                    @Override
+                    public void onContactInteractionsInfoComplete(String callId,
+                            ContactInfoCache.ContactCacheEntry entry) {
+                    }
+                });
+    }
+
+    /**
+     * Dismisses a notification for an external call.
+     */
+    private void dismissNotification(Call call) {
+        Preconditions.checkArgument(mNotifications.containsKey(call));
+
+        NotificationManager notificationManager =
+                (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+        notificationManager.cancel(NOTIFICATION_TAG, mNotifications.get(call).getNotificationId());
+
+        mNotifications.remove(call);
+    }
+
+    /**
+     * 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) {
+        Log.i(this, "postNotification : " + info.getContentTitle());
+        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);
+        // Set the content ("Ongoing call on another device")
+        builder.setContentText(mContext.getString(R.string.notification_external_call));
+        builder.setSmallIcon(R.drawable.ic_call_white_24dp);
+        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 ((info.getCall().getDetails().getCallCapabilities()
+                & CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL)
+                == CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL) {
+
+            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.ic_call_white_24dp,
+                    mContext.getText(R.string.notification_transfer_call),
+                    PendingIntent.getBroadcast(mContext, 0, 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.ic_call_white_24dp);
+        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);
+    }
+
+    /**
+     * 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.card_title_conf_call);
+        }
+
+        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 "";
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallPresenter.java b/InCallUI/src/com/android/incallui/InCallPresenter.java
index 0109d7e..38507ee 100644
--- a/InCallUI/src/com/android/incallui/InCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/InCallPresenter.java
@@ -41,6 +41,7 @@
 import android.view.WindowManager;
 
 import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.CallSdkCompat;
 import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
 import com.android.contacts.common.interactions.TouchPointManager;
@@ -109,9 +110,11 @@
 
     private AudioModeProvider mAudioModeProvider;
     private StatusBarNotifier mStatusBarNotifier;
+    private ExternalCallNotifier mExternalCallNotifier;
     private ContactInfoCache mContactInfoCache;
     private Context mContext;
     private CallList mCallList;
+    private ExternalCallList mExternalCallList;
     private InCallActivity mInCallActivity;
     private InCallState mInCallState = InCallState.NO_CALLS;
     private ProximitySensor mProximitySensor;
@@ -299,8 +302,10 @@
 
     public void setUp(Context context,
             CallList callList,
+            ExternalCallList externalCallList,
             AudioModeProvider audioModeProvider,
             StatusBarNotifier statusBarNotifier,
+            ExternalCallNotifier externalCallNotifier,
             ContactInfoCache contactInfoCache,
             ProximitySensor proximitySensor) {
         if (mServiceConnected) {
@@ -318,6 +323,7 @@
         mContactInfoCache = contactInfoCache;
 
         mStatusBarNotifier = statusBarNotifier;
+        mExternalCallNotifier = externalCallNotifier;
         addListener(mStatusBarNotifier);
 
         mAudioModeProvider = audioModeProvider;
@@ -329,6 +335,8 @@
         addInCallUiListener(mAnswerPresenter);
 
         mCallList = callList;
+        mExternalCallList = externalCallList;
+        externalCallList.addExternalCallListener(mExternalCallNotifier);
 
         // This only gets called by the service so this is okay.
         mServiceConnected = true;
@@ -501,7 +509,12 @@
         if (shouldAttemptBlocking(call)) {
             maybeBlockCall(call);
         } else {
-            mCallList.onCallAdded(call);
+            if (call.getDetails()
+                    .hasProperty(CallSdkCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+                mExternalCallList.onCallAdded(call);
+            } else {
+                mCallList.onCallAdded(call);
+            }
         }
 
         // Since a call has been added we are no longer waiting for Telecom to send us a call.
@@ -590,8 +603,13 @@
     }
 
     public void onCallRemoved(android.telecom.Call call) {
-        mCallList.onCallRemoved(call);
-        call.unregisterCallback(mCallCallback);
+        if (call.getDetails()
+                .hasProperty(CallSdkCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
+            mExternalCallList.onCallRemoved(call);
+        } else {
+            mCallList.onCallRemoved(call);
+            call.unregisterCallback(mCallCallback);
+        }
     }
 
     public void onCanAddCallChanged(boolean canAddCall) {
@@ -1506,6 +1524,9 @@
             if (mStatusBarNotifier != null) {
                 removeListener(mStatusBarNotifier);
             }
+            if (mExternalCallNotifier != null && mExternalCallList != null) {
+                mExternalCallList.removeExternalCallListener(mExternalCallNotifier);
+            }
             mStatusBarNotifier = null;
 
             if (mCallList != null) {
@@ -1808,6 +1829,10 @@
         return mAnswerPresenter;
     }
 
+    ExternalCallNotifier getExternalCallNotifier() {
+        return mExternalCallNotifier;
+    }
+
     /**
      * Private constructor. Must use getInstance() to get this singleton.
      */
diff --git a/InCallUI/src/com/android/incallui/InCallServiceImpl.java b/InCallUI/src/com/android/incallui/InCallServiceImpl.java
index 8693697..1414bc5 100644
--- a/InCallUI/src/com/android/incallui/InCallServiceImpl.java
+++ b/InCallUI/src/com/android/incallui/InCallServiceImpl.java
@@ -64,8 +64,10 @@
         InCallPresenter.getInstance().setUp(
                 getApplicationContext(),
                 CallList.getInstance(),
+                new ExternalCallList(),
                 AudioModeProvider.getInstance(),
                 new StatusBarNotifier(context, contactInfoCache),
+                new ExternalCallNotifier(context, contactInfoCache),
                 contactInfoCache,
                 new ProximitySensor(
                         context,
diff --git a/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java b/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java
index 2543b78..27f7115 100644
--- a/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java
+++ b/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java
@@ -45,6 +45,10 @@
             "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";
+    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) {
@@ -68,6 +72,10 @@
                     VideoProfile.STATE_BIDIRECTIONAL, context);
         } else if (action.equals(ACTION_DECLINE_VIDEO_UPGRADE_REQUEST)) {
             InCallPresenter.getInstance().declineUpgradeRequest(context);
+        } else if (action.equals(ACTION_PULL_EXTERNAL_CALL)) {
+            int notificationId = intent.getIntExtra(EXTRA_NOTIFICATION_ID, -1);
+            InCallPresenter.getInstance().getExternalCallNotifier()
+                    .pullExternalCall(notificationId);
         }
     }
 
diff --git a/InCallUI/src/com/android/incallui/StatusBarNotifier.java b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
index 7d212aa..a616203 100644
--- a/InCallUI/src/com/android/incallui/StatusBarNotifier.java
+++ b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
@@ -247,8 +247,11 @@
                 getContentString(call, contactInfo.userType);
         final String contentTitle = getContentTitle(contactInfo, call);
 
+        final boolean isVideoUpgradeRequest = call.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
         final int notificationType;
-        if (callState == Call.State.INCOMING || callState == Call.State.CALL_WAITING) {
+        if (callState == Call.State.INCOMING || callState == Call.State.CALL_WAITING
+                || isVideoUpgradeRequest) {
             notificationType = NOTIFICATION_INCOMING_CALL;
         } else {
             notificationType = NOTIFICATION_IN_CALL;
@@ -301,8 +304,6 @@
         builder.setLargeIcon(largeIcon);
         builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
 
-        final boolean isVideoUpgradeRequest = call.getSessionModificationState()
-                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
         if (isVideoUpgradeRequest) {
             builder.setUsesChronometer(false);
             addDismissUpgradeRequestAction(builder);
diff --git a/InCallUI/src/com/android/incallui/VideoCallFragment.java b/InCallUI/src/com/android/incallui/VideoCallFragment.java
index cb8c644..2e65f81 100644
--- a/InCallUI/src/com/android/incallui/VideoCallFragment.java
+++ b/InCallUI/src/com/android/incallui/VideoCallFragment.java
@@ -499,6 +499,7 @@
     public void onPause() {
         super.onPause();
         Log.d(this, "onPause:");
+        getPresenter().cancelAutoFullScreen();
     }
 
     @Override
@@ -549,6 +550,7 @@
      * Hides and shows the incoming video view and changes the outgoing video view's state based on
      * whether outgoing view is enabled or not.
      */
+    @Override
     public void showVideoViews(boolean previewPaused, boolean showIncoming) {
         inflateVideoUi(true);
 
@@ -567,6 +569,7 @@
     /**
      * Hide all video views.
      */
+    @Override
     public void hideVideoUi() {
         inflateVideoUi(false);
     }
diff --git a/InCallUI/src/com/android/incallui/VideoCallPresenter.java b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
index 9a33d80..7617608 100644
--- a/InCallUI/src/com/android/incallui/VideoCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
@@ -81,7 +81,9 @@
     private Runnable mAutoFullscreenRunnable =  new Runnable() {
         @Override
         public void run() {
-            if (mAutoFullScreenPending && !InCallPresenter.getInstance().isDialpadVisible()) {
+            if (mAutoFullScreenPending && !InCallPresenter.getInstance().isDialpadVisible()
+                    && mIsVideoMode) {
+
                 Log.v(this, "Automatically entering fullscreen mode.");
                 InCallPresenter.getInstance().setFullScreen(true);
                 mAutoFullScreenPending = false;
@@ -258,6 +260,8 @@
             return;
         }
 
+        cancelAutoFullScreen();
+
         InCallPresenter.getInstance().removeListener(this);
         InCallPresenter.getInstance().removeDetailsListener(this);
         InCallPresenter.getInstance().removeIncomingCallListener(this);
@@ -495,7 +499,7 @@
         updateCameraSelection(call);
 
         if (isVideoCall) {
-            enterVideoMode(call);
+            adjustVideoMode(call);
         } else if (isVideoMode()) {
             exitVideoMode();
         }
@@ -555,7 +559,7 @@
             Log.d(this, "onPrimaryCallChanged: Entering video mode...");
 
             updateCameraSelection(newPrimaryCall);
-            enterVideoMode(newPrimaryCall);
+            adjustVideoMode(newPrimaryCall);
         }
     }
 
@@ -630,7 +634,7 @@
      * 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 videoCall The new video call.
+     * @param call The new video call.
      */
     private void changeVideoCall(Call call) {
         final VideoCall videoCall = call.getTelecomCall().getVideoCall();
@@ -651,13 +655,13 @@
         }
 
         if (VideoUtils.isVideoCall(call) && hasChanged) {
-            enterVideoMode(call);
+            adjustVideoMode(call);
         }
     }
 
     private static boolean isCameraRequired(int videoState) {
-        return VideoProfile.isBidirectional(videoState) ||
-                VideoProfile.isTransmissionEnabled(videoState);
+        return VideoProfile.isBidirectional(videoState)
+                || VideoProfile.isTransmissionEnabled(videoState);
     }
 
     private boolean isCameraRequired() {
@@ -665,14 +669,16 @@
     }
 
     /**
-     * Enters video mode by showing the video surfaces and making other adjustments (eg. audio).
+     * 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(vt): Need to adjust size and orientation of preview surface here.
      */
-    private void enterVideoMode(Call call) {
+    private void adjustVideoMode(Call call) {
         VideoCall videoCall = call.getVideoCall();
         int newVideoState = call.getVideoState();
 
-        Log.d(this, "enterVideoMode videoCall= " + videoCall + " videoState: " + newVideoState);
+        Log.d(this, "adjustVideoMode videoCall= " + videoCall + " videoState: " + newVideoState);
         VideoCallUi ui = getUi();
         if (ui == null) {
             Log.e(this, "Error VideoCallUi is null so returning");
@@ -692,16 +698,15 @@
             videoCall.setDeviceOrientation(mDeviceOrientation);
             enableCamera(videoCall, isCameraRequired(newVideoState));
         }
+        int previousVideoState = mCurrentVideoState;
         mCurrentVideoState = newVideoState;
-
         mIsVideoMode = true;
 
-        maybeAutoEnterFullscreen(call);
-    }
-
-    private static boolean isSpeakerEnabledForVideoCalls() {
-        // TODO: Make this a carrier configurable setting. For now this is always true. b/20090407
-        return 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 void enableCamera(VideoCall videoCall, boolean isCameraRequired) {
@@ -1068,6 +1073,8 @@
      * 2. Call is not active
      * 3. Call is not video call
      * 4. Already in fullscreen mode
+     * 5. The current video state is not bi-directional (if the remote party stops transmitting,
+     *    the user's contact photo would dominate in fullscreen mode).
      *
      * @param call The current call.
      */
@@ -1079,7 +1086,8 @@
         if (call == null || (
                 call != null && (call.getState() != Call.State.ACTIVE ||
                         !VideoUtils.isVideoCall(call)) ||
-                        InCallPresenter.getInstance().isFullscreen())) {
+                        InCallPresenter.getInstance().isFullscreen()) ||
+                        !VideoUtils.isBidirectionalVideoCall(call)) {
             // Ensure any previously scheduled attempt to enter fullscreen is cancelled.
             cancelAutoFullScreen();
             return;
@@ -1106,10 +1114,6 @@
         mAutoFullScreenPending = false;
     }
 
-    private static boolean isAudioRouteEnabled(int audioRoute, int audioRouteMask) {
-        return ((audioRoute & audioRouteMask) != 0);
-    }
-
     private static void updateCameraSelection(Call call) {
         Log.d(TAG, "updateCameraSelection: call=" + call);
         Log.d(TAG, "updateCameraSelection: call=" + toSimpleString(call));
diff --git a/InCallUI/src/com/android/incallui/VideoUtils.java b/InCallUI/src/com/android/incallui/VideoUtils.java
index 8641d60..a2eb8bc 100644
--- a/InCallUI/src/com/android/incallui/VideoUtils.java
+++ b/InCallUI/src/com/android/incallui/VideoUtils.java
@@ -45,6 +45,14 @@
         return VideoProfile.isBidirectional(call.getVideoState());
     }
 
+    public static boolean isTransmissionEnabled(Call call) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return false;
+        }
+
+        return VideoProfile.isTransmissionEnabled(call.getVideoState());
+    }
+
     public static boolean isIncomingVideoCall(Call call) {
         if (!VideoUtils.isVideoCall(call)) {
             return false;
diff --git a/InCallUI/tests/src/com/android/incallui/ExternalCallListTest.java b/InCallUI/tests/src/com/android/incallui/ExternalCallListTest.java
new file mode 100644
index 0000000..070bdf5
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ExternalCallListTest.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.ComponentName;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Bundle;
+import android.telecom.*;
+import android.telecom.Call;
+import android.test.AndroidTestCase;
+
+import java.lang.reflect.Constructor;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class ExternalCallListTest extends AndroidTestCase {
+
+    private static class Listener implements ExternalCallList.ExternalCallListener {
+        private CountDownLatch mCallAddedLatch = new CountDownLatch(1);
+        private CountDownLatch mCallRemovedLatch = new CountDownLatch(1);
+        private CountDownLatch mCallUpdatedLatch = new CountDownLatch(1);
+
+        @Override
+        public void onExternalCallAdded(Call call) {
+            mCallAddedLatch.countDown();
+        }
+
+        @Override
+        public void onExternalCallRemoved(Call call) {
+            mCallRemovedLatch.countDown();
+        }
+
+        @Override
+        public void onExternalCallUpdated(Call call) {
+            mCallUpdatedLatch.countDown();
+        }
+
+        public boolean awaitCallAdded() {
+            try {
+                return mCallAddedLatch.await(WAIT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                return false;
+            }
+        }
+
+        public boolean awaitCallRemoved() {
+            try {
+                return mCallRemovedLatch.await(WAIT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                return false;
+            }
+        }
+
+        public boolean awaitCallUpdated() {
+            try {
+                return mCallUpdatedLatch.await(WAIT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                return false;
+            }
+        }
+    }
+
+    private static final int WAIT_TIMEOUT_MILLIS = 5000;
+
+    private ExternalCallList mExternalCallList = new ExternalCallList();
+    private Listener mExternalCallListener = new Listener();
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        mExternalCallList.addExternalCallListener(mExternalCallListener);
+    }
+
+    public void testAddCallSuccess() {
+        TestTelecomCall call = getTestCall(Call.Details.PROPERTY_IS_EXTERNAL_CALL);
+        mExternalCallList.onCallAdded(call.getCall());
+        assertTrue(mExternalCallListener.awaitCallAdded());
+    }
+
+    public void testAddCallFail() {
+        TestTelecomCall call = getTestCall(0 /* no properties */);
+        try {
+            mExternalCallList.onCallAdded(call.getCall());
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    public void testUpdateCall() {
+        TestTelecomCall call = getTestCall(Call.Details.PROPERTY_IS_EXTERNAL_CALL);
+        mExternalCallList.onCallAdded(call.getCall());
+        assertTrue(mExternalCallListener.awaitCallAdded());
+
+        call.forceDetailsUpdate();
+        assertTrue(mExternalCallListener.awaitCallUpdated());
+    }
+
+    public void testRemoveCall() {
+        TestTelecomCall call = getTestCall(Call.Details.PROPERTY_IS_EXTERNAL_CALL);
+        mExternalCallList.onCallAdded(call.getCall());
+        assertTrue(mExternalCallListener.awaitCallAdded());
+
+        mExternalCallList.onCallRemoved(call.getCall());
+        assertTrue(mExternalCallListener.awaitCallRemoved());
+    }
+
+    private TestTelecomCall getTestCall(int properties) {
+        TestTelecomCall testCall = TestTelecomCall.createInstance(
+                "1",
+                Uri.parse("tel:650-555-1212"), /* handle */
+                TelecomManager.PRESENTATION_ALLOWED, /* handlePresentation */
+                "Joe", /* callerDisplayName */
+                TelecomManager.PRESENTATION_ALLOWED, /* callerDisplayNamePresentation */
+                new PhoneAccountHandle(new ComponentName("test", "class"),
+                        "handle"), /* accountHandle */
+                Call.Details.CAPABILITY_CAN_PULL_CALL, /* capabilities */
+                properties, /* properties */
+                null, /* disconnectCause */
+                0, /* connectTimeMillis */
+                null, /* GatewayInfo */
+                VideoProfile.STATE_AUDIO_ONLY, /* videoState */
+                null, /* statusHints */
+                null, /* extras */
+                null /* intentExtras */);
+        return testCall;
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ExternalCallNotifierTest.java b/InCallUI/tests/src/com/android/incallui/ExternalCallNotifierTest.java
new file mode 100644
index 0000000..e57efef
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ExternalCallNotifierTest.java
@@ -0,0 +1,212 @@
+/*
+ * 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 static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.android.contacts.common.preference.ContactsPreferences;
+
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.telecom.*;
+import android.telecom.Call;
+import android.telephony.TelephonyManager;
+import android.test.AndroidTestCase;
+import android.test.mock.MockContext;
+
+/**
+ * Unit tests for {@link ExternalCallNotifier}.
+ */
+public class ExternalCallNotifierTest extends AndroidTestCase {
+    private static final int TIMEOUT_MILLIS = 5000;
+    private static final String NAME_PRIMARY = "Full Name";
+    private static final String NAME_ALTERNATIVE = "Name, Full";
+    private static final String LOCATION = "US";
+    private static final String NUMBER = "6505551212";
+
+    @Mock private ContactsPreferences mContactsPreferences;
+    @Mock private NotificationManager mNotificationManager;
+    @Mock private MockContext mMockContext;
+    @Mock private Resources mResources;
+    @Mock private StatusBarNotifier mStatusBarNotifier;
+    @Mock private ContactInfoCache mContactInfoCache;
+    @Mock private TelecomManager mTelecomManager;
+    @Mock private TelephonyManager mTelephonyManager;
+    @Mock private ProximitySensor mProximitySensor;
+    @Mock private CallList mCallList;
+    private InCallPresenter mInCallPresenter;
+    private ExternalCallNotifier mExternalCallNotifier;
+    private ContactInfoCache.ContactCacheEntry mContactInfo;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+
+        when(mContactsPreferences.getDisplayOrder())
+                .thenReturn(ContactsPreferences.DISPLAY_ORDER_PRIMARY);
+
+        // Setup the mock context to return mocks for some of the needed services; the notification
+        // service is especially important as we want to be able to intercept calls into it and
+        // validate the notifcations.
+        when(mMockContext.getSystemService(eq(Context.NOTIFICATION_SERVICE)))
+                .thenReturn(mNotificationManager);
+        when(mMockContext.getSystemService(eq(Context.TELECOM_SERVICE)))
+                .thenReturn(mTelecomManager);
+        when(mMockContext.getSystemService(eq(Context.TELEPHONY_SERVICE)))
+                .thenReturn(mTelephonyManager);
+
+        // These aspects of the context are used by the notification builder to build the actual
+        // notification; we will rely on the actual implementations of these.
+        when(mMockContext.getPackageManager()).thenReturn(mContext.getPackageManager());
+        when(mMockContext.getResources()).thenReturn(mContext.getResources());
+        when(mMockContext.getApplicationInfo()).thenReturn(mContext.getApplicationInfo());
+        when(mMockContext.getContentResolver()).thenReturn(mContext.getContentResolver());
+        when(mMockContext.getPackageName()).thenReturn(mContext.getPackageName());
+
+        ContactsPreferencesFactory.setTestInstance(null);
+        mExternalCallNotifier = new ExternalCallNotifier(mMockContext, mContactInfoCache);
+
+        // We don't directly use the InCallPresenter in the test, or even in ExternalCallNotifier
+        // itself.  However, ExternalCallNotifier needs to make instances of
+        // com.android.incallui.Call for the purpose of performing contact cache lookups.  The
+        // Call class depends on the static InCallPresenter for a number of things, so we need to
+        // set it up here to prevent crashes.
+        mInCallPresenter = InCallPresenter.getInstance();
+        mInCallPresenter.setUp(mMockContext, mCallList, new ExternalCallList(),
+                null, mStatusBarNotifier, mExternalCallNotifier, mContactInfoCache,
+                mProximitySensor);
+
+        // Unlocked all contact info is available
+        mContactInfo = new ContactInfoCache.ContactCacheEntry();
+        mContactInfo.namePrimary = NAME_PRIMARY;
+        mContactInfo.nameAlternative = NAME_ALTERNATIVE;
+        mContactInfo.location = LOCATION;
+        mContactInfo.number = NUMBER;
+
+        // Given the mock ContactInfoCache cache, we need to mock out what happens when the
+        // ExternalCallNotifier calls into the contact info cache to do a lookup.  We will always
+        // return mock info stored in mContactInfo.
+        doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                Object[] args = invocation.getArguments();
+                com.android.incallui.Call call = (com.android.incallui.Call) args[0];
+                ContactInfoCache.ContactInfoCacheCallback callback
+                        = (ContactInfoCache.ContactInfoCacheCallback) args[2];
+                callback.onContactInfoComplete(call.getId(), mContactInfo);
+                return null;
+            }
+        }).when(mContactInfoCache).findInfo(any(com.android.incallui.Call.class), anyBoolean(),
+                any(ContactInfoCache.ContactInfoCacheCallback.class));
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        ContactsPreferencesFactory.setTestInstance(null);
+        mInCallPresenter.tearDown();
+    }
+
+    public void testPostNonPullable() {
+        TestTelecomCall call = getTestCall(false);
+        mExternalCallNotifier.onExternalCallAdded(call.getCall());
+        Notification notification = verifyNotificationPosted();
+        assertNull(notification.actions);
+    }
+
+    public void testPostPullable() {
+        TestTelecomCall call = getTestCall(true);
+        mExternalCallNotifier.onExternalCallAdded(call.getCall());
+        Notification notification = verifyNotificationPosted();
+        assertEquals(1, notification.actions.length);
+    }
+
+    public void testNotificationDismissed() {
+        TestTelecomCall call = getTestCall(false);
+        mExternalCallNotifier.onExternalCallAdded(call.getCall());
+        verifyNotificationPosted();
+
+        mExternalCallNotifier.onExternalCallRemoved(call.getCall());
+        verify(mNotificationManager, timeout(TIMEOUT_MILLIS)).cancel(eq("EXTERNAL_CALL"), eq(0));
+    }
+
+    public void testNotificationUpdated() {
+        TestTelecomCall call = getTestCall(false);
+        mExternalCallNotifier.onExternalCallAdded(call.getCall());
+        verifyNotificationPosted();
+
+        call.setCapabilities(android.telecom.Call.Details.CAPABILITY_CAN_PULL_CALL);
+        mExternalCallNotifier.onExternalCallUpdated(call.getCall());
+
+        ArgumentCaptor<Notification> notificationCaptor =
+                ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager, timeout(TIMEOUT_MILLIS).times(2))
+                .notify(eq("EXTERNAL_CALL"), eq(0), notificationCaptor.capture());
+        Notification notification1 = notificationCaptor.getAllValues().get(0);
+        assertNull(notification1.actions);
+        Notification notification2 = notificationCaptor.getAllValues().get(1);
+        assertEquals(1, notification2.actions.length);
+    }
+
+    private Notification verifyNotificationPosted() {
+        ArgumentCaptor<Notification> notificationCaptor =
+                ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager, timeout(TIMEOUT_MILLIS))
+                .notify(eq("EXTERNAL_CALL"), eq(0), notificationCaptor.capture());
+        return notificationCaptor.getValue();
+    }
+
+    private TestTelecomCall getTestCall(boolean canPull) {
+        TestTelecomCall testCall = TestTelecomCall.createInstance(
+                "1",
+                Uri.parse("tel:650-555-1212"), /* handle */
+                TelecomManager.PRESENTATION_ALLOWED, /* handlePresentation */
+                "Joe", /* callerDisplayName */
+                TelecomManager.PRESENTATION_ALLOWED, /* callerDisplayNamePresentation */
+                new PhoneAccountHandle(new ComponentName("test", "class"),
+                        "handle"), /* accountHandle */
+                canPull ? android.telecom.Call.Details.CAPABILITY_CAN_PULL_CALL : 0, /* capabilities */
+                Call.Details.PROPERTY_IS_EXTERNAL_CALL, /* properties */
+                null, /* disconnectCause */
+                0, /* connectTimeMillis */
+                null, /* GatewayInfo */
+                VideoProfile.STATE_AUDIO_ONLY, /* videoState */
+                null, /* statusHints */
+                null, /* extras */
+                null /* intentExtras */);
+        return testCall;
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java b/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java
index ed8d622..f0f08ab 100644
--- a/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java
+++ b/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java
@@ -39,6 +39,7 @@
     @Mock private InCallActivity mInCallActivity;
     @Mock private AudioModeProvider mAudioModeProvider;
     @Mock private StatusBarNotifier mStatusBarNotifier;
+    @Mock private ExternalCallNotifier mExternalCallNotifier;
     @Mock private ContactInfoCache mContactInfoCache;
     @Mock private ProximitySensor mProximitySensor;
 
@@ -57,8 +58,9 @@
         when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
 
         mInCallPresenter = InCallPresenter.getInstance();
-        mInCallPresenter.setUp(mContext, mCallList.getCallList(), mAudioModeProvider,
-                mStatusBarNotifier, mContactInfoCache, mProximitySensor);
+        mInCallPresenter.setUp(mContext, mCallList.getCallList(), new ExternalCallList(),
+                mAudioModeProvider, mStatusBarNotifier, mExternalCallNotifier, mContactInfoCache,
+                mProximitySensor);
     }
 
     @Override
diff --git a/InCallUI/tests/src/com/android/incallui/TestTelecomCall.java b/InCallUI/tests/src/com/android/incallui/TestTelecomCall.java
new file mode 100644
index 0000000..48ac6e1
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/TestTelecomCall.java
@@ -0,0 +1,161 @@
+/*
+ * 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 com.google.common.base.Preconditions;
+
+import android.content.Context;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.telecom.DisconnectCause;
+import android.telecom.GatewayInfo;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.StatusHints;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Wrapper class which uses reflection to create instances of {@link android.telecom.Call} for use
+ * with unit testing.  Since {@link android.telecom.Call} is final, it cannot be mocked using
+ * mockito, and since all setter methods are hidden, it is necessary to use reflection.  In the
+ * future, it would be desirable to replace this if a different mocking solution is used.
+ */
+public class TestTelecomCall {
+
+    private android.telecom.Call mCall;
+
+    public static @Nullable TestTelecomCall createInstance(String callId,
+            Uri handle,
+            int handlePresentation,
+            String callerDisplayName,
+            int callerDisplayNamePresentation,
+            PhoneAccountHandle accountHandle,
+            int capabilities,
+            int properties,
+            DisconnectCause disconnectCause,
+            long connectTimeMillis,
+            GatewayInfo gatewayInfo,
+            int videoState,
+            StatusHints statusHints,
+            Bundle extras,
+            Bundle intentExtras) {
+
+        try {
+            // Phone and InCall adapter are @hide, so we cannot refer to them directly.
+            Class<?> phoneClass = Class.forName("android.telecom.Phone");
+            Class<?> incallAdapterClass = Class.forName("android.telecom.InCallAdapter");
+            Class<?> callClass = android.telecom.Call.class;
+            Constructor<?> cons = callClass
+                    .getDeclaredConstructor(phoneClass, String.class, incallAdapterClass);
+            cons.setAccessible(true);
+
+            android.telecom.Call call = (android.telecom.Call) cons.newInstance(null, callId, null);
+
+            // Create an instance of the call details.
+            Class<?> callDetailsClass = android.telecom.Call.Details.class;
+            Constructor<?> detailsCons = callDetailsClass.getDeclaredConstructor(
+                    String.class, /* telecomCallId */
+                    Uri.class, /* handle */
+                    int.class, /* handlePresentation */
+                    String.class, /* callerDisplayName */
+                    int.class, /* callerDisplayNamePresentation */
+                    PhoneAccountHandle.class, /* accountHandle */
+                    int.class, /* capabilities */
+                    int.class, /* properties */
+                    DisconnectCause.class, /* disconnectCause */
+                    long.class, /* connectTimeMillis */
+                    GatewayInfo.class, /* gatewayInfo */
+                    int.class, /* videoState */
+                    StatusHints.class, /* statusHints */
+                    Bundle.class, /* extras */
+                    Bundle.class /* intentExtras */);
+            detailsCons.setAccessible(true);
+
+            android.telecom.Call.Details details = (android.telecom.Call.Details)
+                    detailsCons.newInstance(callId, handle, handlePresentation, callerDisplayName,
+                            callerDisplayNamePresentation, accountHandle, capabilities, properties,
+                            disconnectCause, connectTimeMillis, gatewayInfo, videoState,
+                            statusHints,
+                            extras, intentExtras);
+
+            // Finally, set this as the details of the call.
+            Field detailsField = call.getClass().getDeclaredField("mDetails");
+            detailsField.setAccessible(true);
+            detailsField.set(call, details);
+
+            return new TestTelecomCall(call);
+        } catch (NoSuchMethodException nsm) {
+            return null;
+        } catch (ClassNotFoundException cnf) {
+            return null;
+        } catch (IllegalAccessException e) {
+            return null;
+        } catch (InstantiationException e) {
+            return null;
+        } catch (InvocationTargetException e) {
+            return null;
+        } catch (NoSuchFieldException e) {
+            return null;
+        }
+    }
+
+    private TestTelecomCall(android.telecom.Call call) {
+        mCall = call;
+    }
+
+    public android.telecom.Call getCall() {
+        return mCall;
+    }
+
+    public void forceDetailsUpdate() {
+        Preconditions.checkNotNull(mCall);
+
+        try {
+            Method method = mCall.getClass().getDeclaredMethod("fireDetailsChanged",
+                    android.telecom.Call.Details.class);
+            method.setAccessible(true);
+            method.invoke(mCall, mCall.getDetails());
+        } catch (NoSuchMethodException e) {
+            Log.e(this, "forceDetailsUpdate", e);
+        } catch (InvocationTargetException e) {
+            Log.e(this, "forceDetailsUpdate", e);
+        } catch (IllegalAccessException e) {
+            Log.e(this, "forceDetailsUpdate", e);
+        }
+    }
+
+    public void setCapabilities(int capabilities) {
+        Preconditions.checkNotNull(mCall);
+        try {
+            Field field = mCall.getDetails().getClass().getDeclaredField("mCallCapabilities");
+            field.setAccessible(true);
+            field.set(mCall.getDetails(), capabilities);
+        } catch (IllegalAccessException e) {
+            Log.e(this, "setProperties", e);
+        } catch (NoSuchFieldException e) {
+            Log.e(this, "setProperties", e);
+        }
+    }
+
+    public void setCall(android.telecom.Call call) {
+        mCall = call;
+    }
+}