| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.settings.notification; |
| |
| import android.annotation.UserIdInt; |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.DialogFragment; |
| import android.app.FragmentManager; |
| import android.app.NotificationManager; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ServiceInfo; |
| import android.database.ContentObserver; |
| import android.database.Cursor; |
| import android.database.sqlite.SQLiteException; |
| import android.media.AudioManager; |
| import android.media.AudioSystem; |
| import android.media.Ringtone; |
| import android.media.RingtoneManager; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.os.Vibrator; |
| import android.preference.SeekBarVolumizer; |
| import android.provider.MediaStore; |
| import android.provider.OpenableColumns; |
| import android.provider.SearchIndexableResource; |
| import android.provider.Settings; |
| import android.support.v7.preference.Preference; |
| import android.support.v7.preference.PreferenceGroup; |
| import android.support.v7.preference.Preference.OnPreferenceChangeListener; |
| import android.support.v7.preference.TwoStatePreference; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.logging.MetricsProto.MetricsEvent; |
| import com.android.settings.R; |
| import com.android.settings.RingtonePreference; |
| import com.android.settings.DefaultRingtonePreference; |
| import com.android.settings.SettingsPreferenceFragment; |
| import com.android.settings.Utils; |
| import com.android.settings.core.instrumentation.InstrumentedDialogFragment; |
| import com.android.settings.dashboard.SummaryLoader; |
| import com.android.settings.search.BaseSearchIndexProvider; |
| import com.android.settings.search.Indexable; |
| import com.android.settingslib.RestrictedLockUtils; |
| import com.android.settingslib.RestrictedPreference; |
| |
| import java.text.NumberFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Objects; |
| |
| import static android.content.ContentProvider.getUriWithoutUserId; |
| import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; |
| |
| public class SoundSettings extends SettingsPreferenceFragment |
| implements Indexable, OnPreferenceChangeListener { |
| private static final String TAG = "SoundSettings"; |
| |
| private static final String KEY_MEDIA_VOLUME = "media_volume"; |
| private static final String KEY_ALARM_VOLUME = "alarm_volume"; |
| private static final String KEY_RING_VOLUME = "ring_volume"; |
| private static final String KEY_NOTIFICATION_VOLUME = "notification_volume"; |
| private static final String KEY_PHONE_RINGTONE = "ringtone"; |
| private static final String KEY_NOTIFICATION_RINGTONE = "notification_ringtone"; |
| private static final String KEY_ALARM_RINGTONE = "alarm_ringtone"; |
| private static final String KEY_VIBRATE_WHEN_RINGING = "vibrate_when_ringing"; |
| private static final String KEY_WIFI_DISPLAY = "wifi_display"; |
| private static final String KEY_ZEN_MODE = "zen_mode"; |
| private static final String KEY_CELL_BROADCAST_SETTINGS = "cell_broadcast_settings"; |
| |
| private static final String KEY_WORK_CATEGORY = "sound_work_settings_section"; |
| private static final String KEY_WORK_USE_PERSONAL_SOUNDS = "work_use_personal_sounds"; |
| private static final String KEY_WORK_PHONE_RINGTONE = "work_ringtone"; |
| private static final String KEY_WORK_NOTIFICATION_RINGTONE = "work_notification_ringtone"; |
| private static final String KEY_WORK_ALARM_RINGTONE = "work_alarm_ringtone"; |
| |
| private static final String SELECTED_PREFERENCE_KEY = "selected_preference"; |
| private static final int REQUEST_CODE = 200; |
| |
| private static final String[] RESTRICTED_KEYS = { |
| KEY_MEDIA_VOLUME, |
| KEY_ALARM_VOLUME, |
| KEY_RING_VOLUME, |
| KEY_NOTIFICATION_VOLUME, |
| KEY_ZEN_MODE, |
| }; |
| |
| private static final int SAMPLE_CUTOFF = 2000; // manually cap sample playback at 2 seconds |
| |
| private final VolumePreferenceCallback mVolumeCallback = new VolumePreferenceCallback(); |
| private final H mHandler = new H(); |
| private final SettingsObserver mSettingsObserver = new SettingsObserver(); |
| private final Receiver mReceiver = new Receiver(); |
| private final ArrayList<VolumeSeekBarPreference> mVolumePrefs = new ArrayList<>(); |
| |
| private Context mContext; |
| private boolean mVoiceCapable; |
| private Vibrator mVibrator; |
| private AudioManager mAudioManager; |
| private VolumeSeekBarPreference mRingOrNotificationPreference; |
| |
| private Preference mPhoneRingtonePreference; |
| private Preference mNotificationRingtonePreference; |
| private Preference mAlarmRingtonePreference; |
| private TwoStatePreference mVibrateWhenRinging; |
| private ComponentName mSuppressor; |
| private int mRingerMode = -1; |
| |
| private PreferenceGroup mWorkPreferenceCategory; |
| private TwoStatePreference mWorkUsePersonalSounds; |
| private Preference mWorkPhoneRingtonePreference; |
| private Preference mWorkNotificationRingtonePreference; |
| private Preference mWorkAlarmRingtonePreference; |
| |
| private PackageManager mPm; |
| private UserManager mUserManager; |
| private RingtonePreference mRequestPreference; |
| |
| private @UserIdInt int mManagedProfileId; |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.SOUND; |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| mContext = getActivity(); |
| mPm = getPackageManager(); |
| mUserManager = UserManager.get(getContext()); |
| mVoiceCapable = Utils.isVoiceCapable(mContext); |
| |
| mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); |
| mVibrator = (Vibrator) getActivity().getSystemService(Context.VIBRATOR_SERVICE); |
| if (mVibrator != null && !mVibrator.hasVibrator()) { |
| mVibrator = null; |
| } |
| |
| addPreferencesFromResource(R.xml.sound_settings); |
| |
| initVolumePreference(KEY_MEDIA_VOLUME, AudioManager.STREAM_MUSIC, |
| com.android.internal.R.drawable.ic_audio_media_mute); |
| initVolumePreference(KEY_ALARM_VOLUME, AudioManager.STREAM_ALARM, |
| com.android.internal.R.drawable.ic_audio_alarm_mute); |
| if (mVoiceCapable) { |
| mRingOrNotificationPreference = |
| initVolumePreference(KEY_RING_VOLUME, AudioManager.STREAM_RING, |
| com.android.internal.R.drawable.ic_audio_ring_notif_mute); |
| removePreference(KEY_NOTIFICATION_VOLUME); |
| } else { |
| mRingOrNotificationPreference = |
| initVolumePreference(KEY_NOTIFICATION_VOLUME, AudioManager.STREAM_NOTIFICATION, |
| com.android.internal.R.drawable.ic_audio_ring_notif_mute); |
| removePreference(KEY_RING_VOLUME); |
| } |
| |
| if (!shouldShowRingtoneSettings()) { |
| removePreference(KEY_RING_VOLUME); |
| removePreference(KEY_NOTIFICATION_VOLUME); |
| removePreference(KEY_ALARM_VOLUME); |
| } |
| |
| // Enable link to CMAS app settings depending on the value in config.xml. |
| boolean isCellBroadcastAppLinkEnabled = this.getResources().getBoolean( |
| com.android.internal.R.bool.config_cellBroadcastAppLinks); |
| try { |
| if (isCellBroadcastAppLinkEnabled) { |
| if (mPm.getApplicationEnabledSetting("com.android.cellbroadcastreceiver") |
| == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) { |
| isCellBroadcastAppLinkEnabled = false; // CMAS app disabled |
| } |
| } |
| } catch (IllegalArgumentException ignored) { |
| isCellBroadcastAppLinkEnabled = false; // CMAS app not installed |
| } |
| if (!mUserManager.isAdminUser() || !isCellBroadcastAppLinkEnabled || |
| RestrictedLockUtils.hasBaseUserRestriction(mContext, |
| UserManager.DISALLOW_CONFIG_CELL_BROADCASTS, UserHandle.myUserId())) { |
| removePreference(KEY_CELL_BROADCAST_SETTINGS); |
| } |
| initRingtones(); |
| initVibrateWhenRinging(); |
| updateRingerMode(); |
| updateEffectsSuppressor(); |
| |
| if (savedInstanceState != null) { |
| String selectedPreference = savedInstanceState.getString(SELECTED_PREFERENCE_KEY, null); |
| if (!TextUtils.isEmpty(selectedPreference)) { |
| mRequestPreference = (RingtonePreference) findPreference(selectedPreference); |
| } |
| } |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| lookupRingtoneNames(); |
| mSettingsObserver.register(true); |
| mReceiver.register(true); |
| updateRingOrNotificationPreference(); |
| updateEffectsSuppressor(); |
| for (VolumeSeekBarPreference volumePref : mVolumePrefs) { |
| volumePref.onActivityResume(); |
| } |
| |
| final EnforcedAdmin admin = RestrictedLockUtils.checkIfRestrictionEnforced(mContext, |
| UserManager.DISALLOW_ADJUST_VOLUME, UserHandle.myUserId()); |
| final boolean hasBaseRestriction = RestrictedLockUtils.hasBaseUserRestriction(mContext, |
| UserManager.DISALLOW_ADJUST_VOLUME, UserHandle.myUserId()); |
| for (String key : RESTRICTED_KEYS) { |
| Preference pref = findPreference(key); |
| if (pref != null) { |
| pref.setEnabled(!hasBaseRestriction); |
| } |
| if (pref instanceof RestrictedPreference && !hasBaseRestriction) { |
| ((RestrictedPreference) pref).setDisabledByAdmin(admin); |
| } |
| } |
| RestrictedPreference broadcastSettingsPref = (RestrictedPreference) findPreference( |
| KEY_CELL_BROADCAST_SETTINGS); |
| if (broadcastSettingsPref != null) { |
| broadcastSettingsPref.checkRestrictionAndSetDisabled( |
| UserManager.DISALLOW_CONFIG_CELL_BROADCASTS); |
| } |
| |
| mManagedProfileId = Utils.getManagedProfileId(mUserManager, UserHandle.myUserId()); |
| if (mManagedProfileId != UserHandle.USER_NULL && shouldShowRingtoneSettings()) { |
| if ((mWorkPreferenceCategory == null)) { |
| // Work preferences not yet set |
| addPreferencesFromResource(R.xml.sound_work_settings); |
| initWorkPreferences(); |
| } |
| if (!mWorkUsePersonalSounds.isChecked()) { |
| updateWorkRingtoneSummaries(); |
| } |
| } else { |
| maybeRemoveWorkPreferences(); |
| } |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| for (VolumeSeekBarPreference volumePref : mVolumePrefs) { |
| volumePref.onActivityPause(); |
| } |
| mVolumeCallback.stopSample(); |
| mSettingsObserver.register(false); |
| mReceiver.register(false); |
| } |
| |
| @Override |
| public boolean onPreferenceTreeClick(Preference preference) { |
| if (preference instanceof RingtonePreference) { |
| mRequestPreference = (RingtonePreference) preference; |
| mRequestPreference.onPrepareRingtonePickerIntent(mRequestPreference.getIntent()); |
| startActivityForResult(preference.getIntent(), REQUEST_CODE); |
| return true; |
| } |
| return super.onPreferenceTreeClick(preference); |
| } |
| |
| @Override |
| public void onActivityResult(int requestCode, int resultCode, Intent data) { |
| if (mRequestPreference != null) { |
| mRequestPreference.onActivityResult(requestCode, resultCode, data); |
| mRequestPreference = null; |
| } |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| if (mRequestPreference != null) { |
| outState.putString(SELECTED_PREFERENCE_KEY, mRequestPreference.getKey()); |
| } |
| } |
| |
| /** |
| * Updates the summary of work preferences |
| * |
| * This fragment only listens to changes on the work ringtone preferences, identified by keys |
| * "work_ringtone", "work_notification_ringtone" and "work_alarm_ringtone". |
| * |
| * Note: Changes to the personal ringtones aren't listened to this way because they were already |
| * handled using a {@link #SettingsObserver} ContentObserver. This wouldn't be appropriate for |
| * work settings since the Settings app runs on the personal user. |
| */ |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| int ringtoneType; |
| if (KEY_WORK_PHONE_RINGTONE.equals(preference.getKey())) { |
| ringtoneType = RingtoneManager.TYPE_RINGTONE; |
| } else if (KEY_WORK_NOTIFICATION_RINGTONE.equals(preference.getKey())) { |
| ringtoneType = RingtoneManager.TYPE_NOTIFICATION; |
| } else if (KEY_WORK_ALARM_RINGTONE.equals(preference.getKey())) { |
| ringtoneType = RingtoneManager.TYPE_ALARM; |
| } else { |
| return true; |
| } |
| |
| preference.setSummary(updateRingtoneName(getManagedProfileContext(), ringtoneType)); |
| return true; |
| } |
| |
| // === Volumes === |
| |
| private VolumeSeekBarPreference initVolumePreference(String key, int stream, int muteIcon) { |
| final VolumeSeekBarPreference volumePref = (VolumeSeekBarPreference) findPreference(key); |
| volumePref.setCallback(mVolumeCallback); |
| volumePref.setStream(stream); |
| mVolumePrefs.add(volumePref); |
| volumePref.setMuteIcon(muteIcon); |
| return volumePref; |
| } |
| |
| private void updateRingOrNotificationPreference() { |
| mRingOrNotificationPreference.showIcon(mSuppressor != null |
| ? com.android.internal.R.drawable.ic_audio_ring_notif_mute |
| : mRingerMode == AudioManager.RINGER_MODE_VIBRATE || wasRingerModeVibrate() |
| ? com.android.internal.R.drawable.ic_audio_ring_notif_vibrate |
| : com.android.internal.R.drawable.ic_audio_ring_notif); |
| } |
| |
| private boolean wasRingerModeVibrate() { |
| return mVibrator != null && mRingerMode == AudioManager.RINGER_MODE_SILENT |
| && mAudioManager.getLastAudibleStreamVolume(AudioManager.STREAM_RING) == 0; |
| } |
| |
| private void updateRingerMode() { |
| final int ringerMode = mAudioManager.getRingerModeInternal(); |
| if (mRingerMode == ringerMode) return; |
| mRingerMode = ringerMode; |
| updateRingOrNotificationPreference(); |
| } |
| |
| private void updateEffectsSuppressor() { |
| final ComponentName suppressor = NotificationManager.from(mContext).getEffectsSuppressor(); |
| if (Objects.equals(suppressor, mSuppressor)) return; |
| mSuppressor = suppressor; |
| if (mRingOrNotificationPreference != null) { |
| final String text = suppressor != null ? |
| mContext.getString(com.android.internal.R.string.muted_by, |
| getSuppressorCaption(suppressor)) : null; |
| mRingOrNotificationPreference.setSuppressionText(text); |
| } |
| updateRingOrNotificationPreference(); |
| } |
| |
| private String getSuppressorCaption(ComponentName suppressor) { |
| final PackageManager pm = mContext.getPackageManager(); |
| try { |
| final ServiceInfo info = pm.getServiceInfo(suppressor, 0); |
| if (info != null) { |
| final CharSequence seq = info.loadLabel(pm); |
| if (seq != null) { |
| final String str = seq.toString().trim(); |
| if (str.length() > 0) { |
| return str; |
| } |
| } |
| } |
| } catch (Throwable e) { |
| Log.w(TAG, "Error loading suppressor caption", e); |
| } |
| return suppressor.getPackageName(); |
| } |
| |
| private final class VolumePreferenceCallback implements VolumeSeekBarPreference.Callback { |
| private SeekBarVolumizer mCurrent; |
| |
| @Override |
| public void onSampleStarting(SeekBarVolumizer sbv) { |
| if (mCurrent != null && mCurrent != sbv) { |
| mCurrent.stopSample(); |
| } |
| mCurrent = sbv; |
| if (mCurrent != null) { |
| mHandler.removeMessages(H.STOP_SAMPLE); |
| mHandler.sendEmptyMessageDelayed(H.STOP_SAMPLE, SAMPLE_CUTOFF); |
| } |
| } |
| |
| @Override |
| public void onStreamValueChanged(int stream, int progress) { |
| // noop |
| } |
| |
| public void stopSample() { |
| if (mCurrent != null) { |
| mCurrent.stopSample(); |
| } |
| } |
| }; |
| |
| |
| // === Phone & notification ringtone === |
| |
| private boolean shouldShowRingtoneSettings() { |
| return !AudioSystem.isSingleVolume(mContext); |
| } |
| |
| private void initRingtones() { |
| mPhoneRingtonePreference = getPreferenceScreen().findPreference(KEY_PHONE_RINGTONE); |
| if (mPhoneRingtonePreference != null && !mVoiceCapable) { |
| getPreferenceScreen().removePreference(mPhoneRingtonePreference); |
| mPhoneRingtonePreference = null; |
| } |
| mNotificationRingtonePreference = |
| getPreferenceScreen().findPreference(KEY_NOTIFICATION_RINGTONE); |
| mAlarmRingtonePreference = getPreferenceScreen().findPreference(KEY_ALARM_RINGTONE); |
| } |
| |
| private void lookupRingtoneNames() { |
| AsyncTask.execute(mLookupRingtoneNames); |
| } |
| |
| private final Runnable mLookupRingtoneNames = new Runnable() { |
| @Override |
| public void run() { |
| if (mPhoneRingtonePreference != null) { |
| final CharSequence summary = updateRingtoneName( |
| mContext, RingtoneManager.TYPE_RINGTONE); |
| if (summary != null) { |
| mHandler.obtainMessage(H.UPDATE_PHONE_RINGTONE, summary).sendToTarget(); |
| } |
| } |
| if (mNotificationRingtonePreference != null) { |
| final CharSequence summary = updateRingtoneName( |
| mContext, RingtoneManager.TYPE_NOTIFICATION); |
| if (summary != null) { |
| mHandler.obtainMessage(H.UPDATE_NOTIFICATION_RINGTONE, summary).sendToTarget(); |
| } |
| } |
| if (mAlarmRingtonePreference != null) { |
| final CharSequence summary = |
| updateRingtoneName(mContext, RingtoneManager.TYPE_ALARM); |
| if (summary != null) { |
| mHandler.obtainMessage(H.UPDATE_ALARM_RINGTONE, summary).sendToTarget(); |
| } |
| } |
| } |
| }; |
| |
| private static CharSequence updateRingtoneName(Context context, int type) { |
| if (context == null) { |
| Log.e(TAG, "Unable to update ringtone name, no context provided"); |
| return null; |
| } |
| Uri ringtoneUri = RingtoneManager.getActualDefaultRingtoneUri(context, type); |
| return Ringtone.getTitle(context, ringtoneUri, false /* followSettingsUri */, |
| true /* allowRemote */); |
| } |
| |
| // === Vibrate when ringing === |
| |
| private void initVibrateWhenRinging() { |
| mVibrateWhenRinging = |
| (TwoStatePreference) getPreferenceScreen().findPreference(KEY_VIBRATE_WHEN_RINGING); |
| if (mVibrateWhenRinging == null) { |
| Log.i(TAG, "Preference not found: " + KEY_VIBRATE_WHEN_RINGING); |
| return; |
| } |
| if (!mVoiceCapable) { |
| getPreferenceScreen().removePreference(mVibrateWhenRinging); |
| mVibrateWhenRinging = null; |
| return; |
| } |
| mVibrateWhenRinging.setPersistent(false); |
| updateVibrateWhenRinging(); |
| mVibrateWhenRinging.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| final boolean val = (Boolean) newValue; |
| return Settings.System.putInt(getContentResolver(), |
| Settings.System.VIBRATE_WHEN_RINGING, |
| val ? 1 : 0); |
| } |
| }); |
| } |
| |
| private void updateVibrateWhenRinging() { |
| if (mVibrateWhenRinging == null) return; |
| mVibrateWhenRinging.setChecked(Settings.System.getInt(getContentResolver(), |
| Settings.System.VIBRATE_WHEN_RINGING, 0) != 0); |
| } |
| |
| // === Callbacks === |
| |
| private final class SettingsObserver extends ContentObserver { |
| private final Uri VIBRATE_WHEN_RINGING_URI = |
| Settings.System.getUriFor(Settings.System.VIBRATE_WHEN_RINGING); |
| |
| public SettingsObserver() { |
| super(mHandler); |
| } |
| |
| public void register(boolean register) { |
| final ContentResolver cr = getContentResolver(); |
| if (register) { |
| cr.registerContentObserver(VIBRATE_WHEN_RINGING_URI, false, this); |
| } else { |
| cr.unregisterContentObserver(this); |
| } |
| } |
| |
| @Override |
| public void onChange(boolean selfChange, Uri uri) { |
| super.onChange(selfChange, uri); |
| if (VIBRATE_WHEN_RINGING_URI.equals(uri)) { |
| updateVibrateWhenRinging(); |
| } |
| } |
| } |
| |
| private final class H extends Handler { |
| private static final int UPDATE_PHONE_RINGTONE = 1; |
| private static final int UPDATE_NOTIFICATION_RINGTONE = 2; |
| private static final int STOP_SAMPLE = 3; |
| private static final int UPDATE_EFFECTS_SUPPRESSOR = 4; |
| private static final int UPDATE_RINGER_MODE = 5; |
| private static final int UPDATE_ALARM_RINGTONE = 6; |
| |
| private H() { |
| super(Looper.getMainLooper()); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case UPDATE_PHONE_RINGTONE: |
| mPhoneRingtonePreference.setSummary((CharSequence) msg.obj); |
| break; |
| case UPDATE_NOTIFICATION_RINGTONE: |
| mNotificationRingtonePreference.setSummary((CharSequence) msg.obj); |
| break; |
| case STOP_SAMPLE: |
| mVolumeCallback.stopSample(); |
| break; |
| case UPDATE_EFFECTS_SUPPRESSOR: |
| updateEffectsSuppressor(); |
| break; |
| case UPDATE_RINGER_MODE: |
| updateRingerMode(); |
| break; |
| case UPDATE_ALARM_RINGTONE: |
| mAlarmRingtonePreference.setSummary((CharSequence) msg.obj); |
| break; |
| } |
| } |
| } |
| |
| private class Receiver extends BroadcastReceiver { |
| private boolean mRegistered; |
| |
| public void register(boolean register) { |
| if (mRegistered == register) return; |
| if (register) { |
| final IntentFilter filter = new IntentFilter(); |
| filter.addAction(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED); |
| filter.addAction(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION); |
| mContext.registerReceiver(this, filter); |
| } else { |
| mContext.unregisterReceiver(this); |
| } |
| mRegistered = register; |
| } |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| final String action = intent.getAction(); |
| if (NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED.equals(action)) { |
| mHandler.sendEmptyMessage(H.UPDATE_EFFECTS_SUPPRESSOR); |
| } else if (AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION.equals(action)) { |
| mHandler.sendEmptyMessage(H.UPDATE_RINGER_MODE); |
| } |
| } |
| } |
| |
| // === Summary === |
| |
| private static class SummaryProvider extends BroadcastReceiver |
| implements SummaryLoader.SummaryProvider { |
| |
| private final Context mContext; |
| private final AudioManager mAudioManager; |
| private final SummaryLoader mSummaryLoader; |
| private final int maxVolume; |
| |
| public SummaryProvider(Context context, SummaryLoader summaryLoader) { |
| mContext = context; |
| mSummaryLoader = summaryLoader; |
| mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); |
| maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_RING); |
| } |
| |
| @Override |
| public void setListening(boolean listening) { |
| if (listening) { |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(AudioManager.VOLUME_CHANGED_ACTION); |
| filter.addAction(AudioManager.STREAM_DEVICES_CHANGED_ACTION); |
| filter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION); |
| filter.addAction(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION); |
| filter.addAction(AudioManager.STREAM_MUTE_CHANGED_ACTION); |
| filter.addAction(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED); |
| mContext.registerReceiver(this, filter); |
| } else { |
| mContext.unregisterReceiver(this); |
| } |
| } |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| final int ringerMode = mAudioManager.getRingerMode(); |
| int resId; |
| String percent = ""; |
| if (ringerMode == mAudioManager.RINGER_MODE_SILENT) { |
| resId = R.string.sound_settings_summary_silent; |
| } else if (ringerMode == mAudioManager.RINGER_MODE_VIBRATE){ |
| resId = R.string.sound_settings_summary_vibrate; |
| } |
| else { |
| percent = NumberFormat.getPercentInstance().format( |
| (double) mAudioManager.getStreamVolume( |
| AudioManager.STREAM_RING) / maxVolume); |
| resId = R.string.sound_settings_summary; |
| } |
| mSummaryLoader.setSummary(this, mContext.getString(resId, percent)); |
| } |
| } |
| |
| public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY |
| = new SummaryLoader.SummaryProviderFactory() { |
| @Override |
| public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity, |
| SummaryLoader summaryLoader) { |
| return new SummaryProvider(activity, summaryLoader); |
| } |
| }; |
| |
| // === Indexing === |
| |
| public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = |
| new BaseSearchIndexProvider() { |
| |
| public List<SearchIndexableResource> getXmlResourcesToIndex( |
| Context context, boolean enabled) { |
| final SearchIndexableResource sir = new SearchIndexableResource(context); |
| sir.xmlResId = R.xml.sound_settings; |
| return Arrays.asList(sir); |
| } |
| |
| public List<String> getNonIndexableKeys(Context context) { |
| final ArrayList<String> rt = new ArrayList<String>(); |
| if (Utils.isVoiceCapable(context)) { |
| rt.add(KEY_NOTIFICATION_VOLUME); |
| } else { |
| rt.add(KEY_RING_VOLUME); |
| rt.add(KEY_PHONE_RINGTONE); |
| rt.add(KEY_WIFI_DISPLAY); |
| rt.add(KEY_VIBRATE_WHEN_RINGING); |
| } |
| |
| final PackageManager pm = context.getPackageManager(); |
| final UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); |
| |
| // Enable link to CMAS app settings depending on the value in config.xml. |
| boolean isCellBroadcastAppLinkEnabled = context.getResources().getBoolean( |
| com.android.internal.R.bool.config_cellBroadcastAppLinks); |
| try { |
| if (isCellBroadcastAppLinkEnabled) { |
| if (pm.getApplicationEnabledSetting("com.android.cellbroadcastreceiver") |
| == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) { |
| isCellBroadcastAppLinkEnabled = false; // CMAS app disabled |
| } |
| } |
| } catch (IllegalArgumentException ignored) { |
| isCellBroadcastAppLinkEnabled = false; // CMAS app not installed |
| } |
| if (!um.isAdminUser() || !isCellBroadcastAppLinkEnabled) { |
| rt.add(KEY_CELL_BROADCAST_SETTINGS); |
| } |
| |
| return rt; |
| } |
| }; |
| |
| // === Work Sound Settings === |
| |
| private Context getManagedProfileContext() { |
| if (mManagedProfileId == UserHandle.USER_NULL) { |
| return null; |
| } |
| return Utils.createPackageContextAsUser(mContext, mManagedProfileId); |
| } |
| |
| private DefaultRingtonePreference initWorkPreference(String key) { |
| DefaultRingtonePreference pref = |
| (DefaultRingtonePreference) getPreferenceScreen().findPreference(key); |
| pref.setOnPreferenceChangeListener(this); |
| |
| // Required so that RingtonePickerActivity lists the work profile ringtones |
| pref.setUserId(mManagedProfileId); |
| return pref; |
| } |
| |
| private void initWorkPreferences() { |
| mWorkPreferenceCategory = (PreferenceGroup) getPreferenceScreen() |
| .findPreference(KEY_WORK_CATEGORY); |
| mWorkUsePersonalSounds = (TwoStatePreference) getPreferenceScreen() |
| .findPreference(KEY_WORK_USE_PERSONAL_SOUNDS); |
| mWorkPhoneRingtonePreference = initWorkPreference(KEY_WORK_PHONE_RINGTONE); |
| mWorkNotificationRingtonePreference = initWorkPreference(KEY_WORK_NOTIFICATION_RINGTONE); |
| mWorkAlarmRingtonePreference = initWorkPreference(KEY_WORK_ALARM_RINGTONE); |
| |
| if (!mVoiceCapable) { |
| mWorkPreferenceCategory.removePreference(mWorkPhoneRingtonePreference); |
| mWorkPhoneRingtonePreference = null; |
| } |
| |
| Context managedProfileContext = getManagedProfileContext(); |
| if (Settings.Secure.getIntForUser(managedProfileContext.getContentResolver(), |
| Settings.Secure.SYNC_PARENT_SOUNDS, 0, mManagedProfileId) == 1) { |
| enableWorkSyncSettings(); |
| } else { |
| disableWorkSyncSettings(); |
| } |
| |
| mWorkUsePersonalSounds.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| if ((boolean) newValue) { |
| UnifyWorkDialogFragment.show(SoundSettings.this); |
| return false; |
| } else { |
| disableWorkSync(); |
| return true; |
| } |
| } |
| }); |
| } |
| |
| private void enableWorkSync() { |
| RingtoneManager.enableSyncFromParent(getManagedProfileContext()); |
| enableWorkSyncSettings(); |
| } |
| |
| private void enableWorkSyncSettings() { |
| mWorkUsePersonalSounds.setChecked(true); |
| |
| if (mWorkPhoneRingtonePreference != null) { |
| mWorkPhoneRingtonePreference.setSummary(R.string.work_sound_same_as_personal); |
| } |
| mWorkNotificationRingtonePreference.setSummary(R.string.work_sound_same_as_personal); |
| mWorkAlarmRingtonePreference.setSummary(R.string.work_sound_same_as_personal); |
| } |
| |
| private void disableWorkSync() { |
| RingtoneManager.disableSyncFromParent(getManagedProfileContext()); |
| disableWorkSyncSettings(); |
| } |
| |
| private void disableWorkSyncSettings() { |
| if (mWorkPhoneRingtonePreference != null) { |
| mWorkPhoneRingtonePreference.setEnabled(true); |
| } |
| mWorkNotificationRingtonePreference.setEnabled(true); |
| mWorkAlarmRingtonePreference.setEnabled(true); |
| |
| updateWorkRingtoneSummaries(); |
| } |
| |
| private void updateWorkRingtoneSummaries() { |
| Context managedProfileContext = getManagedProfileContext(); |
| |
| if (mWorkPhoneRingtonePreference != null) { |
| mWorkPhoneRingtonePreference.setSummary( |
| updateRingtoneName(managedProfileContext, RingtoneManager.TYPE_RINGTONE)); |
| } |
| mWorkNotificationRingtonePreference.setSummary( |
| updateRingtoneName(managedProfileContext, RingtoneManager.TYPE_NOTIFICATION)); |
| mWorkAlarmRingtonePreference.setSummary( |
| updateRingtoneName(managedProfileContext, RingtoneManager.TYPE_ALARM)); |
| } |
| |
| private void maybeRemoveWorkPreferences() { |
| if (mWorkPreferenceCategory == null) { |
| // No work preferences to remove |
| return; |
| } |
| getPreferenceScreen().removePreference(mWorkPreferenceCategory); |
| mWorkPreferenceCategory = null; |
| mWorkPhoneRingtonePreference = null; |
| mWorkNotificationRingtonePreference = null; |
| mWorkAlarmRingtonePreference = null; |
| } |
| |
| public static class UnifyWorkDialogFragment extends InstrumentedDialogFragment |
| implements DialogInterface.OnClickListener { |
| private static final String TAG = "UnifyWorkDialogFragment"; |
| private static final int REQUEST_CODE = 200; |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_UNIFY_SOUND_SETTINGS; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| return new AlertDialog.Builder(getActivity()) |
| .setTitle(R.string.work_sync_dialog_title) |
| .setMessage(R.string.work_sync_dialog_message) |
| .setPositiveButton(R.string.work_sync_dialog_yes, UnifyWorkDialogFragment.this) |
| .setNegativeButton(android.R.string.no, null) |
| .create(); |
| } |
| |
| public static void show(SoundSettings parent) { |
| FragmentManager fm = parent.getFragmentManager(); |
| if (fm.findFragmentByTag(TAG) == null) { |
| UnifyWorkDialogFragment fragment = new UnifyWorkDialogFragment(); |
| fragment.setTargetFragment(parent, REQUEST_CODE); |
| fragment.show(fm, TAG); |
| } |
| } |
| |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| SoundSettings soundSettings = (SoundSettings) getTargetFragment(); |
| if (soundSettings.isAdded()) { |
| soundSettings.enableWorkSync(); |
| } |
| } |
| } |
| } |
