diff options
Diffstat (limited to 'src/com')
6 files changed, 323 insertions, 110 deletions
diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertFullScreen.java index fdecc104..9e9abbe5 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,8 @@ 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, + SubscriptionManager.getPhoneId(message.getSubId())); } /** diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java index e4cae6c1..1a609e14 100644 --- a/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java +++ b/src/com/android/cellbroadcastreceiver/CellBroadcastAlertReminder.java @@ -28,9 +28,11 @@ import android.net.Uri; import android.os.IBinder; import android.os.SystemClock; import android.preference.PreferenceManager; +import android.telephony.SubscriptionManager; import android.util.Log; import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.DBG; +import com.android.internal.telephony.PhoneConstants; /** * Manages alert reminder notification. @@ -68,7 +70,10 @@ public class CellBroadcastAlertReminder extends Service { log("playing alert reminder"); playAlertReminderSound(); - if (queueAlertReminder(this, false)) { + int phoneId = intent.getIntExtra(PhoneConstants.SLOT_KEY, + SubscriptionManager.getPhoneId(SubscriptionManager.getDefaultSmsSubId())); + + if (queueAlertReminder(this, false, phoneId)) { return START_STICKY; } else { log("no reminders queued"); @@ -100,12 +105,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 phoneId) { // 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); + String prefStr = prefs.getString(CellBroadcastSettings.KEY_ALERT_REMINDER_INTERVAL + + phoneId, null); if (prefStr == null) { if (DBG) log("no preference value for alert reminder"); @@ -131,6 +137,7 @@ public class CellBroadcastAlertReminder extends Service { Intent playIntent = new Intent(context, CellBroadcastAlertReminder.class); playIntent.setAction(ACTION_PLAY_ALERT_REMINDER); + playIntent.putExtra(PhoneConstants.SLOT_KEY, phoneId); sPlayReminderIntent = PendingIntent.getService(context, 0, playIntent, PendingIntent.FLAG_UPDATE_CURRENT); diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java b/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java index 3569456e..06256265 100644 --- a/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java +++ b/src/com/android/cellbroadcastreceiver/CellBroadcastConfigService.java @@ -25,12 +25,14 @@ 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.cdma.sms.SmsEnvelope; import com.android.internal.telephony.gsm.SmsCbConstants; +import com.android.internal.telephony.PhoneConstants; import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.DBG; @@ -53,6 +55,10 @@ public class CellBroadcastConfigService extends IntentService { static final String EMERGENCY_BROADCAST_RANGE_GSM = "ro.cb.gsm.emergencyids"; + private int mPhoneId = SubscriptionManager.getPhoneId( + SubscriptionManager.getDefaultSmsSubId()); + private static long mSubId = SubscriptionManager.getDefaultSmsSubId(); + public CellBroadcastConfigService() { super(TAG); // use class name for worker thread name } @@ -68,19 +74,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); + manager.enableCellBroadcastRange(mSubId, startId, endId); } else { if (DBG) log("disabling emergency IDs " + startId + '-' + endId); - manager.disableCellBroadcastRange(startId, endId); + manager.disableCellBroadcastRange(mSubId, startId, endId); } } else { int messageId = Integer.decode(channelRange.trim()); if (enable) { if (DBG) log("enabling emergency message ID " + messageId); - manager.enableCellBroadcast(messageId); + manager.enableCellBroadcast(mSubId, messageId); } else { if (DBG) log("disabling emergency message ID " + messageId); - manager.disableCellBroadcast(messageId); + manager.disableCellBroadcast(mSubId, messageId); } } } @@ -90,8 +96,9 @@ 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(mSubId)) { + manager.enableCellBroadcast(mSubId, + SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT); } else { manager.enableCellBroadcast(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL); // register Taiwan PWS 4383 also, by default @@ -111,7 +118,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)) { @@ -143,6 +150,10 @@ public class CellBroadcastConfigService extends IntentService { @Override protected void onHandleIntent(Intent intent) { if (ACTION_ENABLE_CHANNELS.equals(intent.getAction())) { + mPhoneId = intent.getIntExtra(PhoneConstants.SLOT_KEY, + SubscriptionManager.getPhoneId(SubscriptionManager.getDefaultSmsSubId())); + long[] subId = SubscriptionManager.getSubId(mPhoneId); + mSubId = subId[0]; try { SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); Resources res = getResources(); @@ -152,7 +163,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 + mPhoneId, true); TelephonyManager tm = (TelephonyManager) getSystemService( Context.TELEPHONY_SERVICE); @@ -161,23 +172,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 + + mPhoneId, true); // Note: ETWS is for 3GPP only boolean enableEtwsTestAlerts = prefs.getBoolean( - CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false); + CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS + mPhoneId, false); boolean enableCmasExtremeAlerts = prefs.getBoolean( - CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); + CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + + mPhoneId, true); boolean enableCmasSevereAlerts = prefs.getBoolean( - CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); + CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + + mPhoneId, true); boolean enableCmasAmberAlerts = prefs.getBoolean( - CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); + CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS + mPhoneId, true); boolean enableCmasTestAlerts = prefs.getBoolean( - CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, false); + CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS + mPhoneId, false); // set up broadcast ID ranges to be used for each category int cmasExtremeStart = @@ -193,7 +207,7 @@ public class CellBroadcastConfigService extends IntentService { 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(mSubId); if (isCdma) { cmasExtremeStart = SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT; cmasExtremeEnd = cmasExtremeStart; @@ -217,33 +231,33 @@ public class CellBroadcastConfigService extends IntentService { // No emergency channel system property, enable all emergency channels // that have checkbox checked if (!isCdma) { - manager.enableCellBroadcastRange( + manager.enableCellBroadcastRange(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING); if (enableEtwsTestAlerts) { - manager.enableCellBroadcast( + manager.enableCellBroadcast(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE); } - manager.enableCellBroadcast( - SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE); + manager.enableCellBroadcast(mSubId, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE); } if (enableCmasExtremeAlerts) { - manager.enableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd); + manager.enableCellBroadcastRange(mSubId, cmasExtremeStart, cmasExtremeEnd); } if (enableCmasSevereAlerts) { - manager.enableCellBroadcastRange(cmasSevereStart, cmasSevereEnd); + manager.enableCellBroadcastRange(mSubId, cmasSevereStart, cmasSevereEnd); } if (enableCmasAmberAlerts) { - manager.enableCellBroadcast(cmasAmber); + manager.enableCellBroadcast(mSubId, cmasAmber); } if (enableCmasTestAlerts) { - manager.enableCellBroadcastRange(cmasTestStart, cmasTestEnd); + manager.enableCellBroadcastRange(mubId, cmasTestStart, cmasTestEnd); } // CMAS Presidential must be on (See 3GPP TS 22.268 Section 6.2). - manager.enableCellBroadcast(cmasPresident); + manager.enableCellBroadcast(mSubId, cmasPresident); if (!isCdma) { // register Taiwan PWS 4383 also, by default - manager.enableCellBroadcast(cmasTaiwanPWS); + manager.enableCellBroadcast(mSubId, cmasTaiwanPWS); } } if (DBG) log("enabled emergency cell broadcast channels"); @@ -256,24 +270,24 @@ public class CellBroadcastConfigService extends IntentService { // 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( + manager.disableCellBroadcastRange(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING); - manager.disableCellBroadcast( + manager.disableCellBroadcast(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE); - manager.disableCellBroadcast( + manager.disableCellBroadcast(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE); } - manager.disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd); - manager.disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd); - manager.disableCellBroadcast(cmasAmber); - manager.disableCellBroadcastRange(cmasTestStart, cmasTestEnd); + manager.disableCellBroadcastRange(mSubId, cmasExtremeStart, cmasExtremeEnd); + manager.disableCellBroadcastRange(mSubId, cmasSevereStart, cmasSevereEnd); + manager.disableCellBroadcast(mSubId, cmasAmber); + manager.disableCellBroadcastRange(mSubId, cmasTestStart, cmasTestEnd); // CMAS Presidential must be on (See 3GPP TS 22.268 Section 6.2). - manager.enableCellBroadcast(cmasPresident); + manager.enableCellBroadcast(mSubId, cmasPresident); if (!isCdma) { // register Taiwan PWS 4383 also, by default - manager.enableCellBroadcast(cmasTaiwanPWS); + manager.enableCellBroadcast(mSubId, cmasTaiwanPWS); } } if (DBG) log("disabled emergency cell broadcast channels"); @@ -283,18 +297,18 @@ public class CellBroadcastConfigService extends IntentService { if (DBG) log("channel 50 is not applicable for cdma"); } else if (enableChannel50Alerts) { if (DBG) log("enabling cell broadcast channel 50"); - manager.enableCellBroadcast(50); + manager.enableCellBroadcast(mSubId, 50); } else { if (DBG) log("disabling cell broadcast channel 50"); - manager.disableCellBroadcast(50); + manager.disableCellBroadcast(mSubId, 50); } if ("il".equals(tm.getSimCountryIso()) || "il".equals(tm.getNetworkCountryIso())) { if (DBG) log("enabling channels 919-928 for Israel"); - manager.enableCellBroadcastRange(919, 928); + manager.enableCellBroadcastRange(mSubId, 919, 928); } else { if (DBG) log("disabling channels 919-928"); - manager.disableCellBroadcastRange(919, 928); + manager.disableCellBroadcastRange(mSubId, 919, 928); } // Disable per user preference/checkbox. @@ -302,24 +316,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( + manager.disableCellBroadcast(mSubId, SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE); } if (!enableCmasExtremeAlerts) { if (DBG) Log.d(TAG, "disabling cell broadcast CMAS extreme"); - manager.disableCellBroadcastRange(cmasExtremeStart, cmasExtremeEnd); + manager.disableCellBroadcastRange(mSubId, cmasExtremeStart, cmasExtremeEnd); } if (!enableCmasSevereAlerts) { if (DBG) Log.d(TAG, "disabling cell broadcast CMAS severe"); - manager.disableCellBroadcastRange(cmasSevereStart, cmasSevereEnd); + manager.disableCellBroadcastRange(mSubId, cmasSevereStart, cmasSevereEnd); } if (!enableCmasAmberAlerts) { if (DBG) Log.d(TAG, "disabling cell broadcast CMAS amber"); - manager.disableCellBroadcast(cmasAmber); + manager.disableCellBroadcast(mSubId, cmasAmber); } if (!enableCmasTestAlerts) { if (DBG) Log.d(TAG, "disabling cell broadcast CMAS test messages"); - manager.disableCellBroadcastRange(cmasTestStart, cmasTestEnd); + manager.disableCellBroadcastRange(mSubId, cmasTestStart, cmasTestEnd); } } 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 a04cc2c7..32b42ffc 100644 --- a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java +++ b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiver.java @@ -28,12 +28,14 @@ import android.preference.PreferenceManager; import android.provider.Telephony; import android.telephony.CellBroadcastMessage; import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; import android.telephony.cdma.CdmaSmsCbProgramData; import android.util.Log; import com.android.internal.telephony.ITelephony; import com.android.internal.telephony.cdma.sms.SmsEnvelope; +import com.android.internal.telephony.PhoneConstants; import com.android.internal.telephony.TelephonyIntents; public class CellBroadcastReceiver extends BroadcastReceiver { @@ -43,6 +45,20 @@ public class CellBroadcastReceiver extends BroadcastReceiver { private static final String GET_LATEST_CB_AREA_INFO_ACTION = "android.cellbroadcastreceiver.GET_LATEST_CB_AREA_INFO"; + private static int mPhoneId = SubscriptionManager.getPhoneId( + SubscriptionManager.getDefaultSmsSubId()); + + // FIXME on latest AOSP refresh, google removed PhoneStateListener and + // listening for SERVICE STATE intent. Same way for MSIM also we need + // to listen for intent. + // private PhoneStateListener[] mPhoneStateListener; + + private int mPhoneCount = 0; + + private long[] mSubId; + + private TelephonyManager mPhone; + @Override public void onReceive(Context context, Intent intent) { onReceiveWithPrivilege(context, intent, false); @@ -70,7 +86,9 @@ public class CellBroadcastReceiver extends BroadcastReceiver { boolean airplaneModeOn = intent.getBooleanExtra("state", false); if (DBG) log("airplaneModeOn: " + airplaneModeOn); if (!airplaneModeOn) { - startConfigService(context); + for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++){ + startConfigService(context, i); + } } } else if (Telephony.Sms.Intents.SMS_EMERGENCY_CB_RECEIVED_ACTION.equals(action) || Telephony.Sms.Intents.SMS_CB_RECEIVED_ACTION.equals(action)) { @@ -87,6 +105,10 @@ public class CellBroadcastReceiver extends BroadcastReceiver { } else if (Telephony.Sms.Intents.SMS_SERVICE_CATEGORY_PROGRAM_DATA_RECEIVED_ACTION .equals(action)) { if (privileged) { + int phoneId = intent.getIntExtra(PhoneConstants.SLOT_KEY, + SubscriptionManager.getPhoneId( + SubscriptionManager.getDefaultSmsSubId())); + Log.d(TAG, "onReceive SMS_CATEGORY_PROGRAM_DATA phoneId :" + phoneId); CdmaSmsCbProgramData[] programDataList = (CdmaSmsCbProgramData[]) intent.getParcelableArrayExtra("program_data_list"); if (programDataList != null) { @@ -99,7 +121,10 @@ public class CellBroadcastReceiver extends BroadcastReceiver { } } else if (GET_LATEST_CB_AREA_INFO_ACTION.equals(action)) { if (privileged) { - CellBroadcastMessage message = CellBroadcastReceiverApp.getLatestAreaInfo(); + int phoneId = intent.getIntExtra(PhoneConstants.SLOT_KEY, + SubscriptionManager.getPhoneId( + SubscriptionManager.getDefaultSmsSubId())); + CellBroadcastMessage message = CellBroadcastReceiverApp.getLatestAreaInfo(phoneId); if (message != null) { Intent areaInfoIntent = new Intent( CellBroadcastAlertService.CB_AREA_INFO_RECEIVED_ACTION); @@ -110,6 +135,12 @@ public class CellBroadcastReceiver extends BroadcastReceiver { } else { Log.e(TAG, "caller missing READ_PHONE_STATE permission, returning"); } + } else if (action.equals(TelephonyIntents.ACTION_SUBINFO_RECORD_UPDATED)) { + // FIXME on latest AOSP refresh, google removed PhoneStateListener and + // listening for SERVICE STATE intent. Same way for MSIM also we need + // to listen for intent. + //unregisterPhoneStateListener(); + //registerPhoneStateListener(context); } else { Log.w(TAG, "onReceive() unexpected action " + action); } @@ -153,34 +184,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 + mPhoneId; 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 + mPhoneId; 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 + mPhoneId; 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 + mPhoneId; 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(); } /** @@ -193,15 +220,23 @@ public class CellBroadcastReceiver extends BroadcastReceiver { context.startService(serviceIntent); } + static void startConfigService(Context context, int phoneId) { + Intent serviceIntent = new Intent(CellBroadcastConfigService.ACTION_ENABLE_CHANNELS, null, + context, CellBroadcastConfigService.class); + serviceIntent.putExtra(PhoneConstants.SLOT_KEY, phoneId); + context.startService(serviceIntent); + } + /** * @return true if the phone is a CDMA phone type */ - static boolean phoneIsCdma() { + static boolean phoneIsCdma(long 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/CellBroadcastReceiverApp.java b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java index b9e60398..6973840d 100644 --- a/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java +++ b/src/com/android/cellbroadcastreceiver/CellBroadcastReceiverApp.java @@ -18,11 +18,14 @@ package com.android.cellbroadcastreceiver; import android.app.Application; import android.telephony.CellBroadcastMessage; +import android.telephony.SubscriptionManager; import android.util.Log; 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, @@ -43,7 +46,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 +62,11 @@ public class CellBroadcastReceiverApp extends Application { /** Saves the latest area info broadcast received. */ static void setLatestAreaInfo(CellBroadcastMessage areaInfo) { - sLatestAreaInfo = areaInfo; + sLatestAreaInfo.put(SubscriptionManager.getPhoneId(areaInfo.getSubId()), areaInfo); } /** Returns the latest area info broadcast received. */ - static CellBroadcastMessage getLatestAreaInfo() { - return sLatestAreaInfo; + static CellBroadcastMessage getLatestAreaInfo(int phoneId) { + return sLatestAreaInfo.get(phoneId); } } diff --git a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java index 0079c37a..07787184 100644 --- a/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java +++ b/src/com/android/cellbroadcastreceiver/CellBroadcastSettings.java @@ -1,5 +1,7 @@ /* * Copyright (C) 2011 The Android Open Source Project + * Copyright (c) 2014, 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,24 +18,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.os.UserManager; 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.SubscriptionManager; import android.telephony.TelephonyManager; +import android.util.Log; /** * 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"; @@ -88,20 +100,63 @@ 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 is off. + public static final String ALERT_REMINDER_INTERVAL_DEFAULT_DURATION = "0"; + + public static String subTag = "SUB"; + + public static int sPhoneId; + @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); + sPhoneId = SubscriptionManager.getPhoneId(SubscriptionManager.getDefaultSmsSubId()); + if (TelephonyManager.getDefault().getPhoneCount() > 1) { + final ActionBar actionBar = getActionBar(); + actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS); + actionBar.setDisplayShowTitleEnabled(true); + for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) { + actionBar.addTab(actionBar.newTab().setText(subTag+(i+1)).setTabListener( + new SubTabListener(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 SubTabListener implements ActionBar.TabListener { - UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE); + private CellBroadcastSettingsFragment mFragment; + private String tag; + private int phoneId; - if (userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) { - setContentView(R.layout.cell_broadcast_disallowed_preference_screen); - return; + public SubTabListener(CellBroadcastSettingsFragment cbFragment, String tag, + int phoneId) { + this.mFragment = cbFragment; + this.tag = tag; + this.phoneId = phoneId; + } + + @Override + public void onTabSelected(Tab tab, FragmentTransaction ft) { + ft.add(android.R.id.content, mFragment, tag); + sPhoneId = phoneId; + Log.d(TAG, "onTabSelected sPhoneId:" + sPhoneId); } - // Display the fragment as the main content. - getFragmentManager().beginTransaction().replace(android.R.id.content, - new CellBroadcastSettingsFragment()).commit(); + @Override + public void onTabUnselected(Tab tab, FragmentTransaction ft) { + if (mFragment != null) { + ft.remove(mFragment); + } + } + + @Override + public void onTabReselected(Tab tab, FragmentTransaction ft) { + } } /** @@ -113,20 +168,134 @@ public class CellBroadcastSettings extends PreferenceActivity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); + Log.d(TAG, "onCreate CellBroadcastSettingsFragment sPhoneId :" + sPhoneId); // 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 ListPreference interval = + (ListPreference) findPreference(KEY_ALERT_REMINDER_INTERVAL); + 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); + final CheckBoxPreference enableVibrateAlerts = + (CheckBoxPreference) findPreference(KEY_ENABLE_ALERT_VIBRATE); + + final int idx = interval.findIndexOfValue( + (String)prefs.getString(KEY_ALERT_REMINDER_INTERVAL + sPhoneId, + ALERT_REMINDER_INTERVAL_DEFAULT_DURATION)); + interval.setSummary(interval.getEntries()[idx]); + interval.setValue(prefs.getString(KEY_ALERT_REMINDER_INTERVAL + + sPhoneId, ALERT_REMINDER_INTERVAL_DEFAULT_DURATION)); + + final int index = duration.findIndexOfValue( + (String)prefs.getString(KEY_ALERT_SOUND_DURATION + sPhoneId, + ALERT_SOUND_DEFAULT_DURATION)); + duration.setSummary(duration.getEntries()[index]); + duration.setValue(prefs.getString(KEY_ALERT_SOUND_DURATION + + sPhoneId, ALERT_SOUND_DEFAULT_DURATION)); + + enablePwsAlerts.setChecked(prefs.getBoolean( KEY_ENABLE_EMERGENCY_ALERTS + + sPhoneId, true)); + enableChannel50Alerts.setChecked(prefs.getBoolean( + KEY_ENABLE_CHANNEL_50_ALERTS + sPhoneId, true)); + enableEtwsAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_ETWS_TEST_ALERTS + sPhoneId, false)); + enableCmasExtremeAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + sPhoneId, true)); + enableCmasSevereAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + sPhoneId, true)); + enableCmasAmberAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_CMAS_AMBER_ALERTS + sPhoneId, true)); + enableCmasTestAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_CMAS_TEST_ALERTS + sPhoneId, false)); + enableSpeakerAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_ALERT_SPEECH + sPhoneId, true)); + enableVibrateAlerts.setChecked(prefs.getBoolean( + KEY_ENABLE_ALERT_VIBRATE + sPhoneId, 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 + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableChannel50Alerts) { + editor.putBoolean(KEY_ENABLE_CHANNEL_50_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableEtwsAlerts) { + editor.putBoolean(KEY_ENABLE_ETWS_TEST_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableCmasExtremeAlerts) { + editor.putBoolean(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableCmasSevereAlerts) { + editor.putBoolean(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableCmasAmberAlerts) { + editor.putBoolean(KEY_ENABLE_CMAS_AMBER_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableCmasTestAlerts) { + editor.putBoolean(KEY_ENABLE_CMAS_TEST_ALERTS + + sPhoneId, Boolean.valueOf((value))); + } + editor.commit(); + CellBroadcastReceiver.startConfigService(pref.getContext(), sPhoneId); + + return true; + } + }; + + //Listener for non-radio functionality + Preference.OnPreferenceChangeListener startListener = + new Preference.OnPreferenceChangeListener() { + @Override + public boolean onPreferenceChange(Preference pref, Object newValue) { + String value = String.valueOf(newValue); + SharedPreferences.Editor editor = prefs.edit(); + + if (pref == enableSpeakerAlerts) { + editor.putBoolean(KEY_ENABLE_ALERT_SPEECH + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == enableVibrateAlerts) { + editor.putBoolean(KEY_ENABLE_ALERT_VIBRATE + + sPhoneId, Boolean.valueOf((value))); + } else if (pref == interval) { + final int idx = interval.findIndexOfValue((String) newValue); + + editor.putString(KEY_ALERT_REMINDER_INTERVAL + sPhoneId, + String.valueOf(newValue)); + interval.setSummary(interval.getEntries()[idx]); + } + editor.commit(); + return true; + } + }; // Show extra settings when developer options is enabled in settings. boolean enableDevSettings = Settings.Global.getInt(getActivity().getContentResolver(), @@ -135,40 +304,21 @@ 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()); - 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; - } - }); - // 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 + sPhoneId, + String.valueOf(newValue)).commit(); return true; } }); @@ -202,33 +352,34 @@ public class CellBroadcastSettings extends PreferenceActivity { if (!enableDevSettings) { 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); } + //Setting the listerner for non-radio functionality + if (enableSpeakerAlerts != null) { + enableSpeakerAlerts.setOnPreferenceChangeListener(startListener); + } + if (enableVibrateAlerts != null) { + enableVibrateAlerts.setOnPreferenceChangeListener(startListener); + } + if (interval != null) { + interval.setOnPreferenceChangeListener(startListener); + } } } } |