Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Introduce separate setting key for hardware haptic feedback"

Browse Source
This commit is contained in:
Lais Andrade
2021-11-22 17:54:42 +00:00
committed by Android (Google) Code Review
parent 811ae06be3 657b009bca
commit 2dda258471
9 changed files with 293 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
core/java/android/provider/Settings.java
View File

@@ -4536,6 +4536,25 @@ public final class Settings {
public static final String HAPTIC_FEEDBACK_INTENSITY =
"haptic_feedback_intensity";
/**
* The intensity of haptic feedback vibrations for interaction with hardware components from
* the device, like buttons and sensors, if configurable.
*
* Not all devices are capable of changing their feedback intensity; on these devices
* there will likely be no difference between the various vibration intensities except for
* intensity 0 (off) and the rest.
*
* <b>Values:</b><br/>
* 0 - Vibration is disabled<br/>
* 1 - Weak vibrations<br/>
* 2 - Medium vibrations<br/>
* 3 - Strong vibrations
* @hide
*/
@Readable
public static final String HARDWARE_HAPTIC_FEEDBACK_INTENSITY =
"hardware_haptic_feedback_intensity";
/**
* Ringer volume. This is used internally, changing this value will not
* change the volume. See AudioManager.

9
core/java/android/view/HapticFeedbackConstants.java
View File

@@ -153,10 +153,19 @@ public class HapticFeedbackConstants {
/**
* Invocation of the voice assistant via hardware button.
* This is a private constant. Feel free to renumber as desired.
* @hide
*/
public static final int ASSISTANT_BUTTON = 10002;
/**
* The user has performed a long press on the power button hardware that is resulting
* in an action being performed.
* This is a private constant. Feel free to renumber as desired.
* @hide
*/
public static final int LONG_PRESS_POWER_BUTTON = 10003;
/**
* Flag for {@link View#performHapticFeedback(int, int)
* View.performHapticFeedback(int, int)}: Ignore the setting in the

1
packages/SettingsProvider/src/android/provider/settings/backup/SystemSettings.java
View File

@@ -80,6 +80,7 @@ public class SystemSettings {
Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
Settings.System.RING_VIBRATION_INTENSITY,
Settings.System.HAPTIC_FEEDBACK_INTENSITY,
Settings.System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY,
Settings.System.DISPLAY_COLOR_MODE_VENDOR_HINT, // must precede DISPLAY_COLOR_MODE
Settings.System.DISPLAY_COLOR_MODE,
Settings.System.ALARM_ALERT,

1
packages/SettingsProvider/src/android/provider/settings/validators/SystemSettingsValidators.java
View File

@@ -120,6 +120,7 @@ public class SystemSettingsValidators {
VALIDATORS.put(System.NOTIFICATION_VIBRATION_INTENSITY, VIBRATION_INTENSITY_VALIDATOR);
VALIDATORS.put(System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_VALIDATOR);
VALIDATORS.put(System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_VALIDATOR);
VALIDATORS.put(System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_VALIDATOR);
VALIDATORS.put(System.RINGTONE, URI_VALIDATOR);
VALIDATORS.put(System.NOTIFICATION_SOUND, URI_VALIDATOR);
VALIDATORS.put(System.ALARM_ALERT, URI_VALIDATOR);

14
packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarCommandQueueCallbacks.java
View File

@@ -30,11 +30,11 @@ import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.media.AudioAttributes;
import android.os.Bundle;
import android.os.PowerManager;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.VibrationAttributes;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.util.Log;
@@ -106,10 +106,8 @@ public class StatusBarCommandQueueCallbacks implements CommandQueue.Callbacks {
private final VibrationEffect mCameraLaunchGestureVibrationEffect;
private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
.setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
.setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION)
.build();
private static final VibrationAttributes HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_HARDWARE_FEEDBACK);
@Inject
StatusBarCommandQueueCallbacks(
@@ -611,9 +609,9 @@ public class StatusBarCommandQueueCallbacks implements CommandQueue.Callbacks {
}
private void vibrateForCameraGesture() {
// Make sure to pass -1 for repeat so VibratorService doesn't stop us when going to sleep.
mVibratorOptional.ifPresent(
v -> v.vibrate(mCameraLaunchGestureVibrationEffect, VIBRATION_ATTRIBUTES));
v -> v.vibrate(mCameraLaunchGestureVibrationEffect,
HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES));
}
private static VibrationEffect getCameraGestureVibrationEffect(
@@ -627,6 +625,8 @@ public class StatusBarCommandQueueCallbacks implements CommandQueue.Callbacks {
.compose();
}
if (vibratorOptional.isPresent() && vibratorOptional.get().hasAmplitudeControl()) {
// Make sure to pass -1 for repeat so VibratorManagerService doesn't stop us when going
// to sleep.
return VibrationEffect.createWaveform(
StatusBar.CAMERA_LAUNCH_GESTURE_VIBRATION_TIMINGS,
StatusBar.CAMERA_LAUNCH_GESTURE_VIBRATION_AMPLITUDES,

34
services/core/java/com/android/server/policy/PhoneWindowManager.java
View File

@@ -332,6 +332,10 @@ public class PhoneWindowManager implements WindowManagerPolicy {
private static final int POWER_BUTTON_SUPPRESSION_DELAY_DEFAULT_MILLIS = 800;
private static final VibrationAttributes TOUCH_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_TOUCH);
private static final VibrationAttributes PHYSICAL_EMULATION_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_PHYSICAL_EMULATION);
private static final VibrationAttributes HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_HARDWARE_FEEDBACK);
/**
* Keyguard stuff
@@ -1115,21 +1119,21 @@ public class PhoneWindowManager implements WindowManagerPolicy {
break;
case LONG_PRESS_POWER_GLOBAL_ACTIONS:
mPowerKeyHandled = true;
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, false,
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON, false,
"Power - Long Press - Global Actions");
showGlobalActions();
break;
case LONG_PRESS_POWER_SHUT_OFF:
case LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM:
mPowerKeyHandled = true;
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, false,
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON, false,
"Power - Long Press - Shut Off");
sendCloseSystemWindows(SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS);
mWindowManagerFuncs.shutdown(behavior == LONG_PRESS_POWER_SHUT_OFF);
break;
case LONG_PRESS_POWER_GO_TO_VOICE_ASSIST:
mPowerKeyHandled = true;
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, false,
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON, false,
"Power - Long Press - Go To Voice Assist");
// Some devices allow the voice assistant intent during setup (and use that intent
// to launch something else, like Settings). So we explicitly allow that via the
@@ -1153,7 +1157,7 @@ public class PhoneWindowManager implements WindowManagerPolicy {
break;
case VERY_LONG_PRESS_POWER_GLOBAL_ACTIONS:
mPowerKeyHandled = true;
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, false,
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON, false,
"Power - Very Long Press - Show Global Actions");
showGlobalActions();
break;
@@ -2098,7 +2102,8 @@ public class PhoneWindowManager implements WindowManagerPolicy {
mPowerKeyHandled = true;
break;
case POWER_VOLUME_UP_BEHAVIOR_GLOBAL_ACTIONS:
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, false,
performHapticFeedback(
HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON, false,
"Power + Volume Up - Global Actions");
showGlobalActions();
mPowerKeyHandled = true;
@@ -5291,7 +5296,7 @@ public class PhoneWindowManager implements WindowManagerPolicy {
return false;
}
mVibrator.vibrate(uid, packageName, effect, reason, TOUCH_VIBRATION_ATTRIBUTES);
mVibrator.vibrate(uid, packageName, effect, reason, getVibrationAttributes(effectId));
return true;
}
@@ -5320,6 +5325,7 @@ public class PhoneWindowManager implements WindowManagerPolicy {
case HapticFeedbackConstants.GESTURE_START:
return VibrationEffect.get(VibrationEffect.EFFECT_CLICK);
case HapticFeedbackConstants.LONG_PRESS:
case HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON:
case HapticFeedbackConstants.EDGE_SQUEEZE:
return VibrationEffect.get(VibrationEffect.EFFECT_HEAVY_CLICK);
case HapticFeedbackConstants.REJECT:
@@ -5358,6 +5364,22 @@ public class PhoneWindowManager implements WindowManagerPolicy {
}
}
private VibrationAttributes getVibrationAttributes(int effectId) {
switch (effectId) {
case HapticFeedbackConstants.EDGE_SQUEEZE:
case HapticFeedbackConstants.EDGE_RELEASE:
return PHYSICAL_EMULATION_VIBRATION_ATTRIBUTES;
case HapticFeedbackConstants.ASSISTANT_BUTTON:
case HapticFeedbackConstants.LONG_PRESS_POWER_BUTTON:
case HapticFeedbackConstants.ROTARY_SCROLL_TICK:
case HapticFeedbackConstants.ROTARY_SCROLL_ITEM_FOCUS:
case HapticFeedbackConstants.ROTARY_SCROLL_LIMIT:
return HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES;
default:
return TOUCH_VIBRATION_ATTRIBUTES;
}
}
@Override
public void keepScreenOnStartedLw() {
}

6
services/core/java/com/android/server/power/Notifier.java
View File

@@ -110,8 +110,8 @@ public class Notifier {
private static final VibrationEffect CHARGING_VIBRATION_EFFECT =
VibrationEffect.createWaveform(CHARGING_VIBRATION_TIME, CHARGING_VIBRATION_AMPLITUDE,
-1);
private static final VibrationAttributes TOUCH_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_TOUCH);
private static final VibrationAttributes HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES =
VibrationAttributes.createForUsage(VibrationAttributes.USAGE_HARDWARE_FEEDBACK);
private final Object mLock = new Object();
@@ -807,7 +807,7 @@ public class Notifier {
final boolean vibrate = Settings.Secure.getIntForUser(mContext.getContentResolver(),
Settings.Secure.CHARGING_VIBRATION_ENABLED, 1, userId) != 0;
if (vibrate) {
mVibrator.vibrate(CHARGING_VIBRATION_EFFECT, TOUCH_VIBRATION_ATTRIBUTES);
mVibrator.vibrate(CHARGING_VIBRATION_EFFECT, HARDWARE_FEEDBACK_VIBRATION_ATTRIBUTES);
}
// play sound

118
services/core/java/com/android/server/vibrator/VibrationSettings.java
View File

@@ -16,6 +16,14 @@
package com.android.server.vibrator;
import static android.os.VibrationAttributes.USAGE_ALARM;
import static android.os.VibrationAttributes.USAGE_COMMUNICATION_REQUEST;
import static android.os.VibrationAttributes.USAGE_HARDWARE_FEEDBACK;
import static android.os.VibrationAttributes.USAGE_NOTIFICATION;
import static android.os.VibrationAttributes.USAGE_PHYSICAL_EMULATION;
import static android.os.VibrationAttributes.USAGE_RINGTONE;
import static android.os.VibrationAttributes.USAGE_TOUCH;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.IUidObserver;
@@ -90,6 +98,8 @@ final class VibrationSettings {
@GuardedBy("mLock")
private int mHapticFeedbackIntensity;
@GuardedBy("mLock")
private int mHardwareFeedbackIntensity;
@GuardedBy("mLock")
private int mNotificationIntensity;
@GuardedBy("mLock")
private int mRingIntensity;
@@ -232,17 +242,20 @@ final class VibrationSettings {
* @return The vibration intensity, one of Vibrator.VIBRATION_INTENSITY_*
*/
public int getDefaultIntensity(int usageHint) {
if (isAlarm(usageHint)) {
if (usageHint == USAGE_ALARM) {
return Vibrator.VIBRATION_INTENSITY_HIGH;
}
synchronized (mLock) {
if (mVibrator != null) {
if (isRingtone(usageHint)) {
return mVibrator.getDefaultRingVibrationIntensity();
} else if (isNotification(usageHint)) {
return mVibrator.getDefaultNotificationVibrationIntensity();
} else if (isHapticFeedback(usageHint)) {
return mVibrator.getDefaultHapticFeedbackIntensity();
switch (usageHint) {
case USAGE_RINGTONE:
return mVibrator.getDefaultRingVibrationIntensity();
case USAGE_NOTIFICATION:
return mVibrator.getDefaultNotificationVibrationIntensity();
case USAGE_TOUCH:
case USAGE_HARDWARE_FEEDBACK:
case USAGE_PHYSICAL_EMULATION:
return mVibrator.getDefaultHapticFeedbackIntensity();
}
}
}
@@ -257,16 +270,20 @@ final class VibrationSettings {
*/
public int getCurrentIntensity(int usageHint) {
synchronized (mLock) {
if (isRingtone(usageHint)) {
return mRingIntensity;
} else if (isNotification(usageHint)) {
return mNotificationIntensity;
} else if (isHapticFeedback(usageHint)) {
return mHapticFeedbackIntensity;
} else if (isAlarm(usageHint)) {
return Vibrator.VIBRATION_INTENSITY_HIGH;
} else {
return Vibrator.VIBRATION_INTENSITY_MEDIUM;
switch (usageHint) {
case USAGE_RINGTONE:
return mRingIntensity;
case USAGE_NOTIFICATION:
return mNotificationIntensity;
case USAGE_TOUCH:
return mHapticFeedbackIntensity;
case USAGE_HARDWARE_FEEDBACK:
case USAGE_PHYSICAL_EMULATION:
return mHardwareFeedbackIntensity;
case USAGE_ALARM:
return Vibrator.VIBRATION_INTENSITY_HIGH;
default:
return Vibrator.VIBRATION_INTENSITY_MEDIUM;
}
}
}
@@ -289,7 +306,7 @@ final class VibrationSettings {
* for ringtone usage only. All other usages are allowed independently of ringer mode.
*/
public boolean shouldVibrateForRingerMode(int usageHint) {
if (!isRingtone(usageHint)) {
if (usageHint != USAGE_RINGTONE) {
return true;
}
synchronized (mLock) {
@@ -324,8 +341,10 @@ final class VibrationSettings {
* {@link VibrationAttributes#USAGE_COMMUNICATION_REQUEST} usages are allowed to vibrate.
*/
public boolean shouldVibrateForPowerMode(int usageHint) {
return !mLowPowerMode || isRingtone(usageHint) || isAlarm(usageHint)
|| usageHint == VibrationAttributes.USAGE_COMMUNICATION_REQUEST;
synchronized (mLock) {
return !mLowPowerMode || usageHint == USAGE_RINGTONE || usageHint == USAGE_ALARM
|| usageHint == USAGE_COMMUNICATION_REQUEST;
}
}
/** Return {@code true} if input devices should vibrate instead of this device. */
@@ -338,22 +357,6 @@ final class VibrationSettings {
return mZenMode != Settings.Global.ZEN_MODE_OFF;
}
private static boolean isNotification(int usageHint) {
return usageHint == VibrationAttributes.USAGE_NOTIFICATION;
}
private static boolean isRingtone(int usageHint) {
return usageHint == VibrationAttributes.USAGE_RINGTONE;
}
private static boolean isHapticFeedback(int usageHint) {
return usageHint == VibrationAttributes.USAGE_TOUCH;
}
private static boolean isAlarm(int usageHint) {
return usageHint == VibrationAttributes.USAGE_ALARM;
}
private static boolean isClassAlarm(int usageHint) {
return (usageHint & VibrationAttributes.USAGE_CLASS_MASK)
== VibrationAttributes.USAGE_CLASS_ALARM;
@@ -365,18 +368,35 @@ final class VibrationSettings {
mVibrateWhenRinging = getSystemSetting(Settings.System.VIBRATE_WHEN_RINGING, 0) != 0;
mApplyRampingRinger = getGlobalSetting(Settings.Global.APPLY_RAMPING_RINGER, 0) != 0;
mHapticFeedbackIntensity = getSystemSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_TOUCH));
getDefaultIntensity(USAGE_TOUCH));
mHardwareFeedbackIntensity = getSystemSetting(
Settings.System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY,
getHardwareFeedbackIntensityWhenSettingIsMissing(mHapticFeedbackIntensity));
mNotificationIntensity = getSystemSetting(
Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_NOTIFICATION));
getDefaultIntensity(USAGE_NOTIFICATION));
mRingIntensity = getSystemSetting(Settings.System.RING_VIBRATION_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_RINGTONE));
getDefaultIntensity(USAGE_RINGTONE));
mVibrateInputDevices = getSystemSetting(Settings.System.VIBRATE_INPUT_DEVICES, 0) > 0;
mZenMode = getGlobalSetting(Settings.Global.ZEN_MODE, Settings.Global.ZEN_MODE_OFF);
}
notifyListeners();
}
/**
* Return the value to be used for {@link Settings.System#HARDWARE_HAPTIC_FEEDBACK_INTENSITY}
* when the value was not set by the user.
*
* <p>This should adapt the behavior preceding the introduction of this new setting key, which
* is to apply {@link Settings.System#HAPTIC_FEEDBACK_INTENSITY} unless it's disabled.
*/
private int getHardwareFeedbackIntensityWhenSettingIsMissing(int hapticFeedbackIntensity) {
if (hapticFeedbackIntensity == Vibrator.VIBRATION_INTENSITY_OFF) {
return getDefaultIntensity(USAGE_HARDWARE_FEEDBACK);
}
return hapticFeedbackIntensity;
}
@Override
public String toString() {
return "VibrationSettings{"
@@ -389,18 +409,20 @@ final class VibrationSettings {
+ ", mHapticChannelMaxVibrationAmplitude=" + getHapticChannelMaxVibrationAmplitude()
+ ", mRampStepDuration=" + mRampStepDuration
+ ", mRampDownDuration=" + mRampDownDuration
+ ", mHardwareHapticFeedbackIntensity="
+ intensityToString(getCurrentIntensity(USAGE_HARDWARE_FEEDBACK))
+ ", mHapticFeedbackIntensity="
+ intensityToString(getCurrentIntensity(VibrationAttributes.USAGE_TOUCH))
+ intensityToString(getCurrentIntensity(USAGE_TOUCH))
+ ", mHapticFeedbackDefaultIntensity="
+ intensityToString(getDefaultIntensity(VibrationAttributes.USAGE_TOUCH))
+ intensityToString(getDefaultIntensity(USAGE_TOUCH))
+ ", mNotificationIntensity="
+ intensityToString(getCurrentIntensity(VibrationAttributes.USAGE_NOTIFICATION))
+ intensityToString(getCurrentIntensity(USAGE_NOTIFICATION))
+ ", mNotificationDefaultIntensity="
+ intensityToString(getDefaultIntensity(VibrationAttributes.USAGE_NOTIFICATION))
+ intensityToString(getDefaultIntensity(USAGE_NOTIFICATION))
+ ", mRingIntensity="
+ intensityToString(getCurrentIntensity(VibrationAttributes.USAGE_RINGTONE))
+ intensityToString(getCurrentIntensity(USAGE_RINGTONE))
+ ", mRingDefaultIntensity="
+ intensityToString(getDefaultIntensity(VibrationAttributes.USAGE_RINGTONE))
+ intensityToString(getDefaultIntensity(USAGE_RINGTONE))
+ '}';
}
@@ -410,15 +432,15 @@ final class VibrationSettings {
proto.write(VibratorManagerServiceDumpProto.HAPTIC_FEEDBACK_INTENSITY,
mHapticFeedbackIntensity);
proto.write(VibratorManagerServiceDumpProto.HAPTIC_FEEDBACK_DEFAULT_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_TOUCH));
getDefaultIntensity(USAGE_TOUCH));
proto.write(VibratorManagerServiceDumpProto.NOTIFICATION_INTENSITY,
mNotificationIntensity);
proto.write(VibratorManagerServiceDumpProto.NOTIFICATION_DEFAULT_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_NOTIFICATION));
getDefaultIntensity(USAGE_NOTIFICATION));
proto.write(VibratorManagerServiceDumpProto.RING_INTENSITY,
mRingIntensity);
proto.write(VibratorManagerServiceDumpProto.RING_DEFAULT_INTENSITY,
getDefaultIntensity(VibrationAttributes.USAGE_RINGTONE));
getDefaultIntensity(USAGE_RINGTONE));
}
}

290
services/tests/servicestests/src/com/android/server/vibrator/VibrationSettingsTest.java
View File

@@ -16,6 +16,19 @@
package com.android.server.vibrator;
import static android.os.VibrationAttributes.USAGE_ALARM;
import static android.os.VibrationAttributes.USAGE_COMMUNICATION_REQUEST;
import static android.os.VibrationAttributes.USAGE_HARDWARE_FEEDBACK;
import static android.os.VibrationAttributes.USAGE_NOTIFICATION;
import static android.os.VibrationAttributes.USAGE_PHYSICAL_EMULATION;
import static android.os.VibrationAttributes.USAGE_RINGTONE;
import static android.os.VibrationAttributes.USAGE_TOUCH;
import static android.os.VibrationAttributes.USAGE_UNKNOWN;
import static android.os.Vibrator.VIBRATION_INTENSITY_HIGH;
import static android.os.Vibrator.VIBRATION_INTENSITY_LOW;
import static android.os.Vibrator.VIBRATION_INTENSITY_MEDIUM;
import static android.os.Vibrator.VIBRATION_INTENSITY_OFF;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
@@ -39,9 +52,7 @@ import android.os.Handler;
import android.os.PowerManagerInternal;
import android.os.PowerSaveState;
import android.os.UserHandle;
import android.os.VibrationAttributes;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.os.test.TestLooper;
import android.platform.test.annotations.Presubmit;
import android.provider.Settings;
@@ -70,16 +81,19 @@ import org.mockito.junit.MockitoRule;
public class VibrationSettingsTest {
private static final int UID = 1;
private static final int USER_OPERATION_TIMEOUT_MILLIS = 60_000; // 1 min
private static final PowerSaveState NORMAL_POWER_STATE = new PowerSaveState.Builder().build();
private static final PowerSaveState LOW_POWER_STATE = new PowerSaveState.Builder()
.setBatterySaverEnabled(true).build();
@Rule public MockitoRule mMockitoRule = MockitoJUnit.rule();
@Rule public FakeSettingsProviderRule mSettingsProviderRule = FakeSettingsProvider.rule();
@Rule
public MockitoRule mMockitoRule = MockitoJUnit.rule();
@Rule
public FakeSettingsProviderRule mSettingsProviderRule = FakeSettingsProvider.rule();
@Mock private VibrationSettings.OnVibratorSettingsChanged mListenerMock;
@Mock private PowerManagerInternal mPowerManagerInternalMock;
@Mock
private VibrationSettings.OnVibratorSettingsChanged mListenerMock;
@Mock
private PowerManagerInternal mPowerManagerInternalMock;
private TestLooper mTestLooper;
private ContextWrapper mContextSpy;
@@ -129,14 +143,12 @@ public class VibrationSettingsTest {
setUserSetting(Settings.System.VIBRATE_WHEN_RINGING, 0);
setGlobalSetting(Settings.Global.APPLY_RAMPING_RINGER, 0);
setGlobalSetting(Settings.Global.ZEN_MODE, Settings.Global.ZEN_MODE_ALARMS);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
verify(mListenerMock, times(7)).onChange();
verify(mListenerMock, times(8)).onChange();
}
@Test
@@ -171,89 +183,83 @@ public class VibrationSettingsTest {
VibrationSettings vibrationSettings = new VibrationSettings(mContextSpy,
new Handler(mTestLooper.getLooper()));
assertFalse(vibrationSettings.shouldVibrateForRingerMode(
VibrationAttributes.USAGE_RINGTONE));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(VibrationAttributes.USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(VibrationAttributes.USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(
VibrationAttributes.USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(
VibrationAttributes.USAGE_COMMUNICATION_REQUEST));
assertFalse(vibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_HARDWARE_FEEDBACK));
}
@Test
public void shouldVibrateForRingerMode_withoutRingtoneUsage_returnsTrue() {
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(VibrationAttributes.USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(VibrationAttributes.USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(
VibrationAttributes.USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(
VibrationAttributes.USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_HARDWARE_FEEDBACK));
}
@Test
public void shouldVibrateForRingerMode_withVibrateWhenRinging_ignoreSettingsForSilentMode() {
int usageRingtone = VibrationAttributes.USAGE_RINGTONE;
setUserSetting(Settings.System.VIBRATE_WHEN_RINGING, 1);
setRingerMode(AudioManager.RINGER_MODE_SILENT);
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_MAX);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_NORMAL);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
}
@Test
public void shouldVibrateForRingerMode_withApplyRampingRinger_ignoreSettingsForSilentMode() {
int usageRingtone = VibrationAttributes.USAGE_RINGTONE;
setUserSetting(Settings.System.VIBRATE_WHEN_RINGING, 0);
setGlobalSetting(Settings.Global.APPLY_RAMPING_RINGER, 1);
setRingerMode(AudioManager.RINGER_MODE_SILENT);
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_MAX);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_NORMAL);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
}
@Test
public void shouldVibrateForRingerMode_withAllSettingsOff_onlyVibratesForVibrateMode() {
int usageRingtone = VibrationAttributes.USAGE_RINGTONE;
setUserSetting(Settings.System.VIBRATE_WHEN_RINGING, 0);
setGlobalSetting(Settings.Global.APPLY_RAMPING_RINGER, 0);
setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertTrue(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_SILENT);
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_MAX);
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
setRingerMode(AudioManager.RINGER_MODE_NORMAL);
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(usageRingtone));
assertFalse(mVibrationSettings.shouldVibrateForRingerMode(USAGE_RINGTONE));
}
@Test
public void shouldVibrateForUid_withForegroundOnlyUsage_returnsTrueWhInForeground() {
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, VibrationAttributes.USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, USAGE_TOUCH));
mVibrationSettings.mUidObserver.onUidStateChanged(
UID, ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND, 0, 0);
assertFalse(mVibrationSettings.shouldVibrateForUid(UID, VibrationAttributes.USAGE_TOUCH));
assertFalse(mVibrationSettings.shouldVibrateForUid(UID, USAGE_TOUCH));
}
@Test
@@ -261,38 +267,32 @@ public class VibrationSettingsTest {
mVibrationSettings.mUidObserver.onUidStateChanged(
UID, ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND, 0, 0);
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, VibrationAttributes.USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID,
VibrationAttributes.USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID,
VibrationAttributes.USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, VibrationAttributes.USAGE_RINGTONE));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForUid(UID, USAGE_RINGTONE));
}
@Test
public void shouldVibrateForPowerMode_withLowPowerAndAllowedUsage_returnTrue() {
mRegisteredPowerModeListener.onLowPowerModeChanged(LOW_POWER_STATE);
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(VibrationAttributes.USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(
VibrationAttributes.USAGE_RINGTONE));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(
VibrationAttributes.USAGE_COMMUNICATION_REQUEST));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(USAGE_ALARM));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(USAGE_RINGTONE));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(USAGE_COMMUNICATION_REQUEST));
}
@Test
public void shouldVibrateForPowerMode_withRestrictedUsage_returnsFalseWhileInLowPowerMode() {
mRegisteredPowerModeListener.onLowPowerModeChanged(NORMAL_POWER_STATE);
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(VibrationAttributes.USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(
VibrationAttributes.USAGE_NOTIFICATION));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(USAGE_TOUCH));
assertTrue(mVibrationSettings.shouldVibrateForPowerMode(USAGE_NOTIFICATION));
mRegisteredPowerModeListener.onLowPowerModeChanged(LOW_POWER_STATE);
assertFalse(mVibrationSettings.shouldVibrateForPowerMode(VibrationAttributes.USAGE_TOUCH));
assertFalse(mVibrationSettings.shouldVibrateForPowerMode(
VibrationAttributes.USAGE_NOTIFICATION));
assertFalse(mVibrationSettings.shouldVibrateForPowerMode(USAGE_TOUCH));
assertFalse(mVibrationSettings.shouldVibrateForPowerMode(USAGE_NOTIFICATION));
}
@Test
@@ -324,108 +324,128 @@ public class VibrationSettingsTest {
@Test
public void getDefaultIntensity_beforeSystemReady_returnsMediumToAllExceptAlarm() {
mFakeVibrator.setDefaultHapticFeedbackIntensity(Vibrator.VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultNotificationVibrationIntensity(Vibrator.VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultRingVibrationIntensity(Vibrator.VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultHapticFeedbackIntensity(VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultNotificationVibrationIntensity(VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultRingVibrationIntensity(VIBRATION_INTENSITY_HIGH);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
VibrationSettings vibrationSettings = new VibrationSettings(mContextSpy,
new Handler(mTestLooper.getLooper()));
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
vibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_ALARM));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_TOUCH));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_NOTIFICATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_UNKNOWN));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(
VibrationAttributes.USAGE_PHYSICAL_EMULATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_RINGTONE));
assertEquals(VIBRATION_INTENSITY_HIGH,
vibrationSettings.getDefaultIntensity(USAGE_ALARM));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_TOUCH));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_HARDWARE_FEEDBACK));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_PHYSICAL_EMULATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_NOTIFICATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_UNKNOWN));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
vibrationSettings.getDefaultIntensity(USAGE_RINGTONE));
}
@Test
public void getDefaultIntensity_returnsIntensityFromVibratorService() {
mFakeVibrator.setDefaultHapticFeedbackIntensity(Vibrator.VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultNotificationVibrationIntensity(Vibrator.VIBRATION_INTENSITY_MEDIUM);
mFakeVibrator.setDefaultRingVibrationIntensity(Vibrator.VIBRATION_INTENSITY_LOW);
mFakeVibrator.setDefaultHapticFeedbackIntensity(VIBRATION_INTENSITY_HIGH);
mFakeVibrator.setDefaultNotificationVibrationIntensity(VIBRATION_INTENSITY_MEDIUM);
mFakeVibrator.setDefaultRingVibrationIntensity(VIBRATION_INTENSITY_LOW);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY,
Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_ALARM));
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_TOUCH));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_NOTIFICATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_UNKNOWN));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getDefaultIntensity(
VibrationAttributes.USAGE_PHYSICAL_EMULATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_LOW,
mVibrationSettings.getDefaultIntensity(VibrationAttributes.USAGE_RINGTONE));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(USAGE_ALARM));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(USAGE_TOUCH));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(USAGE_HARDWARE_FEEDBACK));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getDefaultIntensity(USAGE_PHYSICAL_EMULATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getDefaultIntensity(USAGE_NOTIFICATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getDefaultIntensity(USAGE_UNKNOWN));
assertEquals(VIBRATION_INTENSITY_LOW,
mVibrationSettings.getDefaultIntensity(USAGE_RINGTONE));
}
@Test
public void getCurrentIntensity_returnsIntensityFromSettings() {
mFakeVibrator.setDefaultHapticFeedbackIntensity(Vibrator.VIBRATION_INTENSITY_OFF);
mFakeVibrator.setDefaultNotificationVibrationIntensity(Vibrator.VIBRATION_INTENSITY_OFF);
mFakeVibrator.setDefaultRingVibrationIntensity(Vibrator.VIBRATION_INTENSITY_OFF);
mFakeVibrator.setDefaultHapticFeedbackIntensity(VIBRATION_INTENSITY_OFF);
mFakeVibrator.setDefaultNotificationVibrationIntensity(VIBRATION_INTENSITY_OFF);
mFakeVibrator.setDefaultRingVibrationIntensity(VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY,
Vibrator.VIBRATION_INTENSITY_HIGH);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_HIGH);
setUserSetting(Settings.System.HARDWARE_HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_LOW);
setUserSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_MEDIUM);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_LOW);
VIBRATION_INTENSITY_MEDIUM);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_LOW);
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_ALARM));
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_TOUCH));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_NOTIFICATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_UNKNOWN));
assertEquals(Vibrator.VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(
VibrationAttributes.USAGE_PHYSICAL_EMULATION));
assertEquals(Vibrator.VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_RINGTONE));
assertEquals(VIBRATION_INTENSITY_HIGH, mVibrationSettings.getCurrentIntensity(USAGE_ALARM));
assertEquals(VIBRATION_INTENSITY_HIGH, mVibrationSettings.getCurrentIntensity(USAGE_TOUCH));
assertEquals(VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(USAGE_HARDWARE_FEEDBACK));
assertEquals(VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(USAGE_PHYSICAL_EMULATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(USAGE_NOTIFICATION));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(USAGE_UNKNOWN));
assertEquals(VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(USAGE_RINGTONE));
}
@Test
public void getCurrentIntensity_updateTriggeredAfterUserSwitched() {
mFakeVibrator.setDefaultRingVibrationIntensity(Vibrator.VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY,
Vibrator.VIBRATION_INTENSITY_HIGH);
assertEquals(Vibrator.VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_RINGTONE));
mFakeVibrator.setDefaultRingVibrationIntensity(VIBRATION_INTENSITY_OFF);
setUserSetting(Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_HIGH);
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(USAGE_RINGTONE));
// Switching user is not working with FakeSettingsProvider.
// Testing the broadcast flow manually.
Settings.System.putIntForUser(mContextSpy.getContentResolver(),
Settings.System.RING_VIBRATION_INTENSITY, Vibrator.VIBRATION_INTENSITY_LOW,
Settings.System.RING_VIBRATION_INTENSITY, VIBRATION_INTENSITY_LOW,
UserHandle.USER_CURRENT);
mVibrationSettings.mUserReceiver.onReceive(mContextSpy,
new Intent(Intent.ACTION_USER_SWITCHED));
assertEquals(Vibrator.VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(VibrationAttributes.USAGE_RINGTONE));
assertEquals(VIBRATION_INTENSITY_LOW,
mVibrationSettings.getCurrentIntensity(USAGE_RINGTONE));
}
@Test
public void getCurrentIntensity_noHardwareFeedbackValueUsesHapticFeedbackValue() {
mFakeVibrator.setDefaultHapticFeedbackIntensity(VIBRATION_INTENSITY_MEDIUM);
setUserSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_OFF);
assertEquals(VIBRATION_INTENSITY_OFF, mVibrationSettings.getCurrentIntensity(USAGE_TOUCH));
// If haptic feedback is off, fallback to default value.
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(USAGE_HARDWARE_FEEDBACK));
assertEquals(VIBRATION_INTENSITY_MEDIUM,
mVibrationSettings.getCurrentIntensity(USAGE_PHYSICAL_EMULATION));
// Switching user is not working with FakeSettingsProvider.
// Testing the broadcast flow manually.
Settings.System.putIntForUser(mContextSpy.getContentResolver(),
Settings.System.HAPTIC_FEEDBACK_INTENSITY, VIBRATION_INTENSITY_HIGH,
UserHandle.USER_CURRENT);
mVibrationSettings.mUserReceiver.onReceive(mContextSpy,
new Intent(Intent.ACTION_USER_SWITCHED));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(USAGE_TOUCH));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(USAGE_HARDWARE_FEEDBACK));
assertEquals(VIBRATION_INTENSITY_HIGH,
mVibrationSettings.getCurrentIntensity(USAGE_PHYSICAL_EMULATION));
}
@Test