am 5a02bbf6: am c4ef6116: Make CellBroadCast MSIM aware

* commit '5a02bbf6ac5d4c3618c3889326539579f176f82b':
  Make CellBroadCast MSIM aware

7 files changed, 556 insertions, 195 deletions

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 79f49853..47ce5dbf 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -24,6 +24,7 @@
     <uses-permission android:name="android.permission.RECEIVE_SMS" />
     <uses-permission android:name="android.permission.RECEIVE_EMERGENCY_BROADCAST" />
     <uses-permission android:name="android.permission.READ_PRIVILEGED_PHONE_STATE" />
+    <uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
     <uses-permission android:name="android.permission.VIBRATE" />
@@ -127,6 +128,13 @@
             <intent-filter>
                  <action android:name="android.intent.action.SERVICE_STATE" />
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.internal_sim_state_changed" />
+            </intent-filter>
+
+            <intent-filter>
+                 <action android:name="android.intent.action.AIRPLANE_MODE" />
+            </intent-filter>
         </receiver>
 
         <provider
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java
index fdecc104..26d56437 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java
@@ -31,6 +31,7 @@ import android.preference.PreferenceManager;
 import android.provider.Telephony;
 import android.telephony.CellBroadcastMessage;
 import android.telephony.SmsCbCmasInfo;
+import android.telephony.SubscriptionManager;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
@@ -355,7 +356,7 @@ public class CellBroadcastAlertFullScreen extends Activity {
         ((TextView) findViewById(R.id.message)).setText(message.getMessageBody());
 
         // Set alert reminder depending on user preference
-        CellBroadcastAlertReminder.queueAlertReminder(this, true);
+        CellBroadcastAlertReminder.queueAlertReminder(this, true, message.getSubId());
     }
 
     /**
@@ -435,12 +436,14 @@ public class CellBroadcastAlertFullScreen extends Activity {
 
         // Show opt-in/opt-out dialog when the first CMAS alert is received.
         if (mShowOptOutDialog) {
-            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
-            if (prefs.getBoolean(CellBroadcastSettings.KEY_SHOW_CMAS_OPT_OUT_DIALOG, true)) {
-                // Clear the flag so the user will only see the opt-out dialog once.
-                prefs.edit().putBoolean(CellBroadcastSettings.KEY_SHOW_CMAS_OPT_OUT_DIALOG, false)
-                        .apply();
+            boolean boolResult = SubscriptionManager.getBooleanSubscriptionProperty(
+                    lastMessage.getSubId(), SubscriptionManager.CB_OPT_OUT_DIALOG, true, this);
 
+            if (boolResult) {
+                // Clear the flag so the user will only see the opt-out dialog once.
+                Log.d(TAG, "subscriptionId of last message = " + lastMessage.getSubId());
+                SubscriptionManager.setSubscriptionProperty(lastMessage.getSubId(),
+                        SubscriptionManager.CB_OPT_OUT_DIALOG, "0");
                 KeyguardManager km = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
                 if (km.inKeyguardRestrictedInputMode()) {
                     Log.d(TAG, "Showing opt-out dialog in new activity (secure keyguard)");
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java
index 5fa332a1..b2cdef7d 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java
@@ -28,9 +28,12 @@ import android.net.Uri;
 import android.os.IBinder;
 import android.os.SystemClock;
 import android.preference.PreferenceManager;
+import android.telephony.CellBroadcastMessage;
+import android.telephony.SubscriptionManager;
 import android.util.Log;
 import android.media.AudioManager;
 import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.DBG;
+import com.android.internal.telephony.PhoneConstants;
 
 /**
  * Manages alert reminder notification.
@@ -65,10 +68,13 @@ public class CellBroadcastAlertReminder extends Service {
             return START_NOT_STICKY;
         }
 
+        int subId = intent.getExtras().getInt(PhoneConstants.SUBSCRIPTION_KEY);
+        if(DBG) Log.d(TAG, "subscription id = " + subId);
+
         log("playing alert reminder");
         playAlertReminderSound();
 
-        if (queueAlertReminder(this, false)) {
+        if (queueAlertReminder(this, false, subId)) {
             return START_STICKY;
         } else {
             log("no reminders queued");
@@ -102,25 +108,13 @@ public class CellBroadcastAlertReminder extends Service {
      * Helper method to start the alert reminder service to queue the alert reminder.
      * @return true if a pending reminder was set; false if there are no more reminders
      */
-    static boolean queueAlertReminder(Context context, boolean firstTime) {
+    static boolean queueAlertReminder(Context context, boolean firstTime, int subId) {
         // Stop any alert reminder sound and cancel any previously queued reminders.
         cancelAlertReminder();
 
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-        String prefStr = prefs.getString(CellBroadcastSettings.KEY_ALERT_REMINDER_INTERVAL, null);
-
-        if (prefStr == null) {
-            if (DBG) log("no preference value for alert reminder");
-            return false;
-        }
-
-        int interval;
-        try {
-            interval = Integer.valueOf(prefStr);
-        } catch (NumberFormatException ignored) {
-            loge("invalid alert reminder interval preference: " + prefStr);
-            return false;
-        }
+        int interval = SubscriptionManager.getIntegerSubscriptionProperty(subId,
+                SubscriptionManager.CB_ALERT_REMINDER_INTERVAL, Integer.parseInt(
+                        CellBroadcastSettings.ALERT_REMINDER_INTERVAL), context);
 
         if (interval == 0 || (interval == 1 && !firstTime)) {
             return false;
@@ -133,6 +127,7 @@ public class CellBroadcastAlertReminder extends Service {
 
         Intent playIntent = new Intent(context, CellBroadcastAlertReminder.class);
         playIntent.setAction(ACTION_PLAY_ALERT_REMINDER);
+        playIntent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId);
         sPlayReminderIntent = PendingIntent.getService(context, 0, playIntent,
                 PendingIntent.FLAG_UPDATE_CURRENT);
 
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
index 3500d6fc..072b0782 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
@@ -35,7 +35,9 @@ import android.telephony.CellBroadcastMessage;
 import android.telephony.SmsCbCmasInfo;
 import android.telephony.SmsCbLocation;
 import android.telephony.SmsCbMessage;
+import android.telephony.SubscriptionManager;
 import android.util.Log;
+import com.android.internal.telephony.PhoneConstants;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -156,6 +158,12 @@ public class CellBroadcastAlertService extends Service {
         }
 
         final CellBroadcastMessage cbm = new CellBroadcastMessage(message);
+        int subId = intent.getExtras().getInt(PhoneConstants.SUBSCRIPTION_KEY);
+        if (SubscriptionManager.isValidSubscriptionId(subId)) {
+            cbm.setSubId(subId);
+        } else {
+            Log.e(TAG, "Invalid subscription id");
+        }
         if (!isMessageEnabledByUser(cbm)) {
             Log.d(TAG, "ignoring alert of type " + cbm.getServiceCategory() +
                     " by user preference");
@@ -217,7 +225,7 @@ public class CellBroadcastAlertService extends Service {
             return;
         }
 
-        CellBroadcastMessage cbm = (CellBroadcastMessage) extras.get("message");
+        CellBroadcastMessage cbm = (CellBroadcastMessage) intent.getParcelableExtra("message");
 
         if (cbm == null) {
             Log.e(TAG, "received SHOW_NEW_ALERT_ACTION with no message extra");
@@ -247,29 +255,29 @@ public class CellBroadcastAlertService extends Service {
      */
     private boolean isMessageEnabledByUser(CellBroadcastMessage message) {
         if (message.isEtwsTestMessage()) {
-            return PreferenceManager.getDefaultSharedPreferences(this)
-                    .getBoolean(CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false);
+            return SubscriptionManager.getBooleanSubscriptionProperty(
+                    message.getSubId(), SubscriptionManager.CB_ETWS_TEST_ALERT, false, this);
         }
 
         if (message.isCmasMessage()) {
             switch (message.getCmasMessageClass()) {
                 case SmsCbCmasInfo.CMAS_CLASS_EXTREME_THREAT:
-                    return PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
-                            CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true);
+                    return SubscriptionManager.getBooleanSubscriptionProperty(
+                            message.getSubId(), SubscriptionManager.CB_EXTREME_THREAT_ALERT, true, this);
 
                 case SmsCbCmasInfo.CMAS_CLASS_SEVERE_THREAT:
-                    return PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
-                            CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true);
+                    return SubscriptionManager.getBooleanSubscriptionProperty(
+                            message.getSubId(), SubscriptionManager.CB_SEVERE_THREAT_ALERT, true, this);
 
                 case SmsCbCmasInfo.CMAS_CLASS_CHILD_ABDUCTION_EMERGENCY:
-                    return PreferenceManager.getDefaultSharedPreferences(this)
-                            .getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true);
+                    return SubscriptionManager.getBooleanSubscriptionProperty(
+                            message.getSubId(), SubscriptionManager.CB_AMBER_ALERT, true, this);
 
                 case SmsCbCmasInfo.CMAS_CLASS_REQUIRED_MONTHLY_TEST:
                 case SmsCbCmasInfo.CMAS_CLASS_CMAS_EXERCISE:
                 case SmsCbCmasInfo.CMAS_CLASS_OPERATOR_DEFINED_USE:
-                    return PreferenceManager.getDefaultSharedPreferences(this)
-                            .getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, false);
+                    return SubscriptionManager.getBooleanSubscriptionProperty(
+                            message.getSubId(), SubscriptionManager.CB_CMAS_TEST_ALERT, false, this);
 
                 default:
                     return true;    // presidential-level CMAS alerts are always enabled
@@ -308,16 +316,15 @@ public class CellBroadcastAlertService extends Service {
         // start audio/vibration/speech service for emergency alerts
         Intent audioIntent = new Intent(this, CellBroadcastAlertAudio.class);
         audioIntent.setAction(CellBroadcastAlertAudio.ACTION_START_ALERT_AUDIO);
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
 
         int duration;   // alert audio duration in ms
         if (message.isCmasMessage()) {
             // CMAS requirement: duration of the audio attention signal is 10.5 seconds.
             duration = 10500;
         } else {
-            duration = Integer.parseInt(prefs.getString(
-                    CellBroadcastSettings.KEY_ALERT_SOUND_DURATION,
-                    CellBroadcastSettings.ALERT_SOUND_DEFAULT_DURATION)) * 1000;
+            duration = SubscriptionManager.getIntegerSubscriptionProperty(message.getSubId(),
+                    SubscriptionManager.CB_ALERT_SOUND_DURATION,
+                    Integer.parseInt(CellBroadcastSettings.ALERT_SOUND_DEFAULT_DURATION), this);
         }
         audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_DURATION_EXTRA, duration);
 
@@ -327,13 +334,15 @@ public class CellBroadcastAlertService extends Service {
             audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_ETWS_VIBRATE_EXTRA, true);
         } else {
             // For other alerts, vibration can be disabled in app settings.
-            audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_VIBRATE_EXTRA,
-                    prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_VIBRATE, true));
+            boolean vibrateFlag = SubscriptionManager.getBooleanSubscriptionProperty(
+                    message.getSubId(), SubscriptionManager.CB_ALERT_VIBRATE, true, this);
+            audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_VIBRATE_EXTRA, vibrateFlag);
         }
 
         String messageBody = message.getMessageBody();
 
-        if (prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_SPEECH, true)) {
+        if (SubscriptionManager.getBooleanSubscriptionProperty(message.getSubId(),
+                SubscriptionManager.CB_ALERT_SPEECH, true, this)) {
             audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_MESSAGE_BODY, messageBody);
 
             String language = message.getLanguageCode();
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java b/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java
index 09b57f1e..6c5a7d32 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java
@@ -25,10 +25,11 @@ import android.os.SystemProperties;
 import android.preference.PreferenceManager;
 import android.telephony.CellBroadcastMessage;
 import android.telephony.SmsManager;
+import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
 import android.text.TextUtils;
 import android.util.Log;
-
+import com.android.internal.telephony.PhoneConstants;
 import com.android.internal.telephony.cdma.sms.SmsEnvelope;
 import com.android.internal.telephony.gsm.SmsCbConstants;
 
@@ -68,19 +69,23 @@ public class CellBroadcastConfigService extends IntentService {
                     int endId = Integer.decode(channelRange.substring(dashIndex + 1).trim());
                     if (enable) {
                         if (DBG) log("enabling emergency IDs " + startId + '-' + endId);
-                        manager.enableCellBroadcastRange(startId, endId, SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.enableCellBroadcastRange(startId, endId,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
                     } else {
                         if (DBG) log("disabling emergency IDs " + startId + '-' + endId);
-                        manager.disableCellBroadcastRange(startId, endId, SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.disableCellBroadcastRange(startId, endId,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
                     }
                 } else {
                     int messageId = Integer.decode(channelRange.trim());
                     if (enable) {
                         if (DBG) log("enabling emergency message ID " + messageId);
-                        manager.enableCellBroadcast(messageId, SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.enableCellBroadcast(messageId,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
                     } else {
                         if (DBG) log("disabling emergency message ID " + messageId);
-                        manager.disableCellBroadcast(messageId, SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.disableCellBroadcast(messageId,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
                     }
                 }
             }
@@ -112,7 +117,7 @@ public class CellBroadcastConfigService extends IntentService {
         }
 
         // Check for system property defining the emergency channel ranges to enable
-        String emergencyIdRange = (CellBroadcastReceiver.phoneIsCdma()) ?
+        String emergencyIdRange = (CellBroadcastReceiver.phoneIsCdma(message.getSubId())) ?
                 "" : SystemProperties.get(EMERGENCY_BROADCAST_RANGE_GSM);
 
         if (TextUtils.isEmpty(emergencyIdRange)) {
@@ -144,16 +149,21 @@ public class CellBroadcastConfigService extends IntentService {
     @Override
     protected void onHandleIntent(Intent intent) {
         if (ACTION_ENABLE_CHANNELS.equals(intent.getAction())) {
+            int subId = intent.getExtras().getInt(PhoneConstants.SUBSCRIPTION_KEY);
+
             try {
                 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
                 Resources res = getResources();
 
-                // boolean for each user preference checkbox, true for checked, false for unchecked
+
+                // boolean for each user preference checkbox, true for checked, false for
+                // unchecked
                 // Note: If enableEmergencyAlerts is false, it disables ALL emergency broadcasts
                 // except for cmas presidential. i.e. to receive cmas severe alerts, both
                 // enableEmergencyAlerts AND enableCmasSevereAlerts must be true.
-                boolean enableEmergencyAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_EMERGENCY_ALERTS, true);
+
+                boolean enableEmergencyAlerts = SubscriptionManager.getBooleanSubscriptionProperty(
+                        subId, SubscriptionManager.CB_EMERGENCY_ALERT, true, this);
 
                 TelephonyManager tm = (TelephonyManager) getSystemService(
                         Context.TELEPHONY_SERVICE);
@@ -162,23 +172,25 @@ public class CellBroadcastConfigService extends IntentService {
                         "br".equals(tm.getSimCountryIso());
 
                 boolean enableChannel50Alerts = enableChannel50Support &&
-                        prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_CHANNEL_50_ALERTS, true);
+                        SubscriptionManager.getBooleanSubscriptionProperty(subId,
+                                SubscriptionManager.CB_CHANNEL_50_ALERT, true, this);
 
                 // Note:  ETWS is for 3GPP only
-                boolean enableEtwsTestAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false);
+                boolean enableEtwsTestAlerts = SubscriptionManager.getBooleanSubscriptionProperty(
+                        subId, SubscriptionManager.CB_ETWS_TEST_ALERT, false, this);
 
-                boolean enableCmasExtremeAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true);
+                boolean enableCmasExtremeAlerts = SubscriptionManager
+                        .getBooleanSubscriptionProperty(subId,
+                                SubscriptionManager.CB_EXTREME_THREAT_ALERT, true, this);
 
-                boolean enableCmasSevereAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true);
+                boolean enableCmasSevereAlerts = SubscriptionManager.getBooleanSubscriptionProperty(
+                        subId, SubscriptionManager.CB_SEVERE_THREAT_ALERT, true, this);
 
-                boolean enableCmasAmberAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true);
+                boolean enableCmasAmberAlerts = SubscriptionManager.getBooleanSubscriptionProperty(
+                        subId, SubscriptionManager.CB_AMBER_ALERT, true, this);
 
-                boolean enableCmasTestAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, false);
+                boolean enableCmasTestAlerts = SubscriptionManager.getBooleanSubscriptionProperty(
+                        subId, SubscriptionManager.CB_CMAS_TEST_ALERT, false, this);
 
                 // set up broadcast ID ranges to be used for each category
                 int cmasExtremeStart =
@@ -191,12 +203,13 @@ public class CellBroadcastConfigService extends IntentService {
                 int cmasTestStart = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST;
                 int cmasTestEnd = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE;
                 int cmasPresident = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL;
-                int cmasTaiwanPWS = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE;
+                int cmasTaiwanPWS =
+                        SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE;
 
                 // set to CDMA broadcast ID rage if phone is in CDMA mode.
-                boolean isCdma = CellBroadcastReceiver.phoneIsCdma();
+                boolean isCdma = CellBroadcastReceiver.phoneIsCdma(subId);
 
-                SmsManager manager = SmsManager.getDefault();
+                SmsManager manager = SmsManager.getSmsManagerForSubscriptionId(subId);
                 // Check for system property defining the emergency channel ranges to enable
                 String emergencyIdRange = isCdma ?
                         "" : SystemProperties.get(EMERGENCY_BROADCAST_RANGE_GSM);
@@ -207,20 +220,20 @@ public class CellBroadcastConfigService extends IntentService {
                     } else {
                         // No emergency channel system property, enable all emergency channels
                         // that have checkbox checked
-                       manager.enableCellBroadcastRange(
-                               SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING,
-                               SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING,
-                               SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.enableCellBroadcastRange(
+                                SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING,
+                                SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
 
-                       if (enableEtwsTestAlerts) {
+                        if (enableEtwsTestAlerts) {
                             manager.enableCellBroadcast(
                                     SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE,
                                     SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
-                       }
+                        }
 
-                       manager.enableCellBroadcast(
-                                    SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE,
-                                    SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
+                        manager.enableCellBroadcast(
+                                SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE,
+                                SmsManager.CELL_BROADCAST_RAN_TYPE_GSM);
 
                         if (enableCmasExtremeAlerts) {
                             manager.enableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd,
@@ -299,7 +312,7 @@ public class CellBroadcastConfigService extends IntentService {
                                 SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY,
                                 SmsManager.CELL_BROADCAST_RAN_TYPE_CDMA);
                         manager.disableCellBroadcast(
-                                SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE ,
+                                SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE,
                                 SmsManager.CELL_BROADCAST_RAN_TYPE_CDMA);
                         // CMAS Presidential must be on (See 3GPP TS 22.268 Section 6.2).
                         manager.enableCellBroadcast(cmasPresident,
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
index 8c747637..42cf053b 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
@@ -21,6 +21,7 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
+import android.os.Bundle;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.os.UserHandle;
@@ -28,13 +29,20 @@ import android.preference.PreferenceManager;
 import android.provider.Telephony;
 import android.telephony.CellBroadcastMessage;
 import android.telephony.ServiceState;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
 import android.telephony.cdma.CdmaSmsCbProgramData;
 import android.util.Log;
+import com.android.internal.telephony.PhoneConstants;
 
 import com.android.internal.telephony.ITelephony;
+import com.android.internal.telephony.IccCardConstants;
 import com.android.internal.telephony.cdma.sms.SmsEnvelope;
 import com.android.internal.telephony.TelephonyIntents;
+import com.android.internal.telephony.uicc.IccCardProxy;
+
+import java.util.List;
 
 public class CellBroadcastReceiver extends BroadcastReceiver {
     private static final String TAG = "CellBroadcastReceiver";
@@ -55,16 +63,33 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
 
         if (TelephonyIntents.ACTION_SERVICE_STATE_CHANGED.equals(action)) {
             if (DBG) log("Intent ACTION_SERVICE_STATE_CHANGED");
+            int subId = intent.getExtras().getInt(PhoneConstants.SUBSCRIPTION_KEY);
+            Log.d(TAG, "subscriptionId = " + subId);
+            if (!SubscriptionManager.isValidSubscriptionId(subId)) {
+                return;
+            }
             ServiceState serviceState = ServiceState.newFromBundle(intent.getExtras());
             int newState = serviceState.getState();
             if (newState != mServiceState) {
                 Log.d(TAG, "Service state changed! " + newState + " Full: " + serviceState +
                         " Current state=" + mServiceState);
                 mServiceState = newState;
+
                 if (((newState == ServiceState.STATE_IN_SERVICE) ||
                         (newState == ServiceState.STATE_EMERGENCY_ONLY)) &&
                         (UserHandle.myUserId() == UserHandle.USER_OWNER)) {
-                    startConfigService(context.getApplicationContext());
+                    startConfigService(context.getApplicationContext(), subId);
+                }
+            }
+        } else if (IccCardProxy.ACTION_INTERNAL_SIM_STATE_CHANGED.equals(action)){
+            String simStatus = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
+            if (IccCardConstants.INTENT_VALUE_ICC_LOADED.equals(simStatus)) {
+                List<SubscriptionInfo> subscriptionInfoList = SubscriptionManager.from(
+                        context).getActiveSubscriptionInfoList();
+                if (subscriptionInfoList != null) {
+                    for (SubscriptionInfo subInfo : subscriptionInfoList) {
+                        startConfigService(context, subInfo.getSubscriptionId());
+                    }
                 }
             }
         } else if (Telephony.Sms.Intents.SMS_EMERGENCY_CB_RECEIVED_ACTION.equals(action) ||
@@ -85,7 +110,9 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
                 CdmaSmsCbProgramData[] programDataList = (CdmaSmsCbProgramData[])
                         intent.getParcelableArrayExtra("program_data_list");
                 if (programDataList != null) {
-                    handleCdmaSmsCbProgramData(context, programDataList);
+                    int subId = intent.getExtras().getInt(PhoneConstants.SUBSCRIPTION_KEY);
+                    Log.d(TAG, "subscriptionId = " + subId);
+                    handleCdmaSmsCbProgramData(context, programDataList, subId);
                 } else {
                     loge("SCPD intent received with no program_data_list");
                 }
@@ -122,26 +149,27 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
      * @param programDataList
      */
     private void handleCdmaSmsCbProgramData(Context context,
-            CdmaSmsCbProgramData[] programDataList) {
+            CdmaSmsCbProgramData[] programDataList, int subId) {
         for (CdmaSmsCbProgramData programData : programDataList) {
             switch (programData.getOperation()) {
                 case CdmaSmsCbProgramData.OPERATION_ADD_CATEGORY:
-                    tryCdmaSetCategory(context, programData.getCategory(), true);
+                    tryCdmaSetCategory(context, programData.getCategory(), true, subId);
                     break;
 
                 case CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY:
-                    tryCdmaSetCategory(context, programData.getCategory(), false);
+                    tryCdmaSetCategory(context, programData.getCategory(), false, subId);
                     break;
 
                 case CdmaSmsCbProgramData.OPERATION_CLEAR_CATEGORIES:
                     tryCdmaSetCategory(context,
-                            SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, false);
+                            SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, false, subId);
                     tryCdmaSetCategory(context,
-                            SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, false);
+                            SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, false, subId);
                     tryCdmaSetCategory(context,
-                            SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, false);
+                            SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, false,
+                            subId);
                     tryCdmaSetCategory(context,
-                            SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, false);
+                            SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, false, subId);
                     break;
 
                 default:
@@ -150,30 +178,30 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
         }
     }
 
-    private void tryCdmaSetCategory(Context context, int category, boolean enable) {
-        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
-
+    private void tryCdmaSetCategory(Context context, int category, boolean enable, int subId) {
         switch (category) {
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, enable)
-                        .apply();
+                SubscriptionManager.setSubscriptionProperty(subId,
+                        SubscriptionManager.CB_EXTREME_THREAT_ALERT,
+                        (enable ? "1" : "0"));
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, enable)
-                        .apply();
+                SubscriptionManager.setSubscriptionProperty(subId,
+                        SubscriptionManager.CB_SEVERE_THREAT_ALERT,
+                        (enable ? "1" : "0"));
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, enable).apply();
+                SubscriptionManager.setSubscriptionProperty(subId,
+                        SubscriptionManager.CB_AMBER_ALERT,
+                        (enable ? "1" : "0"));
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, enable).apply();
+                SubscriptionManager.setSubscriptionProperty(subId,
+                        SubscriptionManager.CB_CMAS_TEST_ALERT,
+                        (enable ? "1" : "0"));
                 break;
 
             default:
@@ -186,21 +214,23 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
      * Tell {@link CellBroadcastConfigService} to enable the CB channels.
      * @param context the broadcast receiver context
      */
-    static void startConfigService(Context context) {
+    static void startConfigService(Context context, int subId) {
         Intent serviceIntent = new Intent(CellBroadcastConfigService.ACTION_ENABLE_CHANNELS,
                 null, context, CellBroadcastConfigService.class);
+        serviceIntent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId);
         context.startService(serviceIntent);
     }
 
     /**
      * @return true if the phone is a CDMA phone type
      */
-    static boolean phoneIsCdma() {
+    static boolean phoneIsCdma(int subId) {
         boolean isCdma = false;
         try {
             ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
             if (phone != null) {
-                isCdma = (phone.getActivePhoneType() == TelephonyManager.PHONE_TYPE_CDMA);
+                isCdma = (phone.getActivePhoneTypeForSubscriber(subId) ==
+                        TelephonyManager.PHONE_TYPE_CDMA);
             }
         } catch (RemoteException e) {
             Log.w(TAG, "phone.getActivePhoneType() failed", e);
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
index c8226025..10cfa09d 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
@@ -17,7 +17,6 @@
 package com.android.cellbroadcastreceiver;
 
 import android.content.Context;
-import android.content.res.Resources;
 import android.os.Bundle;
 import android.os.UserManager;
 import android.preference.CheckBoxPreference;
@@ -25,10 +24,20 @@ import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.PreferenceActivity;
 import android.preference.PreferenceCategory;
-import android.preference.PreferenceFragment;
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
 import android.telephony.TelephonyManager;
+import android.telephony.SubscriptionManager;
+import android.telephony.SubscriptionInfo;
+import android.util.Log;
+import android.view.View;
+import android.widget.TabHost;
+import android.widget.TabHost.OnTabChangeListener;
+import android.widget.TabHost.TabContentFactory;
+import android.widget.TabHost.TabSpec;
+import android.widget.TabWidget;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Settings activity for the cell broadcast receiver.
@@ -89,164 +98,458 @@ public class CellBroadcastSettings extends PreferenceActivity {
     // Alert reminder interval ("once" = single 2 minute reminder).
     public static final String KEY_ALERT_REMINDER_INTERVAL = "alert_reminder_interval";
 
+    // Default reminder interval.
+    public static final String ALERT_REMINDER_INTERVAL = "0";
+
+    private final static String TAG = "CellBroadcastSettings";
+
+    private TelephonyManager mTelephonyManager;
+    private SubscriptionInfo mSir;
+    private TabHost mTabHost;
+    private TabWidget mTabWidget;
+    private List<SubscriptionInfo> mSelectableSubInfos;
+
+    private CheckBoxPreference mExtremeCheckBox;
+    private CheckBoxPreference mSevereCheckBox;
+    private CheckBoxPreference mAmberCheckBox;
+    private CheckBoxPreference mEmergencyCheckBox;
+    private ListPreference mAlertDuration;
+    private ListPreference mReminderInterval;
+    private CheckBoxPreference mVibrateCheckBox;
+    private CheckBoxPreference mSpeechCheckBox;
+    private CheckBoxPreference mEtwsTestCheckBox;
+    private CheckBoxPreference mChannel50CheckBox;
+    private CheckBoxPreference mCmasCheckBox;
+    private CheckBoxPreference mOptOutCheckBox;
+    private PreferenceCategory mAlertCategory;
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
         UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
-
         if (userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) {
             setContentView(R.layout.cell_broadcast_disallowed_preference_screen);
             return;
         }
 
-        // Display the fragment as the main content.
-        getFragmentManager().beginTransaction().replace(android.R.id.content,
-                new CellBroadcastSettingsFragment()).commit();
+        mTelephonyManager = (TelephonyManager) getSystemService(
+                Context.TELEPHONY_SERVICE);
+        mSelectableSubInfos = new ArrayList<SubscriptionInfo>();
+        for (int i = 0; i < mTelephonyManager.getSimCount(); i++) {
+            final SubscriptionInfo sir =
+                    findRecordBySlotId(getApplicationContext(), i);
+            if (sir != null) {
+                mSelectableSubInfos.add(sir);
+            }
+        }
+
+        addPreferencesFromResource(R.xml.preferences);
+        mSir = mSelectableSubInfos.size() > 0 ? mSelectableSubInfos.get(0) : null;
+        if (mSelectableSubInfos.size() > 1) {
+            setContentView(com.android.internal.R.layout.common_tab_settings);
+
+            mTabHost = (TabHost) findViewById(android.R.id.tabhost);
+            mTabHost.setup();
+            mTabHost.setOnTabChangedListener(mTabListener);
+            mTabHost.clearAllTabs();
+
+            for (int i = 0; i < mSelectableSubInfos.size(); i++) {
+                mTabHost.addTab(buildTabSpec(String.valueOf(i),
+                        String.valueOf(mSelectableSubInfos.get(i).getDisplayName())));
+            }
+        }
+        updatePreferences();
     }
 
-    /**
-     * New fragment-style implementation of preferences.
-     */
-    public static class CellBroadcastSettingsFragment extends PreferenceFragment {
+    private void updatePreferences() {
 
-        @Override
-        public void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
+        PreferenceScreen prefScreen = getPreferenceScreen();
 
+        if (prefScreen != null) {
+            prefScreen.removeAll();
             // Load the preferences from an XML resource
             addPreferencesFromResource(R.xml.preferences);
 
-            PreferenceScreen preferenceScreen = getPreferenceScreen();
+            mExtremeCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
+            mSevereCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
+            mAmberCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS);
+            mEmergencyCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_EMERGENCY_ALERTS);
+            mAlertDuration = (ListPreference)
+                    findPreference(KEY_ALERT_SOUND_DURATION);
+            mReminderInterval = (ListPreference)
+                    findPreference(KEY_ALERT_REMINDER_INTERVAL);
+            mVibrateCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_ALERT_VIBRATE);
+            mSpeechCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_ALERT_SPEECH);
+            mEtwsTestCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_ETWS_TEST_ALERTS);
+            mChannel50CheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_CHANNEL_50_ALERTS);
+            mCmasCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_ENABLE_CMAS_TEST_ALERTS);
+            mOptOutCheckBox = (CheckBoxPreference)
+                    findPreference(KEY_SHOW_CMAS_OPT_OUT_DIALOG);
+            mAlertCategory = (PreferenceCategory)
+                    findPreference(KEY_CATEGORY_ALERT_SETTINGS);
+
+            if(mSir == null) {
+                mExtremeCheckBox.setEnabled(false);
+                mSevereCheckBox.setEnabled(false);
+                mAmberCheckBox.setEnabled(false);
+                mEmergencyCheckBox.setEnabled(false);
+                mReminderInterval.setEnabled(false);
+                mAlertDuration.setEnabled(false);
+                mVibrateCheckBox.setEnabled(false);
+                mSpeechCheckBox.setEnabled(false);
+                mEtwsTestCheckBox.setEnabled(false);
+                mChannel50CheckBox.setEnabled(false);
+                mCmasCheckBox.setEnabled(false);
+                mOptOutCheckBox.setEnabled(false);
+                return;
+            }
 
             // Handler for settings that require us to reconfigure enabled channels in radio
             Preference.OnPreferenceChangeListener startConfigServiceListener =
                     new Preference.OnPreferenceChangeListener() {
                         @Override
                         public boolean onPreferenceChange(Preference pref, Object newValue) {
-                            CellBroadcastReceiver.startConfigService(pref.getContext());
-                            boolean isExtreme =
-                                (pref.getKey()).equals(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
-                            if (isExtreme) {
-                                boolean isExtremeAlertChecked =
-                                    ((Boolean) newValue).booleanValue();
-                                CheckBoxPreference severeCheckBox = (CheckBoxPreference)
-                                        findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
-                                if (severeCheckBox != null) {
-                                    severeCheckBox.setEnabled(isExtremeAlertChecked);
-                                    severeCheckBox.setChecked(false);
-                                }
+                            int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
+
+                            switch (pref.getKey()) {
+                                case KEY_ENABLE_EMERGENCY_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_EMERGENCY_ALERT,
+                                                    newVal + "");
+                                    break;
+                                case KEY_ENABLE_CHANNEL_50_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_CHANNEL_50_ALERT,
+                                                    newVal + "");
+                                    break;
+                                case KEY_ENABLE_ETWS_TEST_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_ETWS_TEST_ALERT,
+                                                    newVal + "");
+                                    break;
+                                case KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_EXTREME_THREAT_ALERT,
+                                                    newVal + "");
+                                    if (newVal == 1) {
+                                        SubscriptionManager
+                                                .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                        SubscriptionManager.CB_SEVERE_THREAT_ALERT,
+                                                        "0");
+                                    }
+                                    boolean isExtremeAlertChecked =
+                                            ((Boolean) newValue).booleanValue();
+
+                                    if (mSevereCheckBox != null) {
+                                        mSevereCheckBox.setEnabled(isExtremeAlertChecked);
+                                        mSevereCheckBox.setChecked(false);
+                                    }
+                                    break;
+                                case KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_SEVERE_THREAT_ALERT,
+                                                    newVal + "");
+                                    break;
+                                case KEY_ENABLE_CMAS_AMBER_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_AMBER_ALERT,
+                                                    newVal + "");
+                                    break;
+                                case KEY_ENABLE_CMAS_TEST_ALERTS:
+                                    SubscriptionManager
+                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
+                                                    SubscriptionManager.CB_CMAS_TEST_ALERT,
+                                                    newVal + "");
+                                    break;
+                                default:
+                                    Log.d(TAG, "Invalid preference changed");
+
                             }
+
+                            CellBroadcastReceiver.startConfigService(pref.getContext(),
+                                    mSir.getSubscriptionId());
                             return true;
                         }
                     };
 
             // Show extra settings when developer options is enabled in settings.
-            boolean enableDevSettings = Settings.Global.getInt(getActivity().getContentResolver(),
+            boolean enableDevSettings = Settings.Global.getInt(getContentResolver(),
                     Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0) != 0;
 
-            Resources res = getResources();
-            boolean showEtwsSettings = res.getBoolean(R.bool.show_etws_settings);
-
-            // Emergency alert preference category (general and CMAS preferences).
-            PreferenceCategory alertCategory = (PreferenceCategory)
-                    findPreference(KEY_CATEGORY_ALERT_SETTINGS);
+            boolean showEtwsSettings = SubscriptionManager.getResourcesForSubId(
+                    getApplicationContext(), mSir.getSubscriptionId())
+                    .getBoolean(R.bool.show_etws_settings);
 
+            String queryReturnVal;
             // alert reminder interval
-            ListPreference interval = (ListPreference) findPreference(KEY_ALERT_REMINDER_INTERVAL);
-            interval.setSummary(interval.getEntry());
-            interval.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
-                @Override
-                public boolean onPreferenceChange(Preference pref, Object newValue) {
-                    final ListPreference listPref = (ListPreference) pref;
-                    final int idx = listPref.findIndexOfValue((String) newValue);
-                    listPref.setSummary(listPref.getEntries()[idx]);
-                    return true;
-                }
-            });
+            queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
+                    mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
+                    Integer.parseInt(ALERT_REMINDER_INTERVAL), this) + "";
+
+            mReminderInterval.setValue(queryReturnVal);
+            mReminderInterval.setSummary(mReminderInterval
+                    .getEntries()[mReminderInterval.findIndexOfValue(queryReturnVal)]);
+
+            mReminderInterval.setOnPreferenceChangeListener(
+                    new Preference.OnPreferenceChangeListener() {
+                        @Override
+                        public boolean onPreferenceChange(Preference pref, Object newValue) {
+                            final ListPreference listPref = (ListPreference) pref;
+                            final int idx = listPref.findIndexOfValue((String) newValue);
+                            listPref.setSummary(listPref.getEntries()[idx]);
+                            SubscriptionManager.setSubscriptionProperty(mSir.getSubscriptionId(),
+                                    SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
+                                    (String) newValue);
+                            return true;
+                        }
+                    });
 
             // Show alert settings and ETWS categories for ETWS builds and developer mode.
             if (enableDevSettings || showEtwsSettings) {
                 // enable/disable all alerts
-                Preference enablePwsAlerts = findPreference(KEY_ENABLE_EMERGENCY_ALERTS);
-                if (enablePwsAlerts != null) {
-                    enablePwsAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
+                if (mEmergencyCheckBox != null) {
+                    if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                            SubscriptionManager.CB_EMERGENCY_ALERT, true, this)) {
+                        mEmergencyCheckBox.setChecked(true);
+                    } else {
+                        mEmergencyCheckBox.setChecked(false);
+                    }
+                    mEmergencyCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
                 }
 
                 // alert sound duration
-                ListPreference duration = (ListPreference) findPreference(KEY_ALERT_SOUND_DURATION);
-                duration.setSummary(duration.getEntry());
-                duration.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
-                    @Override
-                    public boolean onPreferenceChange(Preference pref, Object newValue) {
-                        final ListPreference listPref = (ListPreference) pref;
-                        final int idx = listPref.findIndexOfValue((String) newValue);
-                        listPref.setSummary(listPref.getEntries()[idx]);
-                        return true;
-                    }
-                });
+                queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
+                        mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_SOUND_DURATION,
+                        Integer.parseInt(ALERT_SOUND_DEFAULT_DURATION), this) + "";
+                mAlertDuration.setValue(queryReturnVal);
+                mAlertDuration.setSummary(mAlertDuration
+                        .getEntries()[mAlertDuration.findIndexOfValue(queryReturnVal)]);
+                mAlertDuration.setOnPreferenceChangeListener(
+                        new Preference.OnPreferenceChangeListener() {
+                            @Override
+                            public boolean onPreferenceChange(Preference pref, Object newValue) {
+                                final ListPreference listPref = (ListPreference) pref;
+                                final int idx = listPref.findIndexOfValue((String) newValue);
+                                listPref.setSummary(listPref.getEntries()[idx]);
+                                SubscriptionManager.setSubscriptionProperty(
+                                        mSir.getSubscriptionId(),
+                                        SubscriptionManager.CB_ALERT_SOUND_DURATION,
+                                        (String) newValue);
+                                return true;
+                            }
+                        });
             } else {
                 // Remove general emergency alert preference items (not shown for CMAS builds).
-                alertCategory.removePreference(findPreference(KEY_ENABLE_EMERGENCY_ALERTS));
-                alertCategory.removePreference(findPreference(KEY_ALERT_SOUND_DURATION));
-                alertCategory.removePreference(findPreference(KEY_ENABLE_ALERT_SPEECH));
+                mAlertCategory.removePreference(findPreference(KEY_ENABLE_EMERGENCY_ALERTS));
+                mAlertCategory.removePreference(findPreference(KEY_ALERT_SOUND_DURATION));
+                mAlertCategory.removePreference(findPreference(KEY_ENABLE_ALERT_SPEECH));
                 // Remove ETWS preference category.
-                preferenceScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
+                prefScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
             }
 
-            if (!res.getBoolean(R.bool.show_cmas_settings)) {
+            if (!SubscriptionManager.getResourcesForSubId(getApplicationContext(),
+                    mSir.getSubscriptionId()).getBoolean(R.bool.show_cmas_settings)) {
                 // Remove CMAS preference items in emergency alert category.
-                alertCategory.removePreference(
+                mAlertCategory.removePreference(
                         findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS));
-                alertCategory.removePreference(
+                mAlertCategory.removePreference(
                         findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS));
-                alertCategory.removePreference(findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS));
+                mAlertCategory.removePreference(findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS));
             }
 
-            TelephonyManager tm = (TelephonyManager) getActivity().getSystemService(
-                    Context.TELEPHONY_SERVICE);
-
-            boolean enableChannel50Support = res.getBoolean(R.bool.show_brazil_settings) ||
-                    "br".equals(tm.getSimCountryIso());
+            boolean enableChannel50Support = SubscriptionManager.getResourcesForSubId(
+                    getApplicationContext(), mSir.getSubscriptionId()).getBoolean(
+                    R.bool.show_brazil_settings)
+                    || "br".equals(mTelephonyManager.getSimCountryIso());
 
             if (!enableChannel50Support) {
-                preferenceScreen.removePreference(findPreference(KEY_CATEGORY_BRAZIL_SETTINGS));
+                prefScreen.removePreference(findPreference(KEY_CATEGORY_BRAZIL_SETTINGS));
             }
             if (!enableDevSettings) {
-                preferenceScreen.removePreference(findPreference(KEY_CATEGORY_DEV_SETTINGS));
+                prefScreen.removePreference(findPreference(KEY_CATEGORY_DEV_SETTINGS));
             }
 
-            Preference enableChannel50Alerts = findPreference(KEY_ENABLE_CHANNEL_50_ALERTS);
-            if (enableChannel50Alerts != null) {
-                enableChannel50Alerts.setOnPreferenceChangeListener(startConfigServiceListener);
+            if (mSpeechCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_ALERT_SPEECH, true, this)) {
+                    mSpeechCheckBox.setChecked(true);
+                } else {
+                    mSpeechCheckBox.setChecked(false);
+                }
+                mSpeechCheckBox.setOnPreferenceChangeListener(
+                        new Preference.OnPreferenceChangeListener() {
+                            @Override
+                            public boolean onPreferenceChange(Preference pref, Object newValue) {
+                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
+                                SubscriptionManager.setSubscriptionProperty(
+                                        mSir.getSubscriptionId(),
+                                        SubscriptionManager.CB_ALERT_SPEECH, newVal + "");
+                                return true;
+                            }
+                        });
             }
-            Preference enableEtwsAlerts = findPreference(KEY_ENABLE_ETWS_TEST_ALERTS);
-            if (enableEtwsAlerts != null) {
-                enableEtwsAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
+
+            if (mVibrateCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_ALERT_VIBRATE, true, this)) {
+                    mVibrateCheckBox.setChecked(true);
+                } else {
+                    mVibrateCheckBox.setChecked(false);
+                }
+                mVibrateCheckBox.setOnPreferenceChangeListener(
+                        new Preference.OnPreferenceChangeListener() {
+                            @Override
+                            public boolean onPreferenceChange(Preference pref, Object newValue) {
+                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
+                                SubscriptionManager.setSubscriptionProperty(
+                                        mSir.getSubscriptionId(),
+                                        SubscriptionManager.CB_ALERT_VIBRATE, newVal + "");
+                                return true;
+                            }
+                        });
             }
-            Preference enableCmasExtremeAlerts =
-                    findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
-            if (enableCmasExtremeAlerts != null) {
-                enableCmasExtremeAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
+
+            if (mOptOutCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_OPT_OUT_DIALOG, true, this)) {
+                    mOptOutCheckBox.setChecked(true);
+                } else {
+                    mOptOutCheckBox.setChecked(false);
+                }
+                mOptOutCheckBox.setOnPreferenceChangeListener(
+                        new Preference.OnPreferenceChangeListener() {
+                            @Override
+                            public boolean onPreferenceChange(Preference pref, Object newValue) {
+                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
+                                SubscriptionManager.setSubscriptionProperty(
+                                        mSir.getSubscriptionId(),
+                                        SubscriptionManager.CB_OPT_OUT_DIALOG, newVal + "");
+                                return true;
+                            }
+                        });
             }
-            Preference enableCmasSevereAlerts =
-                    findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
-            if (enableCmasSevereAlerts != null) {
-                enableCmasSevereAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
-                if (enableCmasExtremeAlerts != null) {
+
+            if (mChannel50CheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_CHANNEL_50_ALERT, true, this)) {
+                    mChannel50CheckBox.setChecked(true);
+                } else {
+                    mChannel50CheckBox.setChecked(false);
+                }
+                mChannel50CheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
+            }
+
+            if (mEtwsTestCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_ETWS_TEST_ALERT, false, this)) {
+                    mEtwsTestCheckBox.setChecked(true);
+                } else {
+                    mEtwsTestCheckBox.setChecked(false);
+                }
+                mEtwsTestCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
+            }
+
+            if (mExtremeCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_EXTREME_THREAT_ALERT, true, this)) {
+                    mExtremeCheckBox.setChecked(true);
+                } else {
+                    mExtremeCheckBox.setChecked(false);
+                }
+                mExtremeCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
+            }
+
+            if (mSevereCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_SEVERE_THREAT_ALERT, true, this)) {
+                    mSevereCheckBox.setChecked(true);
+                } else {
+                    mSevereCheckBox.setChecked(false);
+                }
+                mSevereCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
+                if (mExtremeCheckBox != null) {
                     boolean isExtremeAlertChecked =
-                            ((CheckBoxPreference)enableCmasExtremeAlerts).isChecked();
-                    enableCmasSevereAlerts.setEnabled(isExtremeAlertChecked);
+                            ((CheckBoxPreference) mExtremeCheckBox).isChecked();
+                    mSevereCheckBox.setEnabled(isExtremeAlertChecked);
                 }
             }
-            Preference enableCmasAmberAlerts = findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS);
-            if (enableCmasAmberAlerts != null) {
-                enableCmasAmberAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
+
+            if (mAmberCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_AMBER_ALERT, true, this)) {
+                    mAmberCheckBox.setChecked(true);
+                } else {
+                    mAmberCheckBox.setChecked(false);
+                }
+                mAmberCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableCmasTestAlerts = findPreference(KEY_ENABLE_CMAS_TEST_ALERTS);
-            if (enableCmasTestAlerts != null) {
-                enableCmasTestAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
+
+            if (mCmasCheckBox != null) {
+                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
+                        SubscriptionManager.CB_CMAS_TEST_ALERT, false, this)) {
+                    mCmasCheckBox.setChecked(true);
+                } else {
+                    mCmasCheckBox.setChecked(false);
+                }
+                mCmasCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
             }
         }
+
+    }
+
+    private OnTabChangeListener mTabListener = new OnTabChangeListener() {
+        @Override
+        public void onTabChanged(String tabId) {
+            final int slotId = Integer.parseInt(tabId);
+            mSir = mSelectableSubInfos.get(slotId);
+            updatePreferences();
+        }
+    };
+
+    private TabContentFactory mEmptyTabContent = new TabContentFactory() {
+        @Override
+        public View createTabContent(String tag) {
+            return new View(mTabHost.getContext());
+        }
+    };
+
+    private TabSpec buildTabSpec(String tag, String title) {
+        return mTabHost.newTabSpec(tag).setIndicator(title).setContent(
+                mEmptyTabContent);
+
     }
+
+    public SubscriptionInfo findRecordBySlotId(Context context, final int slotId) {
+        final List<SubscriptionInfo> subInfoList =
+                SubscriptionManager.from(context).getActiveSubscriptionInfoList();
+        if (subInfoList != null) {
+            final int subInfoLength = subInfoList.size();
+
+            for (int i = 0; i < subInfoLength; ++i) {
+                final SubscriptionInfo sir = subInfoList.get(i);
+                if (sir.getSimSlotIndex() == slotId) {
+                    return sir;
+                }
+            }
+        }
+
+        return null;
+    }
+
 }