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

Introduce separate setting key for hardware haptic feedback

Browse Source 
Apply usages for hardware feedback and physical emulation to existing
feedback that should be enabled even then the user has disabled the
"Touch feedback" settings.

Bug: 185351540
Test: VibrationSettingsTest
Change-Id: I4f463ffa726424ee7615b1de4deb5627ae3f8717
This commit is contained in:
Lais Andrade
2021-10-29 20:36:59 +01:00
parent 86ef373a37
commit 657b009bca
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

@@ -4521,6 +4521,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