diff --git a/src/com/android/telecomm/Call.java b/src/com/android/telecomm/Call.java
index 82bde9e..57074b7 100644
--- a/src/com/android/telecomm/Call.java
+++ b/src/com/android/telecomm/Call.java
@@ -20,7 +20,6 @@
 import android.telecomm.CallInfo;
 import android.telecomm.CallState;
 
-import com.android.internal.telecomm.ICallServiceSelector;
 import com.google.android.collect.Sets;
 import com.google.common.base.Preconditions;
 
@@ -65,9 +64,8 @@
 
     /**
      * The call-service selector for this call.
-     * TODO(gilad): Switch to using a wrapper object, see {@link #mCallService}.
      */
-    private ICallServiceSelector mCallServiceSelector;
+    private CallServiceSelectorWrapper mCallServiceSelector;
 
     /** Read-only and parcelable version of this call. */
     private CallInfo mCallInfo;
@@ -188,7 +186,7 @@
         }
     }
 
-    void setCallServiceSelector(ICallServiceSelector selector) {
+    void setCallServiceSelector(CallServiceSelectorWrapper selector) {
         Preconditions.checkNotNull(selector);
         mCallServiceSelector = selector;
     }
diff --git a/src/com/android/telecomm/CallServiceSelectorRepository.java b/src/com/android/telecomm/CallServiceSelectorRepository.java
index 6203ffd..0ec805f 100644
--- a/src/com/android/telecomm/CallServiceSelectorRepository.java
+++ b/src/com/android/telecomm/CallServiceSelectorRepository.java
@@ -19,77 +19,35 @@
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
-import android.content.ServiceConnection;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
-import android.os.Handler;
-import android.os.IBinder;
-import android.os.Looper;
 import android.telecomm.TelecommConstants;
 
 import com.android.internal.telecomm.ICallServiceSelector;
-import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
+import com.google.common.collect.Maps;
 
 import java.util.List;
-import java.util.Set;
+import java.util.Map;
 
 /**
  * Helper class to retrieve {@link ICallServiceSelector} implementations on the device and
- * asynchronously bind to them.  Each lookup cycle is time-boxed, hence selectors too slow
- * to bind are effectively omitted from the set that is passed back to {@link Switchboard}.
+ * asynchronously bind to them.
  */
 final class CallServiceSelectorRepository {
 
-    /**
-     * Used to interrupt lookup cycles that didn't terminate naturally within the allowed
-     * period, see {@link Timeouts#getSelectorLookupMs()}.
-     */
-    private final Runnable mLookupTerminator = new Runnable() {
-        @Override
-        public void run() {
-            Log.d(CallServiceSelectorRepository.this, "Timed out processing selectors");
-            terminateLookup();
-        }
-    };
-
-    /** Used to run code (e.g. messages, Runnables) on the main (UI) thread. */
-    private final Handler mHandler = new Handler(Looper.getMainLooper());
-
     private final Switchboard mSwitchboard;
 
     /** The application context. */
     private final Context mContext;
 
     /**
-     * Determines whether or not a lookup cycle is already running.
+     * The set of call-service selectors. Only populated via initiateLookup scenarios.
      */
-    private boolean mIsLookupInProgress = false;
-
-    /**
-     * The current lookup-cycle ID, unique per invocation of {@link #initiateLookup}.
-     */
-    private int mLookupId = 0;
-
-    /**
-     * The set of bound call-service selectors.  Only populated via initiateLookup scenarios.
-     * Selectors should only be removed upon unbinding.
-     */
-    private final Set<ICallServiceSelector> mSelectorRegistry = Sets.newHashSet();
-
-    /**
-     * Stores the names of the selectors to bind to in one lookup cycle.  The set size represents
-     * the number of call-service selectors this repositories expects to hear back from upon
-     * initiating lookups, see initiateLookup. Whenever all selectors respond before the timeout
-     * occurs, the complete set of available selectors is passed to the switchboard for further
-     * processing of outgoing calls etc.  When the timeout occurs before all responds are received,
-     * the partial (potentially empty) set gets passed to the switchboard instead. Note that cached
-     * selectors do not require finding and hence are excluded from this set.  Also note that
-     * selectors are removed from this set as they register.
-     */
-    private final Set<ComponentName> mUnregisteredSelectors = Sets.newHashSet();
+    private final Map<ComponentName, CallServiceSelectorWrapper> mCallServiceSelectors =
+            Maps.newHashMap();
 
     /**
      * Persists the specified parameters and initializes the new instance.
@@ -108,47 +66,16 @@
      */
     void initiateLookup(int lookupId) {
         ThreadUtil.checkOnMainThread();
-        if (mIsLookupInProgress) {
-            // At most one active lookup is allowed at any given time, bail out.
-            return;
-        }
 
         List<ComponentName> selectorNames = getSelectorNames();
-        if (selectorNames.isEmpty()) {
-            Log.i(this, "No ICallServiceSelector implementations found.");
-            updateSwitchboard();
-            return;
-        }
-
-        mLookupId = lookupId;
-        mIsLookupInProgress = true;
-        mUnregisteredSelectors.clear();
-
         for (ComponentName name : selectorNames) {
-            if (!mSelectorRegistry.contains(name)) {
-                // The selector is either not yet registered or has been unregistered
-                // due to unbinding etc.
-                mUnregisteredSelectors.add(name);
-                bindSelector(name, lookupId);
+            if (!mCallServiceSelectors.containsKey(name)) {
+                mCallServiceSelectors.put(name, new CallServiceSelectorWrapper(name));
             }
         }
 
-        int selectorCount = selectorNames.size();
-        int unregisteredSelectorCount = mUnregisteredSelectors.size();
-
-        Log.i(this, "Found %d implementations of ICallServiceSelector, %d of which are not " +
-                "currently registered.", selectorCount , unregisteredSelectorCount);
-
-        if (unregisteredSelectorCount == 0) {
-            // All known (selector) implementations are already registered, pass control
-            // back to the switchboard.
-            updateSwitchboard();
-        } else {
-            // Schedule a lookup terminator to run after Timeouts.getSelectorLookupMs()
-            // milliseconds.
-            mHandler.removeCallbacks(mLookupTerminator);
-            mHandler.postDelayed(mLookupTerminator, Timeouts.getSelectorLookupMs());
-        }
+        Log.i(this, "Found %d implementations of ICallServiceSelector", selectorNames.size());
+        updateSwitchboard();
     }
 
     /**
@@ -174,84 +101,22 @@
     }
 
     /**
-     * Attempts to bind the specified selector and have it register upon successful binding.
-     * Also performs the necessary wiring to unregister the selector upon un-binding.
-     *
-     * @param selectorName The component name of the relevant selector.
-     * @param lookupId The lookup-cycle ID.
-     */
-    private void bindSelector(
-            final ComponentName selectorName, final int lookupId) {
-
-        Preconditions.checkNotNull(selectorName);
-
-        Intent serviceIntent = new Intent(
-                TelecommConstants.ACTION_CALL_SERVICE_SELECTOR).setComponent(selectorName);
-        Log.i(this, "Binding to ICallServiceSelector through %s", serviceIntent);
-
-        // Connection object for the service binding.
-        ServiceConnection connection = new ServiceConnection() {
-            @Override
-            public void onServiceConnected(ComponentName className, IBinder service) {
-                ICallServiceSelector selector = ICallServiceSelector.Stub.asInterface(service);
-                registerSelector(lookupId, selectorName, selector);
-            }
-
-            @Override
-            public void onServiceDisconnected(ComponentName className) {
-                unregisterSelector(selectorName);
-            }
-        };
-
-        if (!mContext.bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE)) {
-            // TODO(gilad): Handle error.
-        }
-    }
-
-    /**
-     * Registers the specified selector.
-     *
-     * @param lookupId The lookup-cycle ID.  Currently unused, consider removing.
-     * @param selectorName The component name of the relevant selector.
-     * @param selector The selector object to register.
-     */
-    private void registerSelector(
-            int lookupId, ComponentName selectorName, ICallServiceSelector selector) {
-
-        ThreadUtil.checkOnMainThread();
-
-        if (mUnregisteredSelectors.remove(selectorName)) {
-            mSelectorRegistry.add(selector);
-            if (mUnregisteredSelectors.size() < 1) {
-                terminateLookup();  // No other selectors to wait for.
-            }
-        }
-    }
-
-    /**
-     * Unregisters the specified selector.
-     *
-     * @param selectorName The component name of the relevant selector.
-     */
-    private void unregisterSelector(ComponentName selectorName) {
-        mSelectorRegistry.remove(selectorName);
-    }
-
-    /**
-     * Timeouts the current lookup cycle, see LookupTerminator.
-     */
-    private void terminateLookup() {
-        mHandler.removeCallbacks(mLookupTerminator);
-        updateSwitchboard();
-    }
-
-    /**
      * Updates the switchboard passing the relevant call services selectors.
      */
     private void updateSwitchboard() {
         ThreadUtil.checkOnMainThread();
 
-        mSwitchboard.setSelectors(mSelectorRegistry);
-        mIsLookupInProgress = false;
+        List<CallServiceSelectorWrapper> selectors = Lists.newLinkedList();
+        for (CallServiceSelectorWrapper selector : mCallServiceSelectors.values()) {
+            if (TelephonyUtil.isTelephonySelector(selector)) {
+                // Add telephony selectors to the end to serve as a fallback.
+                selectors.add(selector);
+            } else {
+                // TODO(sail): Need a way to order selectors.
+                selectors.add(0, selector);
+            }
+        }
+
+        mSwitchboard.setSelectors(ImmutableList.copyOf((selectors)));
     }
 }
diff --git a/src/com/android/telecomm/CallServiceSelectorWrapper.java b/src/com/android/telecomm/CallServiceSelectorWrapper.java
new file mode 100644
index 0000000..a535798
--- /dev/null
+++ b/src/com/android/telecomm/CallServiceSelectorWrapper.java
@@ -0,0 +1,111 @@
+/*
+ * 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.content.ComponentName;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.telecomm.CallInfo;
+import android.telecomm.CallServiceDescriptor;
+import android.telecomm.TelecommConstants;
+import android.telecomm.CallServiceSelector.CallServiceSelectionResponse;
+
+import com.google.common.base.Preconditions;
+import com.android.internal.telecomm.ICallServiceSelectionResponse;
+import com.android.internal.telecomm.ICallServiceSelector;
+
+import java.util.List;
+
+/**
+ * Wrapper for {@link ICallServiceSelector}s, handles binding and keeps track of when the object can
+ * safely be unbound.
+ */
+final class CallServiceSelectorWrapper extends ServiceBinder<ICallServiceSelector> {
+    class SelectionResponseImpl extends ICallServiceSelectionResponse.Stub {
+        private final CallServiceSelectionResponse mResponse;
+
+        SelectionResponseImpl(CallServiceSelectionResponse response) {
+            mResponse = response;
+        }
+
+        @Override
+        public void setSelectedCallServiceDescriptors(
+                final List<CallServiceDescriptor> descriptors) {
+            mHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    mResponse.setSelectedCallServices(descriptors);
+                }
+            });
+        }
+    }
+
+    private ICallServiceSelector mSelectorInterface;
+
+    private Binder mBinder = new Binder();
+
+    private Handler mHandler = new Handler();
+
+    /**
+     * Creates a call-service selector for the specified component.
+     *
+     * @param componentName The component name of the service.
+     */
+    CallServiceSelectorWrapper(ComponentName componentName) {
+        super(TelecommConstants.ACTION_CALL_SERVICE_SELECTOR, componentName);
+    }
+
+    /**
+     * Retrieves the sorted set of call services that are preferred by this selector. Upon failure,
+     * the error callback is invoked. Can be invoked even when the call service is unbound.
+     *
+     * @param callInfo The details of the call.
+     * @param selectionResponse The selection response callback to invoke upon success.
+     * @param errorCallback The callback to invoke upon failure.
+     */
+    void select(final CallInfo callInfo, final List<CallServiceDescriptor> callServiceDescriptors,
+            final CallServiceSelectionResponse selectionResponse, final Runnable errorCallback) {
+        BindCallback callback = new BindCallback() {
+            @Override
+            public void onSuccess() {
+                if (isServiceValid("select")) {
+                    try {
+                        mSelectorInterface.select(callInfo, callServiceDescriptors,
+                                new SelectionResponseImpl(selectionResponse));
+                    } catch (RemoteException e) {
+                        Log.e(CallServiceSelectorWrapper.this, e, "Failed calling select for selector: %s.",
+                                getComponentName());
+                    }
+                }
+            }
+
+            @Override
+            public void onFailure() {
+                errorCallback.run();
+            }
+        };
+
+        mBinder.bind(callback);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setServiceInterface(IBinder binder) {
+        mSelectorInterface = ICallServiceSelector.Stub.asInterface(binder);
+    }
+}
diff --git a/src/com/android/telecomm/CallServiceWrapper.java b/src/com/android/telecomm/CallServiceWrapper.java
index d69aa96..426a019 100644
--- a/src/com/android/telecomm/CallServiceWrapper.java
+++ b/src/com/android/telecomm/CallServiceWrapper.java
@@ -49,7 +49,7 @@
     private Binder mBinder = new Binder();
 
     /**
-     * Creates a call-service provider for the specified component.
+     * Creates a call-service provider for the specified descriptor.
      *
      * @param descriptor The call-service descriptor from
      *         {@link ICallServiceProvider#lookupCallServices}.
diff --git a/src/com/android/telecomm/OutgoingCallProcessor.java b/src/com/android/telecomm/OutgoingCallProcessor.java
index bbcdb17..3d41fe7 100644
--- a/src/com/android/telecomm/OutgoingCallProcessor.java
+++ b/src/com/android/telecomm/OutgoingCallProcessor.java
@@ -21,13 +21,13 @@
 import android.os.RemoteException;
 import android.telecomm.CallState;
 import android.telecomm.CallServiceDescriptor;
+import android.telecomm.CallServiceSelector.CallServiceSelectionResponse;
 
-import com.android.internal.telecomm.ICallServiceSelectionResponse;
-import com.android.internal.telecomm.ICallServiceSelector;
 import com.google.android.collect.Sets;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Lists;
 
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -79,10 +79,7 @@
     /**
      * The list of currently-available call-service selector implementations.
      */
-    private final List<ICallServiceSelector> mSelectors;
-
-    /** Used to run code (e.g. messages, Runnables) on the main (UI) thread. */
-    private final Handler mHandler = new Handler(Looper.getMainLooper());
+    private final Collection<CallServiceSelectorWrapper> mSelectors;
 
     /** Manages all outgoing call processors. */
     private final OutgoingCallsManager mOutgoingCallsManager;
@@ -95,12 +92,18 @@
         }
     };
 
+    private final Runnable mNextSelectorCallback = new Runnable() {
+        @Override public void run() {
+            attemptNextSelector();
+        }
+    };
+
     /**
      * The iterator over the currently-selected ordered list of call-service descriptors.
      */
     private Iterator<CallServiceDescriptor> mCallServiceDescriptorIterator;
 
-    private Iterator<ICallServiceSelector> mSelectorIterator;
+    private Iterator<CallServiceSelectorWrapper> mSelectorIterator;
 
     private boolean mIsAborted = false;
 
@@ -120,7 +123,7 @@
     OutgoingCallProcessor(
             Call call,
             Set<CallServiceWrapper> callServices,
-            List<ICallServiceSelector> selectors,
+            Collection<CallServiceSelectorWrapper> selectors,
             OutgoingCallsManager outgoingCallsManager,
             Switchboard switchboard) {
 
@@ -247,16 +250,17 @@
         }
 
         if (mSelectorIterator.hasNext()) {
-            ICallServiceSelector selector = mSelectorIterator.next();
+            CallServiceSelectorWrapper selector = mSelectorIterator.next();
             mCall.setCallServiceSelector(selector);
 
-            ICallServiceSelectionResponse.Stub response = createSelectionResponse();
-            try {
-                selector.select(mCall.toCallInfo(), mCallServiceDescriptors, response);
-            } catch (RemoteException e) {
-                attemptNextSelector();
-            }
-
+            CallServiceSelectionResponse responseCallback = new CallServiceSelectionResponse() {
+                    @Override
+                    public void setSelectedCallServices(List<CallServiceDescriptor> callServices) {
+                        processSelectedCallServiceDescriptors(callServices);
+                    }
+                };
+            selector.select(mCall.toCallInfo(), mCallServiceDescriptors, responseCallback,
+                    mNextSelectorCallback);
         } else {
             Log.v(this, "attemptNextSelector, no more selectors, failing");
             mOutgoingCallsManager.handleFailedOutgoingCall(mCall, false /* isAborted */);
@@ -264,25 +268,6 @@
     }
 
     /**
-     * @return A new selection-response object that's wired to run on the main (UI) thread.
-     */
-    private ICallServiceSelectionResponse.Stub createSelectionResponse() {
-        return new ICallServiceSelectionResponse.Stub() {
-            @Override public void setSelectedCallServiceDescriptors(
-                    final List<CallServiceDescriptor> selectedCallServiceDescriptors) {
-
-                Runnable runnable = new Runnable() {
-                    @Override public void run() {
-                        processSelectedCallServiceDescriptors(selectedCallServiceDescriptors);
-                    }
-                };
-
-                mHandler.post(runnable);
-            }
-        };
-    }
-
-    /**
      * Persists the ordered-list of call-service descriptor as selected by the current selector and
      * starts iterating through the corresponding call services continuing the attempt to place the
      * call.
diff --git a/src/com/android/telecomm/OutgoingCallsManager.java b/src/com/android/telecomm/OutgoingCallsManager.java
index 37f7eb1..50c24ea 100644
--- a/src/com/android/telecomm/OutgoingCallsManager.java
+++ b/src/com/android/telecomm/OutgoingCallsManager.java
@@ -19,7 +19,7 @@
 import com.android.internal.telecomm.ICallServiceSelector;
 import com.google.common.collect.Maps;
 
-import java.util.List;
+import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 
@@ -54,7 +54,9 @@
      * @param selectors The ordered list of selectors used in placing the call.
      */
     void placeCall(
-            Call call, Set<CallServiceWrapper> callServices, List<ICallServiceSelector> selectors) {
+            Call call,
+            Set<CallServiceWrapper> callServices,
+            Collection<CallServiceSelectorWrapper> selectors) {
 
         Log.i(this, "Placing an outgoing call (%s)", call.getId());
 
diff --git a/src/com/android/telecomm/Switchboard.java b/src/com/android/telecomm/Switchboard.java
index 8a3fc81..d8c57fb 100644
--- a/src/com/android/telecomm/Switchboard.java
+++ b/src/com/android/telecomm/Switchboard.java
@@ -16,6 +16,9 @@
 
 package com.android.telecomm;
 
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 
@@ -26,16 +29,18 @@
 import android.telecomm.CallServiceDescriptor;
 import android.telecomm.TelecommConstants;
 
-import com.android.internal.telecomm.ICallServiceSelector;
-
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 /**
- * Switchboard is responsible for (1) gathering the {@link CallServiceWrapper}s and
- * {@link ICallServiceSelector}s through which to place outgoing calls, (2) starting outgoing calls
- * (via {@link OutgoingCallsManager} and (3) switching active calls between call services.
+ * Switchboard is responsible for:
+ * <ul>
+ * <li> gathering the {@link CallServiceWrapper}s and {@link CallServiceSelectorWrapper}s through which to place
+ * outgoing calls
+ * <li> starting outgoing calls (via {@link OutgoingCallsManager}
+ * <li> switching active calls between call services.
+ * </ul>
  */
 final class Switchboard {
 
@@ -87,7 +92,7 @@
      * see {@link CallServiceSelectorRepository}.
      * TODO(gilad): Clear once the active-call count goes to zero.
      */
-    private final Set<ICallServiceSelector> mSelectors = Sets.newHashSet();
+    private ImmutableCollection<CallServiceSelectorWrapper> mSelectors = ImmutableList.of();
 
     /**
      * The current lookup-cycle ID used with the repositories. Incremented with each invocation
@@ -126,7 +131,7 @@
         // be okay since the call-service lookup completed. Specifically the already-available call
         // services are cached and will be provided in response to the second lookup cycle.
         mCallServices.clear();
-        mSelectors.clear();
+        mSelectors = ImmutableList.of();
 
         mNewOutgoingCalls.add(call);
 
@@ -175,22 +180,19 @@
      * Persists the specified list of selectors and attempts to connect any pending outgoing
      * calls.  Intended to be invoked by {@link CallServiceSelectorRepository} exclusively.
      *
-     * @param selectors The potentially-partial set of selectors.  Partial since the lookup
-     *     procedure is time-boxed such that some selectors may be slow to respond and hence
-     *     effectively omitted from the specified set.
+     * @param selectors Collection of selectors. The order of the collection determines the order in
+     *     which the selectors are tried.
      */
-    void setSelectors(Set<ICallServiceSelector> selectors) {
-        // TODO(santoscordon): This should take in CallServiceSelectorWrapper instead of the direct
-        // ICallServiceSelector implementation. Copy what we have for CallServiceWrapper. Also need
-        // to invoke updateBinders(selectors) once this to-do is addressed.
+    void setSelectors(ImmutableCollection<CallServiceSelectorWrapper> selectors) {
+        // TODO(santoscordon):: Need to invoke updateBinders(selectors).
         ThreadUtil.checkOnMainThread();
+        Preconditions.checkNotNull(selectors);
 
         // TODO(gilad): Add logic to include the built-in selectors (e.g. for dealing with
         // emergency calls) and order the entire set prior to the assignment below. If the
         // built-in selectors can be implemented in a manner that does not require binding,
-        // that's probably preferred.  May want to use a LinkedHashSet for the sorted set.
-        mSelectors.clear();
-        mSelectors.addAll(selectors);
+        // that's probably preferred.
+        mSelectors = selectors;
         processNewOutgoingCalls();
     }
 
@@ -294,12 +296,7 @@
      * @param call The call to place.
      */
     private void processNewOutgoingCall(Call call) {
-        // Convert to (duplicate-free) list to aid index-based iteration, see the comment under
-        // setSelectors regarding using LinkedHashSet instead.
-        List<ICallServiceSelector> selectors = Lists.newArrayList();
-        selectors.addAll(mSelectors);
-
-        mOutgoingCallsManager.placeCall(call, mCallServices, selectors);
+        mOutgoingCallsManager.placeCall(call, mCallServices, mSelectors);
     }
 
     /**
diff --git a/src/com/android/telecomm/TelephonyUtil.java b/src/com/android/telecomm/TelephonyUtil.java
new file mode 100644
index 0000000..7a9ac22
--- /dev/null
+++ b/src/com/android/telecomm/TelephonyUtil.java
@@ -0,0 +1,78 @@
+/*
+ * 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.content.ComponentName;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.telecomm.CallServiceDescriptor;
+
+/**
+ * Utilities to deal with the system telephony services. The system telephony services are treated
+ * differently from 3rd party services in some situations (emergency calls, audio focus, etc...).
+ */
+public final class TelephonyUtil {
+    private static final String TAG = ThreadUtil.class.getSimpleName();
+
+    private static final String TELEPHONY_PACKAGE_NAME =
+            "com.android.phone";
+
+    private static final String GSM_CALL_SERVICE_CLASS_NAME =
+            "com.android.services.telephony.GsmCallService";
+
+    private static final String CDMA_CALL_SERVICE_CLASS_NAME =
+            "com.android.services.telephony.CdmaCallService";
+
+    private TelephonyUtil() {}
+
+    static boolean isTelephonySelector(CallServiceSelectorWrapper selector) {
+        return selector.getComponentName().getPackageName().equals(TELEPHONY_PACKAGE_NAME);
+    }
+
+    /**
+     * Returns whether or not the call is currently connected as a cellular call (through the
+     * device's cellular radio).
+     */
+    static boolean isCurrentlyPSTNCall(Call call) {
+        if (Log.DEBUG) {
+            verifyCallServiceExists(GSM_CALL_SERVICE_CLASS_NAME);
+            verifyCallServiceExists(CDMA_CALL_SERVICE_CLASS_NAME);
+        }
+
+        CallServiceWrapper callService = call.getCallService();
+        if (callService == null) {
+            return false;
+        }
+        CallServiceDescriptor descriptor = callService.getDescriptor();
+        String className = descriptor.getServiceComponent().getClassName();
+        return className.equals(GSM_CALL_SERVICE_CLASS_NAME) ||
+                className.equals(CDMA_CALL_SERVICE_CLASS_NAME);
+    }
+
+    private static void verifyCallServiceExists(String serviceName) {
+        PackageManager packageManager = TelecommApp.getInstance().getPackageManager();
+        try {
+            ServiceInfo info = packageManager.getServiceInfo(
+                    new ComponentName(TELEPHONY_PACKAGE_NAME, serviceName), 0);
+            if (info == null) {
+                Log.wtf(TAG, "Error, unable to find call service: %s", serviceName);
+            }
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.wtf(TAG, e, "Error, exception while trying to find call service: %s", serviceName);
+        }
+    }
+}
diff --git a/src/com/android/telecomm/Timeouts.java b/src/com/android/telecomm/Timeouts.java
index 0fab3c4..4096c02 100644
--- a/src/com/android/telecomm/Timeouts.java
+++ b/src/com/android/telecomm/Timeouts.java
@@ -54,14 +54,6 @@
     }
 
     /**
-     * @return The longest period in milliseconds each {@link CallServiceSelector} lookup cycle is
-     *     allowed to span over.
-     */
-    public static long getSelectorLookupMs() {
-        return get("selector_lookup_ms", 1000);
-    }
-
-    /**
      * @return How frequently, in milliseconds, to run {@link Switchboard}'s clean-up "tick" cycle.
      */
     public static long getTickMs() {