• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License. You may obtain a copy of
6  * the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations under
14  * the License.
15  */
16 
17 package com.android.cellbroadcastreceiver;
18 
19 import android.content.Context;
20 import android.os.Bundle;
21 import android.os.PersistableBundle;
22 import android.os.UserManager;
23 import android.preference.CheckBoxPreference;
24 import android.preference.ListPreference;
25 import android.preference.Preference;
26 import android.preference.PreferenceActivity;
27 import android.preference.PreferenceCategory;
28 import android.preference.PreferenceScreen;
29 import android.provider.Settings;
30 import android.telephony.CarrierConfigManager;
31 import android.telephony.TelephonyManager;
32 import android.telephony.SubscriptionManager;
33 import android.telephony.SubscriptionInfo;
34 import android.util.Log;
35 import android.view.View;
36 import android.widget.TabHost;
37 import android.widget.TabHost.OnTabChangeListener;
38 import android.widget.TabHost.TabContentFactory;
39 import android.widget.TabHost.TabSpec;
40 import android.widget.TabWidget;
41 import java.util.ArrayList;
42 import java.util.List;
43 
44 /**
45  * Settings activity for the cell broadcast receiver.
46  */
47 public class CellBroadcastSettings extends PreferenceActivity {
48 
49     // Preference key for whether to enable emergency notifications (default enabled).
50     public static final String KEY_ENABLE_EMERGENCY_ALERTS = "enable_emergency_alerts";
51 
52     // Duration of alert sound (in seconds).
53     public static final String KEY_ALERT_SOUND_DURATION = "alert_sound_duration";
54 
55     // Default alert duration (in seconds).
56     public static final String ALERT_SOUND_DEFAULT_DURATION = "4";
57 
58     // Enable vibration on alert (unless master volume is silent).
59     public static final String KEY_ENABLE_ALERT_VIBRATE = "enable_alert_vibrate";
60 
61     // Speak contents of alert after playing the alert sound.
62     public static final String KEY_ENABLE_ALERT_SPEECH = "enable_alert_speech";
63 
64     // Preference category for emergency alert and CMAS settings.
65     public static final String KEY_CATEGORY_ALERT_SETTINGS = "category_alert_settings";
66 
67     // Preference category for ETWS related settings.
68     public static final String KEY_CATEGORY_ETWS_SETTINGS = "category_etws_settings";
69 
70     // Whether to display CMAS extreme threat notifications (default is enabled).
71     public static final String KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS =
72             "enable_cmas_extreme_threat_alerts";
73 
74     // Whether to display CMAS severe threat notifications (default is enabled).
75     public static final String KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS =
76             "enable_cmas_severe_threat_alerts";
77 
78     // Whether to display CMAS amber alert messages (default is enabled).
79     public static final String KEY_ENABLE_CMAS_AMBER_ALERTS = "enable_cmas_amber_alerts";
80 
81     // Preference category for development settings (enabled by settings developer options toggle).
82     public static final String KEY_CATEGORY_DEV_SETTINGS = "category_dev_settings";
83 
84     // Whether to display ETWS test messages (default is disabled).
85     public static final String KEY_ENABLE_ETWS_TEST_ALERTS = "enable_etws_test_alerts";
86 
87     // Whether to display CMAS monthly test messages (default is disabled).
88     public static final String KEY_ENABLE_CMAS_TEST_ALERTS = "enable_cmas_test_alerts";
89 
90     // Preference category for Brazil specific settings.
91     public static final String KEY_CATEGORY_BRAZIL_SETTINGS = "category_brazil_settings";
92 
93     // Preference key for whether to enable channel 50 notifications
94     // Enabled by default for phones sold in Brazil, otherwise this setting may be hidden.
95     public static final String KEY_ENABLE_CHANNEL_50_ALERTS = "enable_channel_50_alerts";
96 
97     // Preference key for initial opt-in/opt-out dialog.
98     public static final String KEY_SHOW_CMAS_OPT_OUT_DIALOG = "show_cmas_opt_out_dialog";
99 
100     // Alert reminder interval ("once" = single 2 minute reminder).
101     public static final String KEY_ALERT_REMINDER_INTERVAL = "alert_reminder_interval";
102 
103     // Default reminder interval.
104     public static final String ALERT_REMINDER_INTERVAL = "0";
105 
106     private final static String TAG = "CellBroadcastSettings";
107 
108     private TelephonyManager mTelephonyManager;
109     private SubscriptionInfo mSir;
110     private TabHost mTabHost;
111     private TabWidget mTabWidget;
112     private List<SubscriptionInfo> mSelectableSubInfos;
113 
114     private CheckBoxPreference mExtremeCheckBox;
115     private CheckBoxPreference mSevereCheckBox;
116     private CheckBoxPreference mAmberCheckBox;
117     private CheckBoxPreference mEmergencyCheckBox;
118     private ListPreference mAlertDuration;
119     private ListPreference mReminderInterval;
120     private CheckBoxPreference mVibrateCheckBox;
121     private CheckBoxPreference mSpeechCheckBox;
122     private CheckBoxPreference mEtwsTestCheckBox;
123     private CheckBoxPreference mChannel50CheckBox;
124     private CheckBoxPreference mCmasCheckBox;
125     private CheckBoxPreference mOptOutCheckBox;
126     private PreferenceCategory mAlertCategory;
127 
128     @Override
onCreate(Bundle savedInstanceState)129     public void onCreate(Bundle savedInstanceState) {
130         super.onCreate(savedInstanceState);
131 
132         UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
133         if (userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) {
134             setContentView(R.layout.cell_broadcast_disallowed_preference_screen);
135             return;
136         }
137 
138         mTelephonyManager = (TelephonyManager) getSystemService(
139                 Context.TELEPHONY_SERVICE);
140         mSelectableSubInfos = new ArrayList<SubscriptionInfo>();
141         for (int i = 0; i < mTelephonyManager.getSimCount(); i++) {
142             final SubscriptionInfo sir =
143                     findRecordBySlotId(getApplicationContext(), i);
144             if (sir != null) {
145                 mSelectableSubInfos.add(sir);
146             }
147         }
148 
149         addPreferencesFromResource(R.xml.preferences);
150         mSir = mSelectableSubInfos.size() > 0 ? mSelectableSubInfos.get(0) : null;
151         if (mSelectableSubInfos.size() > 1) {
152             setContentView(com.android.internal.R.layout.common_tab_settings);
153 
154             mTabHost = (TabHost) findViewById(android.R.id.tabhost);
155             mTabHost.setup();
156             mTabHost.setOnTabChangedListener(mTabListener);
157             mTabHost.clearAllTabs();
158 
159             for (int i = 0; i < mSelectableSubInfos.size(); i++) {
160                 mTabHost.addTab(buildTabSpec(String.valueOf(i),
161                         String.valueOf(mSelectableSubInfos.get(i).getDisplayName())));
162             }
163         }
164         updatePreferences();
165     }
166 
updatePreferences()167     private void updatePreferences() {
168 
169         PreferenceScreen prefScreen = getPreferenceScreen();
170 
171         if (prefScreen != null) {
172             prefScreen.removeAll();
173             // Load the preferences from an XML resource
174             addPreferencesFromResource(R.xml.preferences);
175 
176             mExtremeCheckBox = (CheckBoxPreference)
177                     findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS);
178             mSevereCheckBox = (CheckBoxPreference)
179                     findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS);
180             mAmberCheckBox = (CheckBoxPreference)
181                     findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS);
182             mEmergencyCheckBox = (CheckBoxPreference)
183                     findPreference(KEY_ENABLE_EMERGENCY_ALERTS);
184             mAlertDuration = (ListPreference)
185                     findPreference(KEY_ALERT_SOUND_DURATION);
186             mReminderInterval = (ListPreference)
187                     findPreference(KEY_ALERT_REMINDER_INTERVAL);
188             mVibrateCheckBox = (CheckBoxPreference)
189                     findPreference(KEY_ENABLE_ALERT_VIBRATE);
190             mSpeechCheckBox = (CheckBoxPreference)
191                     findPreference(KEY_ENABLE_ALERT_SPEECH);
192             mEtwsTestCheckBox = (CheckBoxPreference)
193                     findPreference(KEY_ENABLE_ETWS_TEST_ALERTS);
194             mChannel50CheckBox = (CheckBoxPreference)
195                     findPreference(KEY_ENABLE_CHANNEL_50_ALERTS);
196             mCmasCheckBox = (CheckBoxPreference)
197                     findPreference(KEY_ENABLE_CMAS_TEST_ALERTS);
198             mOptOutCheckBox = (CheckBoxPreference)
199                     findPreference(KEY_SHOW_CMAS_OPT_OUT_DIALOG);
200             mAlertCategory = (PreferenceCategory)
201                     findPreference(KEY_CATEGORY_ALERT_SETTINGS);
202 
203             if(mSir == null) {
204                 mExtremeCheckBox.setEnabled(false);
205                 mSevereCheckBox.setEnabled(false);
206                 mAmberCheckBox.setEnabled(false);
207                 mEmergencyCheckBox.setEnabled(false);
208                 mReminderInterval.setEnabled(false);
209                 mAlertDuration.setEnabled(false);
210                 mVibrateCheckBox.setEnabled(false);
211                 mSpeechCheckBox.setEnabled(false);
212                 mEtwsTestCheckBox.setEnabled(false);
213                 mChannel50CheckBox.setEnabled(false);
214                 mCmasCheckBox.setEnabled(false);
215                 mOptOutCheckBox.setEnabled(false);
216                 return;
217             }
218 
219             // Handler for settings that require us to reconfigure enabled channels in radio
220             Preference.OnPreferenceChangeListener startConfigServiceListener =
221                     new Preference.OnPreferenceChangeListener() {
222                         @Override
223                         public boolean onPreferenceChange(Preference pref, Object newValue) {
224                             int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
225 
226                             switch (pref.getKey()) {
227                                 case KEY_ENABLE_EMERGENCY_ALERTS:
228                                     SubscriptionManager
229                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
230                                                     SubscriptionManager.CB_EMERGENCY_ALERT,
231                                                     newVal + "");
232                                     break;
233                                 case KEY_ENABLE_CHANNEL_50_ALERTS:
234                                     SubscriptionManager
235                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
236                                                     SubscriptionManager.CB_CHANNEL_50_ALERT,
237                                                     newVal + "");
238                                     break;
239                                 case KEY_ENABLE_ETWS_TEST_ALERTS:
240                                     SubscriptionManager
241                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
242                                                     SubscriptionManager.CB_ETWS_TEST_ALERT,
243                                                     newVal + "");
244                                     break;
245                                 case KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS:
246                                     SubscriptionManager
247                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
248                                                     SubscriptionManager.CB_EXTREME_THREAT_ALERT,
249                                                     newVal + "");
250                                     SubscriptionManager
251                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
252                                                     SubscriptionManager.CB_SEVERE_THREAT_ALERT,
253                                                     "0");
254 
255                                     boolean isExtremeAlertChecked =
256                                             ((Boolean) newValue).booleanValue();
257 
258                                     if (mSevereCheckBox != null) {
259                                         mSevereCheckBox.setEnabled(isExtremeAlertChecked);
260                                         mSevereCheckBox.setChecked(false);
261                                     }
262                                     break;
263                                 case KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS:
264                                     SubscriptionManager
265                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
266                                                     SubscriptionManager.CB_SEVERE_THREAT_ALERT,
267                                                     newVal + "");
268                                     break;
269                                 case KEY_ENABLE_CMAS_AMBER_ALERTS:
270                                     SubscriptionManager
271                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
272                                                     SubscriptionManager.CB_AMBER_ALERT,
273                                                     newVal + "");
274                                     break;
275                                 case KEY_ENABLE_CMAS_TEST_ALERTS:
276                                     SubscriptionManager
277                                             .setSubscriptionProperty(mSir.getSubscriptionId(),
278                                                     SubscriptionManager.CB_CMAS_TEST_ALERT,
279                                                     newVal + "");
280                                     break;
281                                 default:
282                                     Log.d(TAG, "Invalid preference changed");
283 
284                             }
285 
286                             CellBroadcastReceiver.startConfigService(pref.getContext(),
287                                     mSir.getSubscriptionId());
288                             return true;
289                         }
290                     };
291 
292             // Show extra settings when developer options is enabled in settings.
293             boolean enableDevSettings = Settings.Global.getInt(getContentResolver(),
294                     Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0) != 0;
295 
296             boolean showEtwsSettings = SubscriptionManager.getResourcesForSubId(
297                     getApplicationContext(), mSir.getSubscriptionId())
298                     .getBoolean(R.bool.show_etws_settings);
299 
300             String queryReturnVal;
301             // alert reminder interval
302             queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
303                     mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
304                     Integer.parseInt(ALERT_REMINDER_INTERVAL), this) + "";
305 
306             mReminderInterval.setValue(queryReturnVal);
307             mReminderInterval.setSummary(mReminderInterval
308                     .getEntries()[mReminderInterval.findIndexOfValue(queryReturnVal)]);
309 
310             mReminderInterval.setOnPreferenceChangeListener(
311                     new Preference.OnPreferenceChangeListener() {
312                         @Override
313                         public boolean onPreferenceChange(Preference pref, Object newValue) {
314                             final ListPreference listPref = (ListPreference) pref;
315                             final int idx = listPref.findIndexOfValue((String) newValue);
316                             listPref.setSummary(listPref.getEntries()[idx]);
317                             SubscriptionManager.setSubscriptionProperty(mSir.getSubscriptionId(),
318                                     SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
319                                     (String) newValue);
320                             return true;
321                         }
322                     });
323 
324             boolean forceDisableEtwsCmasTest =
325                     isEtwsCmasTestMessageForcedDisabled(this, mSir.getSubscriptionId());
326 
327             boolean emergencyAlertOnOffOptionEnabled =
328                     isEmergencyAlertOnOffOptionEnabled(this, mSir.getSubscriptionId());
329 
330             if (enableDevSettings || showEtwsSettings || emergencyAlertOnOffOptionEnabled) {
331                 // enable/disable all alerts except CMAS presidential alerts.
332                 if (mEmergencyCheckBox != null) {
333                     if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
334                             SubscriptionManager.CB_EMERGENCY_ALERT, true, this)) {
335                         mEmergencyCheckBox.setChecked(true);
336                     } else {
337                         mEmergencyCheckBox.setChecked(false);
338                     }
339                     mEmergencyCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
340                 }
341             } else {
342                 mAlertCategory.removePreference(findPreference(KEY_ENABLE_EMERGENCY_ALERTS));
343             }
344 
345             // Show alert settings and ETWS categories for ETWS builds and developer mode.
346             if (enableDevSettings || showEtwsSettings) {
347 
348                 // alert sound duration
349                 queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
350                         mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_SOUND_DURATION,
351                         Integer.parseInt(ALERT_SOUND_DEFAULT_DURATION), this) + "";
352                 mAlertDuration.setValue(queryReturnVal);
353                 mAlertDuration.setSummary(mAlertDuration
354                         .getEntries()[mAlertDuration.findIndexOfValue(queryReturnVal)]);
355                 mAlertDuration.setOnPreferenceChangeListener(
356                         new Preference.OnPreferenceChangeListener() {
357                             @Override
358                             public boolean onPreferenceChange(Preference pref, Object newValue) {
359                                 final ListPreference listPref = (ListPreference) pref;
360                                 final int idx = listPref.findIndexOfValue((String) newValue);
361                                 listPref.setSummary(listPref.getEntries()[idx]);
362                                 SubscriptionManager.setSubscriptionProperty(
363                                         mSir.getSubscriptionId(),
364                                         SubscriptionManager.CB_ALERT_SOUND_DURATION,
365                                         (String) newValue);
366                                 return true;
367                             }
368                         });
369                 if (forceDisableEtwsCmasTest) {
370                     // Remove ETWS test preference.
371                     prefScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
372 
373                     PreferenceCategory devSettingCategory =
374                             (PreferenceCategory) findPreference(KEY_CATEGORY_DEV_SETTINGS);
375 
376                     // Remove CMAS test preference.
377                     if (devSettingCategory != null) {
378                         devSettingCategory.removePreference(
379                                 findPreference(KEY_ENABLE_CMAS_TEST_ALERTS));
380                     }
381                 }
382             } else {
383                 // Remove general emergency alert preference items (not shown for CMAS builds).
384 
385                 mAlertCategory.removePreference(findPreference(KEY_ALERT_SOUND_DURATION));
386                 mAlertCategory.removePreference(findPreference(KEY_ENABLE_ALERT_SPEECH));
387                 // Remove ETWS test preference category.
388                 prefScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
389             }
390 
391             if (!SubscriptionManager.getResourcesForSubId(getApplicationContext(),
392                     mSir.getSubscriptionId()).getBoolean(R.bool.show_cmas_settings)) {
393                 // Remove CMAS preference items in emergency alert category.
394                 mAlertCategory.removePreference(
395                         findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS));
396                 mAlertCategory.removePreference(
397                         findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS));
398                 mAlertCategory.removePreference(findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS));
399             }
400 
401             boolean enableChannel50Support = SubscriptionManager.getResourcesForSubId(
402                     getApplicationContext(), mSir.getSubscriptionId()).getBoolean(
403                     R.bool.show_brazil_settings)
404                     || "br".equals(mTelephonyManager.getSimCountryIso());
405 
406             if (!enableChannel50Support) {
407                 prefScreen.removePreference(findPreference(KEY_CATEGORY_BRAZIL_SETTINGS));
408             }
409             if (!enableDevSettings) {
410                 prefScreen.removePreference(findPreference(KEY_CATEGORY_DEV_SETTINGS));
411             }
412 
413             if (mSpeechCheckBox != null) {
414                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
415                         SubscriptionManager.CB_ALERT_SPEECH, true, this)) {
416                     mSpeechCheckBox.setChecked(true);
417                 } else {
418                     mSpeechCheckBox.setChecked(false);
419                 }
420                 mSpeechCheckBox.setOnPreferenceChangeListener(
421                         new Preference.OnPreferenceChangeListener() {
422                             @Override
423                             public boolean onPreferenceChange(Preference pref, Object newValue) {
424                                 int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
425                                 SubscriptionManager.setSubscriptionProperty(
426                                         mSir.getSubscriptionId(),
427                                         SubscriptionManager.CB_ALERT_SPEECH, newVal + "");
428                                 return true;
429                             }
430                         });
431             }
432 
433             if (mVibrateCheckBox != null) {
434                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
435                         SubscriptionManager.CB_ALERT_VIBRATE, true, this)) {
436                     mVibrateCheckBox.setChecked(true);
437                 } else {
438                     mVibrateCheckBox.setChecked(false);
439                 }
440                 mVibrateCheckBox.setOnPreferenceChangeListener(
441                         new Preference.OnPreferenceChangeListener() {
442                             @Override
443                             public boolean onPreferenceChange(Preference pref, Object newValue) {
444                                 int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
445                                 SubscriptionManager.setSubscriptionProperty(
446                                         mSir.getSubscriptionId(),
447                                         SubscriptionManager.CB_ALERT_VIBRATE, newVal + "");
448                                 return true;
449                             }
450                         });
451             }
452 
453             if (mOptOutCheckBox != null) {
454                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
455                         SubscriptionManager.CB_OPT_OUT_DIALOG, true, this)) {
456                     mOptOutCheckBox.setChecked(true);
457                 } else {
458                     mOptOutCheckBox.setChecked(false);
459                 }
460                 mOptOutCheckBox.setOnPreferenceChangeListener(
461                         new Preference.OnPreferenceChangeListener() {
462                             @Override
463                             public boolean onPreferenceChange(Preference pref, Object newValue) {
464                                 int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
465                                 SubscriptionManager.setSubscriptionProperty(
466                                         mSir.getSubscriptionId(),
467                                         SubscriptionManager.CB_OPT_OUT_DIALOG, newVal + "");
468                                 return true;
469                             }
470                         });
471             }
472 
473             if (mChannel50CheckBox != null) {
474                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
475                         SubscriptionManager.CB_CHANNEL_50_ALERT, true, this)) {
476                     mChannel50CheckBox.setChecked(true);
477                 } else {
478                     mChannel50CheckBox.setChecked(false);
479                 }
480                 mChannel50CheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
481             }
482 
483             if (mEtwsTestCheckBox != null) {
484                 if (!forceDisableEtwsCmasTest &&
485                         SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
486                         SubscriptionManager.CB_ETWS_TEST_ALERT, false, this)) {
487                     mEtwsTestCheckBox.setChecked(true);
488                 } else {
489                     mEtwsTestCheckBox.setChecked(false);
490                 }
491                 mEtwsTestCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
492             }
493 
494             if (mExtremeCheckBox != null) {
495                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
496                         SubscriptionManager.CB_EXTREME_THREAT_ALERT, true, this)) {
497                     mExtremeCheckBox.setChecked(true);
498                 } else {
499                     mExtremeCheckBox.setChecked(false);
500                 }
501                 mExtremeCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
502             }
503 
504             if (mSevereCheckBox != null) {
505                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
506                         SubscriptionManager.CB_SEVERE_THREAT_ALERT, true, this)) {
507                     mSevereCheckBox.setChecked(true);
508                 } else {
509                     mSevereCheckBox.setChecked(false);
510                 }
511                 mSevereCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
512                 if (mExtremeCheckBox != null) {
513                     boolean isExtremeAlertChecked =
514                             ((CheckBoxPreference) mExtremeCheckBox).isChecked();
515                     mSevereCheckBox.setEnabled(isExtremeAlertChecked);
516                 }
517             }
518 
519             if (mAmberCheckBox != null) {
520                 if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
521                         SubscriptionManager.CB_AMBER_ALERT, true, this)) {
522                     mAmberCheckBox.setChecked(true);
523                 } else {
524                     mAmberCheckBox.setChecked(false);
525                 }
526                 mAmberCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
527             }
528 
529             if (mCmasCheckBox != null) {
530                 if (!forceDisableEtwsCmasTest &&
531                         SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
532                         SubscriptionManager.CB_CMAS_TEST_ALERT, false, this)) {
533                     mCmasCheckBox.setChecked(true);
534                 } else {
535                     mCmasCheckBox.setChecked(false);
536                 }
537                 mCmasCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
538             }
539         }
540     }
541 
542     // Check if ETWS/CMAS test message is forced disabled on the device.
isEtwsCmasTestMessageForcedDisabled(Context context, int subId)543     public static boolean isEtwsCmasTestMessageForcedDisabled(Context context, int subId) {
544 
545         if (context == null) {
546             return false;
547         }
548 
549         CarrierConfigManager configManager =
550                 (CarrierConfigManager) context.getSystemService(Context.CARRIER_CONFIG_SERVICE);
551 
552         if (configManager != null) {
553             PersistableBundle carrierConfig =
554                     configManager.getConfigForSubId(subId);
555 
556             if (carrierConfig != null) {
557                 return carrierConfig.getBoolean(
558                         CarrierConfigManager.KEY_CARRIER_FORCE_DISABLE_ETWS_CMAS_TEST_BOOL);
559             }
560         }
561 
562         return false;
563     }
564 
565     // Check if "Turn on Notifications" option should be always displayed regardless of developer
566     // options turned on or not.
isEmergencyAlertOnOffOptionEnabled(Context context, int subId)567     public static boolean isEmergencyAlertOnOffOptionEnabled(Context context, int subId) {
568 
569         if (context == null) {
570             return false;
571         }
572 
573         CarrierConfigManager configManager =
574                 (CarrierConfigManager) context.getSystemService(Context.CARRIER_CONFIG_SERVICE);
575 
576         if (configManager != null) {
577             PersistableBundle carrierConfig =
578                     configManager.getConfigForSubId(subId);
579 
580             if (carrierConfig != null) {
581                 return carrierConfig.getBoolean(
582                     CarrierConfigManager.KEY_ALWAYS_SHOW_EMERGENCY_ALERT_ONOFF_BOOL);
583             }
584         }
585 
586         return false;
587     }
588 
589     private OnTabChangeListener mTabListener = new OnTabChangeListener() {
590         @Override
591         public void onTabChanged(String tabId) {
592             final int slotId = Integer.parseInt(tabId);
593             mSir = mSelectableSubInfos.get(slotId);
594             updatePreferences();
595         }
596     };
597 
598     private TabContentFactory mEmptyTabContent = new TabContentFactory() {
599         @Override
600         public View createTabContent(String tag) {
601             return new View(mTabHost.getContext());
602         }
603     };
604 
buildTabSpec(String tag, String title)605     private TabSpec buildTabSpec(String tag, String title) {
606         return mTabHost.newTabSpec(tag).setIndicator(title).setContent(
607                 mEmptyTabContent);
608 
609     }
610 
findRecordBySlotId(Context context, final int slotId)611     public SubscriptionInfo findRecordBySlotId(Context context, final int slotId) {
612         final List<SubscriptionInfo> subInfoList =
613                 SubscriptionManager.from(context).getActiveSubscriptionInfoList();
614         if (subInfoList != null) {
615             final int subInfoLength = subInfoList.size();
616 
617             for (int i = 0; i < subInfoLength; ++i) {
618                 final SubscriptionInfo sir = subInfoList.get(i);
619                 if (sir.getSimSlotIndex() == slotId) {
620                     return sir;
621                 }
622             }
623         }
624 
625         return null;
626     }
627 
628 }
629