PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add items in Other Sound directly into Sound settings.

Browse Source 
- In new IA, Other Sound no longer is a separate preference screen, but
individual preferences are put directly under SoundSettings.

- Add controllers for each other sounds preference.

- Remove Cast settings from Soundsettings in new IA.

Change-Id: I75d771674ffabfecbd66079bc86844b2ff098b71
Fix: 33944294
Test: make RunSettingsRoboTests
This commit is contained in:
Doris Ling
2017-01-11 15:57:02 -08:00
parent a0f1e5adb9
commit 3ca367757b
25 changed files with 2179 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
src/com/android/settings/notification/BootSoundPreferenceController.java Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright (C) 2017 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.content.Context;
import android.os.SystemProperties;
import android.support.annotation.VisibleForTesting;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
public class BootSoundPreferenceController extends PreferenceController {
// Boot Sounds needs to be a system property so it can be accessed during boot.
private static final String KEY_BOOT_SOUNDS = "boot_sounds";
@VisibleForTesting
static final String PROPERTY_BOOT_SOUNDS = "persist.sys.bootanim.play_sound";
public BootSoundPreferenceController(Context context) {
super(context);
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
if (isAvailable()) {
SwitchPreference preference = (SwitchPreference) screen.findPreference(KEY_BOOT_SOUNDS);
preference.setChecked(SystemProperties.getBoolean(PROPERTY_BOOT_SOUNDS, true));
}
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (KEY_BOOT_SOUNDS.equals(preference.getKey())) {
SwitchPreference switchPreference = (SwitchPreference) preference;
SystemProperties.set(PROPERTY_BOOT_SOUNDS, switchPreference.isChecked() ? "1" : "0");
}
return false;
}
@Override
public String getPreferenceKey() {
return KEY_BOOT_SOUNDS;
}
@Override
public boolean isAvailable() {
return mContext.getResources().getBoolean(com.android.settings.R.bool.has_boot_sounds);
}
}

39
src/com/android/settings/notification/ChargingSoundPreferenceController.java Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_GLOBAL;
import android.content.Context;
import android.provider.Settings.Global;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class ChargingSoundPreferenceController extends SettingPrefController {
private static final String KEY_CHARGING_SOUNDS = "charging_sounds";
public ChargingSoundPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_GLOBAL, KEY_CHARGING_SOUNDS, Global.CHARGING_SOUNDS_ENABLED, DEFAULT_ON);
}
}

44
src/com/android/settings/notification/DialPadTonePreferenceController.java Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_SYSTEM;
import android.content.Context;
import android.provider.Settings.System;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.Utils;
import com.android.settings.core.lifecycle.Lifecycle;
public class DialPadTonePreferenceController extends SettingPrefController {
private static final String KEY_DIAL_PAD_TONES = "dial_pad_tones";
public DialPadTonePreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_SYSTEM, KEY_DIAL_PAD_TONES, System.DTMF_TONE_WHEN_DIALING, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return Utils.isVoiceCapable(context);
}
};
}
}

64
src/com/android/settings/notification/DockAudioMediaPreferenceController.java Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_GLOBAL;
import android.content.Context;
import android.content.res.Resources;
import android.provider.Settings.Global;
import android.telephony.TelephonyManager;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class DockAudioMediaPreferenceController extends SettingPrefController {
private static final String KEY_DOCK_AUDIO_MEDIA = "dock_audio_media";
private static final int DOCK_AUDIO_MEDIA_DISABLED = 0;
private static final int DOCK_AUDIO_MEDIA_ENABLED = 1;
private static final int DEFAULT_DOCK_AUDIO_MEDIA = DOCK_AUDIO_MEDIA_DISABLED;
public DockAudioMediaPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_GLOBAL, KEY_DOCK_AUDIO_MEDIA, Global.DOCK_AUDIO_MEDIA_ENABLED,
DEFAULT_DOCK_AUDIO_MEDIA, DOCK_AUDIO_MEDIA_DISABLED, DOCK_AUDIO_MEDIA_ENABLED) {
@Override
public boolean isApplicable(Context context) {
return context.getResources().getBoolean(
com.android.settings.R.bool.has_dock_settings);
}
@Override
protected String getCaption(Resources res, int value) {
switch(value) {
case DOCK_AUDIO_MEDIA_DISABLED:
return res.getString(
com.android.settings.R.string.dock_audio_media_disabled);
case DOCK_AUDIO_MEDIA_ENABLED:
return res.getString(
com.android.settings.R.string.dock_audio_media_enabled);
default:
throw new IllegalArgumentException();
}
}
};
}
}

43
src/com/android/settings/notification/DockingSoundPreferenceController.java Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_GLOBAL;
import android.content.Context;
import android.provider.Settings.Global;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class DockingSoundPreferenceController extends SettingPrefController {
private static final String KEY_DOCKING_SOUNDS = "docking_sounds";
public DockingSoundPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_GLOBAL, KEY_DOCKING_SOUNDS, Global.DOCK_SOUNDS_ENABLED, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return context.getResources().getBoolean(R.bool.has_dock_settings);
}
};
}
}

69
src/com/android/settings/notification/EmergencyTonePreferenceController.java Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_GLOBAL;
import android.content.Context;
import android.content.res.Resources;
import android.provider.Settings.Global;
import android.telephony.TelephonyManager;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class EmergencyTonePreferenceController extends SettingPrefController {
private static final String KEY_EMERGENCY_TONE = "emergency_tone";
private static final int EMERGENCY_TONE_SILENT = 0;
private static final int EMERGENCY_TONE_ALERT = 1;
private static final int EMERGENCY_TONE_VIBRATE = 2;
private static final int DEFAULT_EMERGENCY_TONE = EMERGENCY_TONE_SILENT;
public EmergencyTonePreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_GLOBAL, KEY_EMERGENCY_TONE, Global.EMERGENCY_TONE, DEFAULT_EMERGENCY_TONE,
EMERGENCY_TONE_ALERT, EMERGENCY_TONE_VIBRATE, EMERGENCY_TONE_SILENT) {
@Override
public boolean isApplicable(Context context) {
final TelephonyManager telephony =
(TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
return telephony != null
&& telephony.getCurrentPhoneType() == TelephonyManager.PHONE_TYPE_CDMA;
}
@Override
protected String getCaption(Resources res, int value) {
switch(value) {
case EMERGENCY_TONE_SILENT:
return res.getString(R.string.emergency_tone_silent);
case EMERGENCY_TONE_ALERT:
return res.getString(R.string.emergency_tone_alert);
case EMERGENCY_TONE_VIBRATE:
return res.getString(R.string.emergency_tone_vibrate);
default:
throw new IllegalArgumentException();
}
}
};
}
}

275
src/com/android/settings/notification/OtherSoundSettings.java
View File

@@ -16,177 +16,26 @@
package com.android.settings.notification;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.Resources;
import android.database.ContentObserver;
import android.media.AudioManager;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemProperties;
import android.os.Vibrator;
import android.provider.SearchIndexableResource;
import android.provider.Settings.Global;
import android.provider.Settings.System;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
import android.telephony.TelephonyManager;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.Utils;
import com.android.settings.core.PreferenceController;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Indexable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static com.android.settings.notification.SettingPref.TYPE_GLOBAL;
import static com.android.settings.notification.SettingPref.TYPE_SYSTEM;
public class OtherSoundSettings extends SettingsPreferenceFragment implements Indexable {
/* This class has been deprecated Modifications to Other Sounds settings should be made in
{@link SoundSettings } instead. */
@Deprecated
public class OtherSoundSettings extends DashboardFragment {
private static final String TAG = "OtherSoundSettings";
private static final int DEFAULT_ON = 1;
private static final int EMERGENCY_TONE_SILENT = 0;
private static final int EMERGENCY_TONE_ALERT = 1;
private static final int EMERGENCY_TONE_VIBRATE = 2;
private static final int DEFAULT_EMERGENCY_TONE = EMERGENCY_TONE_SILENT;
private static final int DOCK_AUDIO_MEDIA_DISABLED = 0;
private static final int DOCK_AUDIO_MEDIA_ENABLED = 1;
private static final int DEFAULT_DOCK_AUDIO_MEDIA = DOCK_AUDIO_MEDIA_DISABLED;
private static final String KEY_DIAL_PAD_TONES = "dial_pad_tones";
private static final String KEY_SCREEN_LOCKING_SOUNDS = "screen_locking_sounds";
private static final String KEY_CHARGING_SOUNDS = "charging_sounds";
private static final String KEY_DOCKING_SOUNDS = "docking_sounds";
private static final String KEY_TOUCH_SOUNDS = "touch_sounds";
private static final String KEY_VIBRATE_ON_TOUCH = "vibrate_on_touch";
private static final String KEY_DOCK_AUDIO_MEDIA = "dock_audio_media";
private static final String KEY_EMERGENCY_TONE = "emergency_tone";
// Boot Sounds needs to be a system property so it can be accessed during boot.
private static final String KEY_BOOT_SOUNDS = "boot_sounds";
private static final String PROPERTY_BOOT_SOUNDS = "persist.sys.bootanim.play_sound";
private static final SettingPref PREF_DIAL_PAD_TONES = new SettingPref(
TYPE_SYSTEM, KEY_DIAL_PAD_TONES, System.DTMF_TONE_WHEN_DIALING, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return Utils.isVoiceCapable(context);
}
};
private static final SettingPref PREF_SCREEN_LOCKING_SOUNDS = new SettingPref(
TYPE_SYSTEM, KEY_SCREEN_LOCKING_SOUNDS, System.LOCKSCREEN_SOUNDS_ENABLED, DEFAULT_ON);
private static final SettingPref PREF_CHARGING_SOUNDS = new SettingPref(
TYPE_GLOBAL, KEY_CHARGING_SOUNDS, Global.CHARGING_SOUNDS_ENABLED, DEFAULT_ON);
private static final SettingPref PREF_DOCKING_SOUNDS = new SettingPref(
TYPE_GLOBAL, KEY_DOCKING_SOUNDS, Global.DOCK_SOUNDS_ENABLED, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return hasDockSettings(context);
}
};
private static final SettingPref PREF_TOUCH_SOUNDS = new SettingPref(
TYPE_SYSTEM, KEY_TOUCH_SOUNDS, System.SOUND_EFFECTS_ENABLED, DEFAULT_ON) {
@Override
protected boolean setSetting(final Context context, final int value) {
AsyncTask.execute(new Runnable() {
@Override
public void run() {
final AudioManager am =
(AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
if (value != 0) {
am.loadSoundEffects();
} else {
am.unloadSoundEffects();
}
}
});
return super.setSetting(context, value);
}
};
private static final SettingPref PREF_VIBRATE_ON_TOUCH = new SettingPref(
TYPE_SYSTEM, KEY_VIBRATE_ON_TOUCH, System.HAPTIC_FEEDBACK_ENABLED, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return hasHaptic(context);
}
};
private static final SettingPref PREF_DOCK_AUDIO_MEDIA = new SettingPref(
TYPE_GLOBAL, KEY_DOCK_AUDIO_MEDIA, Global.DOCK_AUDIO_MEDIA_ENABLED,
DEFAULT_DOCK_AUDIO_MEDIA, DOCK_AUDIO_MEDIA_DISABLED, DOCK_AUDIO_MEDIA_ENABLED) {
@Override
public boolean isApplicable(Context context) {
return hasDockSettings(context);
}
@Override
protected String getCaption(Resources res, int value) {
switch(value) {
case DOCK_AUDIO_MEDIA_DISABLED:
return res.getString(R.string.dock_audio_media_disabled);
case DOCK_AUDIO_MEDIA_ENABLED:
return res.getString(R.string.dock_audio_media_enabled);
default:
throw new IllegalArgumentException();
}
}
};
private static final SettingPref PREF_EMERGENCY_TONE = new SettingPref(
TYPE_GLOBAL, KEY_EMERGENCY_TONE, Global.EMERGENCY_TONE, DEFAULT_EMERGENCY_TONE,
EMERGENCY_TONE_ALERT, EMERGENCY_TONE_VIBRATE, EMERGENCY_TONE_SILENT) {
@Override
public boolean isApplicable(Context context) {
final int activePhoneType = TelephonyManager.getDefault().getCurrentPhoneType();
return activePhoneType == TelephonyManager.PHONE_TYPE_CDMA;
}
@Override
protected String getCaption(Resources res, int value) {
switch(value) {
case EMERGENCY_TONE_SILENT:
return res.getString(R.string.emergency_tone_silent);
case EMERGENCY_TONE_ALERT:
return res.getString(R.string.emergency_tone_alert);
case EMERGENCY_TONE_VIBRATE:
return res.getString(R.string.emergency_tone_vibrate);
default:
throw new IllegalArgumentException();
}
}
};
private static final SettingPref[] PREFS = {
PREF_DIAL_PAD_TONES,
PREF_SCREEN_LOCKING_SOUNDS,
PREF_CHARGING_SOUNDS,
PREF_DOCKING_SOUNDS,
PREF_TOUCH_SOUNDS,
PREF_VIBRATE_ON_TOUCH,
PREF_DOCK_AUDIO_MEDIA,
PREF_EMERGENCY_TONE,
};
private SwitchPreference mBootSounds;
private final SettingsObserver mSettingsObserver = new SettingsObserver();
private Context mContext;
@Override
public int getMetricsCategory() {
return MetricsEvent.NOTIFICATION_OTHER_SOUND;
@@ -198,84 +47,34 @@ public class OtherSoundSettings extends SettingsPreferenceFragment implements In
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.other_sound_settings);
mContext = getActivity();
for (SettingPref pref : PREFS) {
pref.init(this);
}
if (mContext.getResources().getBoolean(R.bool.has_boot_sounds)) {
mBootSounds = (SwitchPreference) findPreference(KEY_BOOT_SOUNDS);
mBootSounds.setChecked(SystemProperties.getBoolean(PROPERTY_BOOT_SOUNDS, true));
} else {
removePreference(KEY_BOOT_SOUNDS);
}
protected String getCategoryKey() {
return null;
}
@Override
public void onResume() {
super.onResume();
mSettingsObserver.register(true);
protected String getLogTag() {
return TAG;
}
@Override
public void onPause() {
super.onPause();
mSettingsObserver.register(false);
protected int getPreferenceScreenResId() {
return R.xml.other_sound_settings;
}
@Override
public boolean onPreferenceTreeClick(Preference preference) {
if (mBootSounds != null && preference == mBootSounds) {
SystemProperties.set(PROPERTY_BOOT_SOUNDS, mBootSounds.isChecked() ? "1" : "0");
return false;
} else {
return super.onPreferenceTreeClick(preference);
}
}
private static boolean hasDockSettings(Context context) {
return context.getResources().getBoolean(R.bool.has_dock_settings);
}
private static boolean hasHaptic(Context context) {
final Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
return vibrator != null && vibrator.hasVibrator();
}
// === Callbacks ===
private final class SettingsObserver extends ContentObserver {
public SettingsObserver() {
super(new Handler());
}
public void register(boolean register) {
final ContentResolver cr = getContentResolver();
if (register) {
for (SettingPref pref : PREFS) {
cr.registerContentObserver(pref.getUri(), false, this);
}
} else {
cr.unregisterContentObserver(this);
}
}
@Override
public void onChange(boolean selfChange, Uri uri) {
super.onChange(selfChange, uri);
for (SettingPref pref : PREFS) {
if (pref.getUri().equals(uri)) {
pref.update(mContext);
return;
}
}
}
protected List<PreferenceController> getPreferenceControllers(Context context) {
final List<PreferenceController> controllers = new ArrayList<>();
Lifecycle lifecycle = getLifecycle();
controllers.add(new DialPadTonePreferenceController(context, this, lifecycle));
controllers.add(new ScreenLockSoundPreferenceController(context, this, lifecycle));
controllers.add(new ChargingSoundPreferenceController(context, this, lifecycle));
controllers.add(new DockingSoundPreferenceController(context, this, lifecycle));
controllers.add(new TouchSoundPreferenceController(context, this, lifecycle));
controllers.add(new VibrateOnTouchPreferenceController(context, this, lifecycle));
controllers.add(new DockAudioMediaPreferenceController(context, this, lifecycle));
controllers.add(new BootSoundPreferenceController(context));
controllers.add(new EmergencyTonePreferenceController(context, this, lifecycle));
return controllers;
}
// === Indexing ===
@@ -292,11 +91,23 @@ public class OtherSoundSettings extends SettingsPreferenceFragment implements In
public List<String> getNonIndexableKeys(Context context) {
final ArrayList<String> rt = new ArrayList<String>();
for (SettingPref pref : PREFS) {
if (!pref.isApplicable(context)) {
rt.add(pref.getKey());
}
}
new DialPadTonePreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new ScreenLockSoundPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new ChargingSoundPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new DockingSoundPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new TouchSoundPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new VibrateOnTouchPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new DockAudioMediaPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new BootSoundPreferenceController(context).updateNonIndexableKeys(rt);
new EmergencyTonePreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
return rt;
}
};

38
src/com/android/settings/notification/ScreenLockSoundPreferenceController.java Normal file
View File

@@ -0,0 +1,38 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_SYSTEM;
import android.content.Context;
import android.provider.Settings.System;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class ScreenLockSoundPreferenceController extends SettingPrefController {
private static final String KEY_SCREEN_LOCKING_SOUNDS = "screen_locking_sounds";
public ScreenLockSoundPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_SYSTEM, KEY_SCREEN_LOCKING_SOUNDS, System.LOCKSCREEN_SOUNDS_ENABLED, DEFAULT_ON);
}
}

123
src/com/android/settings/notification/SettingPrefController.java Normal file
View File

@@ -0,0 +1,123 @@
/*
* Copyright (C) 2017 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.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.PreferenceController;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.core.lifecycle.LifecycleObserver;
import com.android.settings.core.lifecycle.events.OnPause;
import com.android.settings.core.lifecycle.events.OnResume;
import java.util.List;
public abstract class SettingPrefController extends PreferenceController implements
LifecycleObserver, OnResume, OnPause {
protected static final int DEFAULT_ON = 1;
private SettingsPreferenceFragment mParent;
protected SettingsObserver mSettingsObserver;
protected SettingPref mPreference;
public SettingPrefController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context);
mParent = parent;
if (lifecycle != null) {
lifecycle.addObserver(this);
}
}
@Override
public void displayPreference(PreferenceScreen screen) {
mPreference.init(mParent);
if (isAvailable()) {
mSettingsObserver = new SettingsObserver();
}
}
@Override
public String getPreferenceKey() {
return mPreference.getKey();
}
@Override
public boolean isAvailable() {
return mPreference.isApplicable(mContext);
}
@Override
public void updateNonIndexableKeys(List<String> keys) {
if (!mPreference.isApplicable(mContext)) {
keys.add(mPreference.getKey());
}
}
@Override
public void updateState(Preference preference) {
mPreference.update(mContext);
}
@Override
public void onResume() {
if (mSettingsObserver != null) {
mSettingsObserver.register(true /* register */);
}
}
@Override
public void onPause() {
if (mSettingsObserver != null) {
mSettingsObserver.register(false /* register */);
}
}
@VisibleForTesting
final class SettingsObserver extends ContentObserver {
public SettingsObserver() {
super(new Handler());
}
public void register(boolean register) {
final ContentResolver cr = mContext.getContentResolver();
if (register) {
cr.registerContentObserver(mPreference.getUri(), false, this);
} else {
cr.unregisterContentObserver(this);
}
}
@Override
public void onChange(boolean selfChange, Uri uri) {
super.onChange(selfChange, uri);
if (mPreference.getUri().equals(uri)) {
mPreference.update(mContext);
}
}
}
}

51
src/com/android/settings/notification/SoundSettings.java
View File

@@ -41,6 +41,7 @@ import com.android.settings.core.PreferenceController;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.dashboard.SummaryLoader;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.drawer.CategoryKey;
import java.text.NumberFormat;
@@ -113,14 +114,17 @@ public class SoundSettings extends DashboardFragment {
@Override
protected int getPreferenceScreenResId() {
return R.xml.sound_settings;
return mDashboardFeatureProvider.isEnabled()
? R.xml.ia_sound_settings : R.xml.sound_settings;
}
@Override
protected List<PreferenceController> getPreferenceControllers(Context context) {
final List<PreferenceController> controllers = new ArrayList<>();
Lifecycle lifecycle = getLifecycle();
controllers.add(new CastPreferenceController(context));
if (!mDashboardFeatureProvider.isEnabled()) {
controllers.add(new CastPreferenceController(context));
}
controllers.add(new ZenModePreferenceController(context));
controllers.add(new EmergencyBroadcastPreferenceController(context));
controllers.add(new VibrateWhenRingPreferenceController(context));
@@ -141,6 +145,19 @@ public class SoundSettings extends DashboardFragment {
mWorkSoundController = new WorkSoundPreferenceController(context, this, getLifecycle());
controllers.add(mWorkSoundController);
// === Other Sound Settings ===
if (mDashboardFeatureProvider.isEnabled()) {
controllers.add(new DialPadTonePreferenceController(context, this, lifecycle));
controllers.add(new ScreenLockSoundPreferenceController(context, this, lifecycle));
controllers.add(new ChargingSoundPreferenceController(context, this, lifecycle));
controllers.add(new DockingSoundPreferenceController(context, this, lifecycle));
controllers.add(new TouchSoundPreferenceController(context, this, lifecycle));
controllers.add(new VibrateOnTouchPreferenceController(context, this, lifecycle));
controllers.add(new DockAudioMediaPreferenceController(context, this, lifecycle));
controllers.add(new BootSoundPreferenceController(context));
controllers.add(new EmergencyTonePreferenceController(context, this, lifecycle));
}
return controllers;
}
@@ -297,10 +314,38 @@ public class SoundSettings extends DashboardFragment {
context, null /* Callback */, null /* Lifecycle */).updateNonIndexableKeys(rt);
new RingVolumePreferenceController(
context, null /* Callback */, null /* Lifecycle */).updateNonIndexableKeys(rt);
new CastPreferenceController(context).updateNonIndexableKeys(rt);
new PhoneRingtonePreferenceController(context).updateNonIndexableKeys(rt);
new VibrateWhenRingPreferenceController(context).updateNonIndexableKeys(rt);
new EmergencyBroadcastPreferenceController(context).updateNonIndexableKeys(rt);
if (FeatureFactory.getFactory(context).getDashboardFeatureProvider(context)
.isEnabled()) {
new DialPadTonePreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new ScreenLockSoundPreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new ChargingSoundPreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new DockingSoundPreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new TouchSoundPreferenceController(context, null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new VibrateOnTouchPreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new DockAudioMediaPreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
new BootSoundPreferenceController(context).updateNonIndexableKeys(rt);
new EmergencyTonePreferenceController(context,
null /* SettingsPreferenceFragment */,
null /* Lifecycle */).updateNonIndexableKeys(rt);
} else {
new CastPreferenceController(context).updateNonIndexableKeys(rt);
}
return rt;
}

56
src/com/android/settings/notification/TouchSoundPreferenceController.java Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_SYSTEM;
import android.content.Context;
import android.media.AudioManager;
import android.os.AsyncTask;
import android.provider.Settings.System;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class TouchSoundPreferenceController extends SettingPrefController {
private static final String KEY_TOUCH_SOUNDS = "touch_sounds";
public TouchSoundPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_SYSTEM, KEY_TOUCH_SOUNDS, System.SOUND_EFFECTS_ENABLED, DEFAULT_ON) {
@Override
protected boolean setSetting(final Context context, final int value) {
AsyncTask.execute(new Runnable() {
@Override
public void run() {
final AudioManager am =
(AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
if (value != 0) {
am.loadSoundEffects();
} else {
am.unloadSoundEffects();
}
}
});
return super.setSetting(context, value);
}
};
}
}

49
src/com/android/settings/notification/VibrateOnTouchPreferenceController.java Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright (C) 2017 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 static com.android.settings.notification.SettingPref.TYPE_SYSTEM;
import android.content.Context;
import android.os.Vibrator;
import android.provider.Settings.System;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.lifecycle.Lifecycle;
public class VibrateOnTouchPreferenceController extends SettingPrefController {
private static final String KEY_VIBRATE_ON_TOUCH = "vibrate_on_touch";
public VibrateOnTouchPreferenceController(Context context, SettingsPreferenceFragment parent,
Lifecycle lifecycle) {
super(context, parent, lifecycle);
mPreference = new SettingPref(
TYPE_SYSTEM, KEY_VIBRATE_ON_TOUCH, System.HAPTIC_FEEDBACK_ENABLED, DEFAULT_ON) {
@Override
public boolean isApplicable(Context context) {
return hasHaptic(context);
}
};
}
private static boolean hasHaptic(Context context) {
final Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
return vibrator != null && vibrator.hasVibrator();
}
}