CellBroadcastSettings.java revision dd9555e7e5eb29852576197de1c61fa99007ba34 
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
17package com.android.cellbroadcastreceiver;
18
19import android.content.Context;
20import android.os.Bundle;
21import android.os.PersistableBundle;
22import android.os.UserManager;
23import android.preference.CheckBoxPreference;
24import android.preference.ListPreference;
25import android.preference.Preference;
26import android.preference.PreferenceActivity;
27import android.preference.PreferenceCategory;
28import android.preference.PreferenceScreen;
29import android.provider.Settings;
30import android.telephony.CarrierConfigManager;
31import android.telephony.TelephonyManager;
32import android.telephony.SubscriptionManager;
33import android.telephony.SubscriptionInfo;
34import android.util.Log;
35import android.view.View;
36import android.widget.TabHost;
37import android.widget.TabHost.OnTabChangeListener;
38import android.widget.TabHost.TabContentFactory;
39import android.widget.TabHost.TabSpec;
40import android.widget.TabWidget;
41import java.util.ArrayList;
42import java.util.List;
43
44/**
45 * Settings activity for the cell broadcast receiver.
46 */
47public 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
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
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                                    if (newVal == 1) {
251                                        SubscriptionManager
252                                                .setSubscriptionProperty(mSir.getSubscriptionId(),
253                                                        SubscriptionManager.CB_SEVERE_THREAT_ALERT,
254                                                        "0");
255                                    }
256                                    boolean isExtremeAlertChecked =
257                                            ((Boolean) newValue).booleanValue();
258
259                                    if (mSevereCheckBox != null) {
260                                        mSevereCheckBox.setEnabled(isExtremeAlertChecked);
261                                        mSevereCheckBox.setChecked(false);
262                                    }
263                                    break;
264                                case KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS:
265                                    SubscriptionManager
266                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
267                                                    SubscriptionManager.CB_SEVERE_THREAT_ALERT,
268                                                    newVal + "");
269                                    break;
270                                case KEY_ENABLE_CMAS_AMBER_ALERTS:
271                                    SubscriptionManager
272                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
273                                                    SubscriptionManager.CB_AMBER_ALERT,
274                                                    newVal + "");
275                                    break;
276                                case KEY_ENABLE_CMAS_TEST_ALERTS:
277                                    SubscriptionManager
278                                            .setSubscriptionProperty(mSir.getSubscriptionId(),
279                                                    SubscriptionManager.CB_CMAS_TEST_ALERT,
280                                                    newVal + "");
281                                    break;
282                                default:
283                                    Log.d(TAG, "Invalid preference changed");
284
285                            }
286
287                            CellBroadcastReceiver.startConfigService(pref.getContext(),
288                                    mSir.getSubscriptionId());
289                            return true;
290                        }
291                    };
292
293            // Show extra settings when developer options is enabled in settings.
294            boolean enableDevSettings = Settings.Global.getInt(getContentResolver(),
295                    Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0) != 0;
296
297            boolean showEtwsSettings = SubscriptionManager.getResourcesForSubId(
298                    getApplicationContext(), mSir.getSubscriptionId())
299                    .getBoolean(R.bool.show_etws_settings);
300
301            String queryReturnVal;
302            // alert reminder interval
303            queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
304                    mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
305                    Integer.parseInt(ALERT_REMINDER_INTERVAL), this) + "";
306
307            mReminderInterval.setValue(queryReturnVal);
308            mReminderInterval.setSummary(mReminderInterval
309                    .getEntries()[mReminderInterval.findIndexOfValue(queryReturnVal)]);
310
311            mReminderInterval.setOnPreferenceChangeListener(
312                    new Preference.OnPreferenceChangeListener() {
313                        @Override
314                        public boolean onPreferenceChange(Preference pref, Object newValue) {
315                            final ListPreference listPref = (ListPreference) pref;
316                            final int idx = listPref.findIndexOfValue((String) newValue);
317                            listPref.setSummary(listPref.getEntries()[idx]);
318                            SubscriptionManager.setSubscriptionProperty(mSir.getSubscriptionId(),
319                                    SubscriptionManager.CB_ALERT_REMINDER_INTERVAL,
320                                    (String) newValue);
321                            return true;
322                        }
323                    });
324
325            boolean forceDisableEtwsCmasTest =
326                    isEtwsCmasTestMessageForcedDisabled(this, mSir.getSubscriptionId());
327
328            // Show alert settings and ETWS categories for ETWS builds and developer mode.
329            if (enableDevSettings || showEtwsSettings) {
330                // enable/disable all alerts
331                if (mEmergencyCheckBox != null) {
332                    if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
333                            SubscriptionManager.CB_EMERGENCY_ALERT, true, this)) {
334                        mEmergencyCheckBox.setChecked(true);
335                    } else {
336                        mEmergencyCheckBox.setChecked(false);
337                    }
338                    mEmergencyCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
339                }
340
341                // alert sound duration
342                queryReturnVal = SubscriptionManager.getIntegerSubscriptionProperty(
343                        mSir.getSubscriptionId(), SubscriptionManager.CB_ALERT_SOUND_DURATION,
344                        Integer.parseInt(ALERT_SOUND_DEFAULT_DURATION), this) + "";
345                mAlertDuration.setValue(queryReturnVal);
346                mAlertDuration.setSummary(mAlertDuration
347                        .getEntries()[mAlertDuration.findIndexOfValue(queryReturnVal)]);
348                mAlertDuration.setOnPreferenceChangeListener(
349                        new Preference.OnPreferenceChangeListener() {
350                            @Override
351                            public boolean onPreferenceChange(Preference pref, Object newValue) {
352                                final ListPreference listPref = (ListPreference) pref;
353                                final int idx = listPref.findIndexOfValue((String) newValue);
354                                listPref.setSummary(listPref.getEntries()[idx]);
355                                SubscriptionManager.setSubscriptionProperty(
356                                        mSir.getSubscriptionId(),
357                                        SubscriptionManager.CB_ALERT_SOUND_DURATION,
358                                        (String) newValue);
359                                return true;
360                            }
361                        });
362                if (forceDisableEtwsCmasTest) {
363                    // Remove ETWS test preference.
364                    prefScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
365
366                    PreferenceCategory devSettingCategory =
367                            (PreferenceCategory) findPreference(KEY_CATEGORY_DEV_SETTINGS);
368
369                    // Remove CMAS test preference.
370                    if (devSettingCategory != null) {
371                        devSettingCategory.removePreference(
372                                findPreference(KEY_ENABLE_CMAS_TEST_ALERTS));
373                    }
374                }
375            } else {
376                // Remove general emergency alert preference items (not shown for CMAS builds).
377                mAlertCategory.removePreference(findPreference(KEY_ENABLE_EMERGENCY_ALERTS));
378                mAlertCategory.removePreference(findPreference(KEY_ALERT_SOUND_DURATION));
379                mAlertCategory.removePreference(findPreference(KEY_ENABLE_ALERT_SPEECH));
380                // Remove ETWS test preference category.
381                prefScreen.removePreference(findPreference(KEY_CATEGORY_ETWS_SETTINGS));
382            }
383
384            if (!SubscriptionManager.getResourcesForSubId(getApplicationContext(),
385                    mSir.getSubscriptionId()).getBoolean(R.bool.show_cmas_settings)) {
386                // Remove CMAS preference items in emergency alert category.
387                mAlertCategory.removePreference(
388                        findPreference(KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS));
389                mAlertCategory.removePreference(
390                        findPreference(KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS));
391                mAlertCategory.removePreference(findPreference(KEY_ENABLE_CMAS_AMBER_ALERTS));
392            }
393
394            boolean enableChannel50Support = SubscriptionManager.getResourcesForSubId(
395                    getApplicationContext(), mSir.getSubscriptionId()).getBoolean(
396                    R.bool.show_brazil_settings)
397                    || "br".equals(mTelephonyManager.getSimCountryIso());
398
399            if (!enableChannel50Support) {
400                prefScreen.removePreference(findPreference(KEY_CATEGORY_BRAZIL_SETTINGS));
401            }
402            if (!enableDevSettings) {
403                prefScreen.removePreference(findPreference(KEY_CATEGORY_DEV_SETTINGS));
404            }
405
406            if (mSpeechCheckBox != null) {
407                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
408                        SubscriptionManager.CB_ALERT_SPEECH, true, this)) {
409                    mSpeechCheckBox.setChecked(true);
410                } else {
411                    mSpeechCheckBox.setChecked(false);
412                }
413                mSpeechCheckBox.setOnPreferenceChangeListener(
414                        new Preference.OnPreferenceChangeListener() {
415                            @Override
416                            public boolean onPreferenceChange(Preference pref, Object newValue) {
417                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
418                                SubscriptionManager.setSubscriptionProperty(
419                                        mSir.getSubscriptionId(),
420                                        SubscriptionManager.CB_ALERT_SPEECH, newVal + "");
421                                return true;
422                            }
423                        });
424            }
425
426            if (mVibrateCheckBox != null) {
427                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
428                        SubscriptionManager.CB_ALERT_VIBRATE, true, this)) {
429                    mVibrateCheckBox.setChecked(true);
430                } else {
431                    mVibrateCheckBox.setChecked(false);
432                }
433                mVibrateCheckBox.setOnPreferenceChangeListener(
434                        new Preference.OnPreferenceChangeListener() {
435                            @Override
436                            public boolean onPreferenceChange(Preference pref, Object newValue) {
437                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
438                                SubscriptionManager.setSubscriptionProperty(
439                                        mSir.getSubscriptionId(),
440                                        SubscriptionManager.CB_ALERT_VIBRATE, newVal + "");
441                                return true;
442                            }
443                        });
444            }
445
446            if (mOptOutCheckBox != null) {
447                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
448                        SubscriptionManager.CB_OPT_OUT_DIALOG, true, this)) {
449                    mOptOutCheckBox.setChecked(true);
450                } else {
451                    mOptOutCheckBox.setChecked(false);
452                }
453                mOptOutCheckBox.setOnPreferenceChangeListener(
454                        new Preference.OnPreferenceChangeListener() {
455                            @Override
456                            public boolean onPreferenceChange(Preference pref, Object newValue) {
457                                int newVal = (((Boolean) newValue).booleanValue()) ? 1 : 0;
458                                SubscriptionManager.setSubscriptionProperty(
459                                        mSir.getSubscriptionId(),
460                                        SubscriptionManager.CB_OPT_OUT_DIALOG, newVal + "");
461                                return true;
462                            }
463                        });
464            }
465
466            if (mChannel50CheckBox != null) {
467                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
468                        SubscriptionManager.CB_CHANNEL_50_ALERT, true, this)) {
469                    mChannel50CheckBox.setChecked(true);
470                } else {
471                    mChannel50CheckBox.setChecked(false);
472                }
473                mChannel50CheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
474            }
475
476            if (mEtwsTestCheckBox != null) {
477                if (!forceDisableEtwsCmasTest &&
478                        SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
479                        SubscriptionManager.CB_ETWS_TEST_ALERT, false, this)) {
480                    mEtwsTestCheckBox.setChecked(true);
481                } else {
482                    mEtwsTestCheckBox.setChecked(false);
483                }
484                mEtwsTestCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
485            }
486
487            if (mExtremeCheckBox != null) {
488                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
489                        SubscriptionManager.CB_EXTREME_THREAT_ALERT, true, this)) {
490                    mExtremeCheckBox.setChecked(true);
491                } else {
492                    mExtremeCheckBox.setChecked(false);
493                }
494                mExtremeCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
495            }
496
497            if (mSevereCheckBox != null) {
498                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
499                        SubscriptionManager.CB_SEVERE_THREAT_ALERT, true, this)) {
500                    mSevereCheckBox.setChecked(true);
501                } else {
502                    mSevereCheckBox.setChecked(false);
503                }
504                mSevereCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
505                if (mExtremeCheckBox != null) {
506                    boolean isExtremeAlertChecked =
507                            ((CheckBoxPreference) mExtremeCheckBox).isChecked();
508                    mSevereCheckBox.setEnabled(isExtremeAlertChecked);
509                }
510            }
511
512            if (mAmberCheckBox != null) {
513                if (SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
514                        SubscriptionManager.CB_AMBER_ALERT, true, this)) {
515                    mAmberCheckBox.setChecked(true);
516                } else {
517                    mAmberCheckBox.setChecked(false);
518                }
519                mAmberCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
520            }
521
522            if (mCmasCheckBox != null) {
523                if (!forceDisableEtwsCmasTest &&
524                        SubscriptionManager.getBooleanSubscriptionProperty(mSir.getSubscriptionId(),
525                        SubscriptionManager.CB_CMAS_TEST_ALERT, false, this)) {
526                    mCmasCheckBox.setChecked(true);
527                } else {
528                    mCmasCheckBox.setChecked(false);
529                }
530                mCmasCheckBox.setOnPreferenceChangeListener(startConfigServiceListener);
531            }
532        }
533    }
534
535    // Check if ETWS/CMAS test message is forced disabled on the device.
536    public static boolean isEtwsCmasTestMessageForcedDisabled(Context context, int subId) {
537
538        if (context == null) {
539            return false;
540        }
541
542        CarrierConfigManager configManager =
543                (CarrierConfigManager) context.getSystemService(Context.CARRIER_CONFIG_SERVICE);
544
545        if (configManager != null) {
546            PersistableBundle carrierConfig =
547                    configManager.getConfigForSubId(subId);
548
549            if (carrierConfig != null) {
550                return carrierConfig.getBoolean(
551                        CarrierConfigManager.KEY_CARRIER_FORCE_DISABLE_ETWS_CMAS_TEST_BOOL);
552            }
553        }
554
555        return false;
556    }
557
558    private OnTabChangeListener mTabListener = new OnTabChangeListener() {
559        @Override
560        public void onTabChanged(String tabId) {
561            final int slotId = Integer.parseInt(tabId);
562            mSir = mSelectableSubInfos.get(slotId);
563            updatePreferences();
564        }
565    };
566
567    private TabContentFactory mEmptyTabContent = new TabContentFactory() {
568        @Override
569        public View createTabContent(String tag) {
570            return new View(mTabHost.getContext());
571        }
572    };
573
574    private TabSpec buildTabSpec(String tag, String title) {
575        return mTabHost.newTabSpec(tag).setIndicator(title).setContent(
576                mEmptyTabContent);
577
578    }
579
580    public SubscriptionInfo findRecordBySlotId(Context context, final int slotId) {
581        final List<SubscriptionInfo> subInfoList =
582                SubscriptionManager.from(context).getActiveSubscriptionInfoList();
583        if (subInfoList != null) {
584            final int subInfoLength = subInfoList.size();
585
586            for (int i = 0; i < subInfoLength; ++i) {
587                final SubscriptionInfo sir = subInfoList.get(i);
588                if (sir.getSimSlotIndex() == slotId) {
589                    return sir;
590                }
591            }
592        }
593
594        return null;
595    }
596
597}
598