src/com/android/settings/notification/NotificationSettings.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of 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,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.notification;
  18
  19 import android.app.NotificationManager;
  20 import android.content.BroadcastReceiver;
  21 import android.content.ComponentName;
  22 import android.content.ContentResolver;
  23 import android.content.Context;
  24 import android.content.Intent;
  25 import android.content.IntentFilter;
  26 import android.content.pm.PackageManager;
  27 import android.content.pm.ServiceInfo;
  28 import android.database.ContentObserver;
  29 import android.database.Cursor;
  30 import android.database.sqlite.SQLiteException;
  31 import android.media.AudioManager;
  32 import android.media.RingtoneManager;
  33 import android.net.Uri;
  34 import android.os.AsyncTask;
  35 import android.os.Bundle;
  36 import android.os.Handler;
  37 import android.os.Looper;
  38 import android.os.Message;
  39 import android.os.Vibrator;
  40 import android.preference.Preference;
  41 import android.preference.Preference.OnPreferenceChangeListener;
  42 import android.preference.PreferenceCategory;
  43 import android.preference.SeekBarVolumizer;
  44 import android.preference.TwoStatePreference;
  45 import android.provider.MediaStore;
  46 import android.provider.OpenableColumns;
  47 import android.provider.SearchIndexableResource;
  48 import android.provider.Settings;
  49 import android.util.Log;
  50
  51 import com.android.internal.widget.LockPatternUtils;
  52 import com.android.settings.R;
  53 import com.android.settings.SettingsPreferenceFragment;
  54 import com.android.settings.Utils;
  55 import com.android.settings.search.BaseSearchIndexProvider;
  56 import com.android.settings.search.Indexable;
  57
  58 import java.util.ArrayList;
  59 import java.util.Arrays;
  60 import java.util.List;
  61 import java.util.Objects;
  62
  63 public class NotificationSettings extends SettingsPreferenceFragment implements Indexable {
  64     private static final String TAG = "NotificationSettings";
  65
  66     private static final String KEY_SOUND = "sound";
  67     private static final String KEY_MEDIA_VOLUME = "media_volume";
  68     private static final String KEY_ALARM_VOLUME = "alarm_volume";
  69     private static final String KEY_RING_VOLUME = "ring_volume";
  70     private static final String KEY_NOTIFICATION_VOLUME = "notification_volume";
  71     private static final String KEY_PHONE_RINGTONE = "ringtone";
  72     private static final String KEY_NOTIFICATION_RINGTONE = "notification_ringtone";
  73     private static final String KEY_VIBRATE_WHEN_RINGING = "vibrate_when_ringing";
  74     private static final String KEY_NOTIFICATION = "notification";
  75     private static final String KEY_NOTIFICATION_PULSE = "notification_pulse";
  76     private static final String KEY_LOCK_SCREEN_NOTIFICATIONS = "lock_screen_notifications";
  77     private static final String KEY_NOTIFICATION_ACCESS = "manage_notification_access";
  78
  79     private static final int SAMPLE_CUTOFF = 2000;  // manually cap sample playback at 2 seconds
  80
  81     private final VolumePreferenceCallback mVolumeCallback = new VolumePreferenceCallback();
  82     private final H mHandler = new H();
  83     private final SettingsObserver mSettingsObserver = new SettingsObserver();
  84     private final Receiver mReceiver = new Receiver();
  85     private final ArrayList<VolumeSeekBarPreference> mVolumePrefs = new ArrayList<>();
  86
  87     private Context mContext;
  88     private PackageManager mPM;
  89     private boolean mVoiceCapable;
  90     private Vibrator mVibrator;
  91     private AudioManager mAudioManager;
  92     private VolumeSeekBarPreference mRingOrNotificationPreference;
  93
  94     private Preference mPhoneRingtonePreference;
  95     private Preference mNotificationRingtonePreference;
  96     private TwoStatePreference mVibrateWhenRinging;
  97     private TwoStatePreference mNotificationPulse;
  98     private DropDownPreference mLockscreen;
  99     private Preference mNotificationAccess;
 100     private boolean mSecure;
 101     private int mLockscreenSelectedValue;
 102     private ComponentName mSuppressor;
 103     private int mRingerMode = -1;
 104
 105     @Override
 106     public void onCreate(Bundle savedInstanceState) {
 107         super.onCreate(savedInstanceState);
 108         mContext = getActivity();
 109         mPM = mContext.getPackageManager();
 110         mVoiceCapable = Utils.isVoiceCapable(mContext);
 111         mSecure = new LockPatternUtils(getActivity()).isSecure();
 112
 113         mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
 114         mVibrator = (Vibrator) getActivity().getSystemService(Context.VIBRATOR_SERVICE);
 115         if (mVibrator != null && !mVibrator.hasVibrator()) {
 116             mVibrator = null;
 117         }
 118
 119         addPreferencesFromResource(R.xml.notification_settings);
 120
 121         final PreferenceCategory sound = (PreferenceCategory) findPreference(KEY_SOUND);
 122         initVolumePreference(KEY_MEDIA_VOLUME, AudioManager.STREAM_MUSIC,
 123                 com.android.internal.R.drawable.ic_audio_vol_mute);
 124         initVolumePreference(KEY_ALARM_VOLUME, AudioManager.STREAM_ALARM,
 125                 com.android.internal.R.drawable.ic_audio_alarm_mute);
 126         if (mVoiceCapable) {
 127             mRingOrNotificationPreference =
 128                     initVolumePreference(KEY_RING_VOLUME, AudioManager.STREAM_RING,
 129                             com.android.internal.R.drawable.ic_audio_ring_notif_mute);
 130             sound.removePreference(sound.findPreference(KEY_NOTIFICATION_VOLUME));
 131         } else {
 132             mRingOrNotificationPreference =
 133                     initVolumePreference(KEY_NOTIFICATION_VOLUME, AudioManager.STREAM_NOTIFICATION,
 134                             com.android.internal.R.drawable.ic_audio_ring_notif_mute);
 135             sound.removePreference(sound.findPreference(KEY_RING_VOLUME));
 136         }
 137         initRingtones(sound);
 138         initVibrateWhenRinging(sound);
 139
 140         final PreferenceCategory notification = (PreferenceCategory)
 141                 findPreference(KEY_NOTIFICATION);
 142         initPulse(notification);
 143         initLockscreenNotifications(notification);
 144
 145         mNotificationAccess = findPreference(KEY_NOTIFICATION_ACCESS);
 146         refreshNotificationListeners();
 147         updateRingerMode();
 148         updateEffectsSuppressor();
 149     }
 150
 151     @Override
 152     public void onResume() {
 153         super.onResume();
 154         refreshNotificationListeners();
 155         lookupRingtoneNames();
 156         mSettingsObserver.register(true);
 157         mReceiver.register(true);
 158         updateRingOrNotificationPreference();
 159         updateEffectsSuppressor();
 160         for (VolumeSeekBarPreference volumePref : mVolumePrefs) {
 161             volumePref.onActivityResume();
 162         }
 163     }
 164
 165     @Override
 166     public void onPause() {
 167         super.onPause();
 168         mVolumeCallback.stopSample();
 169         mSettingsObserver.register(false);
 170         mReceiver.register(false);
 171     }
 172
 173     // === Volumes ===
 174
 175     private VolumeSeekBarPreference initVolumePreference(String key, int stream, int muteIcon) {
 176         final VolumeSeekBarPreference volumePref = (VolumeSeekBarPreference) findPreference(key);
 177         volumePref.setCallback(mVolumeCallback);
 178         volumePref.setStream(stream);
 179         mVolumePrefs.add(volumePref);
 180         volumePref.setMuteIcon(muteIcon);
 181         return volumePref;
 182     }
 183
 184     private void updateRingOrNotificationPreference() {
 185         mRingOrNotificationPreference.showIcon(mSuppressor != null
 186                 ? com.android.internal.R.drawable.ic_audio_ring_notif_mute
 187                 : mRingerMode == AudioManager.RINGER_MODE_VIBRATE
 188                 ? com.android.internal.R.drawable.ic_audio_ring_notif_vibrate
 189                 : com.android.internal.R.drawable.ic_audio_ring_notif);
 190     }
 191
 192     private void updateRingerMode() {
 193         final int ringerMode = mAudioManager.getRingerModeInternal();
 194         if (mRingerMode == ringerMode) return;
 195         mRingerMode = ringerMode;
 196         updateRingOrNotificationPreference();
 197     }
 198
 199     private void updateEffectsSuppressor() {
 200         final ComponentName suppressor = NotificationManager.from(mContext).getEffectsSuppressor();
 201         if (Objects.equals(suppressor, mSuppressor)) return;
 202         mSuppressor = suppressor;
 203         if (mRingOrNotificationPreference != null) {
 204             final String text = suppressor != null ?
 205                     mContext.getString(com.android.internal.R.string.muted_by,
 206                             getSuppressorCaption(suppressor)) : null;
 207             mRingOrNotificationPreference.setSuppressionText(text);
 208         }
 209         updateRingOrNotificationPreference();
 210     }
 211
 212     private String getSuppressorCaption(ComponentName suppressor) {
 213         final PackageManager pm = mContext.getPackageManager();
 214         try {
 215             final ServiceInfo info = pm.getServiceInfo(suppressor, 0);
 216             if (info != null) {
 217                 final CharSequence seq = info.loadLabel(pm);
 218                 if (seq != null) {
 219                     final String str = seq.toString().trim();
 220                     if (str.length() > 0) {
 221                         return str;
 222                     }
 223                 }
 224             }
 225         } catch (Throwable e) {
 226             Log.w(TAG, "Error loading suppressor caption", e);
 227         }
 228         return suppressor.getPackageName();
 229     }
 230
 231     private final class VolumePreferenceCallback implements VolumeSeekBarPreference.Callback {
 232         private SeekBarVolumizer mCurrent;
 233
 234         @Override
 235         public void onSampleStarting(SeekBarVolumizer sbv) {
 236             if (mCurrent != null && mCurrent != sbv) {
 237                 mCurrent.stopSample();
 238             }
 239             mCurrent = sbv;
 240             if (mCurrent != null) {
 241                 mHandler.removeMessages(H.STOP_SAMPLE);
 242                 mHandler.sendEmptyMessageDelayed(H.STOP_SAMPLE, SAMPLE_CUTOFF);
 243             }
 244         }
 245
 246         @Override
 247         public void onStreamValueChanged(int stream, int progress) {
 248             // noop
 249         }
 250
 251         public void stopSample() {
 252             if (mCurrent != null) {
 253                 mCurrent.stopSample();
 254             }
 255         }
 256     };
 257
 258
 259     // === Phone & notification ringtone ===
 260
 261     private void initRingtones(PreferenceCategory root) {
 262         mPhoneRingtonePreference = root.findPreference(KEY_PHONE_RINGTONE);
 263         if (mPhoneRingtonePreference != null && !mVoiceCapable) {
 264             root.removePreference(mPhoneRingtonePreference);
 265             mPhoneRingtonePreference = null;
 266         }
 267         mNotificationRingtonePreference = root.findPreference(KEY_NOTIFICATION_RINGTONE);
 268     }
 269
 270     private void lookupRingtoneNames() {
 271         AsyncTask.execute(mLookupRingtoneNames);
 272     }
 273
 274     private final Runnable mLookupRingtoneNames = new Runnable() {
 275         @Override
 276         public void run() {
 277             if (mPhoneRingtonePreference != null) {
 278                 final CharSequence summary = updateRingtoneName(
 279                         mContext, RingtoneManager.TYPE_RINGTONE);
 280                 if (summary != null) {
 281                     mHandler.obtainMessage(H.UPDATE_PHONE_RINGTONE, summary).sendToTarget();
 282                 }
 283             }
 284             if (mNotificationRingtonePreference != null) {
 285                 final CharSequence summary = updateRingtoneName(
 286                         mContext, RingtoneManager.TYPE_NOTIFICATION);
 287                 if (summary != null) {
 288                     mHandler.obtainMessage(H.UPDATE_NOTIFICATION_RINGTONE, summary).sendToTarget();
 289                 }
 290             }
 291         }
 292     };
 293
 294     private static CharSequence updateRingtoneName(Context context, int type) {
 295         if (context == null) {
 296             Log.e(TAG, "Unable to update ringtone name, no context provided");
 297             return null;
 298         }
 299         Uri ringtoneUri = RingtoneManager.getActualDefaultRingtoneUri(context, type);
 300         CharSequence summary = context.getString(com.android.internal.R.string.ringtone_unknown);
 301         // Is it a silent ringtone?
 302         if (ringtoneUri == null) {
 303             summary = context.getString(com.android.internal.R.string.ringtone_silent);
 304         } else {
 305             Cursor cursor = null;
 306             try {
 307                 if (MediaStore.AUTHORITY.equals(ringtoneUri.getAuthority())) {
 308                     // Fetch the ringtone title from the media provider
 309                     cursor = context.getContentResolver().query(ringtoneUri,
 310                             new String[] { MediaStore.Audio.Media.TITLE }, null, null, null);
 311                 } else if (ContentResolver.SCHEME_CONTENT.equals(ringtoneUri.getScheme())) {
 312                     cursor = context.getContentResolver().query(ringtoneUri,
 313                             new String[] { OpenableColumns.DISPLAY_NAME }, null, null, null);
 314                 }
 315                 if (cursor != null) {
 316                     if (cursor.moveToFirst()) {
 317                         summary = cursor.getString(0);
 318                     }
 319                 }
 320             } catch (SQLiteException sqle) {
 321                 // Unknown title for the ringtone
 322             } catch (IllegalArgumentException iae) {
 323                 // Some other error retrieving the column from the provider
 324             } finally {
 325                 if (cursor != null) {
 326                     cursor.close();
 327                 }
 328             }
 329         }
 330         return summary;
 331     }
 332
 333     // === Vibrate when ringing ===
 334
 335     private void initVibrateWhenRinging(PreferenceCategory root) {
 336         mVibrateWhenRinging = (TwoStatePreference) root.findPreference(KEY_VIBRATE_WHEN_RINGING);
 337         if (mVibrateWhenRinging == null) {
 338             Log.i(TAG, "Preference not found: " + KEY_VIBRATE_WHEN_RINGING);
 339             return;
 340         }
 341         if (!mVoiceCapable) {
 342             root.removePreference(mVibrateWhenRinging);
 343             mVibrateWhenRinging = null;
 344             return;
 345         }
 346         mVibrateWhenRinging.setPersistent(false);
 347         updateVibrateWhenRinging();
 348         mVibrateWhenRinging.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
 349             @Override
 350             public boolean onPreferenceChange(Preference preference, Object newValue) {
 351                 final boolean val = (Boolean) newValue;
 352                 return Settings.System.putInt(getContentResolver(),
 353                         Settings.System.VIBRATE_WHEN_RINGING,
 354                         val ? 1 : 0);
 355             }
 356         });
 357     }
 358
 359     private void updateVibrateWhenRinging() {
 360         if (mVibrateWhenRinging == null) return;
 361         mVibrateWhenRinging.setChecked(Settings.System.getInt(getContentResolver(),
 362                 Settings.System.VIBRATE_WHEN_RINGING, 0) != 0);
 363     }
 364
 365     // === Pulse notification light ===
 366
 367     private void initPulse(PreferenceCategory parent) {
 368         mNotificationPulse = (TwoStatePreference) parent.findPreference(KEY_NOTIFICATION_PULSE);
 369         if (mNotificationPulse == null) {
 370             Log.i(TAG, "Preference not found: " + KEY_NOTIFICATION_PULSE);
 371             return;
 372         }
 373         if (!getResources()
 374                 .getBoolean(com.android.internal.R.bool.config_intrusiveNotificationLed)) {
 375             parent.removePreference(mNotificationPulse);
 376         } else {
 377             updatePulse();
 378             mNotificationPulse.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
 379                 @Override
 380                 public boolean onPreferenceChange(Preference preference, Object newValue) {
 381                     final boolean val = (Boolean)newValue;
 382                     return Settings.System.putInt(getContentResolver(),
 383                             Settings.System.NOTIFICATION_LIGHT_PULSE,
 384                             val ? 1 : 0);
 385                 }
 386             });
 387         }
 388     }
 389
 390     private void updatePulse() {
 391         if (mNotificationPulse == null) {
 392             return;
 393         }
 394         try {
 395             mNotificationPulse.setChecked(Settings.System.getInt(getContentResolver(),
 396                     Settings.System.NOTIFICATION_LIGHT_PULSE) == 1);
 397         } catch (Settings.SettingNotFoundException snfe) {
 398             Log.e(TAG, Settings.System.NOTIFICATION_LIGHT_PULSE + " not found");
 399         }
 400     }
 401
 402     // === Lockscreen (public / private) notifications ===
 403
 404     private void initLockscreenNotifications(PreferenceCategory parent) {
 405         mLockscreen = (DropDownPreference) parent.findPreference(KEY_LOCK_SCREEN_NOTIFICATIONS);
 406         if (mLockscreen == null) {
 407             Log.i(TAG, "Preference not found: " + KEY_LOCK_SCREEN_NOTIFICATIONS);
 408             return;
 409         }
 410
 411         mLockscreen.addItem(R.string.lock_screen_notifications_summary_show,
 412                 R.string.lock_screen_notifications_summary_show);
 413         if (mSecure) {
 414             mLockscreen.addItem(R.string.lock_screen_notifications_summary_hide,
 415                     R.string.lock_screen_notifications_summary_hide);
 416         }
 417         mLockscreen.addItem(R.string.lock_screen_notifications_summary_disable,
 418                 R.string.lock_screen_notifications_summary_disable);
 419         updateLockscreenNotifications();
 420         mLockscreen.setCallback(new DropDownPreference.Callback() {
 421             @Override
 422             public boolean onItemSelected(int pos, Object value) {
 423                 final int val = (Integer) value;
 424                 if (val == mLockscreenSelectedValue) {
 425                     return true;
 426                 }
 427                 final boolean enabled = val != R.string.lock_screen_notifications_summary_disable;
 428                 final boolean show = val == R.string.lock_screen_notifications_summary_show;
 429                 Settings.Secure.putInt(getContentResolver(),
 430                         Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, show ? 1 : 0);
 431                 Settings.Secure.putInt(getContentResolver(),
 432                         Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, enabled ? 1 : 0);
 433                 mLockscreenSelectedValue = val;
 434                 return true;
 435             }
 436         });
 437     }
 438
 439     private void updateLockscreenNotifications() {
 440         if (mLockscreen == null) {
 441             return;
 442         }
 443         final boolean enabled = getLockscreenNotificationsEnabled();
 444         final boolean allowPrivate = !mSecure || getLockscreenAllowPrivateNotifications();
 445         mLockscreenSelectedValue = !enabled ? R.string.lock_screen_notifications_summary_disable :
 446                 allowPrivate ? R.string.lock_screen_notifications_summary_show :
 447                 R.string.lock_screen_notifications_summary_hide;
 448         mLockscreen.setSelectedValue(mLockscreenSelectedValue);
 449     }
 450
 451     private boolean getLockscreenNotificationsEnabled() {
 452         return Settings.Secure.getInt(getContentResolver(),
 453                 Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, 0) != 0;
 454     }
 455
 456     private boolean getLockscreenAllowPrivateNotifications() {
 457         return Settings.Secure.getInt(getContentResolver(),
 458                 Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0) != 0;
 459     }
 460
 461     // === Notification listeners ===
 462
 463     private void refreshNotificationListeners() {
 464         if (mNotificationAccess != null) {
 465             final int total = NotificationAccessSettings.getListenersCount(mPM);
 466             if (total == 0) {
 467                 getPreferenceScreen().removePreference(mNotificationAccess);
 468             } else {
 469                 final int n = NotificationAccessSettings.getEnabledListenersCount(mContext);
 470                 if (n == 0) {
 471                     mNotificationAccess.setSummary(getResources().getString(
 472                             R.string.manage_notification_access_summary_zero));
 473                 } else {
 474                     mNotificationAccess.setSummary(String.format(getResources().getQuantityString(
 475                             R.plurals.manage_notification_access_summary_nonzero,
 476                             n, n)));
 477                 }
 478             }
 479         }
 480     }
 481
 482     // === Callbacks ===
 483
 484     private final class SettingsObserver extends ContentObserver {
 485         private final Uri VIBRATE_WHEN_RINGING_URI =
 486                 Settings.System.getUriFor(Settings.System.VIBRATE_WHEN_RINGING);
 487         private final Uri NOTIFICATION_LIGHT_PULSE_URI =
 488                 Settings.System.getUriFor(Settings.System.NOTIFICATION_LIGHT_PULSE);
 489         private final Uri LOCK_SCREEN_PRIVATE_URI =
 490                 Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS);
 491         private final Uri LOCK_SCREEN_SHOW_URI =
 492                 Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
 493
 494         public SettingsObserver() {
 495             super(mHandler);
 496         }
 497
 498         public void register(boolean register) {
 499             final ContentResolver cr = getContentResolver();
 500             if (register) {
 501                 cr.registerContentObserver(VIBRATE_WHEN_RINGING_URI, false, this);
 502                 cr.registerContentObserver(NOTIFICATION_LIGHT_PULSE_URI, false, this);
 503                 cr.registerContentObserver(LOCK_SCREEN_PRIVATE_URI, false, this);
 504                 cr.registerContentObserver(LOCK_SCREEN_SHOW_URI, false, this);
 505             } else {
 506                 cr.unregisterContentObserver(this);
 507             }
 508         }
 509
 510         @Override
 511         public void onChange(boolean selfChange, Uri uri) {
 512             super.onChange(selfChange, uri);
 513             if (VIBRATE_WHEN_RINGING_URI.equals(uri)) {
 514                 updateVibrateWhenRinging();
 515             }
 516             if (NOTIFICATION_LIGHT_PULSE_URI.equals(uri)) {
 517                 updatePulse();
 518             }
 519             if (LOCK_SCREEN_PRIVATE_URI.equals(uri) || LOCK_SCREEN_SHOW_URI.equals(uri)) {
 520                 updateLockscreenNotifications();
 521             }
 522         }
 523     }
 524
 525     private final class H extends Handler {
 526         private static final int UPDATE_PHONE_RINGTONE = 1;
 527         private static final int UPDATE_NOTIFICATION_RINGTONE = 2;
 528         private static final int STOP_SAMPLE = 3;
 529         private static final int UPDATE_EFFECTS_SUPPRESSOR = 4;
 530         private static final int UPDATE_RINGER_MODE = 5;
 531
 532         private H() {
 533             super(Looper.getMainLooper());
 534         }
 535
 536         @Override
 537         public void handleMessage(Message msg) {
 538             switch (msg.what) {
 539                 case UPDATE_PHONE_RINGTONE:
 540                     mPhoneRingtonePreference.setSummary((CharSequence) msg.obj);
 541                     break;
 542                 case UPDATE_NOTIFICATION_RINGTONE:
 543                     mNotificationRingtonePreference.setSummary((CharSequence) msg.obj);
 544                     break;
 545                 case STOP_SAMPLE:
 546                     mVolumeCallback.stopSample();
 547                     break;
 548                 case UPDATE_EFFECTS_SUPPRESSOR:
 549                     updateEffectsSuppressor();
 550                     break;
 551                 case UPDATE_RINGER_MODE:
 552                     updateRingerMode();
 553                     break;
 554             }
 555         }
 556     }
 557
 558     private class Receiver extends BroadcastReceiver {
 559         private boolean mRegistered;
 560
 561         public void register(boolean register) {
 562             if (mRegistered == register) return;
 563             if (register) {
 564                 final IntentFilter filter = new IntentFilter();
 565                 filter.addAction(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED);
 566                 filter.addAction(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION);
 567                 mContext.registerReceiver(this, filter);
 568             } else {
 569                 mContext.unregisterReceiver(this);
 570             }
 571             mRegistered = register;
 572         }
 573
 574         @Override
 575         public void onReceive(Context context, Intent intent) {
 576             final String action = intent.getAction();
 577             if (NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED.equals(action)) {
 578                 mHandler.sendEmptyMessage(H.UPDATE_EFFECTS_SUPPRESSOR);
 579             } else if (AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION.equals(action)) {
 580                 mHandler.sendEmptyMessage(H.UPDATE_RINGER_MODE);
 581             }
 582         }
 583     }
 584
 585     // === Indexing ===
 586
 587     public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 588             new BaseSearchIndexProvider() {
 589
 590         public List<SearchIndexableResource> getXmlResourcesToIndex(
 591                 Context context, boolean enabled) {
 592             final SearchIndexableResource sir = new SearchIndexableResource(context);
 593             sir.xmlResId = R.xml.notification_settings;
 594             return Arrays.asList(sir);
 595         }
 596
 597         public List<String> getNonIndexableKeys(Context context) {
 598             final ArrayList<String> rt = new ArrayList<String>();
 599             if (Utils.isVoiceCapable(context)) {
 600                 rt.add(KEY_NOTIFICATION_VOLUME);
 601             } else {
 602                 rt.add(KEY_RING_VOLUME);
 603                 rt.add(KEY_PHONE_RINGTONE);
 604                 rt.add(KEY_VIBRATE_WHEN_RINGING);
 605             }
 606             return rt;
 607         }
 608     };
 609 }