diff --git a/src/com/android/phone/CallFeaturesSetting.java b/src/com/android/phone/CallFeaturesSetting.java
index 88de152..bb23292 100644
--- a/src/com/android/phone/CallFeaturesSetting.java
+++ b/src/com/android/phone/CallFeaturesSetting.java
@@ -465,6 +465,11 @@
      */
     private boolean mReadingSettingsForDefaultProvider = false;
 
+    /**
+     * Used to indicate that the voicemail preference should be shown.
+     */
+    private boolean mShowVoicemailPreference = false;
+
     /*
      * Click Listeners, handle click based on objects attached to UI.
      */
@@ -603,6 +608,22 @@
         return false;
     }
 
+    /**
+     * Called just prior to showing an AccountSelection dialog to re-populate the model of the
+     * AccountSelection dialog.  Important to ensure changes to the enabled state of
+     * {@code PhoneAccount}s are reflected in the dialog.
+     *
+     * @param pref The account selection preference dialog being shown.
+     */
+    @Override
+    public void onAccountSelectionDialogShow(AccountSelectionPreference pref) {
+        if (pref == mDefaultOutgoingAccount) {
+            populateDefaultOutgoingAccountsModel();
+        } else if (pref == mSimCallManagerAccount) {
+            populateSimCallManagerAccountsModel();
+        }
+    }
+
     @Override
     public void onDialogClosed(EditPhoneNumberPreference preference, int buttonClicked) {
         if (DBG) log("onPreferenceClick: request preference click on dialog close: " +
@@ -1509,13 +1530,121 @@
         super.onCreate(icicle);
         if (DBG) log("onCreate(). Intent: " + getIntent());
         mPhone = PhoneGlobals.getPhone();
+        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
+
+        // create intent to bring up contact list
+        mContactListIntent = new Intent(Intent.ACTION_GET_CONTENT);
+        mContactListIntent.setType(android.provider.Contacts.Phones.CONTENT_ITEM_TYPE);
+
+        mVoicemailRingtoneLookupRunnable = new Runnable() {
+            @Override
+            public void run() {
+                if (mVoicemailNotificationRingtone != null) {
+                    SettingsUtil.updateRingtoneName(
+                            mPhone.getContext(),
+                            mVoicemailRingtoneLookupComplete,
+                            RingtoneManager.TYPE_NOTIFICATION,
+                            mVoicemailNotificationRingtone,
+                            MSG_UPDATE_VOICEMAIL_RINGTONE_SUMMARY);
+                }
+            }
+        };
+
+        ActionBar actionBar = getActionBar();
+        if (actionBar != null) {
+            // android.R.id.home will be triggered in onOptionsItemSelected()
+            actionBar.setDisplayShowHomeEnabled(true);
+            actionBar.setDisplayHomeAsUpEnabled(true);
+            actionBar.setDisplayShowTitleEnabled(true);
+        }
+
+        // Show the voicemail preference in onResume if the calling intent specifies the
+        // ACTION_ADD_VOICEMAIL action.
+        mShowVoicemailPreference = (icicle == null) &&
+                getIntent().getAction().equals(ACTION_ADD_VOICEMAIL);
+    }
+
+    private void initPhoneAccountPreferences() {
+        mDefaultOutgoingAccount = (AccountSelectionPreference)
+                findPreference(DEFAULT_OUTGOING_ACCOUNT_KEY);
+        mSimCallManagerAccount = (AccountSelectionPreference)
+                findPreference(WIFI_CALL_MANAGER_ACCOUNT_KEY);
+
+        TelecommManager telecommManager = TelecommManager.from(this);
+
+        int allPhoneAccountsCount = telecommManager.getAllPhoneAccountsCount();
+        // Show the phone accounts preference if there are is more than one phone account (this
+        // includes disabled phone accounts).  The default selection, however, only includes those
+        // PhoneAccounts which are enabled.
+        if (allPhoneAccountsCount > 1) {
+            populateDefaultOutgoingAccountsModel();
+
+            mDefaultOutgoingAccount.setListener(this);
+        } else {
+            getPreferenceScreen().removePreference(mDefaultOutgoingAccount);
+        }
+
+        List<PhoneAccountHandle> simCallManagers = telecommManager.getSimCallManagers();
+        if (!simCallManagers.isEmpty()) {
+            populateSimCallManagerAccountsModel();
+            mSimCallManagerAccount.setListener(this);
+        } else {
+            getPreferenceScreen().removePreference(mSimCallManagerAccount);
+        }
+    }
+
+    private void createSipCallSettings() {
+        // Add Internet call settings.
+        if (SipUtil.isVoipSupported(this)) {
+            mSipManager = SipManager.newInstance(this);
+            mSipSharedPreferences = new SipSharedPreferences(this);
+            addPreferencesFromResource(
+                    com.android.services.telephony.sip.R.xml.sip_settings_category);
+            mButtonSipCallOptions = getSipCallOptionPreference();
+            mButtonSipCallOptions.setOnPreferenceChangeListener(this);
+            mButtonSipCallOptions.setValueIndex(
+                    mButtonSipCallOptions.findIndexOfValue(
+                            mSipSharedPreferences.getSipCallOption()));
+            mButtonSipCallOptions.setSummary(mButtonSipCallOptions.getEntry());
+        }
+    }
+
+    private boolean canLaunchIntent(Intent intent) {
+        PackageManager pm = getPackageManager();
+        return pm.resolveActivity(intent, PackageManager.GET_ACTIVITIES) != null;
+    }
+
+    // Gets the call options for SIP depending on whether SIP is allowed only
+    // on Wi-Fi only; also make the other options preference invisible.
+    private ListPreference getSipCallOptionPreference() {
+        ListPreference wifiAnd3G = (ListPreference)
+                findPreference(BUTTON_SIP_CALL_OPTIONS);
+        ListPreference wifiOnly = (ListPreference)
+                findPreference(BUTTON_SIP_CALL_OPTIONS_WIFI_ONLY);
+        PreferenceScreen sipSettings = (PreferenceScreen)
+                getPreferenceScreen().findPreference(SIP_SETTINGS_PREFERENCE_SCREEN_KEY);
+        if (SipManager.isSipWifiOnly(this)) {
+            sipSettings.removePreference(wifiAnd3G);
+            return wifiOnly;
+        } else {
+            sipSettings.removePreference(wifiOnly);
+            return wifiAnd3G;
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mForeground = true;
+
+        PreferenceScreen preferenceScreen = getPreferenceScreen();
+        if (preferenceScreen != null) {
+            preferenceScreen.removeAll();
+        }
 
         addPreferencesFromResource(R.xml.call_feature_setting);
-
         initPhoneAccountPreferences();
 
-        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
-
         // get buttons
         PreferenceScreen prefSet = getPreferenceScreen();
         mSubMenuVoicemailSettings = (EditPhoneNumberPreference)findPreference(BUTTON_VOICEMAIL_KEY);
@@ -1541,7 +1670,6 @@
             initVoiceMailProviders();
         }
 
-        final ContentResolver contentResolver = getContentResolver();
 
         if (mButtonDTMF != null) {
             if (getResources().getBoolean(R.bool.dtmf_type_enabled)) {
@@ -1609,134 +1737,29 @@
             }
         }
 
-        // create intent to bring up contact list
-        mContactListIntent = new Intent(Intent.ACTION_GET_CONTENT);
-        mContactListIntent.setType(android.provider.Contacts.Phones.CONTENT_ITEM_TYPE);
-
         // check the intent that started this activity and pop up the voicemail
         // dialog if we've been asked to.
         // If we have at least one non default VM provider registered then bring up
         // the selection for the VM provider, otherwise bring up a VM number dialog.
         // We only bring up the dialog the first time we are called (not after orientation change)
-        if (icicle == null) {
-            if (getIntent().getAction().equals(ACTION_ADD_VOICEMAIL) &&
-                    mVoicemailProviders != null) {
-                if (DBG) {
-                    log("ACTION_ADD_VOICEMAIL Intent is thrown. current VM data size: "
-                            + mVMProvidersData.size());
-                }
-                if (mVMProvidersData.size() > 1) {
-                    simulatePreferenceClick(mVoicemailProviders);
-                } else {
-                    onPreferenceChange(mVoicemailProviders, DEFAULT_VM_PROVIDER_KEY);
-                    mVoicemailProviders.setValue(DEFAULT_VM_PROVIDER_KEY);
-                }
+        if (mShowVoicemailPreference && mVoicemailProviders != null) {
+            if (DBG) {
+                log("ACTION_ADD_VOICEMAIL Intent is thrown. current VM data size: "
+                        + mVMProvidersData.size());
             }
+            if (mVMProvidersData.size() > 1) {
+                simulatePreferenceClick(mVoicemailProviders);
+            } else {
+                onPreferenceChange(mVoicemailProviders, DEFAULT_VM_PROVIDER_KEY);
+                mVoicemailProviders.setValue(DEFAULT_VM_PROVIDER_KEY);
+            }
+            mShowVoicemailPreference = false;
         }
+
         updateVoiceNumberField();
         mVMProviderSettingsForced = false;
         createSipCallSettings();
 
-        mVoicemailRingtoneLookupRunnable = new Runnable() {
-            @Override
-            public void run() {
-                if (mVoicemailNotificationRingtone != null) {
-                    SettingsUtil.updateRingtoneName(
-                            mPhone.getContext(),
-                            mVoicemailRingtoneLookupComplete,
-                            RingtoneManager.TYPE_NOTIFICATION,
-                            mVoicemailNotificationRingtone,
-                            MSG_UPDATE_VOICEMAIL_RINGTONE_SUMMARY);
-                }
-            }
-        };
-
-        ActionBar actionBar = getActionBar();
-        if (actionBar != null) {
-            // android.R.id.home will be triggered in onOptionsItemSelected()
-            actionBar.setDisplayShowHomeEnabled(true);
-            actionBar.setDisplayHomeAsUpEnabled(true);
-            actionBar.setDisplayShowTitleEnabled(true);
-        }
-    }
-
-    private void initPhoneAccountPreferences() {
-        mDefaultOutgoingAccount = (AccountSelectionPreference)
-                findPreference(DEFAULT_OUTGOING_ACCOUNT_KEY);
-        mSimCallManagerAccount = (AccountSelectionPreference)
-                findPreference(WIFI_CALL_MANAGER_ACCOUNT_KEY);
-
-        TelecommManager telecommManager = TelecommManager.from(this);
-
-        List<PhoneAccountHandle> enabledPhoneAccounts = telecommManager.getEnabledPhoneAccounts();
-        if (enabledPhoneAccounts.size() > 1) {
-            mDefaultOutgoingAccount.setModel(
-                    telecommManager,
-                    enabledPhoneAccounts,
-                    telecommManager.getUserSelectedOutgoingPhoneAccount(),
-                    getString(R.string.phone_accounts_ask_every_time));
-            mDefaultOutgoingAccount.setListener(this);
-        } else {
-            getPreferenceScreen().removePreference(mDefaultOutgoingAccount);
-        }
-
-        List<PhoneAccountHandle> simCallManagers = telecommManager.getSimCallManagers();
-        if (!simCallManagers.isEmpty()) {
-            mSimCallManagerAccount.setModel(
-                    telecommManager,
-                    simCallManagers,
-                    telecommManager.getSimCallManager(),
-                    getString(R.string.wifi_calling_do_not_use));
-            mSimCallManagerAccount.setListener(this);
-        } else {
-            getPreferenceScreen().removePreference(mSimCallManagerAccount);
-        }
-    }
-
-    private void createSipCallSettings() {
-        // Add Internet call settings.
-        if (SipUtil.isVoipSupported(this)) {
-            mSipManager = SipManager.newInstance(this);
-            mSipSharedPreferences = new SipSharedPreferences(this);
-            addPreferencesFromResource(
-                    com.android.services.telephony.sip.R.xml.sip_settings_category);
-            mButtonSipCallOptions = getSipCallOptionPreference();
-            mButtonSipCallOptions.setOnPreferenceChangeListener(this);
-            mButtonSipCallOptions.setValueIndex(
-                    mButtonSipCallOptions.findIndexOfValue(
-                            mSipSharedPreferences.getSipCallOption()));
-            mButtonSipCallOptions.setSummary(mButtonSipCallOptions.getEntry());
-        }
-    }
-
-    private boolean canLaunchIntent(Intent intent) {
-        PackageManager pm = getPackageManager();
-        return pm.resolveActivity(intent, PackageManager.GET_ACTIVITIES) != null;
-    }
-
-    // Gets the call options for SIP depending on whether SIP is allowed only
-    // on Wi-Fi only; also make the other options preference invisible.
-    private ListPreference getSipCallOptionPreference() {
-        ListPreference wifiAnd3G = (ListPreference)
-                findPreference(BUTTON_SIP_CALL_OPTIONS);
-        ListPreference wifiOnly = (ListPreference)
-                findPreference(BUTTON_SIP_CALL_OPTIONS_WIFI_ONLY);
-        PreferenceScreen sipSettings = (PreferenceScreen)
-                getPreferenceScreen().findPreference(SIP_SETTINGS_PREFERENCE_SCREEN_KEY);
-        if (SipManager.isSipWifiOnly(this)) {
-            sipSettings.removePreference(wifiAnd3G);
-            return wifiOnly;
-        } else {
-            sipSettings.removePreference(wifiOnly);
-            return wifiAnd3G;
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        mForeground = true;
-
         if (isAirplaneModeOn()) {
             Preference sipSettings = findPreference(SIP_SETTINGS_PREFERENCE_SCREEN_KEY);
             PreferenceScreen screen = getPreferenceScreen();
@@ -2117,6 +2140,41 @@
     }
 
     /**
+     * Populates the phone accounts which could potentially be selected as the default.
+     */
+    private void populateDefaultOutgoingAccountsModel() {
+        if (mDefaultOutgoingAccount == null ) {
+            return;
+        }
+
+        TelecommManager telecommManager = TelecommManager.from(this);
+        List<PhoneAccountHandle> enabledPhoneAccounts = telecommManager.getEnabledPhoneAccounts();
+        mDefaultOutgoingAccount.setModel(
+                telecommManager,
+                enabledPhoneAccounts,
+                telecommManager.getUserSelectedOutgoingPhoneAccount(),
+                getString(R.string.phone_accounts_ask_every_time));
+    }
+
+    /**
+     * Populates the phone accounts which could potentially be selected as the default sim call
+     * manager.
+     */
+    private void populateSimCallManagerAccountsModel() {
+        if (mSimCallManagerAccount == null) {
+            return;
+        }
+
+        TelecommManager telecommManager = TelecommManager.from(this);
+        List<PhoneAccountHandle> simCallManagers = telecommManager.getSimCallManagers();
+        mSimCallManagerAccount.setModel(
+                telecommManager,
+                simCallManagers,
+                telecommManager.getSimCallManager(),
+                getString(R.string.wifi_calling_do_not_use));
+    }
+
+    /**
      * Deletes settings for the specified provider.
      */
     private void deleteSettingsForVoicemailProvider(String key) {
diff --git a/src/com/android/phone/settings/AccountSelectionPreference.java b/src/com/android/phone/settings/AccountSelectionPreference.java
index 32149ae..8469a18 100644
--- a/src/com/android/phone/settings/AccountSelectionPreference.java
+++ b/src/com/android/phone/settings/AccountSelectionPreference.java
@@ -16,7 +16,13 @@
 
 package com.android.phone.settings;
 
+import com.android.phone.R;
+
+import android.app.AlertDialog;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.UserHandle;
 import android.preference.ListPreference;
 import android.preference.Preference;
 import android.telecomm.PhoneAccountHandle;
@@ -31,8 +37,10 @@
 
     public interface AccountSelectionListener {
         boolean onAccountSelected(AccountSelectionPreference pref, PhoneAccountHandle account);
+        void onAccountSelectionDialogShow(AccountSelectionPreference pref);
     }
 
+    private final Context mContext;
     private AccountSelectionListener mListener;
     private PhoneAccountHandle[] mAccounts;
     private String[] mEntryValues;
@@ -40,11 +48,13 @@
 
     public AccountSelectionPreference(Context context) {
         super(context);
+        mContext = context;
         setOnPreferenceChangeListener(this);
     }
 
     public AccountSelectionPreference(Context context, AttributeSet attrs) {
         super(context, attrs);
+        mContext = context;
         setOnPreferenceChangeListener(this);
     }
 
@@ -93,4 +103,39 @@
         }
         return false;
     }
+
+    /**
+     * Modifies the dialog to change the default "Cancel" button to "Choose Accounts", which
+     * triggers the {@link PhoneAccountSelectionPreferenceActivity} to be shown.
+     *
+     * @param builder The {@code AlertDialog.Builder}.
+     */
+    @Override
+    protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
+        // Notify the listener that the dialog is about to be built.  This is important so that the
+        // list of enabled accounts can be updated prior to showing the dialog.
+        mListener.onAccountSelectionDialogShow(this);
+
+        final DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int whichButton) {
+                showSelectPhoneAccounts();
+            }
+        };
+        builder.setNegativeButton(R.string.phone_accounts_choose_accounts, listener);
+        super.onPrepareDialogBuilder(builder);
+    }
+
+    /**
+     * Displays the {@link PhoneAccountSelectionPreferenceActivity} where the user is able to
+     * enable and disable phone accounts.
+     */
+    private void showSelectPhoneAccounts() {
+        Intent intent = new Intent(mContext, PhoneAccountSelectionPreferenceActivity.class);
+        intent.setAction(Intent.ACTION_MAIN);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
+                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
+                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        mContext.startActivityAsUser(intent, null, UserHandle.CURRENT);
+    }
 }
diff --git a/src/com/android/phone/settings/PhoneAccountSelectionPreferenceActivity.java b/src/com/android/phone/settings/PhoneAccountSelectionPreferenceActivity.java
new file mode 100644
index 0000000..7dd1190
--- /dev/null
+++ b/src/com/android/phone/settings/PhoneAccountSelectionPreferenceActivity.java
@@ -0,0 +1,171 @@
+/*
+ * 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.phone.settings;
+
+import android.app.ActionBar;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceFragment;
+import android.preference.SwitchPreference;
+import android.telecomm.PhoneAccount;
+import android.telecomm.PhoneAccountHandle;
+import android.telecomm.TelecommManager;
+
+import com.android.internal.util.CharSequences;
+import com.android.phone.R;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Preference activity used to facilitate enabling and disabling phone accounts by the user.
+ */
+public class PhoneAccountSelectionPreferenceActivity extends PreferenceActivity {
+
+    /**
+     * Preference fragment containing a list of all {@link PhoneAccount}s in the form of switches
+     * the user can use to enable or disable accounts.
+     */
+    public static class PhoneAccountSelectionPreferenceFragment extends PreferenceFragment
+            implements Preference.OnPreferenceChangeListener {
+        private static final String CATEGORY_PHONE_ACCOUNTS_KEY = "phone_accounts_list";
+
+        private TelecommManager mTelecommManager;
+        private PreferenceCategory mPhoneAccountsCategory;
+
+        /**
+         * Represents a single {@link PhoneAccount} for the purpose enabling and disabling.
+         */
+        static class PhoneAccountPreference extends SwitchPreference {
+            private PhoneAccountHandle mPhoneAccountHandle;
+            private boolean mPreviousState;
+
+            public PhoneAccountPreference(Context context, PhoneAccount phoneAccount) {
+                super(context);
+
+                setPhoneAccount(phoneAccount);
+            }
+
+            /**
+             * Configures the {@code PhoneAccountPreference} for the passed in {@link PhoneAccount}.
+             *
+             * @param phoneAccount The phone account.
+             */
+            private void setPhoneAccount(PhoneAccount phoneAccount) {
+                mPhoneAccountHandle = phoneAccount.getAccountHandle();
+                mPreviousState = phoneAccount.isEnabled();
+                this.setTitle(phoneAccount.getLabel());
+                this.setChecked(mPreviousState);
+            }
+
+            public boolean getPreviousState() {
+                return mPreviousState;
+            }
+
+            public PhoneAccountHandle getPhoneAccountHandle() {
+                return mPhoneAccountHandle;
+            }
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            addPreferencesFromResource(R.xml.phone_account_selection);
+            mPhoneAccountsCategory = (PreferenceCategory) findPreference(
+                    CATEGORY_PHONE_ACCOUNTS_KEY);
+            mTelecommManager = TelecommManager.from(this.getActivity());
+
+            List<PhoneAccount> phoneAccounts = mTelecommManager.getAllPhoneAccounts();
+            Collections.sort(phoneAccounts, new Comparator<PhoneAccount>() {
+                @Override
+                public int compare(PhoneAccount o1, PhoneAccount o2) {
+                    return CharSequences.compareToIgnoreCase(o1.getLabel(), o2.getLabel());
+                }
+            });
+
+            for (PhoneAccount phoneAccount : phoneAccounts) {
+                // Do not add Sim PhoneAccounts.
+                if (phoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION)) {
+                    continue;
+                }
+
+                PhoneAccountPreference phoneAccountPreference = new PhoneAccountPreference(
+                        getActivity(), phoneAccount);
+                phoneAccountPreference.setOnPreferenceChangeListener(this);
+                phoneAccountPreference.setEnabled(!phoneAccount.hasCapabilities(
+                        PhoneAccount.CAPABILITY_ALWAYS_ENABLED));
+                mPhoneAccountsCategory.addPreference(phoneAccountPreference);
+            }
+        }
+
+        /**
+         * Handles changes to preferences
+         * @param preference The preference which changed.
+         * @param newValue The new value of the preference.
+         * @return
+         */
+        @Override
+        public boolean onPreferenceChange(Preference preference, Object newValue) {
+            if (preference instanceof PhoneAccountPreference) {
+                PhoneAccountPreference phoneAccountPreference = (PhoneAccountPreference) preference;
+                boolean newState = Boolean.valueOf(newValue.toString()).booleanValue();
+
+                if (newState != phoneAccountPreference.getPreviousState()) {
+                    mTelecommManager.setPhoneAccountEnabled(
+                            phoneAccountPreference.getPhoneAccountHandle(), newState);
+                }
+                return true;
+            }
+            return false;
+        }
+    }
+
+    @Override
+    public void onBuildHeaders(List<Header> target) {
+        loadHeadersFromResource(R.xml.phone_account_selection_activity, target);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        setTitle(getResources().getString(R.string.call_settings));
+        ActionBar actionBar = getActionBar();
+        if (actionBar != null) {
+            actionBar.setDisplayShowHomeEnabled(false);
+            actionBar.setDisplayHomeAsUpEnabled(false);
+        }
+
+        // By default, show the main fragment.
+        Intent intent = getIntent();
+        if (intent.getStringArrayExtra(EXTRA_SHOW_FRAGMENT) == null) {
+            getIntent().putExtra(EXTRA_SHOW_FRAGMENT,
+                    PhoneAccountSelectionPreferenceFragment.class.getName());
+        }
+
+        super.onCreate(savedInstanceState);
+    }
+
+    @Override
+    public boolean isValidFragment(String fragmentName) {
+        return true;
+    }
+}
diff --git a/src/com/android/services/telephony/TelecommAccountRegistry.java b/src/com/android/services/telephony/TelecommAccountRegistry.java
index 749739a..7ec2c4e 100644
--- a/src/com/android/services/telephony/TelecommAccountRegistry.java
+++ b/src/com/android/services/telephony/TelecommAccountRegistry.java
@@ -45,6 +45,8 @@
  * removal of SIMs and SIP accounts.
  */
 final class TelecommAccountRegistry {
+    private static final boolean DBG = false; /* STOP SHIP if true */
+
     private final static int[] phoneAccountIcons = {
             R.drawable.ic_multi_sim,
             R.drawable.ic_multi_sim1,
@@ -67,7 +69,6 @@
         }
 
         void teardown() {
-            mTelecommManager.unregisterPhoneAccount(mAccount.getAccountHandle());
             mIncomingCallNotifier.teardown();
         }
 
@@ -117,22 +118,37 @@
                     dummyPrefix + mContext.getResources().getString(
                             R.string.sim_description_default, slotId);
 
+            // By default all SIM phone accounts can place emergency calls.
+            int capabilities = PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION |
+                    PhoneAccount.CAPABILITY_CALL_PROVIDER |
+                    PhoneAccount.CAPABILITY_PLACE_EMERGENCY_CALLS;
+
+            // Indicate the emergency calling PhoneAccount is ALWAYS enabled.  This capability is
+            // important to ensure the emergency-only PhoneAccount cannot be disabled.
+            if (isEmergency) {
+                capabilities |= PhoneAccount.CAPABILITY_ALWAYS_ENABLED;
+            }
+
             PhoneAccount account = PhoneAccount.builder(phoneAccountHandle, label)
                     .setAddress(Uri.fromParts(PhoneAccount.SCHEME_TEL, line1Number, null))
                     .setSubscriptionAddress(
                             Uri.fromParts(PhoneAccount.SCHEME_TEL, subNumber, null))
-                    .setCapabilities(PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION |
-                            PhoneAccount.CAPABILITY_CALL_PROVIDER)
+                    .setCapabilities(capabilities)
                     .setIconResId(getPhoneAccountIcon(slotId))
                     .setShortDescription(description)
                     .setSupportedUriSchemes(Arrays.asList(
                             PhoneAccount.SCHEME_TEL, PhoneAccount.SCHEME_VOICEMAIL))
+                    .setEnabled(true)
                     .build();
 
             // Register with Telecomm and put into the account entry.
             mTelecommManager.registerPhoneAccount(account);
             return account;
         }
+
+        public PhoneAccountHandle getPhoneAccountHandle() {
+            return mAccount != null ? mAccount.getAccountHandle() : null;
+        }
     }
 
     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@@ -190,7 +206,6 @@
         intentFilter.addAction(TelephonyIntents.ACTION_SUBINFO_RECORD_UPDATED);
         intentFilter.addAction(TelephonyIntents.ACTION_SUBINFO_CONTENT_CHANGE);
         mContext.registerReceiver(mReceiver, intentFilter);
-        setupAccounts();
     }
 
     static PhoneAccountHandle makePstnPhoneAccountHandle(Phone phone) {
@@ -207,22 +222,43 @@
         return new PhoneAccountHandle(pstnConnectionServiceName, id);
     }
 
-    private void clearCurrentTelephonyAccounts() {
+    /**
+     * Determines if the list of {@link AccountEntry}(s) contains an {@link AccountEntry} with a
+     * specified {@link PhoneAccountHandle}.
+     *
+     * @param handle The {@link PhoneAccountHandle}.
+     * @return {@code True} if an entry exists.
+     */
+    private boolean hasAccountEntryForPhoneAccount(PhoneAccountHandle handle) {
+        for (AccountEntry entry : mAccounts) {
+            if (entry.getPhoneAccountHandle().equals(handle)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Un-registers any {@link PhoneAccount}s which are no longer present in the list
+     * {@code AccountEntry}(s).
+     */
+    private void cleanupPhoneAccounts() {
         ComponentName telephonyComponentName =
                 new ComponentName(mContext, TelephonyConnectionService.class);
-        List<PhoneAccountHandle> accountHandles = mTelecommManager.getEnabledPhoneAccounts();
+
+        List<PhoneAccountHandle> accountHandles = mTelecommManager.getAllPhoneAccountHandles();
         for (PhoneAccountHandle handle : accountHandles) {
-            if (telephonyComponentName.equals(handle.getComponentName())) {
+            if (telephonyComponentName.equals(handle.getComponentName()) &&
+                    !hasAccountEntryForPhoneAccount(handle)) {
+                Log.d(this, "Unregistering phone account %s.", handle);
                 mTelecommManager.unregisterPhoneAccount(handle);
             }
         }
     }
 
     private void setupAccounts() {
-        // Before we do anything, we need to clear whatever entries we registered at boot.
-        clearCurrentTelephonyAccounts();
-
-        // Go through SIM-based phones and register ourselves
+        // Go through SIM-based phones and register ourselves -- registering an existing account
+        // will cause the existing entry to be replaced.
         Phone[] phones = PhoneFactory.getPhones();
         Log.d(this, "Found %d phones.  Attempting to register.", phones.length);
         for (Phone phone : phones) {
@@ -242,9 +278,12 @@
         }
 
         // Add a fake account entry.
-        if (phones.length > 0 && "TRUE".equals(System.getProperty("dummy_sim"))) {
+        if ( DBG && phones.length > 0 && "TRUE".equals(System.getProperty("dummy_sim"))) {
             mAccounts.add(new AccountEntry(phones[0], false /* emergency */, true /* isDummy */));
         }
+
+        // Clean up any PhoneAccounts that are no longer relevant
+        cleanupPhoneAccounts();
     }
 
     private int getPhoneAccountIcon(int index) {