diff --git a/src/com/android/settings/notification/AudioHelper.java b/src/com/android/settings/notification/AudioHelper.java index ea5bc4ace22..07cd912d766 100644 --- a/src/com/android/settings/notification/AudioHelper.java +++ b/src/com/android/settings/notification/AudioHelper.java @@ -16,8 +16,12 @@ package com.android.settings.notification; +import android.annotation.UserIdInt; import android.content.Context; import android.media.AudioSystem; +import android.os.UserHandle; +import android.os.UserManager; +import com.android.settings.Utils; /** * Helper class to wrap API for testing @@ -34,4 +38,11 @@ public class AudioHelper { return AudioSystem.isSingleVolume(mContext); } + public int getManagedProfileId(UserManager um) { + return Utils.getManagedProfileId(um, UserHandle.myUserId()); + } + + public Context createPackageContextAsUser(@UserIdInt int profileId) { + return Utils.createPackageContextAsUser(mContext, profileId); + } } diff --git a/src/com/android/settings/notification/SoundSettings.java b/src/com/android/settings/notification/SoundSettings.java index 91663775e35..5f53d9a193c 100644 --- a/src/com/android/settings/notification/SoundSettings.java +++ b/src/com/android/settings/notification/SoundSettings.java @@ -16,45 +16,26 @@ package com.android.settings.notification; -import android.annotation.UserIdInt; import android.app.Activity; -import android.app.AlertDialog; -import android.app.Dialog; -import android.app.FragmentManager; import android.app.NotificationManager; import android.content.BroadcastReceiver; import android.content.Context; -import android.content.DialogInterface; import android.content.Intent; import android.content.IntentFilter; import android.media.AudioManager; -import android.media.AudioSystem; -import android.media.Ringtone; -import android.media.RingtoneManager; -import android.net.Uri; 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.preference.SeekBarVolumizer; 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.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.RingtonePreference; -import com.android.settings.DefaultRingtonePreference; -import com.android.settings.Utils; import com.android.settings.core.PreferenceController; -import com.android.settings.core.instrumentation.InstrumentedDialogFragment; import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.dashboard.DashboardFragment; import com.android.settings.dashboard.SummaryLoader; @@ -66,16 +47,9 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; -public class SoundSettings extends DashboardFragment - implements OnPreferenceChangeListener { +public class SoundSettings extends DashboardFragment { private static final String TAG = "SoundSettings"; - 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; @@ -84,20 +58,9 @@ public class SoundSettings extends DashboardFragment private final VolumePreferenceCallback mVolumeCallback = new VolumePreferenceCallback(); private final H mHandler = new H(); - private Context mContext; - private boolean mVoiceCapable; - - private PreferenceGroup mWorkPreferenceCategory; - private TwoStatePreference mWorkUsePersonalSounds; - private Preference mWorkPhoneRingtonePreference; - private Preference mWorkNotificationRingtonePreference; - private Preference mWorkAlarmRingtonePreference; - - private UserManager mUserManager; + private WorkSoundPreferenceController mWorkSoundController; private RingtonePreference mRequestPreference; - private @UserIdInt int mManagedProfileId; - @Override public int getMetricsCategory() { return MetricsEvent.SOUND; @@ -106,10 +69,6 @@ public class SoundSettings extends DashboardFragment @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - mContext = getActivity(); - mUserManager = UserManager.get(getContext()); - mVoiceCapable = Utils.isVoiceCapable(mContext); - if (savedInstanceState != null) { String selectedPreference = savedInstanceState.getString(SELECTED_PREFERENCE_KEY, null); if (!TextUtils.isEmpty(selectedPreference)) { @@ -118,25 +77,6 @@ public class SoundSettings extends DashboardFragment } } - @Override - public void onResume() { - super.onResume(); - - 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(); @@ -190,6 +130,10 @@ public class SoundSettings extends DashboardFragment controllers.add(new AlarmRingtonePreferenceController(context)); controllers.add(new NotificationRingtonePreferenceController(context)); + // === Work Sound Settings === + mWorkSoundController = new WorkSoundPreferenceController(context, this, getLifecycle()); + controllers.add(mWorkSoundController); + return controllers; } @@ -209,33 +153,6 @@ public class SoundSettings extends DashboardFragment } } - /** - * 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 === final class VolumePreferenceCallback implements VolumeSeekBarPreference.Callback { @@ -265,23 +182,6 @@ public class SoundSettings extends DashboardFragment } }; - - // === Phone & notification ringtone === - - private boolean shouldShowRingtoneSettings() { - return !AudioSystem.isSingleVolume(mContext); - } - - 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 */); - } - // === Callbacks === @@ -393,149 +293,9 @@ public class SoundSettings extends DashboardFragment // === 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(); - } + void enableWorkSync() { + if (mWorkSoundController != null) { + mWorkSoundController.enableWorkSync(); } } } diff --git a/src/com/android/settings/notification/WorkSoundPreferenceController.java b/src/com/android/settings/notification/WorkSoundPreferenceController.java new file mode 100644 index 00000000000..cc671ad11cc --- /dev/null +++ b/src/com/android/settings/notification/WorkSoundPreferenceController.java @@ -0,0 +1,319 @@ +/* + * Copyright (C) 2016 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.AlertDialog; +import android.app.Dialog; +import android.app.FragmentManager; +import android.content.Context; +import android.content.DialogInterface; +import android.media.AudioSystem; +import android.media.Ringtone; +import android.media.RingtoneManager; +import android.net.Uri; +import android.os.Bundle; +import android.os.UserHandle; +import android.os.UserManager; +import android.provider.Settings; +import android.support.v7.preference.Preference; +import android.support.v7.preference.Preference.OnPreferenceChangeListener; +import android.support.v7.preference.PreferenceGroup; +import android.support.v7.preference.PreferenceScreen; +import android.support.v7.preference.TwoStatePreference; +import android.util.Log; + +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.logging.nano.MetricsProto.MetricsEvent; +import com.android.settings.DefaultRingtonePreference; +import com.android.settings.R; +import com.android.settings.Utils; +import com.android.settings.core.PreferenceController; +import com.android.settings.core.instrumentation.InstrumentedDialogFragment; +import com.android.settings.core.lifecycle.Lifecycle; +import com.android.settings.core.lifecycle.LifecycleObserver; +import com.android.settings.core.lifecycle.events.OnResume; + + +public class WorkSoundPreferenceController extends PreferenceController implements + OnPreferenceChangeListener, LifecycleObserver, OnResume { + + private static final String TAG = "WorkSoundPrefController"; + 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 PreferenceGroup mWorkPreferenceCategory; + private TwoStatePreference mWorkUsePersonalSounds; + private Preference mWorkPhoneRingtonePreference; + private Preference mWorkNotificationRingtonePreference; + private Preference mWorkAlarmRingtonePreference; + private boolean mVoiceCapable; + private UserManager mUserManager; + private SoundSettings mParent; + private AudioHelper mHelper; + + private @UserIdInt + int mManagedProfileId; + + public WorkSoundPreferenceController(Context context, SoundSettings parent, + Lifecycle lifecycle) { + this(context, parent, lifecycle, new AudioHelper(context)); + } + + @VisibleForTesting + WorkSoundPreferenceController(Context context, SoundSettings parent, Lifecycle lifecycle, + AudioHelper helper) { + super(context); + mUserManager = UserManager.get(context); + mVoiceCapable = Utils.isVoiceCapable(mContext); + mParent = parent; + mHelper = helper; + if (lifecycle != null) { + lifecycle.addObserver(this); + } + } + + @Override + public void displayPreference(PreferenceScreen screen) { + // do nothing + } + + @Override + public void onResume() { + if (isAvailable()) { + if ((mWorkPreferenceCategory == null)) { + // Work preferences not yet set + mParent.addPreferencesFromResource(R.xml.sound_work_settings); + initWorkPreferences(); + } + if (!mWorkUsePersonalSounds.isChecked()) { + updateWorkRingtoneSummaries(); + } + } else { + maybeRemoveWorkPreferences(); + } + } + + @Override + public String getPreferenceKey() { + return KEY_WORK_CATEGORY; + } + + @Override + public boolean isAvailable() { + mManagedProfileId = mHelper.getManagedProfileId(mUserManager); + return mManagedProfileId != UserHandle.USER_NULL && shouldShowRingtoneSettings(); + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + return false; + } + + /** + * Updates the summary of work preferences + * + * This controller listens to changes on the work ringtone preferences, identified by keys + * "work_ringtone", "work_notification_ringtone" and "work_alarm_ringtone". + */ + @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; + } + + // === Phone & notification ringtone === + + private boolean shouldShowRingtoneSettings() { + return !mHelper.isSingleVolume(); + } + + private 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 */); + } + + private Context getManagedProfileContext() { + if (mManagedProfileId == UserHandle.USER_NULL) { + return null; + } + return mHelper.createPackageContextAsUser(mManagedProfileId); + } + + private DefaultRingtonePreference initWorkPreference(String key) { + DefaultRingtonePreference pref = + (DefaultRingtonePreference) mParent.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) mParent.getPreferenceScreen() + .findPreference(KEY_WORK_CATEGORY); + mWorkUsePersonalSounds = (TwoStatePreference) mParent.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(mParent); + return false; + } else { + disableWorkSync(); + return true; + } + } + }); + } + + void enableWorkSync() { + RingtoneManager.enableSyncFromParent(getManagedProfileContext()); + enableWorkSyncSettings(); + } + + private void enableWorkSyncSettings() { + mWorkUsePersonalSounds.setChecked(true); + + if (mWorkPhoneRingtonePreference != null) { + mWorkPhoneRingtonePreference.setSummary( + com.android.settings.R.string.work_sound_same_as_personal); + } + mWorkNotificationRingtonePreference.setSummary( + com.android.settings.R.string.work_sound_same_as_personal); + mWorkAlarmRingtonePreference.setSummary( + com.android.settings.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; + } + mParent.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(com.android.settings.R.string.work_sync_dialog_title) + .setMessage(com.android.settings.R.string.work_sync_dialog_message) + .setPositiveButton(com.android.settings.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(); + } + } + } + +} diff --git a/tests/robotests/src/com/android/settings/notification/WorkSoundPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/WorkSoundPreferenceControllerTest.java new file mode 100644 index 00000000000..4d8101fef90 --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/WorkSoundPreferenceControllerTest.java @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2016 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.UserHandle; +import android.os.UserManager; +import android.support.v7.preference.Preference; +import android.support.v7.preference.PreferenceGroup; +import android.support.v7.preference.PreferenceScreen; +import android.support.v7.preference.TwoStatePreference; +import android.telephony.TelephonyManager; + +import com.android.settings.DefaultRingtonePreference; +import com.android.settings.R; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class WorkSoundPreferenceControllerTest { + + 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"; + + @Mock + private Context mContext; + @Mock + private PreferenceScreen mScreen; + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private AudioHelper mAudioHelper; + @Mock + private SoundSettings mFragment; + + private WorkSoundPreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); + mController = new WorkSoundPreferenceController(mContext, mFragment, null, mAudioHelper); + } + + @Test + public void isAvailable_managedProfileAndNotSingleVolume_shouldReturnTrue() { + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + when(mAudioHelper.getManagedProfileId(any(UserManager.class))) + .thenReturn(UserHandle.myUserId()); + when(mAudioHelper.isSingleVolume()).thenReturn(false); + + assertThat(mController.isAvailable()).isTrue(); + } + + @Test + public void isAvailable_noManagedProfile_shouldReturnFalse() { + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + when(mAudioHelper.getManagedProfileId(any(UserManager.class))) + .thenReturn(UserHandle.USER_NULL); + when(mAudioHelper.isSingleVolume()).thenReturn(false); + + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void isAvailable_singleVolume_shouldReturnFalse() { + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + when(mAudioHelper.getManagedProfileId(any(UserManager.class))) + .thenReturn(UserHandle.myUserId()); + when(mAudioHelper.isSingleVolume()).thenReturn(true); + + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void onResume_available_shouldAddPreferenceCategory() { + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + when(mAudioHelper.getManagedProfileId(any(UserManager.class))) + .thenReturn(UserHandle.myUserId()); + when(mAudioHelper.isSingleVolume()).thenReturn(false); + when(mFragment.getPreferenceScreen()).thenReturn(mScreen); + when(mScreen.findPreference(KEY_WORK_CATEGORY)) + .thenReturn(mock(PreferenceGroup.class)); + when(mScreen.findPreference(KEY_WORK_USE_PERSONAL_SOUNDS)) + .thenReturn(mock(TwoStatePreference.class)); + when(mScreen.findPreference(KEY_WORK_PHONE_RINGTONE)) + .thenReturn(mock(DefaultRingtonePreference.class)); + when(mScreen.findPreference(KEY_WORK_NOTIFICATION_RINGTONE)) + .thenReturn(mock(DefaultRingtonePreference.class)); + when(mScreen.findPreference(KEY_WORK_ALARM_RINGTONE)) + .thenReturn(mock(DefaultRingtonePreference.class)); + when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext); + + mController.onResume(); + + verify(mFragment).addPreferencesFromResource(R.xml.sound_work_settings); + } + + @Test + public void onResume_notAvailable_shouldNotAddPreferenceCategory() { + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + when(mAudioHelper.getManagedProfileId(any(UserManager.class))) + .thenReturn(UserHandle.USER_NULL); + when(mAudioHelper.isSingleVolume()).thenReturn(true); + when(mFragment.getPreferenceScreen()).thenReturn(mScreen); + + mController.onResume(); + + verify(mFragment, never()).addPreferencesFromResource(anyInt()); + } + + @Test + public void onPreferenceChange_shouldUpdateSummary() { + final Preference preference = mock(Preference.class); + when(preference.getKey()).thenReturn(KEY_WORK_PHONE_RINGTONE); + + mController.onPreferenceChange(preference, "hello"); + + verify(preference).setSummary(anyString()); + } + +}