Merge branch 'kk_2.7_rb1.9' of git://codeaurora.org/platform/packages/apps/CellBroadcastReceiver into cm-10.2caf-rb

6 files changed, 384 insertions, 144 deletions

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 921fe4ac..e1211655 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -73,7 +73,8 @@
         <activity android:name="CellBroadcastSettings"
                   android:label="@string/sms_cb_settings"
                   android:launchMode="singleTask"
-                  android:exported="true" />
+                  android:exported="true"
+                  android:configChanges="orientation|screenSize" />
 
         <activity android:name="CellBroadcastAlertDialog"
                   android:theme="@android:style/Theme.Holo.Dialog"
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
index 75907c9f..d9034055 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertService.java
@@ -1,5 +1,8 @@
 /*
  * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+ *
+ * Not a Contribution.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,12 +30,15 @@ import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.UserHandle;
+import android.os.SystemProperties;
 import android.preference.PreferenceManager;
 import android.provider.Telephony;
 import android.telephony.CellBroadcastMessage;
+import android.telephony.MSimTelephonyManager;
 import android.telephony.SmsCbCmasInfo;
 import android.telephony.SmsCbLocation;
 import android.telephony.SmsCbMessage;
+import com.android.internal.telephony.MSimConstants;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -56,6 +62,11 @@ public class CellBroadcastAlertService extends Service {
     /** Sticky broadcast for latest area info broadcast received. */
     static final String CB_AREA_INFO_RECEIVED_ACTION =
             "android.cellbroadcastreceiver.CB_AREA_INFO_RECEIVED";
+    /** system property to enable/disable broadcast duplicate detecion.  */
+    private static final String CB_DUP_DETECTION = "persist.cb.dup_detection";
+
+    /** Check for system property to enable/disable duplicate detection.  */
+    static boolean mUseDupDetection = SystemProperties.getBoolean(CB_DUP_DETECTION, true);
 
     /** Container for message ID and geographical scope, for duplicate message detection. */
     private static final class MessageServiceCategoryAndScope {
@@ -132,6 +143,7 @@ public class CellBroadcastAlertService extends Service {
         }
 
         SmsCbMessage message = (SmsCbMessage) extras.get("message");
+        int subId = intent.getIntExtra(MSimConstants.SUBSCRIPTION_KEY, 0);
 
         if (message == null) {
             Log.e(TAG, "received SMS_CB_RECEIVED_ACTION with no message extra");
@@ -139,37 +151,40 @@ public class CellBroadcastAlertService extends Service {
         }
 
         final CellBroadcastMessage cbm = new CellBroadcastMessage(message);
+        cbm.setSubId(subId);
         if (!isMessageEnabledByUser(cbm)) {
             Log.d(TAG, "ignoring alert of type " + cbm.getServiceCategory() +
                     " by user preference");
             return;
         }
 
-        // Check for duplicate message IDs according to CMAS carrier requirements. Message IDs
-        // are stored in volatile memory. If the maximum of 65535 messages is reached, the
-        // message ID of the oldest message is deleted from the list.
-        MessageServiceCategoryAndScope newCmasId = new MessageServiceCategoryAndScope(
-                message.getServiceCategory(), message.getSerialNumber(), message.getLocation());
-
-        // Add the new message ID to the list. It's okay if this is a duplicate message ID,
-        // because the list is only used for removing old message IDs from the hash set.
-        if (sCmasIdList.size() < MAX_MESSAGE_ID_SIZE) {
-            sCmasIdList.add(newCmasId);
-        } else {
-            // Get oldest message ID from the list and replace with the new message ID.
-            MessageServiceCategoryAndScope oldestCmasId = sCmasIdList.get(sCmasIdListIndex);
-            sCmasIdList.set(sCmasIdListIndex, newCmasId);
-            Log.d(TAG, "message ID limit reached, removing oldest message ID " + oldestCmasId);
-            // Remove oldest message ID from the set.
-            sCmasIdSet.remove(oldestCmasId);
-            if (++sCmasIdListIndex >= MAX_MESSAGE_ID_SIZE) {
-                sCmasIdListIndex = 0;
+        if (mUseDupDetection) {
+            // Check for duplicate message IDs according to CMAS carrier requirements. Message IDs
+            // are stored in volatile memory. If the maximum of 65535 messages is reached, the
+            // message ID of the oldest message is deleted from the list.
+            MessageServiceCategoryAndScope newCmasId = new MessageServiceCategoryAndScope(
+                    message.getServiceCategory(), message.getSerialNumber(), message.getLocation());
+
+            // Add the new message ID to the list. It's okay if this is a duplicate message ID,
+            // because the list is only used for removing old message IDs from the hash set.
+            if (sCmasIdList.size() < MAX_MESSAGE_ID_SIZE) {
+                sCmasIdList.add(newCmasId);
+            } else {
+                // Get oldest message ID from the list and replace with the new message ID.
+                MessageServiceCategoryAndScope oldestCmasId = sCmasIdList.get(sCmasIdListIndex);
+                sCmasIdList.set(sCmasIdListIndex, newCmasId);
+                Log.d(TAG, "message ID limit reached, removing oldest message ID " + oldestCmasId);
+                // Remove oldest message ID from the set.
+                sCmasIdSet.remove(oldestCmasId);
+                if (++sCmasIdListIndex >= MAX_MESSAGE_ID_SIZE) {
+                    sCmasIdListIndex = 0;
+                }
+            }
+            // Set.add() returns false if message ID has already been added
+            if (!sCmasIdSet.add(newCmasId)) {
+                Log.d(TAG, "ignoring duplicate alert with " + newCmasId);
+                return;
             }
-        }
-        // Set.add() returns false if message ID has already been added
-        if (!sCmasIdSet.add(newCmasId)) {
-            Log.d(TAG, "ignoring duplicate alert with " + newCmasId);
-            return;
         }
 
         final Intent alertIntent = new Intent(SHOW_NEW_ALERT_ACTION);
@@ -228,30 +243,34 @@ public class CellBroadcastAlertService extends Service {
      * @return true if the user has enabled this message type; false otherwise
      */
     private boolean isMessageEnabledByUser(CellBroadcastMessage message) {
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
+        int subscription = message.getSubId();
         if (message.isEtwsTestMessage()) {
-            return PreferenceManager.getDefaultSharedPreferences(this)
-                    .getBoolean(CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false);
+            return prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS
+                    + subscription, false);
         }
 
         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 prefs.getBoolean(
+                            CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS
+                            + subscription, true);
 
                 case SmsCbCmasInfo.CMAS_CLASS_SEVERE_THREAT:
-                    return PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
-                            CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true);
+                    return prefs.getBoolean(
+                            CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS
+                            + subscription, true);
 
                 case SmsCbCmasInfo.CMAS_CLASS_CHILD_ABDUCTION_EMERGENCY:
-                    return PreferenceManager.getDefaultSharedPreferences(this)
-                            .getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true);
+                    return prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS
+                            + subscription, true);
 
                 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 prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS
+                            + subscription, false);
 
                 default:
                     return true;    // presidential-level CMAS alerts are always enabled
@@ -294,9 +313,10 @@ public class CellBroadcastAlertService extends Service {
             duration = 10500;
         } else {
             duration = Integer.parseInt(prefs.getString(
-                    CellBroadcastSettings.KEY_ALERT_SOUND_DURATION,
-                    CellBroadcastSettings.ALERT_SOUND_DEFAULT_DURATION)) * 1000;
+                    CellBroadcastSettings.KEY_ALERT_SOUND_DURATION + message.getSubId(),
+                    CellBroadcastSettings.ALERT_SOUND_DEFAULT_DURATION))*1000;
         }
+
         audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_DURATION_EXTRA, duration);
 
         if (message.isEtwsMessage()) {
@@ -311,7 +331,8 @@ public class CellBroadcastAlertService extends Service {
 
         String messageBody = message.getMessageBody();
 
-        if (prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_SPEECH, true)) {
+        if (prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_SPEECH + message.getSubId(),
+                true)) {
             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 17b9bee1..fc3b975b 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java
@@ -1,4 +1,6 @@
 /*
+ * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,6 +26,8 @@ import android.content.res.Resources;
 import android.os.SystemProperties;
 import android.preference.PreferenceManager;
 import android.telephony.CellBroadcastMessage;
+import android.telephony.MSimSmsManager;
+import android.telephony.MSimTelephonyManager;
 import android.telephony.SmsManager;
 import android.telephony.TelephonyManager;
 import android.text.TextUtils;
@@ -31,6 +35,7 @@ import android.util.Log;
 
 import com.android.internal.telephony.cdma.sms.SmsEnvelope;
 import com.android.internal.telephony.gsm.SmsCbConstants;
+import com.android.internal.telephony.MSimConstants;
 
 import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.DBG;
 
@@ -53,13 +58,49 @@ public class CellBroadcastConfigService extends IntentService {
     static final String EMERGENCY_BROADCAST_RANGE_GSM =
             "ro.cb.gsm.emergencyids";
 
+    private int mSubscription = MSimConstants.DEFAULT_SUBSCRIPTION;
+
     public CellBroadcastConfigService() {
         super(TAG);          // use class name for worker thread name
     }
 
-    private static void setChannelRange(SmsManager manager, String ranges, boolean enable) {
-        if (DBG)log("setChannelRange: " + ranges);
+    private void enableCellBroadcast(int messageIdentifier, boolean isMSim) {
+        if (isMSim) {
+            MSimSmsManager.getDefault().enableCellBroadcast(messageIdentifier, mSubscription);
+        } else {
+            SmsManager.getDefault().enableCellBroadcast(messageIdentifier);
+        }
+    }
 
+    private void disableCellBroadcast(int messageIdentifier, boolean isMSim) {
+        if (isMSim) {
+            MSimSmsManager.getDefault().disableCellBroadcast(messageIdentifier, mSubscription);
+        } else {
+            SmsManager.getDefault().disableCellBroadcast(messageIdentifier);
+        }
+    }
+
+    private void enableCellBroadcastRange(int startMessageId, int endMessageId, boolean isMSim) {
+        if (isMSim) {
+            MSimSmsManager.getDefault().enableCellBroadcastRange(startMessageId, endMessageId,
+                    mSubscription);
+        } else {
+            SmsManager.getDefault().enableCellBroadcastRange(startMessageId, endMessageId);
+        }
+    }
+
+    private void disableCellBroadcastRange(int startMessageId, int endMessageId, boolean isMSim) {
+        if (isMSim) {
+            MSimSmsManager.getDefault().enableCellBroadcastRange(startMessageId, endMessageId,
+                    mSubscription);
+        } else {
+            SmsManager.getDefault().enableCellBroadcastRange(startMessageId, endMessageId);
+        }
+    }
+
+    private void setChannelRange(String ranges, boolean enable) {
+        if (DBG)log("setChannelRange: " + ranges);
+        boolean isMSim = MSimTelephonyManager.getDefault().isMultiSimEnabled();
         try {
             for (String channelRange : ranges.split(",")) {
                 int dashIndex = channelRange.indexOf('-');
@@ -68,19 +109,19 @@ 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);
+                        enableCellBroadcastRange(startId, endId, isMSim);
                     } else {
                         if (DBG) log("disabling emergency IDs " + startId + '-' + endId);
-                        manager.disableCellBroadcastRange(startId, endId);
+                        disableCellBroadcastRange(startId, endId, isMSim);
                     }
                 } else {
                     int messageId = Integer.decode(channelRange.trim());
                     if (enable) {
                         if (DBG) log("enabling emergency message ID " + messageId);
-                        manager.enableCellBroadcast(messageId);
+                        enableCellBroadcast(messageId, isMSim);
                     } else {
                         if (DBG) log("disabling emergency message ID " + messageId);
-                        manager.disableCellBroadcast(messageId);
+                        disableCellBroadcast(messageId, isMSim);
                     }
                 }
             }
@@ -90,10 +131,10 @@ public class CellBroadcastConfigService extends IntentService {
 
         // Make sure CMAS Presidential is enabled (See 3GPP TS 22.268 Section 6.2).
         if (DBG) log("setChannelRange: enabling CMAS Presidential");
-        if (CellBroadcastReceiver.phoneIsCdma()) {
-            manager.enableCellBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT);
+        if (CellBroadcastReceiver.phoneIsCdma(mSubscription)) {
+            enableCellBroadcast(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, isMSim);
         } else {
-            manager.enableCellBroadcast(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL);
+            enableCellBroadcast(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, isMSim);
         }
     }
 
@@ -109,7 +150,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)) {
@@ -141,6 +182,8 @@ public class CellBroadcastConfigService extends IntentService {
     @Override
     protected void onHandleIntent(Intent intent) {
         if (ACTION_ENABLE_CHANNELS.equals(intent.getAction())) {
+            mSubscription = intent.getIntExtra(MSimConstants.SUBSCRIPTION_KEY,
+                    MSimConstants.DEFAULT_SUBSCRIPTION);
             try {
                 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
                 Resources res = getResources();
@@ -150,7 +193,7 @@ public class CellBroadcastConfigService extends IntentService {
                 // 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);
+                        CellBroadcastSettings.KEY_ENABLE_EMERGENCY_ALERTS + mSubscription, true);
 
                 TelephonyManager tm = (TelephonyManager) getSystemService(
                         Context.TELEPHONY_SERVICE);
@@ -159,23 +202,26 @@ public class CellBroadcastConfigService extends IntentService {
                         "br".equals(tm.getSimCountryIso());
 
                 boolean enableChannel50Alerts = enableChannel50Support &&
-                        prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_CHANNEL_50_ALERTS, true);
+                        prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_CHANNEL_50_ALERTS
+                        + mSubscription, true);
 
                 // Note:  ETWS is for 3GPP only
                 boolean enableEtwsTestAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false);
+                        CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS + mSubscription, false);
 
                 boolean enableCmasExtremeAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true);
+                        CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + mSubscription,
+                        true);
 
                 boolean enableCmasSevereAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true);
+                        CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + mSubscription,
+                        true);
 
                 boolean enableCmasAmberAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true);
+                        CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS + mSubscription, true);
 
                 boolean enableCmasTestAlerts = prefs.getBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, false);
+                        CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS + mSubscription, false);
 
                 // set up broadcast ID ranges to be used for each category
                 int cmasExtremeStart =
@@ -189,8 +235,10 @@ public class CellBroadcastConfigService extends IntentService {
                 int cmasTestEnd = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE;
                 int cmasPresident = SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL;
 
+                boolean isMSim = MSimTelephonyManager.getDefault().isMultiSimEnabled();
+
                 // set to CDMA broadcast ID rage if phone is in CDMA mode.
-                boolean isCdma = CellBroadcastReceiver.phoneIsCdma();
+                boolean isCdma = CellBroadcastReceiver.phoneIsCdma(mSubscription);
                 if (isCdma) {
                     cmasExtremeStart = SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT;
                     cmasExtremeEnd = cmasExtremeStart;
@@ -202,68 +250,69 @@ public class CellBroadcastConfigService extends IntentService {
                     cmasPresident = SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT;
                 }
 
-                SmsManager manager = SmsManager.getDefault();
                 // Check for system property defining the emergency channel ranges to enable
                 String emergencyIdRange = isCdma ?
                         "" : SystemProperties.get(EMERGENCY_BROADCAST_RANGE_GSM);
                 if (enableEmergencyAlerts) {
                     if (DBG) log("enabling emergency cell broadcast channels");
                     if (!TextUtils.isEmpty(emergencyIdRange)) {
-                        setChannelRange(manager, emergencyIdRange, true);
+                        setChannelRange(emergencyIdRange, true);
                     } else {
                         // No emergency channel system property, enable all emergency channels
                         // that have checkbox checked
                         if (!isCdma) {
-                            manager.enableCellBroadcastRange(
+                            enableCellBroadcastRange(
                                     SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING,
-                                    SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING);
+                                    SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING,
+                                            isMSim);
                             if (enableEtwsTestAlerts) {
-                                manager.enableCellBroadcast(
-                                        SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE);
+                                enableCellBroadcast(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE,
+                                        isMSim);
                             }
-                            manager.enableCellBroadcast(
-                                    SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE);
+                            enableCellBroadcast(
+                                    SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, isMSim);
                         }
                         if (enableCmasExtremeAlerts) {
-                            manager.enableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd);
+                            enableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd, isMSim);
                         }
                         if (enableCmasSevereAlerts) {
-                            manager.enableCellBroadcastRange(cmasSevereStart, cmasSevereEnd);
+                            enableCellBroadcastRange(cmasSevereStart, cmasSevereEnd, isMSim);
                         }
                         if (enableCmasAmberAlerts) {
-                            manager.enableCellBroadcast(cmasAmber);
+                            enableCellBroadcast(cmasAmber, isMSim);
                         }
                         if (enableCmasTestAlerts) {
-                            manager.enableCellBroadcastRange(cmasTestStart, cmasTestEnd);
+                            enableCellBroadcastRange(cmasTestStart, cmasTestEnd, isMSim);
                         }
                         // CMAS Presidential must be on (See 3GPP TS 22.268 Section 6.2).
-                        manager.enableCellBroadcast(cmasPresident);
+                        enableCellBroadcast(cmasPresident, isMSim);
                     }
                     if (DBG) log("enabled emergency cell broadcast channels");
                 } else {
                     // we may have enabled these channels previously, so try to disable them
                     if (DBG) log("disabling emergency cell broadcast channels");
                     if (!TextUtils.isEmpty(emergencyIdRange)) {
-                        setChannelRange(manager, emergencyIdRange, false);
+                        setChannelRange(emergencyIdRange, false);
                     } else {
                         // No emergency channel system property, disable all emergency channels
                         // except for CMAS Presidential (See 3GPP TS 22.268 Section 6.2)
                         if (!isCdma) {
-                            manager.disableCellBroadcastRange(
+                            disableCellBroadcastRange(
                                     SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING,
-                                    SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING);
-                            manager.disableCellBroadcast(
-                                    SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE);
-                            manager.disableCellBroadcast(
-                                    SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE);
+                                    SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING,
+                                            isMSim);
+                            disableCellBroadcast(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE,
+                                    isMSim);
+                            disableCellBroadcast(
+                                SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, isMSim);
                         }
-                        manager.disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd);
-                        manager.disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd);
-                        manager.disableCellBroadcast(cmasAmber);
-                        manager.disableCellBroadcastRange(cmasTestStart, cmasTestEnd);
+                        disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd, isMSim);
+                        disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd, isMSim);
+                        disableCellBroadcast(cmasAmber, isMSim);
+                        disableCellBroadcastRange(cmasTestStart, cmasTestEnd, isMSim);
 
                         // CMAS Presidential must be on (See 3GPP TS 22.268 Section 6.2).
-                        manager.enableCellBroadcast(cmasPresident);
+                        enableCellBroadcast(cmasPresident, isMSim);
                     }
                     if (DBG) log("disabled emergency cell broadcast channels");
                 }
@@ -272,11 +321,11 @@ public class CellBroadcastConfigService extends IntentService {
                     if (DBG) log("channel 50 is not aplicable for cdma");
                 } else if (enableChannel50Alerts) {
                     if (DBG) log("enabling cell broadcast channel 50");
-                    manager.enableCellBroadcast(50);
+                    enableCellBroadcast(50, isMSim);
                     if (DBG) log("enabled cell broadcast channel 50");
                 } else {
                     if (DBG) log("disabling cell broadcast channel 50");
-                    manager.disableCellBroadcast(50);
+                    disableCellBroadcast(50, isMSim);
                     if (DBG) log("disabled cell broadcast channel 50");
                 }
 
@@ -285,24 +334,24 @@ public class CellBroadcastConfigService extends IntentService {
                 // but check box is unchecked to receive such as cmas severe alerts.
                 if (!enableEtwsTestAlerts  && !isCdma) {
                     if (DBG) Log.d(TAG, "disabling cell broadcast ETWS test messages");
-                    manager.disableCellBroadcast(
-                            SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE);
+                    disableCellBroadcast(
+                            SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, isMSim);
                 }
                 if (!enableCmasExtremeAlerts) {
                     if (DBG) Log.d(TAG, "disabling cell broadcast CMAS extreme");
-                    manager.disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd);
+                    disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd, isMSim);
                 }
                 if (!enableCmasSevereAlerts) {
                     if (DBG) Log.d(TAG, "disabling cell broadcast CMAS severe");
-                    manager.disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd);
+                    disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd, isMSim);
                 }
                 if (!enableCmasAmberAlerts) {
                     if (DBG) Log.d(TAG, "disabling cell broadcast CMAS amber");
-                    manager.disableCellBroadcast(cmasAmber);
+                    disableCellBroadcast(cmasAmber, isMSim);
                 }
                 if (!enableCmasTestAlerts) {
                     if (DBG) Log.d(TAG, "disabling cell broadcast CMAS test messages");
-                    manager.disableCellBroadcastRange(cmasTestStart, cmasTestEnd);
+                    disableCellBroadcastRange(cmasTestStart, cmasTestEnd, isMSim);
                 }
             } catch (Exception ex) {
                 Log.e(TAG, "exception enabling cell broadcast channels", ex);
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
index c1eeeab7..24dfaa4b 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java
@@ -27,6 +27,7 @@ import android.os.UserHandle;
 import android.preference.PreferenceManager;
 import android.provider.Telephony;
 import android.telephony.CellBroadcastMessage;
+import android.telephony.MSimTelephonyManager;
 import android.telephony.PhoneStateListener;
 import android.telephony.ServiceState;
 import android.telephony.TelephonyManager;
@@ -34,7 +35,9 @@ import android.telephony.cdma.CdmaSmsCbProgramData;
 import android.util.Log;
 
 import com.android.internal.telephony.ITelephony;
+import com.android.internal.telephony.MSimConstants;
 import com.android.internal.telephony.cdma.sms.SmsEnvelope;
+import com.android.internal.telephony.msim.ITelephonyMSim;
 
 public class CellBroadcastReceiver extends BroadcastReceiver {
     private static final String TAG = "CellBroadcastReceiver";
@@ -42,6 +45,7 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
 
     private static final String GET_LATEST_CB_AREA_INFO_ACTION =
             "android.cellbroadcastreceiver.GET_LATEST_CB_AREA_INFO";
+    private int mSubscription = MSimConstants.DEFAULT_SUBSCRIPTION;
 
     @Override
     public void onReceive(Context context, Intent intent) {
@@ -55,15 +59,31 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
 
         if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
             if (DBG) log("Registering for ServiceState updates");
-            TelephonyManager tm = (TelephonyManager) context.getSystemService(
-                    Context.TELEPHONY_SERVICE);
-            tm.listen(new ServiceStateListener(context.getApplicationContext()),
-                    PhoneStateListener.LISTEN_SERVICE_STATE);
+            if (MSimTelephonyManager.getDefault().isMultiSimEnabled()) {
+                MSimTelephonyManager msimTm = (MSimTelephonyManager)
+                        context.getSystemService(Context.MSIM_TELEPHONY_SERVICE);;
+                int numPhones = MSimTelephonyManager.getDefault().getPhoneCount();
+                for (int i = 0; i < numPhones; i++) {
+                    msimTm.listen(new ServiceStateListener(context.getApplicationContext(), i),
+                            PhoneStateListener.LISTEN_SERVICE_STATE);
+                }
+            } else {
+                TelephonyManager tm = (TelephonyManager) context.getSystemService(
+                        Context.TELEPHONY_SERVICE);
+                tm.listen(new ServiceStateListener(context.getApplicationContext()),
+                        PhoneStateListener.LISTEN_SERVICE_STATE);
+            }
         } else if (Intent.ACTION_AIRPLANE_MODE_CHANGED.equals(action)) {
             boolean airplaneModeOn = intent.getBooleanExtra("state", false);
             if (DBG) log("airplaneModeOn: " + airplaneModeOn);
             if (!airplaneModeOn) {
-                startConfigService(context);
+                if (MSimTelephonyManager.getDefault().isMultiSimEnabled()) {
+                    for (int i = 0; i < MSimTelephonyManager.getDefault().getPhoneCount(); i++){
+                        startConfigService(context, i);
+                    }
+                } else {
+                    startConfigService(context);
+                }
             }
         } else if (Telephony.Sms.Intents.SMS_EMERGENCY_CB_RECEIVED_ACTION.equals(action) ||
                 Telephony.Sms.Intents.SMS_CB_RECEIVED_ACTION.equals(action)) {
@@ -80,6 +100,9 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
         } else if (Telephony.Sms.Intents.SMS_SERVICE_CATEGORY_PROGRAM_DATA_RECEIVED_ACTION
                 .equals(action)) {
             if (privileged) {
+                mSubscription = intent.getIntExtra(MSimConstants.SUBSCRIPTION_KEY,
+                    MSimConstants.SUB1);
+                Log.d(TAG, "onReceive SMS_CATEGORY_PROGRAM_DATA mSubscription :" + mSubscription);
                 CdmaSmsCbProgramData[] programDataList = (CdmaSmsCbProgramData[])
                         intent.getParcelableArrayExtra("program_data_list");
                 if (programDataList != null) {
@@ -92,7 +115,8 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
             }
         } else if (GET_LATEST_CB_AREA_INFO_ACTION.equals(action)) {
             if (privileged) {
-                CellBroadcastMessage message = CellBroadcastReceiverApp.getLatestAreaInfo();
+                int subId = intent.getIntExtra(MSimConstants.SUBSCRIPTION_KEY, 0);
+                CellBroadcastMessage message = CellBroadcastReceiverApp.getLatestAreaInfo(subId);
                 if (message != null) {
                     Intent areaInfoIntent = new Intent(
                             CellBroadcastAlertService.CB_AREA_INFO_RECEIVED_ACTION);
@@ -146,34 +170,30 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
 
     private void tryCdmaSetCategory(Context context, int category, boolean enable) {
         SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
+        String key = null;
 
         switch (category) {
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, enable)
-                        .apply();
+                key = CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + mSubscription;
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, enable)
-                        .apply();
+                key = CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + mSubscription;
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, enable).apply();
+                key = CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS + mSubscription;
                 break;
 
             case SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE:
-                sharedPrefs.edit().putBoolean(
-                        CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, enable).apply();
+                key = CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS + mSubscription;
                 break;
 
             default:
                 Log.w(TAG, "Ignoring SCPD command to " + (enable ? "enable" : "disable")
                         + " alerts in category " + category);
         }
+        if (null != key) sharedPrefs.edit().putBoolean(key, enable).apply();
     }
 
     /**
@@ -186,15 +206,32 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
         context.startService(serviceIntent);
     }
 
+    static void startConfigService(Context context, int subscription) {
+        Intent serviceIntent = new Intent(CellBroadcastConfigService.ACTION_ENABLE_CHANNELS, null,
+                context, CellBroadcastConfigService.class);
+        serviceIntent.putExtra(MSimConstants.SUBSCRIPTION_KEY, subscription);
+        context.startService(serviceIntent);
+    }
+
     /**
      * @return true if the phone is a CDMA phone type
      */
-    static boolean phoneIsCdma() {
+    static boolean phoneIsCdma(int subscription) {
         boolean isCdma = false;
         try {
-            ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
-            if (phone != null) {
-                isCdma = (phone.getActivePhoneType() == TelephonyManager.PHONE_TYPE_CDMA);
+            if (MSimTelephonyManager.getDefault().isMultiSimEnabled()) {
+                ITelephonyMSim phoneMsim = ITelephonyMSim.Stub.asInterface(
+                        ServiceManager.checkService("phone_msim"));
+                if (phoneMsim != null) {
+                    isCdma = (phoneMsim.getActivePhoneType(subscription) ==
+                            TelephonyManager.PHONE_TYPE_CDMA);
+                }
+            } else {
+                ITelephony phone = ITelephony.Stub.asInterface(
+                        ServiceManager.checkService("phone"));
+                if (phone != null) {
+                    isCdma = (phone.getActivePhoneType() == TelephonyManager.PHONE_TYPE_CDMA);
+                }
             }
         } catch (RemoteException e) {
             Log.w(TAG, "phone.getActivePhoneType() failed", e);
@@ -210,6 +247,11 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
             mContext = context;
         }
 
+        ServiceStateListener(Context context, int subscription) {
+            mContext = context;
+            mSubscription = subscription;
+        }
+
         @Override
         public void onServiceStateChanged(ServiceState ss) {
             int newState = ss.getState();
@@ -218,7 +260,12 @@ public class CellBroadcastReceiver extends BroadcastReceiver {
                 mServiceState = newState;
                 if (newState == ServiceState.STATE_IN_SERVICE ||
                         newState == ServiceState.STATE_EMERGENCY_ONLY) {
-                    startConfigService(mContext);
+                    if (MSimTelephonyManager.getDefault().isMultiSimEnabled()) {
+                        Log.d(TAG, "Service state changed for Subscription: " + mSubscription);
+                        startConfigService(mContext, mSubscription);
+                    } else {
+                        startConfigService(mContext);
+                    }
                 }
             }
         }
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java
index b9e60398..d811d823 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java
@@ -23,7 +23,8 @@ import android.preference.PreferenceManager;
 
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
-
+import java.util.HashMap;
+import java.util.Map;
 /**
  * The application class loads the default preferences at first start,
  * and remembers the time of the most recently received broadcast.
@@ -43,7 +44,8 @@ public class CellBroadcastReceiverApp extends Application {
             new ArrayList<CellBroadcastMessage>(4);
 
     /** Latest area info cell broadcast received. */
-    private static CellBroadcastMessage sLatestAreaInfo;
+    private static Map<Integer, CellBroadcastMessage> sLatestAreaInfo =
+                                new HashMap<Integer,CellBroadcastMessage>();
 
     /** Adds a new unread non-emergency message and returns the current list. */
     static ArrayList<CellBroadcastMessage> addNewMessageToList(CellBroadcastMessage message) {
@@ -58,11 +60,11 @@ public class CellBroadcastReceiverApp extends Application {
 
     /** Saves the latest area info broadcast received. */
     static void setLatestAreaInfo(CellBroadcastMessage areaInfo) {
-        sLatestAreaInfo = areaInfo;
+        sLatestAreaInfo.put(areaInfo.getSubId(), areaInfo);
     }
 
     /** Returns the latest area info broadcast received. */
-    static CellBroadcastMessage getLatestAreaInfo() {
-        return sLatestAreaInfo;
+    static CellBroadcastMessage getLatestAreaInfo(int subId ) {
+        return sLatestAreaInfo.get(subId);
     }
 }
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
index 85133311..c58cb6c1 100644
--- a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
+++ b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java
@@ -1,5 +1,8 @@
 /*
  * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ *
+ * Not a Contribution.
  *
  * 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
@@ -16,23 +19,34 @@
 
 package com.android.cellbroadcastreceiver;
 
+import android.app.ActionBar;
+import android.app.ActionBar.Tab;
+import android.app.FragmentTransaction;
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.content.res.Resources;
 import android.os.Bundle;
+import android.preference.CheckBoxPreference;
 import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.PreferenceActivity;
 import android.preference.PreferenceCategory;
 import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager;
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
+import android.telephony.MSimSmsManager;
+import android.telephony.MSimTelephonyManager;
 import android.telephony.TelephonyManager;
+import android.util.Log;
+import com.android.internal.telephony.MSimConstants;
 
 /**
  * Settings activity for the cell broadcast receiver.
  */
 public class CellBroadcastSettings extends PreferenceActivity {
 
+    public static final String TAG = "CellBroadcastSettings";
     // Preference key for whether to enable emergency notifications (default enabled).
     public static final String KEY_ENABLE_EMERGENCY_ALERTS = "enable_emergency_alerts";
 
@@ -87,38 +101,157 @@ public class CellBroadcastSettings extends PreferenceActivity {
     // Alert reminder interval ("once" = single 2 minute reminder).
     public static final String KEY_ALERT_REMINDER_INTERVAL = "alert_reminder_interval";
 
+    public static String subTag = "SUB";
+    public int mSubscription = MSimConstants.DEFAULT_SUBSCRIPTION;
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        if (MSimTelephonyManager.getDefault().isMultiSimEnabled()) {
+            mSubscription = MSimConstants.SUB1;
+            final ActionBar actionBar = getActionBar();
+            actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
+            actionBar.setDisplayShowTitleEnabled(true);
+            for (int i = 0; i < MSimTelephonyManager.getDefault().getPhoneCount(); i++) {
+                actionBar.addTab(actionBar.newTab().setText(subTag+(i+1)).setTabListener(
+                        new MySubTabListener(new CellBroadcastSettingsFragment(),
+                        subTag+(i+1), i)));
+            }
+        } else {
+            // Display the fragment as the main content.
+            getFragmentManager().beginTransaction().replace(android.R.id.content,
+                    new CellBroadcastSettingsFragment()).commit();
+        }
+    }
+
+    private class MySubTabListener implements ActionBar.TabListener {
 
-        // Display the fragment as the main content.
-        getFragmentManager().beginTransaction().replace(android.R.id.content,
-                new CellBroadcastSettingsFragment()).commit();
+        private CellBroadcastSettingsFragment mFragment;
+        private String tag;
+        private int subScription;
+
+        public MySubTabListener(CellBroadcastSettingsFragment cbFragment, String tag,
+                int subScription) {
+            this.mFragment = cbFragment;
+            this.tag = tag;
+            this.subScription = subScription;
+        }
+
+        @Override
+        public void onTabSelected(Tab tab, FragmentTransaction ft) {
+            ft.add(android.R.id.content, mFragment, tag);
+            mSubscription = subScription;
+            Log.d(TAG, "onTabSelected  mSubscription:" + mSubscription);
+        }
+
+        @Override
+        public void onTabUnselected(Tab tab, FragmentTransaction ft) {
+            if (mFragment != null) {
+                ft.remove(mFragment);
+            }
+        }
+
+        @Override
+        public void onTabReselected(Tab tab, FragmentTransaction ft) {
+        }
     }
 
+
     /**
      * New fragment-style implementation of preferences.
      */
-    public static class CellBroadcastSettingsFragment extends PreferenceFragment {
+    public class CellBroadcastSettingsFragment extends PreferenceFragment {
 
         @Override
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
-
+            Log.d(TAG, "onCreate CellBroadcastSettingsFragment  mSubscription :" + mSubscription);
             // Load the preferences from an XML resource
             addPreferencesFromResource(R.xml.preferences);
 
+            final SharedPreferences prefs = PreferenceManager
+                    .getDefaultSharedPreferences(getActivity());
             PreferenceScreen preferenceScreen = getPreferenceScreen();
+            // Emergency alert preference category (general and CMAS preferences).
+            PreferenceCategory alertCategory =
+                    (PreferenceCategory) findPreference(KEY_CATEGORY_ALERT_SETTINGS);
+            final CheckBoxPreference enablePwsAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_EMERGENCY_ALERTS);
+            final ListPreference duration =
+                    (ListPreference) findPreference(KEY_ALERT_SOUND_DURATION);
+            final CheckBoxPreference enableChannel50Alerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_CHANNEL_50_ALERTS);
+            final CheckBoxPreference enableEtwsAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_ETWS_TEST_ALERTS);
+            final CheckBoxPreference enableCmasExtremeAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
+            final CheckBoxPreference enableCmasSevereAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
+            final CheckBoxPreference enableCmasAmberAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS);
+            final CheckBoxPreference enableCmasTestAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_CMAS_TEST_ALERTS);
+            final CheckBoxPreference enableSpeakerAlerts =
+                    (CheckBoxPreference) findPreference(KEY_ENABLE_ALERT_SPEECH);
+
+            enablePwsAlerts.setChecked(prefs.getBoolean( KEY_ENABLE_EMERGENCY_ALERTS
+                    + mSubscription, true));
+            duration.setSummary(prefs.getString(KEY_ALERT_SOUND_DURATION
+                    + mSubscription, ALERT_SOUND_DEFAULT_DURATION));
+            duration.setValue(prefs.getString(KEY_ALERT_SOUND_DURATION
+                    + mSubscription, ALERT_SOUND_DEFAULT_DURATION));
+            enableChannel50Alerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_CHANNEL_50_ALERTS + mSubscription, true));
+            enableEtwsAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_ETWS_TEST_ALERTS + mSubscription, false));
+            enableCmasExtremeAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + mSubscription, true));
+            enableCmasSevereAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + mSubscription, true));
+            enableCmasAmberAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_CMAS_AMBER_ALERTS + mSubscription, true));
+            enableCmasTestAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_CMAS_TEST_ALERTS + mSubscription, false));
+            enableSpeakerAlerts.setChecked(prefs.getBoolean(
+                    KEY_ENABLE_ALERT_SPEECH + mSubscription, true));
 
             // 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());
-                            return true;
-                        }
-                    };
+                @Override
+                public boolean onPreferenceChange(Preference pref, Object newValue) {
+                    String value = String.valueOf(newValue);
+                    SharedPreferences.Editor editor = prefs.edit();
+                    if (pref == enablePwsAlerts) {
+                        editor.putBoolean(KEY_ENABLE_EMERGENCY_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableChannel50Alerts) {
+                        editor.putBoolean(KEY_ENABLE_CHANNEL_50_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableEtwsAlerts) {
+                        editor.putBoolean(KEY_ENABLE_ETWS_TEST_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableCmasExtremeAlerts) {
+                        editor.putBoolean(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableCmasSevereAlerts) {
+                        editor.putBoolean(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableCmasAmberAlerts) {
+                        editor.putBoolean(KEY_ENABLE_CMAS_AMBER_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableCmasTestAlerts) {
+                        editor.putBoolean(KEY_ENABLE_CMAS_TEST_ALERTS
+                                + mSubscription, Boolean.valueOf((value)));
+                    } else if (pref == enableSpeakerAlerts) {
+                        editor.putBoolean(KEY_ENABLE_ALERT_SPEECH
+                                + mSubscription, Boolean.valueOf((value)));
+                    }
+                    editor.commit();
+                    CellBroadcastReceiver.startConfigService(pref.getContext(), mSubscription);
+                    return true;
+                }
+            };
 
             // Show extra settings when developer options is enabled in settings.
             boolean enableDevSettings = Settings.Global.getInt(getActivity().getContentResolver(),
@@ -127,10 +260,6 @@ public class CellBroadcastSettings extends PreferenceActivity {
             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);
-
             // alert reminder interval
             ListPreference interval = (ListPreference) findPreference(KEY_ALERT_REMINDER_INTERVAL);
             interval.setSummary(interval.getEntry());
@@ -147,20 +276,18 @@ public class CellBroadcastSettings extends PreferenceActivity {
             // 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);
                 }
 
                 // 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]);
+                        final int idx = duration.findIndexOfValue((String) newValue);
+                        duration.setSummary(duration.getEntries()[idx]);
+                        prefs.edit().putString(KEY_ALERT_SOUND_DURATION  + mSubscription,
+                            String.valueOf(newValue)).commit();
                         return true;
                     }
                 });
@@ -195,29 +322,22 @@ public class CellBroadcastSettings extends PreferenceActivity {
                 preferenceScreen.removePreference(findPreference(KEY_CATEGORY_DEV_SETTINGS));
             }
 
-            Preference enableChannel50Alerts = findPreference(KEY_ENABLE_CHANNEL_50_ALERTS);
             if (enableChannel50Alerts != null) {
                 enableChannel50Alerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableEtwsAlerts = findPreference(KEY_ENABLE_ETWS_TEST_ALERTS);
+
             if (enableEtwsAlerts != null) {
                 enableEtwsAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableCmasExtremeAlerts =
-                    findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
             if (enableCmasExtremeAlerts != null) {
                 enableCmasExtremeAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableCmasSevereAlerts =
-                    findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
             if (enableCmasSevereAlerts != null) {
                 enableCmasSevereAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableCmasAmberAlerts = findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS);
             if (enableCmasAmberAlerts != null) {
                 enableCmasAmberAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }
-            Preference enableCmasTestAlerts = findPreference(KEY_ENABLE_CMAS_TEST_ALERTS);
             if (enableCmasTestAlerts != null) {
                 enableCmasTestAlerts.setOnPreferenceChangeListener(startConfigServiceListener);
             }