/*
* 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.app.Activity;
import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
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.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.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.SettingsPreferenceFragment;
import com.android.settings.Utils;
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 com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
public class SoundSettings extends SettingsPreferenceFragment implements Indexable {
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 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 PackageManager mPm;
private UserManager mUserManager;
private RingtonePreference mRequestPreference;
@Override
protected 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);
}
// 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);
}
}
@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());
}
}
// === 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 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);
CharSequence summary = context.getString(com.android.internal.R.string.ringtone_unknown);
// Is it a silent ringtone?
if (ringtoneUri == null) {
summary = context.getString(com.android.internal.R.string.ringtone_silent);
} else {
Cursor cursor = null;
try {
if (MediaStore.AUTHORITY.equals(ringtoneUri.getAuthority())) {
// Fetch the ringtone title from the media provider
cursor = context.getContentResolver().query(ringtoneUri,
new String[] { MediaStore.Audio.Media.TITLE }, null, null, null);
} else if (ContentResolver.SCHEME_CONTENT.equals(ringtoneUri.getScheme())) {
cursor = context.getContentResolver().query(ringtoneUri,
new String[] { OpenableColumns.DISPLAY_NAME }, null, null, null);
}
if (cursor != null) {
if (cursor.moveToFirst()) {
summary = cursor.getString(0);
}
}
} catch (SQLiteException sqle) {
// Unknown title for the ringtone
} catch (IllegalArgumentException iae) {
// Some other error retrieving the column from the provider
} finally {
if (cursor != null) {
cursor.close();
}
}
}
return summary;
}
// === 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;
}
};
}