diff --git a/src/com/android/telecomm/Call.java b/src/com/android/telecomm/Call.java
index 587214a..9f9a692 100644
--- a/src/com/android/telecomm/Call.java
+++ b/src/com/android/telecomm/Call.java
@@ -18,6 +18,7 @@
 
 import android.telecomm.CallInfo;
 import android.telecomm.CallState;
+import android.telecomm.ICallService;
 
 import java.util.Date;
 
@@ -53,6 +54,12 @@
     private final Date mCreationTime;
 
     /**
+     * The call service which is currently connecting this call, null as long as the call is not
+     * connected.
+     */
+    private ICallService mCallService;
+
+    /**
      * Read-only and parcelable version of this call.
      */
     private CallInfo mCallInfo;
@@ -107,6 +114,21 @@
         return new Date().getTime() - mCreationTime.getTime();
     }
 
+    ICallService getCallService() {
+        return mCallService;
+    }
+
+    void setCallService(ICallService callService) {
+        mCallService = callService;
+    }
+
+    /**
+     * Clears the associated call service.
+     */
+    void clearCallService() {
+        setCallService(null);
+    }
+
     /**
      * @return An object containing read-only information about this call.
      */
diff --git a/src/com/android/telecomm/CallServiceAdapter.java b/src/com/android/telecomm/CallServiceAdapter.java
index 43aab4a..bfbdebd 100644
--- a/src/com/android/telecomm/CallServiceAdapter.java
+++ b/src/com/android/telecomm/CallServiceAdapter.java
@@ -1,16 +1,140 @@
+/*
+ * 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.telecomm;
 
+import android.os.Handler;
+import android.os.Looper;
+import android.telecomm.CallInfo;
+import android.telecomm.ICallServiceAdapter;
+
+import com.google.common.base.Strings;
+
 /**
- * Only exposes the CallsManager APIs that CallService implementations should
- * have access to.
+ * Used by call services in order to update state and control calls while the call service is bound
+ * to Telecomm. Each call service is given its own instance for the lifetime of the binding between
+ * Telecomm and the call service.
+ * TODO(santoscordon): Whenever we get any method invocations from the call service, we need to
+ * check that the invocation is expected from that call service.
+ * TODO(santoscordon): Move away from Runnable objects and into messages so that we create fewer
+ * objects per IPC method call.
  */
-public class CallServiceAdapter {
-  private CallsManager callsManager;
+public final class CallServiceAdapter extends ICallServiceAdapter.Stub {
 
-  private CallService callService;
+    private final CallsManager mCallsManager;
 
-  /** Package private */
-  CallServiceAdapter(CallsManager callsManager) {
-    this.callsManager = callsManager;
-  }
+    private final OutgoingCallsManager mOutgoingCallsManager;
+
+    /** Used to run code (e.g. messages, Runnables) on the main (UI) thread. */
+    private final Handler mHandler = new Handler(Looper.getMainLooper());
+
+    /**
+     * Persists the specified parameters.
+     */
+    CallServiceAdapter(OutgoingCallsManager outgoingCallsManager) {
+        mCallsManager = CallsManager.getInstance();
+        mOutgoingCallsManager = outgoingCallsManager;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void getNextCallId() {
+        // TODO(santoscordon): needs response object.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setCompatibleWith(String callId, boolean isCompatible) {
+        // TODO(santoscordon): fill in.
+    }
+
+    /**
+     * TODO(santoscordon): Rename to handleIncomingCall.
+     * {@inheritDoc}
+     */
+    @Override public void newIncomingCall(CallInfo callInfo) {
+        // TODO(santoscordon): fill in.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void handleSuccessfulOutgoingCall(final String callId) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mOutgoingCallsManager.handleSuccessfulCallAttempt(callId);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void handleFailedOutgoingCall(final String callId, final String reason) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mOutgoingCallsManager.handleFailedCallAttempt(callId, reason);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setActive(final String callId) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mCallsManager.markCallAsActive(callId);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setRinging(final String callId) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mCallsManager.markCallAsRinging(callId);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setDialing(final String callId) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mCallsManager.markCallAsDialing(callId);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setDisconnected(final String callId) {
+        checkValidCallId(callId);
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                mCallsManager.markCallAsDisconnected(callId);
+            }
+        });
+    }
+
+    /**
+     * Throws an IllegalArgumentException if the specified call ID is invalid.
+     *
+     * @param callId The call ID to check.
+     */
+    private void checkValidCallId(String callId) {
+        if (Strings.isNullOrEmpty(callId)) {
+            throw new IllegalArgumentException();
+        }
+    }
 }
diff --git a/src/com/android/telecomm/CallServiceFinder.java b/src/com/android/telecomm/CallServiceFinder.java
index 44ce75e..7fc187b 100644
--- a/src/com/android/telecomm/CallServiceFinder.java
+++ b/src/com/android/telecomm/CallServiceFinder.java
@@ -64,6 +64,8 @@
 
     private final Switchboard mSwitchboard;
 
+    private final OutgoingCallsManager mOutgoingCallsManager;
+
     /**
      * Determines whether or not a lookup cycle is already running.
      */
@@ -118,10 +120,12 @@
     /**
      * Persists the specified parameters.
      *
-     * @param switchboard The switchboard for this finer to work against.
+     * @param switchboard The switchboard for this finder to work against.
+     * @param outgoingCallsManager Manager in charge of placing outgoing calls.
      */
-    CallServiceFinder(Switchboard switchboard) {
+    CallServiceFinder(Switchboard switchboard, OutgoingCallsManager outgoingCallsManager) {
         mSwitchboard = switchboard;
+        mOutgoingCallsManager = outgoingCallsManager;
     }
 
     /**
@@ -288,11 +292,20 @@
         ThreadUtil.checkOnMainThread();
 
         // TODO(santoscordon): When saving the call services into this class, also add code to
-        // unregister (remove) the call services upon disconnect. Potentially use RemoteCallbackList.
+        // unregister (remove) the call services upon disconnect. Potentially use
+        // RemoteCallbackList.
 
         if (mUnregisteredProviders.remove(providerName)) {
             mProviderRegistry.add(provider);
-            mCallServiceRegistry.addAll(callServices);
+            for (ICallService callService : callServices) {
+                try {
+                    CallServiceAdapter adapter = new CallServiceAdapter(mOutgoingCallsManager);
+                    callService.setCallServiceAdapter(adapter);
+                    mCallServiceRegistry.add(callService);
+                } catch (RemoteException e) {
+                    Log.e(TAG, "Failed to set call-service adapter.");
+                }
+            }
 
             // TODO(gilad): Introduce a map to retain the association between call services
             // and the corresponding provider such that mCallServiceRegistry can be updated
diff --git a/src/com/android/telecomm/CallsManager.java b/src/com/android/telecomm/CallsManager.java
index 0712f03..332eb0a 100644
--- a/src/com/android/telecomm/CallsManager.java
+++ b/src/com/android/telecomm/CallsManager.java
@@ -17,11 +17,18 @@
 package com.android.telecomm;
 
 import android.content.Context;
+import android.telecomm.CallState;
+import android.text.TextUtils;
+import android.util.Log;
 
 import com.android.telecomm.exceptions.RestrictedCallException;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * Singleton.
@@ -31,6 +38,7 @@
  * beyond the com.android.telecomm package boundary.
  */
 public final class CallsManager {
+    private static final String TAG = CallsManager.class.getSimpleName();
 
     private static final CallsManager INSTANCE = new CallsManager();
 
@@ -40,6 +48,14 @@
     private final InCallController mInCallController;
 
     /**
+     * The main call repository. Keeps an instance of all live calls keyed by call ID. New incoming
+     * and outgoing calls are added to the map and removed when the calls move to the disconnected
+     * state.
+     * TODO(santoscordon): Add new CallId class and use it in place of String.
+     */
+    private final Map<String, Call> mCalls = Maps.newHashMap();
+
+    /**
      * May be unnecessary per off-line discussions (between santoscordon and gilad) since the set
      * of CallsManager APIs that need to be exposed to the dialer (or any application firing call
      * intents) may be empty.
@@ -65,7 +81,7 @@
      */
     private CallsManager() {
         mSwitchboard = new Switchboard();
-        mInCallController = new InCallController(this);
+        mInCallController = new InCallController();
     }
 
     /**
@@ -90,6 +106,21 @@
     }
 
     /**
+     * Adds a new outgoing call to the list of live calls and notifies the in-call app.
+     *
+     * @param call The new outgoing call.
+     */
+    void handleSuccessfulOutgoingCall(Call call) {
+        // OutgoingCallProcessor sets the call state to DIALING when it receives confirmation of the
+        // placed call from the call service so there is no need to set it here. Instead, check that
+        // the state is appropriate.
+        Preconditions.checkState(call.getState() == CallState.DIALING);
+
+        addCall(call);
+        // TODO(santoscordon): Notify in-call UI.
+    }
+
+    /**
      * Instructs Telecomm to answer the specified call. Intended to be invoked by the in-call
      * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
      * the user opting to answer said call.
@@ -121,4 +152,57 @@
     void disconnectCall(String callId) {
         // TODO(santoscordon): fill in and check that the call is in the active state.
     }
+
+    void markCallAsRinging(String callId) {
+        setCallState(callId, CallState.RINGING);
+    }
+
+    void markCallAsDialing(String callId) {
+        setCallState(callId, CallState.DIALING);
+    }
+
+    void markCallAsActive(String callId) {
+        setCallState(callId, CallState.ACTIVE);
+    }
+
+    void markCallAsDisconnected(String callId) {
+        setCallState(callId, CallState.DISCONNECTED);
+        mCalls.remove(callId);
+    }
+
+    /**
+     * Sets the specified state on the specified call.
+     *
+     * @param callId The ID of the call to update.
+     * @param state The new state of the call.
+     */
+    private void setCallState(String callId, CallState state) {
+        Preconditions.checkState(!Strings.isNullOrEmpty(callId));
+        Preconditions.checkNotNull(state);
+
+        Call call = mCalls.get(callId);
+        if (call == null) {
+            Log.e(TAG, "Call " + callId + " was not found while attempting to upda the state to " +
+                    state + ".");
+        } else {
+            // Unfortunately, in the telephony world, the radio is king. So if the call notifies us
+            // that the call is in a particular state, we allow it even if it doesn't make sense
+            // (e.g., ACTIVE -> RINGING).
+            // TODO(santoscordon): Consider putting a stop to the above and turning CallState into
+            // a well-defined state machine.
+            // TODO(santoscordon): Define expected state transitions here, and log when an
+            // unexpected transition occurs.
+            call.setState(state);
+            // TODO(santoscordon): Notify the in-call app whenever a call changes state.
+        }
+    }
+
+    /**
+     * Adds the specified call to the main list of live calls.
+     *
+     * @param call The call to add.
+     */
+    private void addCall(Call call) {
+        mCalls.put(call.getId(), call);
+    }
 }
diff --git a/src/com/android/telecomm/InCallController.java b/src/com/android/telecomm/InCallController.java
index 7b48d95..f597030 100644
--- a/src/com/android/telecomm/InCallController.java
+++ b/src/com/android/telecomm/InCallController.java
@@ -76,11 +76,9 @@
 
     /**
      * Persists the specified parameters.
-     *
-     * @param callsManager The singleton calls manager instance.
      */
-    InCallController(CallsManager callsManager) {
-        mCallsManager = callsManager;
+    InCallController() {
+        mCallsManager = CallsManager.getInstance();
     }
 
     // TODO(santoscordon): May be better to expose the IInCallService methods directly from this
diff --git a/src/com/android/telecomm/OutgoingCallProcessor.java b/src/com/android/telecomm/OutgoingCallProcessor.java
index e7b0ff3..5135326 100644
--- a/src/com/android/telecomm/OutgoingCallProcessor.java
+++ b/src/com/android/telecomm/OutgoingCallProcessor.java
@@ -24,9 +24,11 @@
 import android.os.Looper;
 import android.os.RemoteException;
 import android.telecomm.CallInfo;
+import android.telecomm.CallState;
 import android.telecomm.ICallService;
 import android.telecomm.ICallServiceSelectionResponse;
 import android.telecomm.ICallServiceSelector;
+import android.util.Log;
 
 import java.util.Iterator;
 import java.util.List;
@@ -40,7 +42,8 @@
  * call services is then attempted until either the outgoing call is placed, the attempted call
  * is aborted (by the switchboard), or the list is exhausted -- whichever occurs first.
  *
- * Except for the abort case, all other scenarios should terminate with the switchboard notified.
+ * Except for the abort case, all other scenarios should terminate with the switchboard notified
+ * of the result.
  *
  * NOTE(gilad): Currently operating under the assumption that we'll have one timeout per (outgoing)
  * call attempt.  If we (also) like to timeout individual selectors and/or call services, the code
@@ -49,11 +52,6 @@
 final class OutgoingCallProcessor {
 
     /**
-     * The (singleton) Telecomm switchboard instance.
-     */
-    private final Switchboard mSwitchboard;
-
-    /**
      * The outgoing call this processor is tasked with placing.
      */
     private final Call mCall;
@@ -76,6 +74,11 @@
     /** Used to run code (e.g. messages, Runnables) on the main (UI) thread. */
     private final Handler mHandler = new Handler(Looper.getMainLooper());
 
+    /** Manages all outgoing call processors. */
+    private final OutgoingCallsManager mOutgoingCallsManager;
+
+    private final Switchboard mSwitchboard;
+
     /**
      * The iterator over the currently-selected ordered list of call-service IDs.
      */
@@ -83,6 +86,12 @@
 
     private Iterator<ICallServiceSelector> mSelectorIterator;
 
+    /**
+     * The last call service which we asked to place the call. If null, it indicates that there
+     * exists no call service that we expect to place this call.
+     */
+    private ICallService mCallService;
+
     private boolean mIsAborted = false;
 
     /**
@@ -90,17 +99,19 @@
      * passing to each selector (read-only versions of) the call object and all available call-
      * service IDs.  Stops once a matching selector is found.  Calls with no matching selectors
      * will eventually be killed by the cleanup/monitor switchboard handler, which will in turn
-     * call the abort method of this processor.
+     * call the abort method of this processor via {@link OutgoingCallsManager}.
      *
      * @param call The call to place.
      * @param callServices The available call-service implementations.
      * @param selectors The available call-service selector implementations.
-     * @param switchboard The switchboard for this processor to work against.
+     * @param outgoingCallsManager Manager of all outgoing call processors.
+     * @param switchboard The switchboard.
      */
     OutgoingCallProcessor(
             Call call,
             Set<ICallService> callServices,
             List<ICallServiceSelector> selectors,
+            OutgoingCallsManager outgoingCallsManager,
             Switchboard switchboard) {
 
         ThreadUtil.checkOnMainThread();
@@ -110,6 +121,7 @@
 
         mCall = call;
         mSelectors = selectors;
+        mOutgoingCallsManager = outgoingCallsManager;
         mSwitchboard = switchboard;
 
         // Populate the list and map of call-service IDs.  The list is needed since
@@ -131,7 +143,7 @@
         if (mSelectors.isEmpty() || mCallServiceIds.isEmpty()) {
             // TODO(gilad): Consider adding a failure message/type to differentiate the various
             // cases, or potentially throw an exception in this case.
-            mSwitchboard.handleFailedOutgoingCall(mCall);
+            mOutgoingCallsManager.handleFailedOutgoingCall(mCall);
         } else if (mSelectorIterator == null) {
             mSelectorIterator = mSelectors.iterator();
             attemptNextSelector();
@@ -140,14 +152,39 @@
 
     /**
      * Aborts the attempt to place the relevant call.  Intended to be invoked by
-     * switchboard.
+     * switchboard through the outgoing-calls manager.
      */
     void abort() {
         ThreadUtil.checkOnMainThread();
+        resetCallService();
         mIsAborted = true;
     }
 
     /**
+     * Completes the outgoing call sequence by setting the call service on the call object. This is
+     * invoked when the call service adapter receives positive confirmation that the call service
+     * placed the call.
+     */
+    void handleSuccessfulCallAttempt() {
+        abort();  // Technically not needed but playing it safe.
+        mCall.setCallService(mCallService);
+        mCall.setState(CallState.DIALING);
+        resetCallService();
+
+        mSwitchboard.handleSuccessfulOutgoingCall(mCall);
+    }
+
+    /**
+     * Attempts the next call service if the specified call service is the one currently being
+     * attempted.
+     *
+     * @param reason The call-service supplied reason for the failed call attempt.
+     */
+    void handleFailedCallAttempt(String reason) {
+        attemptNextCallService();
+    }
+
+    /**
      * Attempts to place the call using the next selector, no-op if no other selectors
      * are available.
      */
@@ -166,7 +203,7 @@
             }
 
         } else {
-            mSwitchboard.handleFailedOutgoingCall(mCall);
+            mOutgoingCallsManager.handleFailedOutgoingCall(mCall);
         }
     }
 
@@ -206,7 +243,9 @@
     }
 
     /**
-     * TODO(gilad): Add comment.
+     * Attempts to place the call using the call service specified by the next call-service ID of
+     * mCallServiceIdIterator. If there are no more call services to attempt, the process continues
+     * to the next call-service selector via {@link #attemptNextSelector}.
      */
     private void attemptNextCallService() {
         if (mIsAborted) {
@@ -215,10 +254,12 @@
 
         if (mCallServiceIdIterator.hasNext()) {
             String id = mCallServiceIdIterator.next();
-            ICallService callService = mCallServicesById.get(id);
-            if (callService != null) {
+            mCallService = mCallServicesById.get(id);
+            if (mCallService == null) {
+                attemptNextCallService();
+            } else {
                 try {
-                    callService.call(mCall.toCallInfo());
+                    mCallService.call(mCall.toCallInfo());
                 } catch (RemoteException e) {
                     // TODO(gilad): Log etc.
                     attemptNextCallService();
@@ -226,25 +267,16 @@
             }
         } else {
             mCallServiceIdIterator = null;
+            resetCallService();
             attemptNextSelector();
         }
     }
 
     /**
-     * Handles the successful outgoing-call case.
+     * Nulls out the reference to the current call service. Invoked when the call service is no longer
+     * expected to place the outgoing call.
      */
-    private void handleSuccessfulOutgoingCall() {
-        // TODO(gilad): More here?
-
-        abort();  // Shouldn't be necessary but better safe than sorry.
-        mSwitchboard.handleSuccessfulOutgoingCall(mCall);
-    }
-
-    /**
-     * Handles the failed outgoing-call case.
-     */
-    private void handleFailedOutgoingCall() {
-        // TODO(gilad): Implement.
-        attemptNextCallService();
+    private void resetCallService() {
+        mCallService = null;
     }
 }
diff --git a/src/com/android/telecomm/OutgoingCallsManager.java b/src/com/android/telecomm/OutgoingCallsManager.java
new file mode 100644
index 0000000..27472f1
--- /dev/null
+++ b/src/com/android/telecomm/OutgoingCallsManager.java
@@ -0,0 +1,131 @@
+/*
+ * 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.RemoteException;
+import android.telecomm.ICallService;
+import android.telecomm.ICallServiceSelector;
+import android.util.Log;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.collect.Maps;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Responsible for placing all outgoing calls. For each outgoing call, this class creates an
+ * instance of {@link OutgoingCallProcessor} which handles the details of connecting to the
+ * appropriate call service and placing the call. This class maintains a mapping from call ID
+ * to {@link OutgoingCallProcessor} so that other classes (Switchboard, CallServiceAdapter, etc),
+ * can simply call into this class instead of individual OutgoingCallProcessors.
+ */
+final class OutgoingCallsManager {
+    private static final String TAG = OutgoingCallsManager.class.getSimpleName();
+
+    private final Switchboard mSwitchboard;
+
+    /**
+     * Maps call IDs to {@link OutgoingCallProcessor}s.
+     */
+    private Map<String, OutgoingCallProcessor> mOutgoingCallProcessors = Maps.newHashMap();
+
+    /** Persists specified parameters. */
+    OutgoingCallsManager(Switchboard switchboard) {
+        mSwitchboard = switchboard;
+    }
+
+    /**
+     * Starts the process of placing a call by constructing an outgoing call processor and asking
+     * it to place the call. Upon success, execution will continue (via {@link CallServiceAdapter})
+     * to {@link #handleSuccessfulCall}. Upon failure, execution will return to
+     * {@link #handleFailedCall}.
+     *
+     * @param call The call to place.
+     * @param callServices The set of call services which can potentially place the call.
+     * @param selectors The ordered list of selectors used in placing the call.
+     */
+    void placeCall(
+            Call call, Set<ICallService> callServices, List<ICallServiceSelector> selectors) {
+
+        Log.i(TAG, "Placing an outgoing call (" + call.getId() + ")");
+
+        // Create the processor for this (outgoing) call and store it in a map such that call
+        // attempts can be aborted etc.
+        // TODO(gilad): Consider passing mSelector as an immutable set.
+        OutgoingCallProcessor processor =
+                new OutgoingCallProcessor(call, callServices, selectors, this, mSwitchboard);
+
+        mOutgoingCallProcessors.put(call.getId(), processor);
+        processor.process();
+    }
+
+    /**
+     * Removes the outgoing call processor mapping for the successful call and returns execution to
+     * the switchboard. This method is invoked from {@link CallServiceAdapter} after a call service
+     * has notified Telecomm that it successfully placed the call.
+     *
+     * @param callId The ID of the call.
+     */
+    void handleSuccessfulCallAttempt(String callId) {
+        OutgoingCallProcessor processor = mOutgoingCallProcessors.remove(callId);
+
+        if (processor == null) {
+            // Shouldn't happen, so log a wtf if it does.
+            Log.wtf(TAG, "Received an unexpected placed-call notification.");
+        } else {
+            processor.handleSuccessfulCallAttempt();
+        }
+    }
+
+    /**
+     * Notifies the appropriate outgoing call processor that a call attempt to place the call has
+     * failed and the processor should continue attempting to place the call with the next call
+     * service. This method is called from {@link CallServiceAdapter} after a call service has
+     * notified Telecomm that it could not place the call.
+     *
+     * @param callId The ID of the failed outgoing call.
+     * @param reason The call-service supplied reason for the failed call attempt.
+     */
+    void handleFailedCallAttempt(String callId, String reason) {
+        OutgoingCallProcessor processor = mOutgoingCallProcessors.get(callId);
+
+        // TODO(santoscordon): Consider combining the check here and in handleSuccessfulCallAttempt.
+        if (processor == null) {
+            // Shouldn't happen, so log a wtf if it does.
+            Log.wtf(TAG, "Received an unexpected failed-call notification.");
+        } else {
+            processor.handleFailedCallAttempt(reason);
+        }
+    }
+
+    /**
+     * Removes the outgoing call processor mapping for the failed call and returns execution to the
+     * switchboard. In contrast to handleFailedCallAttempt which comes from the call-service and
+     * goes to the outgoing-call processor indicating a single failed call attempt, this method is
+     * invoked by the outgoing-call processor to indicate that the entire process has failed and we
+     * should cleanup and notify Switchboard.
+     *
+     * @param call The failed outgoing call.
+     */
+    void handleFailedOutgoingCall(Call call) {
+        mOutgoingCallProcessors.remove(call.getId());
+        mSwitchboard.handleFailedOutgoingCall(call);
+    }
+}
diff --git a/src/com/android/telecomm/Switchboard.java b/src/com/android/telecomm/Switchboard.java
index 68ffc73..466f97f 100644
--- a/src/com/android/telecomm/Switchboard.java
+++ b/src/com/android/telecomm/Switchboard.java
@@ -45,9 +45,14 @@
      */
     private final static int TICK_FREQUENCY = 250;
 
-    private final CallServiceFinder mCallServiceFinder = new CallServiceFinder(this);
+    private final CallsManager mCallsManager;
 
-    private final CallServiceSelectorFinder mSelectorFinder = new CallServiceSelectorFinder(this);
+    /** Used to place outgoing calls. */
+    private final OutgoingCallsManager mOutgoingCallsManager;
+
+    private CallServiceFinder mCallServiceFinder;
+
+    private CallServiceSelectorFinder mSelectorFinder;
 
     /** Used to schedule tasks on the main (UI) thread. */
     private final Handler mHandler = new Handler(Looper.getMainLooper());
@@ -84,7 +89,15 @@
      */
     private Set<ICallServiceSelector> mSelectors;
 
-    private Map<Call, OutgoingCallProcessor> outgoingCallProcessors = Maps.newHashMap();
+    /**
+     * Persists the specified parameters and initializes Switchboard.
+     */
+    Switchboard() {
+        mCallsManager = CallsManager.getInstance();
+        mOutgoingCallsManager = new OutgoingCallsManager(this);
+        mCallServiceFinder = new CallServiceFinder(this, mOutgoingCallsManager);
+        mSelectorFinder = new CallServiceSelectorFinder(this);
+    }
 
     /**
      * Attempts to place an outgoing call to the specified handle.
@@ -157,7 +170,7 @@
      * see {@link OutgoingCallProcessor}.
      */
     void handleSuccessfulOutgoingCall(Call call) {
-        // TODO(gilad): More here.
+        mCallsManager.handleSuccessfulOutgoingCall(call);
 
         // Process additional (new) calls, if any.
         processNewOutgoingCalls();
@@ -236,14 +249,7 @@
         List<ICallServiceSelector> selectors = Lists.newArrayList();
         selectors.addAll(mSelectors);
 
-        // Create the processor for this (outgoing) call and store it in a map such that call
-        // attempts can be aborted etc.
-        // TODO(gilad): Consider passing mSelector as an immutable set.
-        OutgoingCallProcessor processor =
-                new OutgoingCallProcessor(call, mCallServices, selectors, this);
-
-        outgoingCallProcessors.put(call, processor);
-        processor.process();
+        mOutgoingCallsManager.placeCall(call, mCallServices, selectors);
     }
 
     /**