diff --git a/src/com/android/telecomm/CallServiceRepository.java b/src/com/android/telecomm/CallServiceRepository.java
index eb31d87..23fffca 100644
--- a/src/com/android/telecomm/CallServiceRepository.java
+++ b/src/com/android/telecomm/CallServiceRepository.java
@@ -174,6 +174,31 @@
     }
 
     /**
+     * Creates and returns the call service for the specified {@link CallServiceInfo}. Inserts newly
+     * created entries into the cache, see {@link #mCallServiceCache}, or if a cached version
+     * already exists, returns that instead. All newly created instances will not yet be bound,
+     * however cached versions may or may not be bound.
+     *
+     * @param info The call service descriptor.
+     * @return The call service.
+     */
+    CallServiceWrapper getCallService(CallServiceInfo info) {
+        Preconditions.checkNotNull(info);
+
+        // TODO(santoscordon): Rename getServiceComponent to getComponentName.
+        ComponentName componentName = info.getServiceComponent();
+
+        CallServiceWrapper callService = mCallServiceCache.get(componentName);
+        if (callService == null) {
+            CallServiceAdapter adapter = new CallServiceAdapter(mOutgoingCallsManager);
+            callService = new CallServiceWrapper(info, adapter);
+            mCallServiceCache.put(componentName, callService);
+        }
+
+        return callService;
+    }
+
+    /**
      * Attempts to bind to the specified provider before continuing to {@link #processProvider}.
      *
      * @param componentName The component name of the relevant provider.
@@ -347,29 +372,4 @@
 
         return provider;
     }
-
-    /**
-     * Creates and returns the call service for the specified call-service info object. Inserts
-     * newly created entries into the cache, see {@link #mCallServiceCache}, or if a cached
-     * version already exists, returns that instead. All newly created instances will not yet
-     * be bound, however cached versions may or may not be bound.
-     *
-     * @param info The call service descriptor.
-     * @return The call service.
-     */
-    private CallServiceWrapper getCallService(CallServiceInfo info) {
-        Preconditions.checkNotNull(info);
-
-        // TODO(santoscordon): Rename getServiceComponent to getComponentName.
-        ComponentName componentName = info.getServiceComponent();
-
-        CallServiceWrapper callService = mCallServiceCache.get(componentName);
-        if (callService == null) {
-            CallServiceAdapter adapter = new CallServiceAdapter(mOutgoingCallsManager);
-            callService = new CallServiceWrapper(info, adapter);
-            mCallServiceCache.put(componentName, callService);
-        }
-
-        return callService;
-    }
 }
diff --git a/src/com/android/telecomm/CallsManager.java b/src/com/android/telecomm/CallsManager.java
index d69af53..ff224e5 100644
--- a/src/com/android/telecomm/CallsManager.java
+++ b/src/com/android/telecomm/CallsManager.java
@@ -17,6 +17,7 @@
 package com.android.telecomm;
 
 import android.content.Context;
+import android.telecomm.CallServiceInfo;
 import android.telecomm.CallState;
 import android.text.TextUtils;
 import android.util.Log;
@@ -86,6 +87,23 @@
     }
 
     /**
+     * Starts the incoming call sequence by having switchboard confirm with the specified call
+     * service that an incoming call actually exists for the specified call token. Upon success,
+     * execution returns to {@link #handleSuccessfulIncomingCall} to start the in-call UI.
+     *
+     * @param callServiceInfo The details of the call service to use for this incoming call.
+     * @param callToken The token used by the call service to identify the incoming call.
+     */
+    void processIncomingCallIntent(CallServiceInfo callServiceInfo, String callToken) {
+        // Create a call with no handle. Eventually, switchboard will update the call with
+        // additional information from the call service, but for now we just need one to pass around
+        // with a unique call ID.
+        Call call = new Call(null, null);
+
+        mSwitchboard.confirmIncomingCall(call, callServiceInfo, callToken);
+    }
+
+    /**
      * Attempts to issue/connect the specified call.  From an (arbitrary) application standpoint,
      * all that is required to initiate this flow is to fire either of the CALL, CALL_PRIVILEGED,
      * and CALL_EMERGENCY intents. These are listened to by CallActivity.java which then invokes
@@ -123,6 +141,17 @@
         mInCallController.addCall(call.toCallInfo());
     }
 
+    /**
+     * Adds a new incoming call to the list of live calls and notifies the in-call app.
+     *
+     * @param call The new incoming call.
+     */
+    void handleSuccessfulIncomingCall(Call call) {
+        Preconditions.checkState(call.getState() == CallState.RINGING);
+        addCall(call);
+        mInCallController.addCall(call.toCallInfo());
+    }
+
     /*
      * Sends all the live calls to the in-call app if any exist. If there are no live calls, then
      * tells the in-call controller to unbind since it is not needed.
diff --git a/src/com/android/telecomm/IncomingCallsManager.java b/src/com/android/telecomm/IncomingCallsManager.java
new file mode 100644
index 0000000..941c248
--- /dev/null
+++ b/src/com/android/telecomm/IncomingCallsManager.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 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.telecomm;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import com.android.telecomm.ServiceBinder.BindCallback;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+
+import java.util.Map;
+
+/**
+ * Utility class to confirm the existence of an incoming call after receiving an incoming-call
+ * intent, see {@link TelecommReceiver}. Binds with the specified call services and requests
+ * confirmation of incoming calls using call tokens provided as part of the intent. Upon receipt of
+ * the confirmation, yields execution back to the switchboard to complete the incoming sequence. The
+ * entire process is timeboxed to protect against unresponsive call services.
+ */
+final class IncomingCallsManager {
+
+    /**
+     * The amount of time to wait for confirmation of an incoming call, in milliseconds.
+     * TODO(santoscordon): Likely needs adjustment.
+     */
+    private static final int INCOMING_CALL_TIMEOUT_MS = 1000;
+
+    private final Switchboard mSwitchboard;
+
+    private final Handler mHandler = new Handler(Looper.getMainLooper());
+
+    /** Maps incoming calls to their call services. */
+    private final Map<Call, CallServiceWrapper> mPendingIncomingCalls = Maps.newHashMap();
+
+    /**
+     * Persists the specified parameters.
+     *
+     * @param switchboard The switchboard.
+     */
+    IncomingCallsManager(Switchboard switchboard) {
+        mSwitchboard = switchboard;
+    }
+
+
+    /**
+     * Confirms the existence of an incoming call with the specified call service (asynchronously).
+     * Starts the timeout sequence in case the call service is unresponsive.
+     *
+     * @param call The call object.
+     * @param callService The call service.
+     * @param callToken The token used by the call service to identify the incoming call.
+     */
+    void confirmIncomingCall(
+            final Call call, final CallServiceWrapper callService, String callToken) {
+
+        ThreadUtil.checkOnMainThread();
+        // Just to be safe, lets make sure we're not already processing this call.
+        Preconditions.checkState(!mPendingIncomingCalls.containsKey(call));
+
+        mPendingIncomingCalls.put(call, callService);
+        startTimeoutForCall(call);
+
+        BindCallback callback = new BindCallback() {
+            @Override public void onSuccess() {
+                // TODO(santoscordon): ICallService needs to be updated with the following method.
+                // Confirmation won't work until this method is filled in.
+                // callService.confirmIncomingCall(call.toCallInfo(), callToken);
+            }
+            @Override public void onFailure() {
+                handleFailedIncomingCall(call);
+            }
+        };
+
+        callService.bind(callback);
+    }
+
+    /**
+     * Starts a timeout to timebox the confirmation of an incoming call. When the timeout expires,
+     * it will notify switchboard that the incoming call was not confirmed and thus does not exist
+     * as far as Telecomm is concerned.
+     *
+     * @param call The call.
+     */
+    void startTimeoutForCall(final Call call) {
+        Runnable timeoutCallback = new Runnable() {
+            @Override public void run() {
+                handleFailedIncomingCall(call);
+            }
+        };
+        mHandler.postDelayed(timeoutCallback, INCOMING_CALL_TIMEOUT_MS);
+    }
+
+    /**
+     * Notifies the switchboard of a successful incoming call after removing it from the pending
+     * list.
+     * TODO(santoscordon): Needs code in CallServiceAdapter to call this method.
+     *
+     * @param call The call.
+     */
+    void handleSuccessfulIncomingCall(Call call) {
+        ThreadUtil.checkOnMainThread();
+        if (mPendingIncomingCalls.remove(call) != null) {
+            mSwitchboard.handleSuccessfulIncomingCall(call);
+        }
+    }
+
+    /**
+     * Notifies switchboard of the failed incoming call after removing it from the pending list.
+     *
+     * @param call The call.
+     */
+    void handleFailedIncomingCall(Call call) {
+        ThreadUtil.checkOnMainThread();
+        if (mPendingIncomingCalls.remove(call) != null) {
+            // The call was found still waiting for confirmation. Consider it failed.
+            mSwitchboard.handleFailedIncomingCall(call);
+        }
+    }
+}
diff --git a/src/com/android/telecomm/Switchboard.java b/src/com/android/telecomm/Switchboard.java
index 32ef914..b5925cc 100644
--- a/src/com/android/telecomm/Switchboard.java
+++ b/src/com/android/telecomm/Switchboard.java
@@ -20,9 +20,9 @@
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 
-import android.content.Context;
 import android.os.Handler;
 import android.os.Looper;
+import android.telecomm.CallServiceInfo;
 import android.telecomm.ICallServiceSelector;
 
 import java.util.Collection;
@@ -47,6 +47,9 @@
     /** Used to place outgoing calls. */
     private final OutgoingCallsManager mOutgoingCallsManager;
 
+    /** Used to confirm incoming calls. */
+    private final IncomingCallsManager mIncomingCallsManager;
+
     private final CallServiceRepository mCallServiceRepository;
 
     private final CallServiceSelectorRepository mSelectorRepository;
@@ -100,6 +103,7 @@
     Switchboard(CallsManager callsManager) {
         mCallsManager = callsManager;
         mOutgoingCallsManager = new OutgoingCallsManager(this);
+        mIncomingCallsManager = new IncomingCallsManager(this);
         mCallServiceRepository = new CallServiceRepository(this, mOutgoingCallsManager);
         mSelectorRepository = new CallServiceSelectorRepository(this);
     }
@@ -123,6 +127,21 @@
     }
 
     /**
+     * Confirms with incoming call manager that an incoming call exists for the specified call
+     * service and call token. The incoming call manager will invoke either
+     * {@link #handleSuccessfulIncomingCall} or {@link #handleFailedIncomingCall} depending
+     * on the result.
+     *
+     * @param call The call object.
+     * @param callServiceInfo The details of the call service.
+     * @param callToken The token used by the call service to identify the incoming call.
+     */
+    void confirmIncomingCall(Call call, CallServiceInfo callServiceInfo, String callToken) {
+        CallServiceWrapper callService = mCallServiceRepository.getCallService(callServiceInfo);
+        mIncomingCallsManager.confirmIncomingCall(call, callService, callToken);
+    }
+
+    /**
      * Persists the specified set of call services and attempts to place any pending outgoing
      * calls.  Intended to be invoked by {@link CallServiceRepository} exclusively.
      *
@@ -181,6 +200,29 @@
     }
 
     /**
+     * Handles the case where we received confirmation of an incoming call. Hands the resulting
+     * call to {@link CallsManager} as the final step in the incoming sequence. At that point,
+     * {@link CallsManager} should bring up the incoming-call UI.
+     */
+    void handleSuccessfulIncomingCall(Call call) {
+        mCallsManager.handleSuccessfulIncomingCall(call);
+    }
+
+    /**
+     * Handles the case where we failed to confirm an incoming call after receiving an incoming-call
+     * intent via {@link TelecommReceiver}.
+     *
+     * @param call The call.
+     */
+    void handleFailedIncomingCall(Call call) {
+        // At the moment there is nothing to do if an incoming call is not confirmed. We may at a
+        // future date bind to the in-call app optimistically during the incoming-call sequence and
+        // this method could tell {@link CallsManager} to unbind from the in-call app if the
+        // incoming call was not confirmed. It's worth keeping this method for parity with the
+        // outgoing call sequence.
+    }
+
+    /**
      * @return True if ticking should continue (or be resumed) and false otherwise.
      */
     private boolean isTicking() {