diff --git a/res/drawable-xxxhdpi/ic_arrow_back_24dp.png b/res/drawable-xxxhdpi/ic_arrow_back_24dp.png
index 037b6f1..3b72636 100644
--- a/res/drawable-xxxhdpi/ic_arrow_back_24dp.png
+++ b/res/drawable-xxxhdpi/ic_arrow_back_24dp.png
Binary files differ
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 23f44e3..274d74c 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -651,6 +651,24 @@
         <item>"10"</item>
     </string-array>
 
+    <string-array name="enabled_networks_cdma_no_lte_choices" translatable="false">
+        <item>@string/network_3G</item>
+        <item>@string/network_1x</item>
+    </string-array>
+    <string-array name="enabled_networks_cdma_no_lte_values" translatable="false">
+        <item>"4"</item>
+        <item>"5"</item>
+    </string-array>
+
+    <string-array name="enabled_networks_cdma_only_lte_choices" translatable="false">
+        <item>@string/network_lte</item>
+        <item>@string/network_global</item>
+    </string-array>
+    <string-array name="enabled_networks_cdma_only_lte_values" translatable="false">
+        <item>"8"</item>
+        <item>"10"</item>
+    </string-array>
+
     <!-- CDMA System select strings -->
     <!-- Mobile network settings screen, setting option name -->
     <string name="cdma_system_select_title">System select</string>
@@ -968,7 +986,7 @@
     <!-- In-call screen: message displayed in an error dialog -->
     <string name="incall_error_supp_service_transfer">Can\'t transfer.</string>
     <!-- In-call screen: message displayed in an error dialog -->
-    <string name="incall_error_supp_service_conference">Can\'t conference.</string>
+    <string name="incall_error_supp_service_conference">Unable to conference calls.</string>
     <!-- In-call screen: message displayed in an error dialog -->
     <string name="incall_error_supp_service_reject">Can\'t reject call.</string>
     <!-- In-call screen: message displayed in an error dialog -->
@@ -1066,7 +1084,9 @@
     </string-array>
 
     <!-- Title for the dialog used to display CDMA DisplayInfo -->
-    <string name="network_message">Network message</string>
+    <string name="network_info_message">Network message</string>
+    <!-- Title for the dialog used to display a network error message to the user -->
+    <string name="network_error_message">Error message</string>
 
     <!-- OTA-specific strings -->
     <!-- Title shown on OTA screen -->
diff --git a/src/com/android/phone/CallFeaturesSetting.java b/src/com/android/phone/CallFeaturesSetting.java
index 7e670aa..0286e71 100644
--- a/src/com/android/phone/CallFeaturesSetting.java
+++ b/src/com/android/phone/CallFeaturesSetting.java
@@ -1246,29 +1246,38 @@
 
             int phoneType = mPhone.getPhoneType();
             Preference fdnButton = prefSet.findPreference(BUTTON_FDN_KEY);
-            if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
+            boolean shouldHideCarrierSettings = Settings.Global.getInt(
+                    getContentResolver(), Settings.Global.HIDE_CARRIER_NETWORK_SETTINGS, 0) == 1;
+            if (shouldHideCarrierSettings) {
                 prefSet.removePreference(fdnButton);
-
-                if (!getResources().getBoolean(R.bool.config_voice_privacy_disable)) {
-                    addPreferencesFromResource(R.xml.cdma_call_privacy);
-                }
-            } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
-                fdnButton.setIntent(mSubscriptionInfoHelper.getIntent(this, FdnSetting.class));
-
-                if (getResources().getBoolean(R.bool.config_additional_call_setting)) {
-                    addPreferencesFromResource(R.xml.gsm_umts_call_options);
-
-                    Preference callForwardingPref = prefSet.findPreference(CALL_FORWARDING_KEY);
-                    callForwardingPref.setIntent(mSubscriptionInfoHelper.getIntent(
-                            this, GsmUmtsCallForwardOptions.class));
-
-                    Preference additionalGsmSettingsPref =
-                            prefSet.findPreference(ADDITIONAL_GSM_SETTINGS_KEY);
-                    additionalGsmSettingsPref.setIntent(mSubscriptionInfoHelper.getIntent(
-                            this, GsmUmtsAdditionalCallOptions.class));
+                if (mButtonDTMF != null) {
+                    prefSet.removePreference(mButtonDTMF);
                 }
             } else {
-                throw new IllegalStateException("Unexpected phone type: " + phoneType);
+                if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
+                    prefSet.removePreference(fdnButton);
+
+                    if (!getResources().getBoolean(R.bool.config_voice_privacy_disable)) {
+                        addPreferencesFromResource(R.xml.cdma_call_privacy);
+                    }
+                } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
+                    fdnButton.setIntent(mSubscriptionInfoHelper.getIntent(this, FdnSetting.class));
+
+                    if (getResources().getBoolean(R.bool.config_additional_call_setting)) {
+                        addPreferencesFromResource(R.xml.gsm_umts_call_options);
+
+                        Preference callForwardingPref = prefSet.findPreference(CALL_FORWARDING_KEY);
+                        callForwardingPref.setIntent(mSubscriptionInfoHelper.getIntent(
+                                this, GsmUmtsCallForwardOptions.class));
+
+                        Preference additionalGsmSettingsPref =
+                                prefSet.findPreference(ADDITIONAL_GSM_SETTINGS_KEY);
+                        additionalGsmSettingsPref.setIntent(mSubscriptionInfoHelper.getIntent(
+                                this, GsmUmtsAdditionalCallOptions.class));
+                    }
+                } else {
+                    throw new IllegalStateException("Unexpected phone type: " + phoneType);
+                }
             }
         }
 
diff --git a/src/com/android/phone/CallNotifier.java b/src/com/android/phone/CallNotifier.java
index f22913c..bc13010 100644
--- a/src/com/android/phone/CallNotifier.java
+++ b/src/com/android/phone/CallNotifier.java
@@ -65,8 +65,8 @@
             (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
     private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2);
 
-    // Time to display the  DisplayInfo Record sent by CDMA network
-    private static final int DISPLAYINFO_NOTIFICATION_TIME = 2000; // msec
+    // Time to display the message from the underlying phone layers.
+    private static final int SHOW_MESSAGE_NOTIFICATION_TIME = 3000; // msec
 
     private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
@@ -86,12 +86,6 @@
     // object used to synchronize access to mCallerInfoQueryState
     private Object mCallerInfoQueryStateGuard = new Object();
 
-    // Events generated internally:
-    private static final int PHONE_MWI_CHANGED = 21;
-    private static final int DISPLAYINFO_NOTIFICATION_DONE = 24;
-    private static final int UPDATE_IN_CALL_NOTIFICATION = 27;
-
-
     private PhoneGlobals mApplication;
     private CallManager mCM;
     private BluetoothHeadset mBluetoothHeadset;
@@ -197,7 +191,7 @@
                 onUnknownConnectionAppeared((AsyncResult) msg.obj);
                 break;
 
-            case PHONE_MWI_CHANGED:
+            case CallStateMonitor.INTERNAL_PHONE_MWI_CHANGED:
                 onMwiChanged(mApplication.phone.getMessageWaitingIndicator());
                 break;
 
@@ -211,9 +205,9 @@
                 onSignalInfo((AsyncResult) msg.obj);
                 break;
 
-            case DISPLAYINFO_NOTIFICATION_DONE:
+            case CallStateMonitor.INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE:
                 if (DBG) log("Received Display Info notification done event ...");
-                CdmaDisplayInfo.dismissDisplayInfoRecord();
+                PhoneDisplayMessage.dismissMessage();
                 break;
 
             case CallStateMonitor.EVENT_OTA_PROVISION_CHANGE:
@@ -239,6 +233,11 @@
                 }
                 break;
 
+            case CallStateMonitor.PHONE_SUPP_SERVICE_FAILED:
+                if (DBG) log("PHONE_SUPP_SERVICE_FAILED...");
+                onSuppServiceFailed((AsyncResult) msg.obj);
+                break;
+
             default:
                 // super.handleMessage(msg);
         }
@@ -485,7 +484,8 @@
         }
 
         int autoretrySetting = 0;
-        if ((c != null) && (c.getCall().getPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)) {
+        if ((c != null) &&
+                (c.getCall().getPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)) {
             autoretrySetting = android.provider.Settings.Global.getInt(mApplication.
                     getContentResolver(),android.provider.Settings.Global.CALL_AUTO_RETRY, 0);
         }
@@ -493,7 +493,8 @@
         // Stop any signalInfo tone being played when a call gets ended
         stopSignalInfoTone();
 
-        if ((c != null) && (c.getCall().getPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)) {
+        if ((c != null) &&
+                (c.getCall().getPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)) {
             // Resetting the CdmaPhoneCallState members
             mApplication.cdmaPhoneCallState.resetCdmaPhoneCallState();
         }
@@ -632,7 +633,7 @@
      * failed NotificationMgr.updateMwi() call.
      */
     /* package */ void sendMwiChangedDelayed(long delayMillis) {
-        Message message = Message.obtain(this, PHONE_MWI_CHANGED);
+        Message message = Message.obtain(this, CallStateMonitor.INTERNAL_PHONE_MWI_CHANGED);
         sendMessageDelayed(message, delayMillis);
     }
 
@@ -916,15 +917,37 @@
         if (displayInfoRec != null) {
             String displayInfo = displayInfoRec.alpha;
             if (DBG) log("onDisplayInfo: displayInfo=" + displayInfo);
-            CdmaDisplayInfo.displayInfoRecord(mApplication, displayInfo);
+            PhoneDisplayMessage.displayNetworkMessage(mApplication, displayInfo);
 
-            // start a 2 second timer
-            sendEmptyMessageDelayed(DISPLAYINFO_NOTIFICATION_DONE,
-                    DISPLAYINFO_NOTIFICATION_TIME);
+            // start a timer that kills the dialog
+            sendEmptyMessageDelayed(CallStateMonitor.INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE,
+                    SHOW_MESSAGE_NOTIFICATION_TIME);
         }
     }
 
     /**
+     * Displays a notification when the phone receives a notice that a supplemental
+     * service has failed.
+     * TODO: This is a NOOP if it isn't for conferences right now.
+     */
+    private void onSuppServiceFailed(AsyncResult r) {
+        if (r.result != Phone.SuppService.CONFERENCE) {
+            if (DBG) log("onSuppServiceFailed: not a merge failure event");
+            return;
+        }
+
+        if (DBG) log("onSuppServiceFailed: displaying merge failure message");
+
+        String mergeFailedString = mApplication.getResources().getString(
+                R.string.incall_error_supp_service_conference);
+        PhoneDisplayMessage.displayErrorMessage(mApplication, mergeFailedString);
+
+        // start a timer that kills the dialog
+        sendEmptyMessageDelayed(CallStateMonitor.INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE,
+                SHOW_MESSAGE_NOTIFICATION_TIME);
+    }
+
+    /**
      * Helper class to play SignalInfo tones using the ToneGenerator.
      *
      * To use, just instantiate a new SignalInfoTonePlayer
diff --git a/src/com/android/phone/CallStateMonitor.java b/src/com/android/phone/CallStateMonitor.java
index eda45b9..9b8a653 100644
--- a/src/com/android/phone/CallStateMonitor.java
+++ b/src/com/android/phone/CallStateMonitor.java
@@ -56,6 +56,13 @@
     public static final int PHONE_RINGBACK_TONE = 11;
     public static final int PHONE_RESEND_MUTE = 12;
     public static final int PHONE_ON_DIAL_CHARS = 13;
+    public static final int PHONE_SUPP_SERVICE_FAILED = 14;
+    // Events generated internally.
+    // We should store all the possible event type values in one place to make sure that
+    // they don't step on each others' toes.
+    public static final int INTERNAL_PHONE_MWI_CHANGED = 21;
+    public static final int INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE = 22;
+    public static final int INTERNAL_UPDATE_IN_CALL_NOTIFICATION = 23;
 
     // Other events from call manager
     public static final int EVENT_OTA_PROVISION_CHANGE = 20;
@@ -89,6 +96,7 @@
         callManager.registerForSignalInfo(this, PHONE_STATE_SIGNALINFO, null);
         callManager.registerForInCallVoicePrivacyOn(this, PHONE_ENHANCED_VP_ON, null);
         callManager.registerForInCallVoicePrivacyOff(this, PHONE_ENHANCED_VP_OFF, null);
+        callManager.registerForSuppServiceFailed(this, PHONE_SUPP_SERVICE_FAILED, null);
         //callManager.registerForRingbackTone(this, PHONE_RINGBACK_TONE, null);
         //callManager.registerForResendIncallMute(this, PHONE_RESEND_MUTE, null);
         //callManager.registerForPostDialCharacter(this, PHONE_ON_DIAL_CHARS, null);
@@ -136,6 +144,7 @@
         callManager.unregisterForInCallVoicePrivacyOn(this);
         callManager.unregisterForInCallVoicePrivacyOff(this);
         //callManager.unregisterForPostDialCharacter(this);
+        callManager.unregisterForSuppServiceFailed(this);
 
         registerForNotifications();
     }
diff --git a/src/com/android/phone/CdmaDisplayInfo.java b/src/com/android/phone/CdmaDisplayInfo.java
deleted file mode 100644
index 1a88333..0000000
--- a/src/com/android/phone/CdmaDisplayInfo.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.phone;
-
-import android.app.AlertDialog;
-import android.content.Context;
-import android.os.SystemProperties;
-import android.util.Log;
-import android.view.WindowManager;
-
-/**
- * Helper class for displaying the DisplayInfo sent by CDMA network.
- */
-public class CdmaDisplayInfo {
-    private static final String LOG_TAG = "CdmaDisplayInfo";
-    private static final boolean DBG = (SystemProperties.getInt("ro.debuggable", 0) == 1);
-
-    /** CDMA DisplayInfo dialog */
-    private static AlertDialog sDisplayInfoDialog = null;
-
-    /**
-     * Handle the DisplayInfo record and display the alert dialog with
-     * the network message.
-     *
-     * @param context context to get strings.
-     * @param infoMsg Text message from Network.
-     */
-    public static void displayInfoRecord(Context context, String infoMsg) {
-
-        if (DBG) log("displayInfoRecord: infoMsg=" + infoMsg);
-
-        if (sDisplayInfoDialog != null) {
-            sDisplayInfoDialog.dismiss();
-        }
-
-        // displaying system alert dialog on the screen instead of
-        // using another activity to display the message.  This
-        // places the message at the forefront of the UI.
-        sDisplayInfoDialog = new AlertDialog.Builder(context)
-                .setIcon(android.R.drawable.ic_dialog_info)
-                .setTitle(context.getText(R.string.network_message))
-                .setMessage(infoMsg)
-                .setCancelable(true)
-                .create();
-
-        sDisplayInfoDialog.getWindow().setType(
-                WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
-        sDisplayInfoDialog.getWindow().addFlags(
-                WindowManager.LayoutParams.FLAG_DIM_BEHIND);
-
-        sDisplayInfoDialog.show();
-        PhoneGlobals.getInstance().wakeUpScreen();
-
-    }
-
-    /**
-     * Dismiss the DisplayInfo record
-     */
-    public static void dismissDisplayInfoRecord() {
-
-        if (DBG) log("Dissmissing Display Info Record...");
-
-        if (sDisplayInfoDialog != null) {
-            sDisplayInfoDialog.dismiss();
-            sDisplayInfoDialog = null;
-        }
-    }
-
-    private static void log(String msg) {
-        Log.d(LOG_TAG, "[CdmaDisplayInfo] " + msg);
-    }
-}
diff --git a/src/com/android/phone/MobileNetworkSettings.java b/src/com/android/phone/MobileNetworkSettings.java
index 5a64528..afeebd8 100644
--- a/src/com/android/phone/MobileNetworkSettings.java
+++ b/src/com/android/phone/MobileNetworkSettings.java
@@ -379,8 +379,6 @@
 
     private void updateBody() {
         final Context context = getApplicationContext();
-        final TelephonyManager tm =
-                (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
         PreferenceScreen prefSet = getPreferenceScreen();
         boolean isLteOnCdma = mPhone.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE;
         final int phoneSubId = mPhone.getSubId();
@@ -416,13 +414,46 @@
             mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet);
         } else {
             prefSet.removePreference(mButtonPreferredNetworkMode);
-            int phoneType = mPhone.getPhoneType();
+            final int phoneType = mPhone.getPhoneType();
             if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
+                int lteForced = android.provider.Settings.Global.getInt(
+                        mPhone.getContext().getContentResolver(),
+                        android.provider.Settings.Global.LTE_SERVICE_FORCED + mPhone.getSubId(),
+                        0);
+
                 if (isLteOnCdma) {
-                    mButtonEnabledNetworks.setEntries(
-                            R.array.enabled_networks_cdma_choices);
-                    mButtonEnabledNetworks.setEntryValues(
-                            R.array.enabled_networks_cdma_values);
+                    if (lteForced == 0) {
+                        mButtonEnabledNetworks.setEntries(
+                                R.array.enabled_networks_cdma_choices);
+                        mButtonEnabledNetworks.setEntryValues(
+                                R.array.enabled_networks_cdma_values);
+                    } else {
+                        switch (settingsNetworkMode) {
+                            case Phone.NT_MODE_CDMA:
+                            case Phone.NT_MODE_CDMA_NO_EVDO:
+                            case Phone.NT_MODE_EVDO_NO_CDMA:
+                                mButtonEnabledNetworks.setEntries(
+                                        R.array.enabled_networks_cdma_no_lte_choices);
+                                mButtonEnabledNetworks.setEntryValues(
+                                        R.array.enabled_networks_cdma_no_lte_values);
+                                break;
+                            case Phone.NT_MODE_GLOBAL:
+                            case Phone.NT_MODE_LTE_CDMA_AND_EVDO:
+                            case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
+                            case Phone.NT_MODE_LTE_ONLY:
+                                mButtonEnabledNetworks.setEntries(
+                                        R.array.enabled_networks_cdma_only_lte_choices);
+                                mButtonEnabledNetworks.setEntryValues(
+                                        R.array.enabled_networks_cdma_only_lte_values);
+                                break;
+                            default:
+                                mButtonEnabledNetworks.setEntries(
+                                        R.array.enabled_networks_cdma_choices);
+                                mButtonEnabledNetworks.setEntryValues(
+                                        R.array.enabled_networks_cdma_values);
+                                break;
+                        }
+                    }
                 }
                 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone);
             } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
diff --git a/src/com/android/phone/PhoneDisplayMessage.java b/src/com/android/phone/PhoneDisplayMessage.java
new file mode 100644
index 0000000..2b86a61
--- /dev/null
+++ b/src/com/android/phone/PhoneDisplayMessage.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.phone;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.os.SystemProperties;
+import android.util.Log;
+import android.view.WindowManager;
+
+/**
+ * Helper class for displaying the a string triggered by a lower level Phone request
+ */
+public class PhoneDisplayMessage {
+    private static final String LOG_TAG = "PhoneDisplayMessage";
+    private static final boolean DBG = (SystemProperties.getInt("ro.debuggable", 0) == 1);
+
+    /** Display message dialog */
+    private static AlertDialog sDisplayMessageDialog = null;
+
+    /**
+     * Display the alert dialog with the network message.
+     *
+     * @param context context to get strings.
+     * @param infoMsg Text message from Network.
+     */
+    public static void displayNetworkMessage(Context context, String infoMsg) {
+        if (DBG) log("displayInfoRecord: infoMsg=" + infoMsg);
+
+        String title = (String)context.getText(R.string.network_info_message);
+        displayMessage(context, title, infoMsg);
+    }
+
+    /**
+     * Display the alert dialog with the error message.
+     *
+     * @param context context to get strings.
+     * @param errorMsg Error message describing the network triggered error
+     */
+    public static void displayErrorMessage(Context context, String errorMsg) {
+        if (DBG) log("displayErrorMessage: errorMsg=" + errorMsg);
+
+        String title = (String)context.getText(R.string.network_error_message);
+        displayMessage(context, title, errorMsg);
+    }
+
+    public static void displayMessage(Context context, String title, String msg) {
+        if (DBG) log("displayMessage: msg=" + msg);
+
+        if (sDisplayMessageDialog != null) {
+            sDisplayMessageDialog.dismiss();
+        }
+
+        // displaying system alert dialog on the screen instead of
+        // using another activity to display the message.  This
+        // places the message at the forefront of the UI.
+        sDisplayMessageDialog = new AlertDialog.Builder(context)
+                .setIcon(android.R.drawable.ic_dialog_info)
+                .setTitle(title)
+                .setMessage(msg)
+                .setCancelable(true)
+                .create();
+
+        sDisplayMessageDialog.getWindow().setType(
+                WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
+        sDisplayMessageDialog.getWindow().addFlags(
+                WindowManager.LayoutParams.FLAG_DIM_BEHIND);
+
+        sDisplayMessageDialog.show();
+        PhoneGlobals.getInstance().wakeUpScreen();
+    }
+
+    /**
+     * Dismiss the DisplayInfo record
+     */
+    public static void dismissMessage() {
+        if (DBG) log("Dissmissing Display Info Record...");
+
+        if (sDisplayMessageDialog != null) {
+            sDisplayMessageDialog.dismiss();
+            sDisplayMessageDialog = null;
+        }
+    }
+
+    private static void log(String msg) {
+        Log.d(LOG_TAG, "[PhoneDisplayMessage] " + msg);
+    }
+}
diff --git a/src/com/android/phone/PhoneInterfaceManager.java b/src/com/android/phone/PhoneInterfaceManager.java
index cbd5ee6..1ca4a8c 100644
--- a/src/com/android/phone/PhoneInterfaceManager.java
+++ b/src/com/android/phone/PhoneInterfaceManager.java
@@ -1360,7 +1360,7 @@
         }
 
         log("No modify permission, check carrier privilege next.");
-        if (hasCarrierPrivileges() != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
+        if (getCarrierPrivilegeStatus() != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
             loge("No Carrier Privilege.");
             throw new SecurityException("No modify permission or carrier privilege.");
         }
@@ -1372,7 +1372,7 @@
      * @throws SecurityException if the caller does not have the required permission
      */
     private void enforceCarrierPrivilege() {
-        if (hasCarrierPrivileges() != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
+        if (getCarrierPrivilegeStatus() != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
             loge("No Carrier Privilege.");
             throw new SecurityException("No Carrier Privilege.");
         }
@@ -1497,7 +1497,7 @@
      */
     @Override
     public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
-        enforceModifyPermissionOrCarrierPrivilege();
+        enforceCarrierPrivilege();
         Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
                 new Pair<String, String>(alphaTag, number), new Integer(subId));
         return success;
@@ -1928,10 +1928,10 @@
     }
 
     @Override
-    public int hasCarrierPrivileges() {
+    public int getCarrierPrivilegeStatus() {
         UiccCard card = UiccController.getInstance().getUiccCard();
         if (card == null) {
-            loge("hasCarrierPrivileges: No UICC");
+            loge("getCarrierPrivilegeStatus: No UICC");
             return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
         }
         return card.getCarrierPrivilegeStatusForCurrentTransaction(
@@ -1975,7 +1975,7 @@
 
     @Override
     public void setLine1NumberForDisplayForSubscriber(int subId, String alphaTag, String number) {
-        enforceModifyPermissionOrCarrierPrivilege();
+        enforceCarrierPrivilege();
 
         String iccId = getIccId(subId);
         if (iccId != null) {
@@ -2023,7 +2023,7 @@
 
     @Override
     public boolean setOperatorBrandOverride(String brand) {
-        enforceModifyPermissionOrCarrierPrivilege();
+        enforceCarrierPrivilege();
         return mPhone.setOperatorBrandOverride(brand);
     }
 
diff --git a/src/com/android/phone/settings/PhoneAccountSettingsFragment.java b/src/com/android/phone/settings/PhoneAccountSettingsFragment.java
index a99c5f0..784be0f 100644
--- a/src/com/android/phone/settings/PhoneAccountSettingsFragment.java
+++ b/src/com/android/phone/settings/PhoneAccountSettingsFragment.java
@@ -50,7 +50,6 @@
     private String LOG_TAG = PhoneAccountSettingsFragment.class.getSimpleName();
 
     private TelecomManager mTelecomManager;
-    private Context mApplicationContext;
 
     private PreferenceCategory mAccountList;
 
@@ -67,7 +66,6 @@
         super.onCreate(icicle);
 
         mTelecomManager = TelecomManager.from(getActivity());
-        mApplicationContext = getActivity().getApplicationContext();
     }
 
     @Override
@@ -243,13 +241,19 @@
     }
 
     private synchronized void handleSipReceiveCallsOption(boolean isEnabled) {
+        Context context = getActivity();
+        if (context == null) {
+            // Return if the fragment is detached from parent activity before executed by thread.
+            return;
+        }
+
         mSipSharedPreferences.setReceivingCallsEnabled(isEnabled);
 
-        SipUtil.useSipToReceiveIncomingCalls(mApplicationContext, isEnabled);
+        SipUtil.useSipToReceiveIncomingCalls(context, isEnabled);
 
         // Restart all Sip services to ensure we reflect whether we are receiving calls.
         SipAccountRegistry sipAccountRegistry = SipAccountRegistry.getInstance();
-        sipAccountRegistry.restartSipService(mApplicationContext);
+        sipAccountRegistry.restartSipService(context);
     }
 
     /**
@@ -303,7 +307,7 @@
             intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             SubscriptionInfoHelper.addExtrasToIntent(intent, subscription);
 
-            Preference accountPreference = new Preference(mApplicationContext);
+            Preference accountPreference = new Preference(getActivity());
             accountPreference.setTitle(label);
             accountPreference.setIntent(intent);
             mAccountList.addPreference(accountPreference);
diff --git a/src/com/android/services/telephony/CdmaConference.java b/src/com/android/services/telephony/CdmaConference.java
index 2d5ee47..a0d6dd2 100755
--- a/src/com/android/services/telephony/CdmaConference.java
+++ b/src/com/android/services/telephony/CdmaConference.java
@@ -34,16 +34,16 @@
  * CDMA-based conference call.
  */
 public class CdmaConference extends Conference {
-
-    private int mCapabilities = PhoneCapabilities.MUTE;
+    private int mCapabilities;
 
     public CdmaConference(PhoneAccountHandle phoneAccount) {
         super(phoneAccount);
         setActive();
     }
 
-    private void updateCapabilities() {
-        setCapabilities(mCapabilities);
+    public void updateCapabilities(int capabilities) {
+        capabilities |=  PhoneCapabilities.MUTE | PhoneCapabilities.GENERIC_CONFERENCE;
+        setCapabilities(capabilities);
     }
 
     /**
@@ -89,7 +89,7 @@
         if (isSwapSupportedAfterMerge()){
             mCapabilities |= PhoneCapabilities.SWAP_CONFERENCE;
         }
-        updateCapabilities();
+        updateCapabilities(mCapabilities);
         sendFlash();
     }
 
diff --git a/src/com/android/services/telephony/CdmaConferenceController.java b/src/com/android/services/telephony/CdmaConferenceController.java
index e2f0b50..f7b9793 100644
--- a/src/com/android/services/telephony/CdmaConferenceController.java
+++ b/src/com/android/services/telephony/CdmaConferenceController.java
@@ -156,11 +156,11 @@
             CdmaConnection newConnection = mCdmaConnections.get(mCdmaConnections.size() - 1);
             if (newConnection.isOutgoing()) {
                 // Only an outgoing call can be merged with an ongoing call.
-                mConference.setCapabilities(PhoneCapabilities.MERGE_CONFERENCE);
+                mConference.updateCapabilities(PhoneCapabilities.MERGE_CONFERENCE);
             } else {
                 // If the most recently added connection was an incoming call, enable
                 // swap instead of merge.
-                mConference.setCapabilities(PhoneCapabilities.SWAP_CONFERENCE);
+                mConference.updateCapabilities(PhoneCapabilities.SWAP_CONFERENCE);
             }
 
             // 2) Add any new connections to the conference
diff --git a/src/com/android/services/telephony/ConferenceParticipantConnection.java b/src/com/android/services/telephony/ConferenceParticipantConnection.java
index e748634..49307ba 100644
--- a/src/com/android/services/telephony/ConferenceParticipantConnection.java
+++ b/src/com/android/services/telephony/ConferenceParticipantConnection.java
@@ -19,8 +19,8 @@
 import com.android.internal.telephony.PhoneConstants;
 
 import android.net.Uri;
-import android.telecom.ConferenceParticipant;
 import android.telecom.Connection;
+import android.telecom.ConferenceParticipant;
 import android.telecom.DisconnectCause;
 import android.telecom.PhoneCapabilities;
 
@@ -37,7 +37,7 @@
     /**
      * The connection which owns this participant.
      */
-    private final Connection mParentConnection;
+    private final com.android.internal.telephony.Connection mParentConnection;
 
     /**
      * Creates a new instance.
@@ -45,7 +45,8 @@
      * @param participant The conference participant to create the instance for.
      */
     public ConferenceParticipantConnection(
-            Connection parentConnection, ConferenceParticipant participant) {
+            com.android.internal.telephony.Connection parentConnection,
+            ConferenceParticipant participant) {
 
         mParentConnection = parentConnection;
         setAddress(participant.getHandle(), PhoneConstants.PRESENTATION_ALLOWED);
@@ -61,6 +62,8 @@
      * @param newState The new state.
      */
     public void updateState(int newState) {
+        Log.v(this, "updateState endPoint: %s state: %s", Log.pii(mEndpoint),
+                Connection.stateToString(newState));
         if (newState == getState()) {
             return;
         }
@@ -100,12 +103,19 @@
      */
     @Override
     public void onDisconnect() {
-        Log.v(this, "onDisconnect");
-
         mParentConnection.onDisconnectConferenceParticipant(mEndpoint);
     }
 
     /**
+     * Retrieves the endpoint for this connection.
+     *
+     * @return The endpoint.
+     */
+    public Uri getEndpoint() {
+        return mEndpoint;
+    }
+
+    /**
      * Configures the {@link android.telecom.PhoneCapabilities} applicable to this connection.  A
      * conference participant can only be disconnected from a conference since there is not
      * actual connection to the participant which could be split from the conference.
@@ -114,4 +124,25 @@
         int capabilities = PhoneCapabilities.DISCONNECT_FROM_CONFERENCE;
         setCallCapabilities(capabilities);
     }
+
+    /**
+     * Builds a string representation of this conference participant connection.
+     *
+     * @return String representation of connection.
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[ConferenceParticipantConnection objId:");
+        sb.append(System.identityHashCode(this));
+        sb.append(" endPoint:");
+        sb.append(Log.pii(mEndpoint));
+        sb.append(" parentConnection:");
+        sb.append(Log.pii(mParentConnection.getAddress()));
+        sb.append(" state:");
+        sb.append(Connection.stateToString(getState()));
+        sb.append("]");
+
+        return sb.toString();
+    }
 }
diff --git a/src/com/android/services/telephony/ImsConference.java b/src/com/android/services/telephony/ImsConference.java
new file mode 100644
index 0000000..5fc3e41
--- /dev/null
+++ b/src/com/android/services/telephony/ImsConference.java
@@ -0,0 +1,577 @@
+/*
+ * 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.services.telephony;
+
+import com.android.internal.telephony.Call;
+import com.android.internal.telephony.CallStateException;
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.imsphone.ImsPhoneConnection;
+
+import android.net.Uri;
+import android.telecom.Connection;
+import android.telecom.Conference;
+import android.telecom.ConferenceParticipant;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.PhoneCapabilities;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Represents an IMS conference call.
+ * <P>
+ * An IMS conference call consists of a conference host connection and potentially a list of
+ * conference participants.  The conference host connection represents the radio connection to the
+ * IMS conference server.  Since it is not a connection to any one individual, it is not represented
+ * in Telecom/InCall as a call.  The conference participant information is received via the host
+ * connection via a conference event package.  Conference participant connections do not represent
+ * actual radio connections to the participants; they act as a virtual representation of the
+ * participant, keyed by a unique endpoint {@link android.net.Uri}.
+ * <p>
+ * The {@link ImsConference} listens for conference event package data received via the host
+ * connection and is responsible for managing the conference participant connections which represent
+ * the participants.
+ */
+public class ImsConference extends Conference {
+
+    /**
+     * TelephonyConnection class used to represent the connection to the conference server.
+     */
+    private class ConferenceHostConnection extends TelephonyConnection {
+        protected ConferenceHostConnection(
+                com.android.internal.telephony.Connection originalConnection) {
+            super(originalConnection);
+        }
+    }
+
+    /**
+     * Listener used to respond to changes to conference participants.  At the conference level we
+     * are most concerned with handling destruction of a conference participant.
+     */
+    private final Connection.Listener mParticipantListener = new Connection.Listener() {
+        /**
+         * Participant has been destroyed.  Remove it from the conference.
+         *
+         * @param connection The participant which was destroyed.
+         */
+        @Override
+        public void onDestroyed(Connection connection) {
+            ConferenceParticipantConnection participant =
+                    (ConferenceParticipantConnection) connection;
+            removeConferenceParticipant(participant);
+            updateManageConference();
+        }
+
+    };
+
+    /**
+     * Listener used to respond to changes to the underlying radio connection for the conference
+     * host connection.  Used to respond to SRVCC changes.
+     */
+    private final TelephonyConnection.TelephonyConnectionListener mTelephonyConnectionListener =
+            new TelephonyConnection.TelephonyConnectionListener() {
+
+        @Override
+        public void onOriginalConnectionConfigured(TelephonyConnection c) {
+            if (c == mConferenceHost) {
+               handleOriginalConnectionChange();
+            }
+        }
+    };
+
+    /**
+     * Listener used to respond to changes to the connection to the IMS conference server.
+     */
+    private final android.telecom.Connection.Listener mConferenceHostListener =
+            new android.telecom.Connection.Listener() {
+
+        /**
+         * Updates the state of the conference based on the new state of the host.
+         *
+         * @param c The host connection.
+         * @param state The new state
+         */
+        @Override
+        public void onStateChanged(android.telecom.Connection c, int state) {
+            setState(state);
+        }
+
+        /**
+         * Disconnects the conference when its host connection disconnects.
+         *
+         * @param c The host connection.
+         * @param disconnectCause The host connection disconnect cause.
+         */
+        @Override
+        public void onDisconnected(android.telecom.Connection c, DisconnectCause disconnectCause) {
+            setDisconnected(disconnectCause);
+        }
+
+        /**
+         * Handles destruction of the host connection; once the host connection has been
+         * destroyed, cleans up the conference participant connection.
+         *
+         * @param connection The host connection.
+         */
+        @Override
+        public void onDestroyed(android.telecom.Connection connection) {
+            disconnectConferenceParticipants();
+        }
+
+        /**
+         * Handles changes to conference participant data as reported by the conference host
+         * connection.
+         *
+         * @param c The connection.
+         * @param participants The participant information.
+         */
+        @Override
+        public void onConferenceParticipantsChanged(android.telecom.Connection c,
+                List<ConferenceParticipant> participants) {
+
+            if (c == null) {
+                return;
+            }
+            Log.v(this, "onConferenceParticipantsChanged: %d participants", participants.size());
+            TelephonyConnection telephonyConnection = (TelephonyConnection) c;
+            handleConferenceParticipantsUpdate(telephonyConnection, participants);
+        }
+    };
+
+    /**
+     * The telephony connection service; used to add new participant connections to Telecom.
+     */
+    private TelephonyConnectionService mTelephonyConnectionService;
+
+    /**
+     * The connection to the conference server which is hosting the conference.
+     */
+    private TelephonyConnection mConferenceHost;
+
+    /**
+     * The known conference participant connections.  The HashMap is keyed by endpoint Uri.
+     * A {@link ConcurrentHashMap} is used as there is a possibility for radio events impacting the
+     * available participants to occur at the same time as an access via the connection service.
+     */
+    private final ConcurrentHashMap<Uri, ConferenceParticipantConnection>
+            mConferenceParticipantConnections =
+                    new ConcurrentHashMap<Uri, ConferenceParticipantConnection>(8, 0.9f, 1);
+
+    /**
+     * Initializes a new {@link ImsConference}.
+     *
+     * @param telephonyConnectionService The connection service responsible for adding new
+     *                                   conferene participants.
+     * @param conferenceHost The IMS radio connection hosting the conference.
+     */
+    public ImsConference(TelephonyConnectionService telephonyConnectionService,
+            com.android.internal.telephony.Connection conferenceHost) {
+
+        super(null);
+        mTelephonyConnectionService = telephonyConnectionService;
+        setConferenceHost(conferenceHost);
+        setCapabilities(
+                PhoneCapabilities.SUPPORT_HOLD |
+                        PhoneCapabilities.HOLD |
+                        PhoneCapabilities.MUTE
+        );
+    }
+
+    /**
+     * Not used by the IMS conference controller.
+     *
+     * @return {@code Null}.
+     */
+    @Override
+    public android.telecom.Connection getPrimaryConnection() {
+        return null;
+    }
+
+    /**
+     * Invoked when the Conference and all its {@link Connection}s should be disconnected.
+     * <p>
+     * Hangs up the call via the conference host connection.  When the host connection has been
+     * successfully disconnected, the {@link #mConferenceHostListener} listener receives an
+     * {@code onDestroyed} event, which triggers the conference participant connections to be
+     * disconnected.
+     */
+    @Override
+    public void onDisconnect() {
+        Log.v(this, "onDisconnect: hanging up conference host.");
+        if (mConferenceHost == null) {
+            return;
+        }
+
+        Call call = mConferenceHost.getCall();
+        if (call != null) {
+            try {
+                call.hangup();
+            } catch (CallStateException e) {
+                Log.e(this, e, "Exception thrown trying to hangup conference");
+            }
+        }
+    }
+
+    /**
+     * Invoked when the specified {@link android.telecom.Connection} should be separated from the
+     * conference call.
+     * <p>
+     * IMS does not support separating connections from the conference.
+     *
+     * @param connection The connection to separate.
+     */
+    @Override
+    public void onSeparate(android.telecom.Connection connection) {
+        Log.wtf(this, "Cannot separate connections from an IMS conference.");
+    }
+
+    /**
+     * Invoked when the specified {@link android.telecom.Connection} should be merged into the
+     * conference call.
+     *
+     * @param connection The {@code Connection} to merge.
+     */
+    @Override
+    public void onMerge(android.telecom.Connection connection) {
+        try {
+            Phone phone = ((TelephonyConnection) connection).getPhone();
+            if (phone != null) {
+                phone.conference();
+            }
+        } catch (CallStateException e) {
+            Log.e(this, e, "Exception thrown trying to merge call into a conference");
+        }
+    }
+
+    /**
+     * Invoked when the conference should be put on hold.
+     */
+    @Override
+    public void onHold() {
+        if (mConferenceHost == null) {
+            return;
+        }
+        mConferenceHost.performHold();
+    }
+
+    /**
+     * Invoked when the conference should be moved from hold to active.
+     */
+    @Override
+    public void onUnhold() {
+        if (mConferenceHost == null) {
+            return;
+        }
+        mConferenceHost.performUnhold();
+    }
+
+    /**
+     * Invoked to play a DTMF tone.
+     *
+     * @param c A DTMF character.
+     */
+    @Override
+    public void onPlayDtmfTone(char c) {
+        if (mConferenceHost == null) {
+            return;
+        }
+        mConferenceHost.onPlayDtmfTone(c);
+    }
+
+    /**
+     * Invoked to stop playing a DTMF tone.
+     */
+    @Override
+    public void onStopDtmfTone() {
+        if (mConferenceHost == null) {
+            return;
+        }
+        mConferenceHost.onStopDtmfTone();
+    }
+
+    /**
+     * Handles the addition of connections to the {@link ImsConference}.  The
+     * {@link ImsConferenceController} does not add connections to the conference.
+     *
+     * @param connection The newly added connection.
+     */
+    @Override
+    public void onConnectionAdded(android.telecom.Connection connection) {
+        // No-op
+    }
+
+    /**
+     * Updates the manage conference capability of the conference.  Where there are one or more
+     * conference event package participants, the conference management is permitted.  Where there
+     * are no conference event package participants, conference management is not permitted.
+     */
+    private void updateManageConference() {
+        boolean couldManageConference = PhoneCapabilities.can(getCapabilities(),
+                PhoneCapabilities.MANAGE_CONFERENCE);
+        boolean canManageConference = !mConferenceParticipantConnections.isEmpty();
+        Log.v(this, "updateManageConference was:%s is:%s", couldManageConference ? "Y" : "N",
+                canManageConference ? "Y" : "N");
+
+        if (couldManageConference != canManageConference) {
+            int newCapabilities = getCapabilities();
+
+            if (canManageConference) {
+                newCapabilities |= PhoneCapabilities.MANAGE_CONFERENCE;
+            } else {
+                newCapabilities = PhoneCapabilities.remove(newCapabilities,
+                        PhoneCapabilities.MANAGE_CONFERENCE);
+            }
+            setCapabilities(newCapabilities);
+        }
+    }
+
+    /**
+     * Sets the connection hosting the conference and registers for callbacks.
+     *
+     * @param conferenceHost The connection hosting the conference.
+     */
+    private void setConferenceHost(com.android.internal.telephony.Connection conferenceHost) {
+        if (Log.VERBOSE) {
+            Log.v(this, "setConferenceHost " + conferenceHost);
+        }
+
+        mConferenceHost = new ConferenceHostConnection(conferenceHost);
+        mConferenceHost.addConnectionListener(mConferenceHostListener);
+        mConferenceHost.addTelephonyConnectionListener(mTelephonyConnectionListener);
+    }
+
+    /**
+     * Handles state changes for conference participant(s).  The participants data passed in
+     *
+     * @param parent The connection which was notified of the conference participant.
+     * @param participants The conference participant information.
+     */
+    private void handleConferenceParticipantsUpdate(
+            TelephonyConnection parent, List<ConferenceParticipant> participants) {
+
+        boolean newParticipantsAdded = false;
+        boolean oldParticipantsRemoved = false;
+        ArrayList<ConferenceParticipant> newParticipants = new ArrayList<>(participants.size());
+        HashSet<Uri> participantEndpoints = new HashSet<>(participants.size());
+
+        // Add any new participants and update existing.
+        for (ConferenceParticipant participant : participants) {
+            Uri endpoint = participant.getEndpoint();
+            participantEndpoints.add(endpoint);
+            if (!mConferenceParticipantConnections.containsKey(endpoint)) {
+                createConferenceParticipantConnection(parent, participant);
+                newParticipants.add(participant);
+                newParticipantsAdded = true;
+            } else {
+                ConferenceParticipantConnection connection =
+                        mConferenceParticipantConnections.get(endpoint);
+                connection.updateState(participant.getState());
+            }
+        }
+
+        // Set state of new participants.
+        if (newParticipantsAdded) {
+            // Set the state of the new participants at once and add to the conference
+            for (ConferenceParticipant newParticipant : newParticipants) {
+                ConferenceParticipantConnection connection =
+                        mConferenceParticipantConnections.get(newParticipant.getEndpoint());
+                connection.updateState(newParticipant.getState());
+            }
+        }
+
+        // Finally, remove any participants from the conference that no longer exist in the
+        // conference event package data.
+        Iterator<Map.Entry<Uri, ConferenceParticipantConnection>> entryIterator =
+                mConferenceParticipantConnections.entrySet().iterator();
+        while (entryIterator.hasNext()) {
+            Map.Entry<Uri, ConferenceParticipantConnection> entry = entryIterator.next();
+
+            if (!participantEndpoints.contains(entry.getKey())) {
+                ConferenceParticipantConnection participant = entry.getValue();
+                participant.removeConnectionListener(mParticipantListener);
+                removeConnection(participant);
+                entryIterator.remove();
+                oldParticipantsRemoved = true;
+            }
+        }
+
+        // If new participants were added or old ones were removed, we need to ensure the state of
+        // the manage conference capability is updated.
+        if (newParticipantsAdded || oldParticipantsRemoved) {
+            updateManageConference();
+        }
+    }
+
+    /**
+     * Creates a new {@link ConferenceParticipantConnection} to represent a
+     * {@link ConferenceParticipant}.
+     * <p>
+     * The new connection is added to the conference controller and connection service.
+     *
+     * @param parent The connection which was notified of the participant change (e.g. the
+     *                         parent connection).
+     * @param participant The conference participant information.
+     */
+    private void createConferenceParticipantConnection(
+            TelephonyConnection parent, ConferenceParticipant participant) {
+
+        // Create and add the new connection in holding state so that it does not become the
+        // active call.
+        ConferenceParticipantConnection connection = new ConferenceParticipantConnection(
+                parent.getOriginalConnection(), participant);
+        connection.addConnectionListener(mParticipantListener);
+
+        if (Log.VERBOSE) {
+            Log.v(this, "createConferenceParticipantConnection: %s", connection);
+        }
+
+        mConferenceParticipantConnections.put(participant.getEndpoint(), connection);
+        PhoneAccountHandle phoneAccountHandle =
+                TelecomAccountRegistry.makePstnPhoneAccountHandle(parent.getPhone());
+        mTelephonyConnectionService.addExistingConnection(phoneAccountHandle, connection);
+        addConnection(connection);
+    }
+
+    /**
+     * Removes a conference participant from the conference.
+     *
+     * @param participant The participant to remove.
+     */
+    private void removeConferenceParticipant(ConferenceParticipantConnection participant) {
+        if (Log.VERBOSE) {
+            Log.v(this, "removeConferenceParticipant: %s", participant);
+        }
+
+        participant.removeConnectionListener(mParticipantListener);
+        participant.getEndpoint();
+        mConferenceParticipantConnections.remove(participant.getEndpoint());
+    }
+
+    /**
+     * Disconnects all conference participants from the conference.
+     */
+    private void disconnectConferenceParticipants() {
+        Log.v(this, "disconnectConferenceParticipants");
+
+        for (ConferenceParticipantConnection connection :
+                mConferenceParticipantConnections.values()) {
+
+            removeConferenceParticipant(connection);
+
+            // Mark disconnect cause as cancelled to ensure that the call is not logged in the
+            // call log.
+            connection.setDisconnected(new DisconnectCause(DisconnectCause.CANCELED));
+            connection.destroy();
+        }
+        mConferenceParticipantConnections.clear();
+    }
+
+    /**
+     * Handles a change in the original connection backing the conference host connection.  This can
+     * happen if an SRVCC event occurs on the original IMS connection, requiring a fallback to
+     * GSM or CDMA.
+     * <p>
+     * If this happens, we will add the conference host connection to telecom and tear down the
+     * conference.
+     */
+    private void handleOriginalConnectionChange() {
+        if (mConferenceHost == null) {
+            Log.w(this, "handleOriginalConnectionChange; conference host missing.");
+            return;
+        }
+
+        com.android.internal.telephony.Connection originalConnection =
+                mConferenceHost.getOriginalConnection();
+
+        if (!(originalConnection instanceof ImsPhoneConnection)) {
+            if (Log.VERBOSE) {
+                Log.v(this,
+                        "Original connection for conference host is no longer an IMS connection; " +
+                                "new connection: %s", originalConnection);
+            }
+
+            PhoneAccountHandle phoneAccountHandle =
+                    TelecomAccountRegistry.makePstnPhoneAccountHandle(mConferenceHost.getPhone());
+            mTelephonyConnectionService.addExistingConnection(phoneAccountHandle, mConferenceHost);
+            mConferenceHost.removeConnectionListener(mConferenceHostListener);
+            mConferenceHost.removeTelephonyConnectionListener(mTelephonyConnectionListener);
+            mConferenceHost = null;
+            setDisconnected(new DisconnectCause(DisconnectCause.OTHER));
+            destroy();
+        }
+    }
+
+    /**
+     * Changes the state of the Ims conference.
+     *
+     * @param state the new state.
+     */
+    public void setState(int state) {
+        Log.v(this, "setState %s", Connection.stateToString(state));
+
+        switch (state) {
+            case Connection.STATE_INITIALIZING:
+            case Connection.STATE_NEW:
+            case Connection.STATE_RINGING:
+            case Connection.STATE_DIALING:
+                // No-op -- not applicable.
+                break;
+            case Connection.STATE_DISCONNECTED:
+                DisconnectCause disconnectCause;
+                if (mConferenceHost == null) {
+                    disconnectCause = new DisconnectCause(DisconnectCause.CANCELED);
+                } else {
+                    disconnectCause = DisconnectCauseUtil.toTelecomDisconnectCause(
+                            mConferenceHost.getOriginalConnection().getDisconnectCause());
+                }
+                setDisconnected(disconnectCause);
+                destroy();
+                break;
+            case Connection.STATE_ACTIVE:
+                setActive();
+                break;
+            case Connection.STATE_HOLDING:
+                setOnHold();
+                break;
+        }
+    }
+
+    /**
+     * Builds a string representation of the {@link ImsConference}.
+     *
+     * @return String representing the conference.
+     */
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[ImsConference objId:");
+        sb.append(System.identityHashCode(this));
+        sb.append(" state:");
+        sb.append(Connection.stateToString(getState()));
+        sb.append(" hostConnection:");
+        sb.append(mConferenceHost);
+        sb.append(" participants:");
+        sb.append(mConferenceParticipantConnections.size());
+        sb.append("]");
+        return sb.toString();
+    }
+}
diff --git a/src/com/android/services/telephony/ImsConferenceController.java b/src/com/android/services/telephony/ImsConferenceController.java
new file mode 100644
index 0000000..e924687
--- /dev/null
+++ b/src/com/android/services/telephony/ImsConferenceController.java
@@ -0,0 +1,275 @@
+/*
+ * 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.services.telephony;
+
+import android.net.Uri;
+import android.telecom.Conference;
+import android.telecom.Connection;
+import android.telecom.ConnectionService;
+import android.telecom.DisconnectCause;
+import android.telecom.IConferenceable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Manages conferences for IMS connections.
+ */
+public class ImsConferenceController {
+
+    /**
+     * Conference listener; used to receive notification when a conference has been disconnected.
+     */
+    private final Conference.Listener mConferenceListener = new Conference.Listener() {
+        @Override
+        public void onDestroyed(Conference conference) {
+            if (Log.VERBOSE) {
+                Log.v(ImsConferenceController.class, "onDestroyed: %s", conference);
+            }
+
+            mImsConferences.remove(conference);
+        }
+    };
+
+    /**
+     * Ims conference controller connection listener.  Used to respond to changes in state of the
+     * Telephony connections the controller is aware of.
+     */
+    private final Connection.Listener mConnectionListener = new Connection.Listener() {
+        @Override
+        public void onStateChanged(Connection c, int state) {
+            Log.v(this, "onStateChanged: %s", Log.pii(c.getAddress()));
+            recalculate();
+        }
+
+        @Override
+        public void onDisconnected(Connection c, DisconnectCause disconnectCause) {
+            Log.v(this, "onDisconnected: %s", Log.pii(c.getAddress()));
+            recalculate();
+        }
+
+        @Override
+        public void onDestroyed(Connection connection) {
+            remove(connection);
+        }
+    };
+
+    /**
+     * The current {@link ConnectionService}.
+     */
+    private final TelephonyConnectionService mConnectionService;
+
+    /**
+     * List of known {@link TelephonyConnection}s.
+     */
+    private final ArrayList<TelephonyConnection> mTelephonyConnections = new ArrayList<>();
+
+    /**
+     * List of known {@link ImsConference}s.  Realistically there will only ever be a single
+     * concurrent IMS conference.
+     */
+    private final ArrayList<ImsConference> mImsConferences = new ArrayList<>(1);
+
+    /**
+     * Creates a new instance of the Ims conference controller.
+     *
+     * @param connectionService The current connection service.
+     */
+    public ImsConferenceController(TelephonyConnectionService connectionService) {
+        mConnectionService = connectionService;
+    }
+
+    /**
+     * Adds a new connection to the IMS conference controller.
+     *
+     * @param connection
+     */
+    void add(TelephonyConnection connection) {
+        // Note: Wrap in Log.VERBOSE to avoid calling connection.toString if we are not going to be
+        // outputting the value.
+        if (Log.VERBOSE) {
+            Log.v(this, "add connection %s", connection);
+        }
+
+        mTelephonyConnections.add(connection);
+        connection.addConnectionListener(mConnectionListener);
+        recalculateConference();
+    }
+
+    /**
+     * Removes a connection from the IMS conference controller.
+     *
+     * @param connection
+     */
+    void remove(Connection connection) {
+        if (Log.VERBOSE) {
+            Log.v(this, "remove connection: %s", connection);
+        }
+
+        mTelephonyConnections.remove(connection);
+        recalculateConferenceable();
+    }
+
+    /**
+     * Triggers both a re-check of conferenceable connections, as well as checking for new
+     * conferences.
+     */
+    private void recalculate() {
+        recalculateConferenceable();
+        recalculateConference();
+    }
+
+    /**
+     * Calculates the conference-capable state of all GSM connections in this connection service.
+     */
+    private void recalculateConferenceable() {
+        Log.v(this, "recalculateConferenceable : %d", mTelephonyConnections.size());
+        List<IConferenceable> activeConnections = new ArrayList<>(mTelephonyConnections.size());
+        List<IConferenceable> backgroundConnections = new ArrayList<>(mTelephonyConnections.size());
+
+        // Loop through and collect all calls which are active or holding
+        for (Connection connection : mTelephonyConnections) {
+            if (Log.DEBUG) {
+                Log.d(this, "recalc - %s %s", connection.getState(), connection);
+            }
+
+            switch (connection.getState()) {
+                case Connection.STATE_ACTIVE:
+                    activeConnections.add(connection);
+                    continue;
+                case Connection.STATE_HOLDING:
+                    backgroundConnections.add(connection);
+                    continue;
+                default:
+                    break;
+            }
+            connection.setConferenceableConnections(Collections.<Connection>emptyList());
+        }
+
+        for (Conference conference : mImsConferences) {
+            if (Log.DEBUG) {
+                Log.d(this, "recalc - %s %s", conference.getState(), conference);
+            }
+
+            switch (conference.getState()) {
+                case Connection.STATE_ACTIVE:
+                    activeConnections.add(conference);
+                    continue;
+                case Connection.STATE_HOLDING:
+                    backgroundConnections.add(conference);
+                    continue;
+                default:
+                    break;
+            }
+        }
+
+        Log.v(this, "active: %d, holding: %d", activeConnections.size(),
+                backgroundConnections.size());
+
+        // Go through all the active connections and set the background connections as
+        // conferenceable.
+        for (IConferenceable conferenceable : activeConnections) {
+            if (conferenceable instanceof Connection) {
+                Connection connection = (Connection) conferenceable;
+                connection.setConferenceables(backgroundConnections);
+            }
+        }
+
+        // Go through all the background connections and set the active connections as
+        // conferenceable.
+        for (IConferenceable conferenceable : backgroundConnections) {
+            if (conferenceable instanceof Connection) {
+                Connection connection = (Connection) conferenceable;
+                connection.setConferenceables(activeConnections);
+            }
+
+        }
+
+        // Set the conference as conferenceable with all the connections
+        for (ImsConference conference : mImsConferences) {
+            List<Connection> nonConferencedConnections =
+                new ArrayList<>(mTelephonyConnections.size());
+            for (Connection c : mTelephonyConnections) {
+                if (c.getConference() == null) {
+                    nonConferencedConnections.add(c);
+                }
+            }
+            if (Log.VERBOSE) {
+                Log.v(this, "conference conferenceable: %s", nonConferencedConnections);
+            }
+            conference.setConferenceableConnections(nonConferencedConnections);
+        }
+    }
+
+    /**
+     * Starts a new ImsConference for a connection which just entered a multiparty state.
+     */
+    private void recalculateConference() {
+        Log.v(this, "recalculateConference");
+
+        Iterator<TelephonyConnection> it = mTelephonyConnections.iterator();
+        while (it.hasNext()) {
+            TelephonyConnection connection = it.next();
+
+            if (connection.isImsConnection() && connection.getOriginalConnection() != null &&
+                    connection.getOriginalConnection().isMultiparty()) {
+
+                startConference(connection);
+                it.remove();
+            }
+        }
+    }
+
+    /**
+     * Starts a new {@link ImsConference} for the given IMS connection.
+     * <p>
+     * Creates a new IMS Conference to manage the conference represented by the connection.
+     * Internally the ImsConference wraps the radio connection with a new TelephonyConnection
+     * which is NOT reported to the connection service and Telecom.
+     * <p>
+     * Once the new IMS Conference has been created, the connection passed in is held and removed
+     * from the connection service (removing it from Telecom).  The connection is put into a held
+     * state to ensure that telecom removes the connection without putting it into a disconnected
+     * state first.
+     *
+     * @param connection The connection to the Ims server.
+     */
+    private void startConference(TelephonyConnection connection) {
+        com.android.internal.telephony.Connection originalConnection =
+                connection.getOriginalConnection();
+        if (Log.VERBOSE) {
+            Log.v(this, "Start new ImsConference - connection: %s", connection);
+        }
+
+        // Create conference and add to telecom
+        ImsConference conference = new ImsConference(mConnectionService, originalConnection);
+        conference.setState(connection.getState());
+        mConnectionService.addConference(conference);
+        conference.addListener(mConferenceListener);
+
+        // Cleanup TelephonyConnection which backed the original connection and remove from telecom.
+        // Use the "Other" disconnect cause to ensure the call is logged to the call log but the
+        // disconnect tone is not played.
+        connection.removeConnectionListener(mConnectionListener);
+        connection.clearOriginalConnection();
+        connection.setDisconnected(new DisconnectCause(DisconnectCause.OTHER));
+        connection.destroy();
+        mImsConferences.add(conference);
+    }
+}
diff --git a/src/com/android/services/telephony/TelephonyConference.java b/src/com/android/services/telephony/TelephonyConference.java
index fc009bc..3a80097 100644
--- a/src/com/android/services/telephony/TelephonyConference.java
+++ b/src/com/android/services/telephony/TelephonyConference.java
@@ -33,12 +33,6 @@
  */
 public class TelephonyConference extends Conference {
 
-    /**
-     * When {@code true}, indicates that conference participant information from an IMS conference
-     * event package has been received.
-     */
-    private boolean mParticipantsReceived = false;
-
     public TelephonyConference(PhoneAccountHandle phoneAccount) {
         super(phoneAccount);
         setCapabilities(
@@ -55,20 +49,33 @@
     @Override
     public void onDisconnect() {
         for (Connection connection : getConnections()) {
-            Call call = getMultipartyCallForConnection(connection, "onDisconnect");
-            if (call != null) {
-                Log.d(this, "Found multiparty call to hangup for conference.");
-                try {
-                    call.hangup();
-                    break;
-                } catch (CallStateException e) {
-                    Log.e(this, e, "Exception thrown trying to hangup conference");
-                }
+            if (disconnectCall(connection)) {
+                break;
             }
         }
     }
 
     /**
+     * Disconnect the underlying Telephony Call for a connection.
+     *
+     * @param connection The connection.
+     * @return {@code True} if the call was disconnected.
+     */
+    private boolean disconnectCall(Connection connection) {
+        Call call = getMultipartyCallForConnection(connection, "onDisconnect");
+        if (call != null) {
+            Log.d(this, "Found multiparty call to hangup for conference.");
+            try {
+                call.hangup();
+                return true;
+            } catch (CallStateException e) {
+                Log.e(this, e, "Exception thrown trying to hangup conference");
+            }
+        }
+        return false;
+    }
+
+    /**
      * Invoked when the specified {@link Connection} should be separated from the conference call.
      *
      * @param connection The connection to separate.
@@ -140,8 +147,7 @@
         // as the default behavior. If there is a conference event package, this may be overridden.
         // If a conference event package was received, do not attempt to remove manage conference.
         if (connection instanceof TelephonyConnection &&
-                ((TelephonyConnection) connection).wasImsConnection() &&
-                !mParticipantsReceived) {
+                ((TelephonyConnection) connection).wasImsConnection()) {
             int capabilities = getCapabilities();
             if (PhoneCapabilities.can(capabilities, PhoneCapabilities.MANAGE_CONFERENCE)) {
                 int newCapabilities =
@@ -153,11 +159,17 @@
 
     @Override
     public Connection getPrimaryConnection() {
+
+        List<Connection> connections = getConnections();
+        if (connections == null || connections.isEmpty()) {
+            return null;
+        }
+
         // Default to the first connection.
-        Connection primaryConnection = getConnections().get(0);
+        Connection primaryConnection = connections.get(0);
 
         // Otherwise look for a connection where the radio connection states it is multiparty.
-        for (Connection connection : getConnections()) {
+        for (Connection connection : connections) {
             com.android.internal.telephony.Connection radioConnection =
                     getOriginalConnection(connection);
 
@@ -182,7 +194,7 @@
         return null;
     }
 
-    private com.android.internal.telephony.Connection getOriginalConnection(
+    protected com.android.internal.telephony.Connection getOriginalConnection(
             Connection connection) {
 
         if (connection instanceof TelephonyConnection) {
@@ -199,17 +211,4 @@
         }
         return (TelephonyConnection) connections.get(0);
     }
-
-    /**
-     * Flags the conference to indicate that a conference event package has been received and there
-     * is now participant data present which would permit conference management.
-     */
-    public void setParticipantsReceived() {
-        if (!mParticipantsReceived) {
-            int capabilities = getCapabilities();
-            capabilities |= PhoneCapabilities.MANAGE_CONFERENCE;
-            setCapabilities(capabilities);
-        }
-        mParticipantsReceived = true;
-    }
 }
diff --git a/src/com/android/services/telephony/TelephonyConferenceController.java b/src/com/android/services/telephony/TelephonyConferenceController.java
index 55c8338..2af10a6 100644
--- a/src/com/android/services/telephony/TelephonyConferenceController.java
+++ b/src/com/android/services/telephony/TelephonyConferenceController.java
@@ -59,36 +59,11 @@
         public void onDestroyed(Connection connection) {
             remove(connection);
         }
-
-        /**
-         * Handles notifications from an connection that participant(s) in a conference have changed
-         * state.
-         *
-         * @param c The connection.
-         * @param participants The participant information.
-         */
-        @Override
-        public void onConferenceParticipantsChanged(Connection c,
-                List<ConferenceParticipant> participants) {
-
-            if (c == null) {
-                return;
-            }
-            Log.v(this, "onConferenceParticipantsChanged: %d participants", participants.size());
-            TelephonyConnection telephonyConnection = (TelephonyConnection) c;
-            handleConferenceParticipantsUpdate(telephonyConnection, participants);
-        }
     };
 
     /** The known connections. */
     private final List<TelephonyConnection> mTelephonyConnections = new ArrayList<>();
 
-    /**
-     * The known conference participant connections.  The HashMap is keyed by endpoint Uri.
-     */
-    private final HashMap<Uri, ConferenceParticipantConnection> mConferenceParticipantConnections =
-            new HashMap<>();
-
     private final TelephonyConnectionService mConnectionService;
 
     public TelephonyConferenceController(TelephonyConnectionService connectionService) {
@@ -106,12 +81,7 @@
 
     void remove(Connection connection) {
         connection.removeConnectionListener(mConnectionListener);
-
-        if (connection instanceof ConferenceParticipantConnection) {
-            mConferenceParticipantConnections.remove(connection);
-        } else {
-            mTelephonyConnections.remove(connection);
-        }
+        mTelephonyConnections.remove(connection);
 
         recalculate();
     }
@@ -192,9 +162,7 @@
 
     private void recalculateConference() {
         Set<Connection> conferencedConnections = new HashSet<>();
-
         int numGsmConnections = 0;
-        int numImsConnections = 0;
 
         for (TelephonyConnection connection : mTelephonyConnections) {
             com.android.internal.telephony.Connection radioConnection =
@@ -206,11 +174,7 @@
                 if ((state == Call.State.ACTIVE || state == Call.State.HOLDING) &&
                         (call != null && call.isMultiparty())) {
 
-                    if (radioConnection instanceof GsmConnection) {
-                        numGsmConnections++;
-                    } else if (radioConnection instanceof ImsPhoneConnection) {
-                        numImsConnections++;
-                    }
+                    numGsmConnections++;
                     conferencedConnections.add(connection);
                 }
             }
@@ -219,18 +183,11 @@
         Log.d(this, "Recalculate conference calls %s %s.",
                 mTelephonyConference, conferencedConnections);
 
-        boolean wasParticipantsAdded = false;
-
-        // If the number of telephony connections drops below the limit, the conference can be
-        // considered terminated.
-        // We must have less than 2 GSM connections and less than 1 IMS connection.
-        if (numGsmConnections < 2 && numImsConnections < 1) {
+        // If this is a GSM conference and the number of connections drops below 2, we will
+        // terminate the conference.
+        if (numGsmConnections < 2) {
             Log.d(this, "not enough connections to be a conference!");
 
-            // The underlying telephony connections have been disconnected -- disconnect the
-            // conference participants now.
-            disconnectConferenceParticipants();
-
             // No more connections are conferenced, destroy any existing conference.
             if (mTelephonyConference != null) {
                 Log.d(this, "with a conference to destroy!");
@@ -254,131 +211,30 @@
                         mTelephonyConference.addConnection(connection);
                     }
                 }
-
-                // Add new conference participants
-                for (Connection conferenceParticipant :
-                        mConferenceParticipantConnections.values()) {
-
-                    if (conferenceParticipant.getState() == Connection.STATE_NEW) {
-                        if (!existingConnections.contains(conferenceParticipant)) {
-                            wasParticipantsAdded = true;
-                            mTelephonyConference.addConnection(conferenceParticipant);
-                        }
-                    }
-                }
             } else {
                 mTelephonyConference = new TelephonyConference(null);
+
                 for (Connection connection : conferencedConnections) {
                     Log.d(this, "Adding a connection to a conference call: %s %s",
                             mTelephonyConference, connection);
                     mTelephonyConference.addConnection(connection);
                 }
 
-                // Add the conference participants
-                for (Connection conferenceParticipant :
-                        mConferenceParticipantConnections.values()) {
-                    wasParticipantsAdded = true;
-                    mTelephonyConference.addConnection(conferenceParticipant);
-                }
-
                 mConnectionService.addConference(mTelephonyConference);
             }
 
-            // If we added conference participants (e.g. via an IMS conference event package),
-            // notify the conference so that the MANAGE_CONFERENCE capability can be added.
-            if (wasParticipantsAdded) {
-                mTelephonyConference.setParticipantsReceived();
-            }
-
             // Set the conference state to the same state as its child connections.
             Connection conferencedConnection = mTelephonyConference.getPrimaryConnection();
-            switch (conferencedConnection.getState()) {
-                case Connection.STATE_ACTIVE:
-                    mTelephonyConference.setActive();
-                    break;
-                case Connection.STATE_HOLDING:
-                    mTelephonyConference.setOnHold();
-                    break;
+            if (conferencedConnection != null) {
+                switch (conferencedConnection.getState()) {
+                    case Connection.STATE_ACTIVE:
+                        mTelephonyConference.setActive();
+                        break;
+                    case Connection.STATE_HOLDING:
+                        mTelephonyConference.setOnHold();
+                        break;
+                }
             }
         }
     }
-
-    /**
-     * Disconnects all conference participants from the conference.
-     */
-    private void disconnectConferenceParticipants() {
-        for (Connection connection : mConferenceParticipantConnections.values()) {
-            // Disconnect listener so that the connection doesn't fire events on the conference
-            // controller, causing a recursive call.
-            connection.removeConnectionListener(mConnectionListener);
-            mConferenceParticipantConnections.remove(connection);
-
-            // Mark disconnect cause as cancelled to ensure that the call is not logged in the
-            // call log.
-            connection.setDisconnected(new DisconnectCause(DisconnectCause.CANCELED));
-            connection.destroy();
-        }
-    }
-
-    /**
-     * Handles state changes for conference participant(s).
-     *
-     * @param parent The connection which was notified of the conference participant.
-     * @param participants The conference participant information.
-     */
-    private void handleConferenceParticipantsUpdate(
-            TelephonyConnection parent, List<ConferenceParticipant> participants) {
-
-        boolean recalculateConference = false;
-        ArrayList<ConferenceParticipant> newParticipants = new ArrayList<>(participants.size());
-
-        for (ConferenceParticipant participant : participants) {
-            Uri endpoint = participant.getEndpoint();
-            if (!mConferenceParticipantConnections.containsKey(endpoint)) {
-                createConferenceParticipantConnection(parent, participant);
-                newParticipants.add(participant);
-                recalculateConference = true;
-            } else {
-                ConferenceParticipantConnection connection =
-                        mConferenceParticipantConnections.get(endpoint);
-                connection.updateState(participant.getState());
-            }
-        }
-
-        if (recalculateConference) {
-            // Recalculate to add new connections to the conference.
-            recalculateConference();
-
-            // Now that conference is established, set the state for all participants.
-            for (ConferenceParticipant newParticipant : newParticipants) {
-                ConferenceParticipantConnection connection =
-                        mConferenceParticipantConnections.get(newParticipant.getEndpoint());
-                connection.updateState(newParticipant.getState());
-            }
-        }
-    }
-
-    /**
-     * Creates a new {@link ConferenceParticipantConnection} to represent a
-     * {@link ConferenceParticipant}.
-     * <p>
-     * The new connection is added to the conference controller and connection service.
-     *
-     * @param parent The connection which was notified of the participant change (e.g. the
-     *                         parent connection).
-     * @param participant The conference participant information.
-     */
-    private void createConferenceParticipantConnection(
-            TelephonyConnection parent, ConferenceParticipant participant) {
-
-        // Create and add the new connection in holding state so that it does not become the
-        // active call.
-        ConferenceParticipantConnection connection = new ConferenceParticipantConnection(
-                parent, participant);
-        connection.addConnectionListener(mConnectionListener);
-        mConferenceParticipantConnections.put(participant.getEndpoint(), connection);
-        PhoneAccountHandle phoneAccountHandle =
-                 TelecomAccountRegistry.makePstnPhoneAccountHandle(parent.getPhone());
-        mConnectionService.addExistingConnection(phoneAccountHandle, connection);
-    }
 }
diff --git a/src/com/android/services/telephony/TelephonyConnection.java b/src/com/android/services/telephony/TelephonyConnection.java
index 056f62f..77a76d0 100644
--- a/src/com/android/services/telephony/TelephonyConnection.java
+++ b/src/com/android/services/telephony/TelephonyConnection.java
@@ -24,6 +24,7 @@
 import android.telecom.Conference;
 import android.telecom.ConferenceParticipant;
 import android.telecom.Connection;
+import android.telecom.DisconnectCause;
 import android.telecom.PhoneAccount;
 import android.telecom.PhoneCapabilities;
 
@@ -31,6 +32,9 @@
 import com.android.internal.telephony.CallStateException;
 import com.android.internal.telephony.Connection.PostDialListener;
 import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.cdma.CdmaCall;
+import com.android.internal.telephony.gsm.*;
+import com.android.internal.telephony.gsm.GsmConnection;
 import com.android.internal.telephony.imsphone.ImsPhoneConnection;
 
 import java.lang.Override;
@@ -442,12 +446,8 @@
 
     void setOriginalConnection(com.android.internal.telephony.Connection originalConnection) {
         Log.v(this, "new TelephonyConnection, originalConnection: " + originalConnection);
-        if (mOriginalConnection != null) {
-            getPhone().unregisterForPreciseCallStateChanged(mHandler);
-            getPhone().unregisterForRingbackTone(mHandler);
-            getPhone().unregisterForHandoverStateChanged(mHandler);
-            getPhone().unregisterForDisconnect(mHandler);
-        }
+        clearOriginalConnection();
+
         mOriginalConnection = originalConnection;
         getPhone().registerForPreciseCallStateChanged(
                 mHandler, MSG_PRECISE_CALL_STATE_CHANGED, null);
@@ -473,6 +473,19 @@
         updateAddress();
     }
 
+    /**
+     * Un-sets the underlying radio connection.
+     */
+    void clearOriginalConnection() {
+        if (mOriginalConnection != null) {
+            getPhone().unregisterForPreciseCallStateChanged(mHandler);
+            getPhone().unregisterForRingbackTone(mHandler);
+            getPhone().unregisterForHandoverStateChanged(mHandler);
+            getPhone().unregisterForDisconnect(mHandler);
+            mOriginalConnection = null;
+        }
+    }
+
     protected void hangup(int telephonyDisconnectCode) {
         if (mOriginalConnection != null) {
             try {
@@ -871,4 +884,41 @@
             l.onOriginalConnectionConfigured(this);
         }
     }
+
+    /**
+     * Creates a string representation of this {@link TelephonyConnection}.  Primarily intended for
+     * use in log statements.
+     *
+     * @return String representation of the connection.
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[TelephonyConnection objId:");
+        sb.append(System.identityHashCode(this));
+        sb.append(" type:");
+        if (isImsConnection()) {
+            sb.append("ims");
+        } else if (this instanceof com.android.services.telephony.GsmConnection) {
+            sb.append("gsm");
+        } else if (this instanceof CdmaConnection) {
+            sb.append("cdma");
+        }
+        sb.append(" state:");
+        sb.append(Connection.stateToString(getState()));
+        sb.append(" capabilities:");
+        sb.append(PhoneCapabilities.toString(getCallCapabilities()));
+        sb.append(" address:");
+        sb.append(Log.pii(getAddress()));
+        sb.append(" originalConnection:");
+        sb.append(mOriginalConnection);
+        sb.append(" partOfConf:");
+        if (getConference() == null) {
+            sb.append("N");
+        } else {
+            sb.append("Y");
+        }
+        sb.append("]");
+        return sb.toString();
+    }
 }
diff --git a/src/com/android/services/telephony/TelephonyConnectionService.java b/src/com/android/services/telephony/TelephonyConnectionService.java
index 8ef9ae8..7ce5005 100644
--- a/src/com/android/services/telephony/TelephonyConnectionService.java
+++ b/src/com/android/services/telephony/TelephonyConnectionService.java
@@ -52,6 +52,8 @@
             new TelephonyConferenceController(this);
     private final CdmaConferenceController mCdmaConferenceController =
             new CdmaConferenceController(this);
+    private final ImsConferenceController mImsConferenceController =
+            new ImsConferenceController(this);
     private ComponentName mExpectedComponentName = null;
     private EmergencyCallHelper mEmergencyCallHelper;
     private EmergencyTonePlayer mEmergencyTonePlayer;
@@ -448,7 +450,7 @@
         // conference controllers first before re-adding it.
         if (connection.isImsConnection()) {
             Log.d(this, "Adding IMS connection to conference controller: " + connection);
-            mTelephonyConferenceController.add(connection);
+            mImsConferenceController.add(connection);
         } else {
             int phoneType = connection.getCall().getPhone().getPhoneType();
             if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {