From d8dc940fc013756cc46bdde7cb1537025dcdaaae Mon Sep 17 00:00:00 2001 From: Lais Andrade Date: Tue, 6 Apr 2021 14:20:23 +0000 Subject: Rename CombinedVibrationEffect to CombinedVibration The change makes the distinction between VibrationEffect and CombinedVibratio clearer. The later is a combination of the former with the extra information about the vibrator ids, allowing effects to be played in one or more vibrators in parallel or in sequence. The methods create/start synced where also renamed to parallel (together with respective builder classes), to indicate they perform one or more effects in parallel on multiple vibrators. This is also a better match to the sequential combinations. This change also deprecates the Context.VIBRATOR_SERVICE in favour of the new VIBRATOR_MANAGER_SERVICE. The default vibrator can be retrieved from the manager system service. Same deprecation applied to InputDevice.getVibrator method. Fix: 184123900 Test: CombinedVibrationTest Change-Id: I44d8b225098d35fbf7783254acaf6a78f9fb4505 --- core/api/current.txt | 22 +- core/api/test-current.txt | 30 +- core/java/android/content/Context.java | 2 + .../java/android/hardware/input/IInputManager.aidl | 4 +- .../hardware/input/InputDeviceVibratorManager.java | 4 +- core/java/android/hardware/input/InputManager.java | 4 +- core/java/android/os/CombinedVibration.aidl | 19 + core/java/android/os/CombinedVibration.java | 687 +++++++++++++++++++++ core/java/android/os/CombinedVibrationEffect.aidl | 19 - core/java/android/os/CombinedVibrationEffect.java | 669 -------------------- core/java/android/os/IVibratorManagerService.aidl | 6 +- core/java/android/os/SystemVibrator.java | 4 +- core/java/android/os/SystemVibratorManager.java | 8 +- core/java/android/os/VibratorManager.java | 16 +- core/java/android/view/InputDevice.java | 2 + .../android/os/CombinedVibrationEffectTest.java | 247 -------- .../src/android/os/CombinedVibrationTest.java | 247 ++++++++ .../android/server/input/InputManagerService.java | 16 +- .../server/vibrator/InputDeviceDelegate.java | 4 +- .../com/android/server/vibrator/Vibration.java | 72 +-- .../android/server/vibrator/VibrationThread.java | 48 +- .../server/vibrator/VibratorManagerService.java | 46 +- .../server/vibrator/InputDeviceDelegateTest.java | 6 +- .../server/vibrator/VibrationThreadTest.java | 36 +- .../vibrator/VibratorManagerServiceTest.java | 42 +- .../VibratorManagerServicePermissionTest.java | 6 +- 26 files changed, 1144 insertions(+), 1122 deletions(-) create mode 100644 core/java/android/os/CombinedVibration.aidl create mode 100644 core/java/android/os/CombinedVibration.java delete mode 100644 core/java/android/os/CombinedVibrationEffect.aidl delete mode 100644 core/java/android/os/CombinedVibrationEffect.java delete mode 100644 core/tests/coretests/src/android/os/CombinedVibrationEffectTest.java create mode 100644 core/tests/coretests/src/android/os/CombinedVibrationTest.java diff --git a/core/api/current.txt b/core/api/current.txt index aad6b37c44ec..d67a48031389 100644 --- a/core/api/current.txt +++ b/core/api/current.txt @@ -10669,7 +10669,7 @@ package android.content { field public static final String USB_SERVICE = "usb"; field public static final String USER_SERVICE = "user"; field public static final String VIBRATOR_MANAGER_SERVICE = "vibrator_manager"; - field public static final String VIBRATOR_SERVICE = "vibrator"; + field @Deprecated public static final String VIBRATOR_SERVICE = "vibrator"; field public static final String VPN_MANAGEMENT_SERVICE = "vpn_management"; field @UiContext public static final String WALLPAPER_SERVICE = "wallpaper"; field public static final String WIFI_AWARE_SERVICE = "wifiaware"; @@ -30836,16 +30836,16 @@ package android.os { method public void onCancel(); } - public abstract class CombinedVibrationEffect implements android.os.Parcelable { - method @NonNull public static android.os.CombinedVibrationEffect createSynced(@NonNull android.os.VibrationEffect); + public abstract class CombinedVibration implements android.os.Parcelable { + method @NonNull public static android.os.CombinedVibration createParallel(@NonNull android.os.VibrationEffect); method public int describeContents(); - method @NonNull public static android.os.CombinedVibrationEffect.SyncedCombination startSynced(); - field @NonNull public static final android.os.Parcelable.Creator CREATOR; + method @NonNull public static android.os.CombinedVibration.ParallelCombination startParallel(); + field @NonNull public static final android.os.Parcelable.Creator CREATOR; } - public static final class CombinedVibrationEffect.SyncedCombination { - method @NonNull public android.os.CombinedVibrationEffect.SyncedCombination addVibrator(int, @NonNull android.os.VibrationEffect); - method @NonNull public android.os.CombinedVibrationEffect combine(); + public static final class CombinedVibration.ParallelCombination { + method @NonNull public android.os.CombinedVibration.ParallelCombination addVibrator(int, @NonNull android.os.VibrationEffect); + method @NonNull public android.os.CombinedVibration combine(); } public class ConditionVariable { @@ -32098,8 +32098,8 @@ package android.os { method @NonNull public abstract android.os.Vibrator getDefaultVibrator(); method @NonNull public abstract android.os.Vibrator getVibrator(int); method @NonNull public abstract int[] getVibratorIds(); - method @RequiresPermission(android.Manifest.permission.VIBRATE) public final void vibrate(@NonNull android.os.CombinedVibrationEffect); - method @RequiresPermission(android.Manifest.permission.VIBRATE) public final void vibrate(@NonNull android.os.CombinedVibrationEffect, @Nullable android.os.VibrationAttributes); + method @RequiresPermission(android.Manifest.permission.VIBRATE) public final void vibrate(@NonNull android.os.CombinedVibration); + method @RequiresPermission(android.Manifest.permission.VIBRATE) public final void vibrate(@NonNull android.os.CombinedVibration, @Nullable android.os.VibrationAttributes); } public class WorkSource implements android.os.Parcelable { @@ -47139,7 +47139,7 @@ package android.view { method @NonNull public android.hardware.SensorManager getSensorManager(); method public int getSources(); method public int getVendorId(); - method public android.os.Vibrator getVibrator(); + method @Deprecated public android.os.Vibrator getVibrator(); method @NonNull public android.os.VibratorManager getVibratorManager(); method public boolean[] hasKeys(int...); method public boolean hasMicrophone(); diff --git a/core/api/test-current.txt b/core/api/test-current.txt index 04dd04cf03d2..94873a54f472 100644 --- a/core/api/test-current.txt +++ b/core/api/test-current.txt @@ -1597,39 +1597,39 @@ package android.os { field public static final int RESOURCES_SDK_INT; } - public abstract class CombinedVibrationEffect implements android.os.Parcelable { + public abstract class CombinedVibration implements android.os.Parcelable { method public abstract long getDuration(); - method @NonNull public static android.os.CombinedVibrationEffect.SequentialCombination startSequential(); + method @NonNull public static android.os.CombinedVibration.SequentialCombination startSequential(); } - public static final class CombinedVibrationEffect.Mono extends android.os.CombinedVibrationEffect { + public static final class CombinedVibration.Mono extends android.os.CombinedVibration { method public long getDuration(); method @NonNull public android.os.VibrationEffect getEffect(); method public void writeToParcel(@NonNull android.os.Parcel, int); - field @NonNull public static final android.os.Parcelable.Creator CREATOR; + field @NonNull public static final android.os.Parcelable.Creator CREATOR; } - public static final class CombinedVibrationEffect.Sequential extends android.os.CombinedVibrationEffect { + public static final class CombinedVibration.Sequential extends android.os.CombinedVibration { method @NonNull public java.util.List getDelays(); method public long getDuration(); - method @NonNull public java.util.List getEffects(); + method @NonNull public java.util.List getEffects(); method public void writeToParcel(@NonNull android.os.Parcel, int); - field @NonNull public static final android.os.Parcelable.Creator CREATOR; + field @NonNull public static final android.os.Parcelable.Creator CREATOR; } - public static final class CombinedVibrationEffect.SequentialCombination { - method @NonNull public android.os.CombinedVibrationEffect.SequentialCombination addNext(int, @NonNull android.os.VibrationEffect); - method @NonNull public android.os.CombinedVibrationEffect.SequentialCombination addNext(int, @NonNull android.os.VibrationEffect, int); - method @NonNull public android.os.CombinedVibrationEffect.SequentialCombination addNext(@NonNull android.os.CombinedVibrationEffect); - method @NonNull public android.os.CombinedVibrationEffect.SequentialCombination addNext(@NonNull android.os.CombinedVibrationEffect, int); - method @NonNull public android.os.CombinedVibrationEffect combine(); + public static final class CombinedVibration.SequentialCombination { + method @NonNull public android.os.CombinedVibration.SequentialCombination addNext(int, @NonNull android.os.VibrationEffect); + method @NonNull public android.os.CombinedVibration.SequentialCombination addNext(int, @NonNull android.os.VibrationEffect, int); + method @NonNull public android.os.CombinedVibration.SequentialCombination addNext(@NonNull android.os.CombinedVibration); + method @NonNull public android.os.CombinedVibration.SequentialCombination addNext(@NonNull android.os.CombinedVibration, int); + method @NonNull public android.os.CombinedVibration combine(); } - public static final class CombinedVibrationEffect.Stereo extends android.os.CombinedVibrationEffect { + public static final class CombinedVibration.Stereo extends android.os.CombinedVibration { method public long getDuration(); method @NonNull public android.util.SparseArray getEffects(); method public void writeToParcel(@NonNull android.os.Parcel, int); - field @NonNull public static final android.os.Parcelable.Creator CREATOR; + field @NonNull public static final android.os.Parcelable.Creator CREATOR; } public class DeviceIdleManager { diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java index 5d66cdf880b8..09ac8103c526 100644 --- a/core/java/android/content/Context.java +++ b/core/java/android/content/Context.java @@ -4128,9 +4128,11 @@ public abstract class Context { * Use with {@link #getSystemService(String)} to retrieve a {@link android.os.Vibrator} for * interacting with the vibration hardware. * + * @deprecated Use {@link android.os.VibratorManager} to retrieve the default system vibrator. * @see #getSystemService(String) * @see android.os.Vibrator */ + @Deprecated public static final String VIBRATOR_SERVICE = "vibrator"; /** diff --git a/core/java/android/hardware/input/IInputManager.aidl b/core/java/android/hardware/input/IInputManager.aidl index 4743fee3257b..336fbf2954a3 100644 --- a/core/java/android/hardware/input/IInputManager.aidl +++ b/core/java/android/hardware/input/IInputManager.aidl @@ -22,7 +22,7 @@ import android.hardware.input.KeyboardLayout; import android.hardware.input.IInputDevicesChangedListener; import android.hardware.input.ITabletModeChangedListener; import android.hardware.input.TouchCalibration; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.hardware.input.IInputSensorEventListener; import android.hardware.input.InputSensorInfo; import android.hardware.lights.Light; @@ -91,7 +91,7 @@ interface IInputManager { // Input device vibrator control. void vibrate(int deviceId, in VibrationEffect effect, IBinder token); - void vibrateCombined(int deviceId, in CombinedVibrationEffect effect, IBinder token); + void vibrateCombined(int deviceId, in CombinedVibration vibration, IBinder token); void cancelVibrate(int deviceId, IBinder token); int[] getVibratorIds(int deviceId); boolean isVibrating(int deviceId); diff --git a/core/java/android/hardware/input/InputDeviceVibratorManager.java b/core/java/android/hardware/input/InputDeviceVibratorManager.java index d843407c289d..ed0efffbb346 100644 --- a/core/java/android/hardware/input/InputDeviceVibratorManager.java +++ b/core/java/android/hardware/input/InputDeviceVibratorManager.java @@ -19,7 +19,7 @@ package android.hardware.input; import android.annotation.NonNull; import android.annotation.Nullable; import android.os.Binder; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.NullVibrator; import android.os.VibrationAttributes; import android.os.Vibrator; @@ -125,7 +125,7 @@ public class InputDeviceVibratorManager extends VibratorManager } @Override - public void vibrate(int uid, String opPkg, @NonNull CombinedVibrationEffect effect, + public void vibrate(int uid, String opPkg, @NonNull CombinedVibration effect, String reason, @Nullable VibrationAttributes attributes) { mInputManager.vibrate(mDeviceId, effect, mToken); } diff --git a/core/java/android/hardware/input/InputManager.java b/core/java/android/hardware/input/InputManager.java index c83ccfa81f95..b6d2eaf11be6 100644 --- a/core/java/android/hardware/input/InputManager.java +++ b/core/java/android/hardware/input/InputManager.java @@ -37,7 +37,7 @@ import android.hardware.lights.LightsManager; import android.hardware.lights.LightsRequest; import android.os.BlockUntrustedTouchesMode; import android.os.Build; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.Handler; import android.os.IBinder; import android.os.IVibratorStateListener; @@ -1470,7 +1470,7 @@ public final class InputManager { /* * Perform combined vibration effect */ - void vibrate(int deviceId, CombinedVibrationEffect effect, IBinder token) { + void vibrate(int deviceId, CombinedVibration effect, IBinder token) { try { mIm.vibrateCombined(deviceId, effect, token); } catch (RemoteException ex) { diff --git a/core/java/android/os/CombinedVibration.aidl b/core/java/android/os/CombinedVibration.aidl new file mode 100644 index 000000000000..91317bde64a3 --- /dev/null +++ b/core/java/android/os/CombinedVibration.aidl @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2020 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 android.os; + +parcelable CombinedVibration; diff --git a/core/java/android/os/CombinedVibration.java b/core/java/android/os/CombinedVibration.java new file mode 100644 index 000000000000..aff55aff39f7 --- /dev/null +++ b/core/java/android/os/CombinedVibration.java @@ -0,0 +1,687 @@ +/* + * Copyright (C) 2020 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 android.os; + +import android.annotation.NonNull; +import android.annotation.TestApi; +import android.util.SparseArray; + +import com.android.internal.util.Preconditions; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +/** + * A CombinedVibration describes a combination of haptic effects to be performed by one or more + * {@link Vibrator Vibrators}. + * + * These effects may be any number of things, from single shot vibrations to complex waveforms. + * + * @see VibrationEffect + */ +@SuppressWarnings({"ParcelNotFinal", "ParcelCreator"}) // Parcel only extended here. +public abstract class CombinedVibration implements Parcelable { + private static final int PARCEL_TOKEN_MONO = 1; + private static final int PARCEL_TOKEN_STEREO = 2; + private static final int PARCEL_TOKEN_SEQUENTIAL = 3; + + /** Prevent subclassing from outside of the framework. */ + CombinedVibration() { + } + + /** + * Create a vibration that plays a single effect in parallel on all vibrators. + * + * A parallel vibration that takes a single {@link VibrationEffect} to be performed by multiple + * vibrators at the same time. + * + * @param effect The {@link VibrationEffect} to perform. + * @return The combined vibration representing the single effect to be played in all vibrators. + */ + @NonNull + public static CombinedVibration createParallel(@NonNull VibrationEffect effect) { + CombinedVibration combined = new Mono(effect); + combined.validate(); + return combined; + } + + /** + * Start creating a vibration that plays effects in parallel on one or more vibrators. + * + * A parallel vibration takes one or more {@link VibrationEffect VibrationEffects} associated to + * individual vibrators to be performed at the same time. + * + * @see CombinedVibration.ParallelCombination + */ + @NonNull + public static ParallelCombination startParallel() { + return new ParallelCombination(); + } + + /** + * Start creating a vibration that plays effects in sequence on one or more vibrators. + * + * A sequential vibration takes one or more {@link CombinedVibration CombinedVibrations} to be + * performed by one or more vibrators in order. Each {@link CombinedVibration} starts only after + * the previous one is finished. + * + * @hide + * @see CombinedVibration.SequentialCombination + */ + @TestApi + @NonNull + public static SequentialCombination startSequential() { + return new SequentialCombination(); + } + + @Override + public int describeContents() { + return 0; + } + + /** + * Gets the estimated duration of the combined vibration in milliseconds. + * + *

For parallel combinations this means the maximum duration of any individual {@link + * VibrationEffect}. For sequential combinations, this is a sum of each step and delays. + * + *

For combinations of effects without a defined end (e.g. a Waveform with a non-negative + * repeat index), this returns Long.MAX_VALUE. For effects with an unknown duration (e.g. + * Prebaked effects where the length is device and potentially run-time dependent), this returns + * -1. + * + * @hide + */ + @TestApi + public abstract long getDuration(); + + /** @hide */ + public abstract void validate(); + + /** @hide */ + public abstract boolean hasVibrator(int vibratorId); + + /** + * A combination of haptic effects that should be played in multiple vibrators in parallel. + * + * @see CombinedVibration#startParallel() + */ + public static final class ParallelCombination { + + private final SparseArray mEffects = new SparseArray<>(); + + ParallelCombination() { + } + + /** + * Add or replace a one shot vibration effect to be performed by the specified vibrator. + * + * @param vibratorId The id of the vibrator that should perform this effect. + * @param effect The effect this vibrator should play. + * @return The {@link ParallelCombination} object to enable adding + * multiple effects in one chain. + * @see VibrationEffect#createOneShot(long, int) + */ + @NonNull + public ParallelCombination addVibrator(int vibratorId, @NonNull VibrationEffect effect) { + mEffects.put(vibratorId, effect); + return this; + } + + /** + * Combine all of the added effects into a {@link CombinedVibration}. + * + * The {@link ParallelCombination} object is still valid after this + * call, so you can continue adding more effects to it and generating more + * {@link CombinedVibration}s by calling this method again. + * + * @return The {@link CombinedVibration} resulting from combining the added effects to + * be played in parallel. + */ + @NonNull + public CombinedVibration combine() { + if (mEffects.size() == 0) { + throw new IllegalStateException( + "Combination must have at least one element to combine."); + } + CombinedVibration combined = new Stereo(mEffects); + combined.validate(); + return combined; + } + } + + /** + * A combination of haptic effects that should be played in multiple vibrators in sequence. + * + * @hide + * @see CombinedVibration#startSequential() + */ + @TestApi + public static final class SequentialCombination { + + private final ArrayList mEffects = new ArrayList<>(); + private final ArrayList mDelays = new ArrayList<>(); + + SequentialCombination() { + } + + /** + * Add a single vibration effect to be performed next. + * + * Similar to {@link #addNext(int, VibrationEffect, int)}, but with no delay. The effect + * will start playing immediately after the previous vibration is finished. + * + * @param vibratorId The id of the vibrator that should perform this effect. + * @param effect The effect this vibrator should play. + * @return The {@link CombinedVibration.SequentialCombination} object to enable adding + * multiple effects in one chain. + */ + @NonNull + public SequentialCombination addNext(int vibratorId, @NonNull VibrationEffect effect) { + return addNext(vibratorId, effect, /* delay= */ 0); + } + + /** + * Add a single vibration effect to be performed next. + * + * The delay is applied immediately after the previous vibration is finished. The effect + * will start playing after the delay. + * + * @param vibratorId The id of the vibrator that should perform this effect. + * @param effect The effect this vibrator should play. + * @param delay The amount of time, in milliseconds, to wait between playing the prior + * vibration and this one, starting at the time the previous vibration in + * this sequence is finished. + * @return The {@link CombinedVibration.SequentialCombination} object to enable adding + * multiple effects in one chain. + */ + @NonNull + public SequentialCombination addNext(int vibratorId, @NonNull VibrationEffect effect, + int delay) { + return addNext( + CombinedVibration.startParallel().addVibrator(vibratorId, effect).combine(), + delay); + } + + /** + * Add a combined vibration effect to be performed next. + * + * Similar to {@link #addNext(CombinedVibration, int)}, but with no delay. The effect will + * start playing immediately after the previous vibration is finished. + * + * @param effect The combined effect to be performed next. + * @return The {@link CombinedVibration.SequentialCombination} object to enable adding + * multiple effects in one chain. + * @see VibrationEffect#createOneShot(long, int) + */ + @NonNull + public SequentialCombination addNext(@NonNull CombinedVibration effect) { + return addNext(effect, /* delay= */ 0); + } + + /** + * Add a combined vibration effect to be performed next. + * + * The delay is applied immediately after the previous vibration is finished. The vibration + * will start playing after the delay. + * + * @param effect The combined effect to be performed next. + * @param delay The amount of time, in milliseconds, to wait between playing the prior + * vibration and this one, starting at the time the previous vibration in this + * sequence is finished. + * @return The {@link CombinedVibration.SequentialCombination} object to enable adding + * multiple effects in one chain. + */ + @NonNull + public SequentialCombination addNext(@NonNull CombinedVibration effect, int delay) { + if (effect instanceof Sequential) { + Sequential sequentialEffect = (Sequential) effect; + int firstEffectIndex = mDelays.size(); + mEffects.addAll(sequentialEffect.getEffects()); + mDelays.addAll(sequentialEffect.getDelays()); + mDelays.set(firstEffectIndex, delay + mDelays.get(firstEffectIndex)); + } else { + mEffects.add(effect); + mDelays.add(delay); + } + return this; + } + + /** + * Combine all of the added effects in sequence. + * + * The {@link CombinedVibration.SequentialCombination} object is still valid after + * this call, so you can continue adding more effects to it and generating more {@link + * CombinedVibration}s by calling this method again. + * + * @return The {@link CombinedVibration} resulting from combining the added effects to + * be played in sequence. + */ + @NonNull + public CombinedVibration combine() { + if (mEffects.size() == 0) { + throw new IllegalStateException( + "Combination must have at least one element to combine."); + } + CombinedVibration combined = new Sequential(mEffects, mDelays); + combined.validate(); + return combined; + } + } + + /** + * Represents a single {@link VibrationEffect} that should be played in all vibrators at the + * same time. + * + * @hide + */ + @TestApi + public static final class Mono extends CombinedVibration { + private final VibrationEffect mEffect; + + Mono(Parcel in) { + mEffect = VibrationEffect.CREATOR.createFromParcel(in); + } + + Mono(@NonNull VibrationEffect effect) { + mEffect = effect; + } + + @NonNull + public VibrationEffect getEffect() { + return mEffect; + } + + @Override + public long getDuration() { + return mEffect.getDuration(); + } + + /** @hide */ + @Override + public void validate() { + mEffect.validate(); + } + + /** @hide */ + @Override + public boolean hasVibrator(int vibratorId) { + return true; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Mono)) { + return false; + } + Mono other = (Mono) o; + return mEffect.equals(other.mEffect); + } + + @Override + public int hashCode() { + return Objects.hash(mEffect); + } + + @Override + public String toString() { + return "Mono{mEffect=" + mEffect + '}'; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(@NonNull Parcel out, int flags) { + out.writeInt(PARCEL_TOKEN_MONO); + mEffect.writeToParcel(out, flags); + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @Override + public Mono createFromParcel(@NonNull Parcel in) { + // Skip the type token + in.readInt(); + return new Mono(in); + } + + @Override + @NonNull + public Mono[] newArray(int size) { + return new Mono[size]; + } + }; + } + + /** + * Represents a set of {@link VibrationEffect VibrationEffects} associated to individual + * vibrators that should be played at the same time. + * + * @hide + */ + @TestApi + public static final class Stereo extends CombinedVibration { + + /** Mapping vibrator ids to effects. */ + private final SparseArray mEffects; + + Stereo(Parcel in) { + int size = in.readInt(); + mEffects = new SparseArray<>(size); + for (int i = 0; i < size; i++) { + int vibratorId = in.readInt(); + mEffects.put(vibratorId, VibrationEffect.CREATOR.createFromParcel(in)); + } + } + + Stereo(@NonNull SparseArray effects) { + mEffects = new SparseArray<>(effects.size()); + for (int i = 0; i < effects.size(); i++) { + mEffects.put(effects.keyAt(i), effects.valueAt(i)); + } + } + + /** Effects to be performed in parallel, where each key represents the vibrator id. */ + @NonNull + public SparseArray getEffects() { + return mEffects; + } + + @Override + public long getDuration() { + long maxDuration = Long.MIN_VALUE; + boolean hasUnknownStep = false; + for (int i = 0; i < mEffects.size(); i++) { + long duration = mEffects.valueAt(i).getDuration(); + if (duration == Long.MAX_VALUE) { + // If any duration is repeating, this combination duration is also repeating. + return duration; + } + maxDuration = Math.max(maxDuration, duration); + // If any step is unknown, this combination duration will also be unknown, unless + // any step is repeating. Repeating vibrations take precedence over non-repeating + // ones in the service, so continue looping to check for repeating steps. + hasUnknownStep |= duration < 0; + } + if (hasUnknownStep) { + // If any step is unknown, this combination duration is also unknown. + return -1; + } + return maxDuration; + } + + /** @hide */ + @Override + public void validate() { + Preconditions.checkArgument(mEffects.size() > 0, + "There should be at least one effect set for a combined effect"); + for (int i = 0; i < mEffects.size(); i++) { + mEffects.valueAt(i).validate(); + } + } + + /** @hide */ + @Override + public boolean hasVibrator(int vibratorId) { + return mEffects.indexOfKey(vibratorId) >= 0; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Stereo)) { + return false; + } + Stereo other = (Stereo) o; + if (mEffects.size() != other.mEffects.size()) { + return false; + } + for (int i = 0; i < mEffects.size(); i++) { + if (!mEffects.valueAt(i).equals(other.mEffects.get(mEffects.keyAt(i)))) { + return false; + } + } + return true; + } + + @Override + public int hashCode() { + return mEffects.contentHashCode(); + } + + @Override + public String toString() { + return "Stereo{mEffects=" + mEffects + '}'; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(@NonNull Parcel out, int flags) { + out.writeInt(PARCEL_TOKEN_STEREO); + out.writeInt(mEffects.size()); + for (int i = 0; i < mEffects.size(); i++) { + out.writeInt(mEffects.keyAt(i)); + mEffects.valueAt(i).writeToParcel(out, flags); + } + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @Override + public Stereo createFromParcel(@NonNull Parcel in) { + // Skip the type token + in.readInt(); + return new Stereo(in); + } + + @Override + @NonNull + public Stereo[] newArray(int size) { + return new Stereo[size]; + } + }; + } + + /** + * Represents a list of {@link CombinedVibration CombinedVibrations} that should be played in + * sequence. + * + * @hide + */ + @TestApi + public static final class Sequential extends CombinedVibration { + private final List mEffects; + private final List mDelays; + + Sequential(Parcel in) { + int size = in.readInt(); + mEffects = new ArrayList<>(size); + mDelays = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + mDelays.add(in.readInt()); + mEffects.add(CombinedVibration.CREATOR.createFromParcel(in)); + } + } + + Sequential(@NonNull List effects, + @NonNull List delays) { + mEffects = new ArrayList<>(effects); + mDelays = new ArrayList<>(delays); + } + + /** Effects to be performed in sequence. */ + @NonNull + public List getEffects() { + return mEffects; + } + + /** Delay to be applied before each effect in {@link #getEffects()}. */ + @NonNull + public List getDelays() { + return mDelays; + } + + @Override + public long getDuration() { + boolean hasUnknownStep = false; + long durations = 0; + final int effectCount = mEffects.size(); + for (int i = 0; i < effectCount; i++) { + CombinedVibration effect = mEffects.get(i); + long duration = effect.getDuration(); + if (duration == Long.MAX_VALUE) { + // If any duration is repeating, this combination duration is also repeating. + return duration; + } + durations += duration; + // If any step is unknown, this combination duration will also be unknown, unless + // any step is repeating. Repeating vibrations take precedence over non-repeating + // ones in the service, so continue looping to check for repeating steps. + hasUnknownStep |= duration < 0; + } + if (hasUnknownStep) { + // If any step is unknown, this combination duration is also unknown. + return -1; + } + long delays = 0; + for (int i = 0; i < effectCount; i++) { + delays += mDelays.get(i); + } + return durations + delays; + } + + /** @hide */ + @Override + public void validate() { + Preconditions.checkArgument(mEffects.size() > 0, + "There should be at least one effect set for a combined effect"); + Preconditions.checkArgument(mEffects.size() == mDelays.size(), + "Effect and delays should have equal length"); + final int effectCount = mEffects.size(); + for (int i = 0; i < effectCount; i++) { + if (mDelays.get(i) < 0) { + throw new IllegalArgumentException("Delays must all be >= 0" + + " (delays=" + mDelays + ")"); + } + } + for (int i = 0; i < effectCount; i++) { + CombinedVibration effect = mEffects.get(i); + if (effect instanceof Sequential) { + throw new IllegalArgumentException( + "There should be no nested sequential effects in a combined effect"); + } + effect.validate(); + } + } + + /** @hide */ + @Override + public boolean hasVibrator(int vibratorId) { + final int effectCount = mEffects.size(); + for (int i = 0; i < effectCount; i++) { + if (mEffects.get(i).hasVibrator(vibratorId)) { + return true; + } + } + return false; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Sequential)) { + return false; + } + Sequential other = (Sequential) o; + return mDelays.equals(other.mDelays) && mEffects.equals(other.mEffects); + } + + @Override + public int hashCode() { + return Objects.hash(mEffects, mDelays); + } + + @Override + public String toString() { + return "Sequential{mEffects=" + mEffects + ", mDelays=" + mDelays + '}'; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(@NonNull Parcel out, int flags) { + out.writeInt(PARCEL_TOKEN_SEQUENTIAL); + out.writeInt(mEffects.size()); + for (int i = 0; i < mEffects.size(); i++) { + out.writeInt(mDelays.get(i)); + mEffects.get(i).writeToParcel(out, flags); + } + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @Override + public Sequential createFromParcel(@NonNull Parcel in) { + // Skip the type token + in.readInt(); + return new Sequential(in); + } + + @Override + @NonNull + public Sequential[] newArray(int size) { + return new Sequential[size]; + } + }; + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @Override + public CombinedVibration createFromParcel(Parcel in) { + int token = in.readInt(); + if (token == PARCEL_TOKEN_MONO) { + return new Mono(in); + } else if (token == PARCEL_TOKEN_STEREO) { + return new Stereo(in); + } else if (token == PARCEL_TOKEN_SEQUENTIAL) { + return new Sequential(in); + } else { + throw new IllegalStateException( + "Unexpected combined vibration event type token in parcel."); + } + } + + @Override + public CombinedVibration[] newArray(int size) { + return new CombinedVibration[size]; + } + }; +} diff --git a/core/java/android/os/CombinedVibrationEffect.aidl b/core/java/android/os/CombinedVibrationEffect.aidl deleted file mode 100644 index 330733c2643f..000000000000 --- a/core/java/android/os/CombinedVibrationEffect.aidl +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) 2020 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 android.os; - -parcelable CombinedVibrationEffect; diff --git a/core/java/android/os/CombinedVibrationEffect.java b/core/java/android/os/CombinedVibrationEffect.java deleted file mode 100644 index e068772e954a..000000000000 --- a/core/java/android/os/CombinedVibrationEffect.java +++ /dev/null @@ -1,669 +0,0 @@ -/* - * Copyright (C) 2020 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 android.os; - -import android.annotation.NonNull; -import android.annotation.TestApi; -import android.util.SparseArray; - -import com.android.internal.util.Preconditions; - -import java.util.ArrayList; -import java.util.List; -import java.util.Objects; - -/** - * A CombinedVibrationEffect describes a haptic effect to be performed by one or more {@link - * Vibrator Vibrators}. - * - * These effects may be any number of things, from single shot vibrations to complex waveforms. - * @see VibrationEffect - */ -@SuppressWarnings({"ParcelNotFinal", "ParcelCreator"}) // Parcel only extended here. -public abstract class CombinedVibrationEffect implements Parcelable { - private static final int PARCEL_TOKEN_MONO = 1; - private static final int PARCEL_TOKEN_STEREO = 2; - private static final int PARCEL_TOKEN_SEQUENTIAL = 3; - - /** Prevent subclassing from outside of the framework. */ - CombinedVibrationEffect() { - } - - /** - * Create a synced vibration effect. - * - * A synced vibration effect should be performed by multiple vibrators at the same time. - * - * @param effect The {@link VibrationEffect} to perform. - * @return The synced effect. - */ - @NonNull - public static CombinedVibrationEffect createSynced(@NonNull VibrationEffect effect) { - CombinedVibrationEffect combined = new Mono(effect); - combined.validate(); - return combined; - } - - /** - * Start creating a synced vibration effect. - * - * A synced vibration effect should be performed by multiple vibrators at the same time. - * - * @see CombinedVibrationEffect.SyncedCombination - */ - @NonNull - public static SyncedCombination startSynced() { - return new SyncedCombination(); - } - - /** - * Start creating a sequential vibration effect. - * - * A sequential vibration effect should be performed by multiple vibrators in order. - * - * @see CombinedVibrationEffect.SequentialCombination - * @hide - */ - @TestApi - @NonNull - public static SequentialCombination startSequential() { - return new SequentialCombination(); - } - - @Override - public int describeContents() { - return 0; - } - - /** - * Gets the estimated duration of the combined vibration in milliseconds. - * - *

For synced combinations this means the maximum duration of any individual {@link - * VibrationEffect}. For sequential combinations, this is a sum of each step and delays. - * - *

For combinations of effects without a defined end (e.g. a Waveform with a non-negative - * repeat index), this returns Long.MAX_VALUE. For effects with an unknown duration (e.g. - * Prebaked effects where the length is device and potentially run-time dependent), this returns - * -1. - * - * @hide - */ - @TestApi - public abstract long getDuration(); - - /** @hide */ - public abstract void validate(); - - /** @hide */ - public abstract boolean hasVibrator(int vibratorId); - - /** - * A combination of haptic effects that should be played in multiple vibrators in sync. - * - * @see CombinedVibrationEffect#startSynced() - */ - public static final class SyncedCombination { - - private final SparseArray mEffects = new SparseArray<>(); - - SyncedCombination() { - } - - /** - * Add or replace a one shot vibration effect to be performed by the specified vibrator. - * - * @param vibratorId The id of the vibrator that should perform this effect. - * @param effect The effect this vibrator should play. - * @return The {@link CombinedVibrationEffect.SyncedCombination} object to enable adding - * multiple effects in one chain. - * @see VibrationEffect#createOneShot(long, int) - */ - @NonNull - public SyncedCombination addVibrator(int vibratorId, @NonNull VibrationEffect effect) { - mEffects.put(vibratorId, effect); - return this; - } - - /** - * Combine all of the added effects into a combined effect. - * - * The {@link CombinedVibrationEffect.SyncedCombination} object is still valid after this - * call, so you can continue adding more effects to it and generating more - * {@link CombinedVibrationEffect}s by calling this method again. - * - * @return The {@link CombinedVibrationEffect} resulting from combining the added effects to - * be played in sync. - */ - @NonNull - public CombinedVibrationEffect combine() { - if (mEffects.size() == 0) { - throw new IllegalStateException( - "Combination must have at least one element to combine."); - } - CombinedVibrationEffect combined = new Stereo(mEffects); - combined.validate(); - return combined; - } - } - - /** - * A combination of haptic effects that should be played in multiple vibrators in sequence. - * - * @see CombinedVibrationEffect#startSequential() - * @hide - */ - @TestApi - public static final class SequentialCombination { - - private final ArrayList mEffects = new ArrayList<>(); - private final ArrayList mDelays = new ArrayList<>(); - - SequentialCombination() { - } - - /** - * Add a single vibration effect to be performed next. - * - * Similar to {@link #addNext(int, VibrationEffect, int)}, but with no delay. - * - * @param vibratorId The id of the vibrator that should perform this effect. - * @param effect The effect this vibrator should play. - * @return The {@link CombinedVibrationEffect.SequentialCombination} object to enable adding - * multiple effects in one chain. - */ - @NonNull - public SequentialCombination addNext(int vibratorId, @NonNull VibrationEffect effect) { - return addNext(vibratorId, effect, /* delay= */ 0); - } - - /** - * Add a single vibration effect to be performed next. - * - * @param vibratorId The id of the vibrator that should perform this effect. - * @param effect The effect this vibrator should play. - * @param delay The amount of time, in milliseconds, to wait between playing the prior - * effect and this one. - * @return The {@link CombinedVibrationEffect.SequentialCombination} object to enable adding - * multiple effects in one chain. - */ - @NonNull - public SequentialCombination addNext(int vibratorId, @NonNull VibrationEffect effect, - int delay) { - return addNext( - CombinedVibrationEffect.startSynced().addVibrator(vibratorId, effect).combine(), - delay); - } - - /** - * Add a combined vibration effect to be performed next. - * - * Similar to {@link #addNext(CombinedVibrationEffect, int)}, but with no delay. - * - * @param effect The combined effect to be performed next. - * @return The {@link CombinedVibrationEffect.SequentialCombination} object to enable adding - * multiple effects in one chain. - * @see VibrationEffect#createOneShot(long, int) - */ - @NonNull - public SequentialCombination addNext(@NonNull CombinedVibrationEffect effect) { - return addNext(effect, /* delay= */ 0); - } - - /** - * Add a one shot vibration effect to be performed by the specified vibrator. - * - * @param effect The combined effect to be performed next. - * @param delay The amount of time, in milliseconds, to wait between playing the prior - * effect and this one. - * @return The {@link CombinedVibrationEffect.SequentialCombination} object to enable adding - * multiple effects in one chain. - */ - @NonNull - public SequentialCombination addNext(@NonNull CombinedVibrationEffect effect, int delay) { - if (effect instanceof Sequential) { - Sequential sequentialEffect = (Sequential) effect; - int firstEffectIndex = mDelays.size(); - mEffects.addAll(sequentialEffect.getEffects()); - mDelays.addAll(sequentialEffect.getDelays()); - mDelays.set(firstEffectIndex, delay + mDelays.get(firstEffectIndex)); - } else { - mEffects.add(effect); - mDelays.add(delay); - } - return this; - } - - /** - * Combine all of the added effects in sequence. - * - * The {@link CombinedVibrationEffect.SequentialCombination} object is still valid after - * this call, so you can continue adding more effects to it and generating more {@link - * CombinedVibrationEffect}s by calling this method again. - * - * @return The {@link CombinedVibrationEffect} resulting from combining the added effects to - * be played in sequence. - */ - @NonNull - public CombinedVibrationEffect combine() { - if (mEffects.size() == 0) { - throw new IllegalStateException( - "Combination must have at least one element to combine."); - } - CombinedVibrationEffect combined = new Sequential(mEffects, mDelays); - combined.validate(); - return combined; - } - } - - /** - * Represents a single {@link VibrationEffect} that should be executed in all vibrators in sync. - * - * @hide - */ - @TestApi - public static final class Mono extends CombinedVibrationEffect { - private final VibrationEffect mEffect; - - Mono(Parcel in) { - mEffect = VibrationEffect.CREATOR.createFromParcel(in); - } - - Mono(@NonNull VibrationEffect effect) { - mEffect = effect; - } - - @NonNull - public VibrationEffect getEffect() { - return mEffect; - } - - @Override - public long getDuration() { - return mEffect.getDuration(); - } - - /** @hide */ - @Override - public void validate() { - mEffect.validate(); - } - - /** @hide */ - @Override - public boolean hasVibrator(int vibratorId) { - return true; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof Mono)) { - return false; - } - Mono other = (Mono) o; - return mEffect.equals(other.mEffect); - } - - @Override - public int hashCode() { - return Objects.hash(mEffect); - } - - @Override - public String toString() { - return "Mono{mEffect=" + mEffect + '}'; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(@NonNull Parcel out, int flags) { - out.writeInt(PARCEL_TOKEN_MONO); - mEffect.writeToParcel(out, flags); - } - - @NonNull - public static final Parcelable.Creator CREATOR = - new Parcelable.Creator() { - @Override - public Mono createFromParcel(@NonNull Parcel in) { - // Skip the type token - in.readInt(); - return new Mono(in); - } - - @Override - @NonNull - public Mono[] newArray(int size) { - return new Mono[size]; - } - }; - } - - /** - * Represents a list of {@link VibrationEffect}s that should be executed in sync. - * - * @hide - */ - @TestApi - public static final class Stereo extends CombinedVibrationEffect { - - /** Mapping vibrator ids to effects. */ - private final SparseArray mEffects; - - Stereo(Parcel in) { - int size = in.readInt(); - mEffects = new SparseArray<>(size); - for (int i = 0; i < size; i++) { - int vibratorId = in.readInt(); - mEffects.put(vibratorId, VibrationEffect.CREATOR.createFromParcel(in)); - } - } - - Stereo(@NonNull SparseArray effects) { - mEffects = new SparseArray<>(effects.size()); - for (int i = 0; i < effects.size(); i++) { - mEffects.put(effects.keyAt(i), effects.valueAt(i)); - } - } - - /** Effects to be performed in sync, where each key represents the vibrator id. */ - @NonNull - public SparseArray getEffects() { - return mEffects; - } - - @Override - public long getDuration() { - long maxDuration = Long.MIN_VALUE; - boolean hasUnknownStep = false; - for (int i = 0; i < mEffects.size(); i++) { - long duration = mEffects.valueAt(i).getDuration(); - if (duration == Long.MAX_VALUE) { - // If any duration is repeating, this combination duration is also repeating. - return duration; - } - maxDuration = Math.max(maxDuration, duration); - // If any step is unknown, this combination duration will also be unknown, unless - // any step is repeating. Repeating vibrations take precedence over non-repeating - // ones in the service, so continue looping to check for repeating steps. - hasUnknownStep |= duration < 0; - } - if (hasUnknownStep) { - // If any step is unknown, this combination duration is also unknown. - return -1; - } - return maxDuration; - } - - /** @hide */ - @Override - public void validate() { - Preconditions.checkArgument(mEffects.size() > 0, - "There should be at least one effect set for a combined effect"); - for (int i = 0; i < mEffects.size(); i++) { - mEffects.valueAt(i).validate(); - } - } - - /** @hide */ - @Override - public boolean hasVibrator(int vibratorId) { - return mEffects.indexOfKey(vibratorId) >= 0; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof Stereo)) { - return false; - } - Stereo other = (Stereo) o; - if (mEffects.size() != other.mEffects.size()) { - return false; - } - for (int i = 0; i < mEffects.size(); i++) { - if (!mEffects.valueAt(i).equals(other.mEffects.get(mEffects.keyAt(i)))) { - return false; - } - } - return true; - } - - @Override - public int hashCode() { - return mEffects.contentHashCode(); - } - - @Override - public String toString() { - return "Stereo{mEffects=" + mEffects + '}'; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(@NonNull Parcel out, int flags) { - out.writeInt(PARCEL_TOKEN_STEREO); - out.writeInt(mEffects.size()); - for (int i = 0; i < mEffects.size(); i++) { - out.writeInt(mEffects.keyAt(i)); - mEffects.valueAt(i).writeToParcel(out, flags); - } - } - - @NonNull - public static final Parcelable.Creator CREATOR = - new Parcelable.Creator() { - @Override - public Stereo createFromParcel(@NonNull Parcel in) { - // Skip the type token - in.readInt(); - return new Stereo(in); - } - - @Override - @NonNull - public Stereo[] newArray(int size) { - return new Stereo[size]; - } - }; - } - - /** - * Represents a list of {@link VibrationEffect}s that should be executed in sequence. - * - * @hide - */ - @TestApi - public static final class Sequential extends CombinedVibrationEffect { - private final List mEffects; - private final List mDelays; - - Sequential(Parcel in) { - int size = in.readInt(); - mEffects = new ArrayList<>(size); - mDelays = new ArrayList<>(size); - for (int i = 0; i < size; i++) { - mDelays.add(in.readInt()); - mEffects.add(CombinedVibrationEffect.CREATOR.createFromParcel(in)); - } - } - - Sequential(@NonNull List effects, - @NonNull List delays) { - mEffects = new ArrayList<>(effects); - mDelays = new ArrayList<>(delays); - } - - /** Effects to be performed in sequence. */ - @NonNull - public List getEffects() { - return mEffects; - } - - /** Delay to be applied before each effect in {@link #getEffects()}. */ - @NonNull - public List getDelays() { - return mDelays; - } - - @Override - public long getDuration() { - boolean hasUnknownStep = false; - long durations = 0; - final int effectCount = mEffects.size(); - for (int i = 0; i < effectCount; i++) { - CombinedVibrationEffect effect = mEffects.get(i); - long duration = effect.getDuration(); - if (duration == Long.MAX_VALUE) { - // If any duration is repeating, this combination duration is also repeating. - return duration; - } - durations += duration; - // If any step is unknown, this combination duration will also be unknown, unless - // any step is repeating. Repeating vibrations take precedence over non-repeating - // ones in the service, so continue looping to check for repeating steps. - hasUnknownStep |= duration < 0; - } - if (hasUnknownStep) { - // If any step is unknown, this combination duration is also unknown. - return -1; - } - long delays = 0; - for (int i = 0; i < effectCount; i++) { - delays += mDelays.get(i); - } - return durations + delays; - } - - /** @hide */ - @Override - public void validate() { - Preconditions.checkArgument(mEffects.size() > 0, - "There should be at least one effect set for a combined effect"); - Preconditions.checkArgument(mEffects.size() == mDelays.size(), - "Effect and delays should have equal length"); - final int effectCount = mEffects.size(); - for (int i = 0; i < effectCount; i++) { - if (mDelays.get(i) < 0) { - throw new IllegalArgumentException("Delays must all be >= 0" - + " (delays=" + mDelays + ")"); - } - } - for (int i = 0; i < effectCount; i++) { - CombinedVibrationEffect effect = mEffects.get(i); - if (effect instanceof Sequential) { - throw new IllegalArgumentException( - "There should be no nested sequential effects in a combined effect"); - } - effect.validate(); - } - } - - /** @hide */ - @Override - public boolean hasVibrator(int vibratorId) { - final int effectCount = mEffects.size(); - for (int i = 0; i < effectCount; i++) { - if (mEffects.get(i).hasVibrator(vibratorId)) { - return true; - } - } - return false; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof Sequential)) { - return false; - } - Sequential other = (Sequential) o; - return mDelays.equals(other.mDelays) && mEffects.equals(other.mEffects); - } - - @Override - public int hashCode() { - return Objects.hash(mEffects, mDelays); - } - - @Override - public String toString() { - return "Sequential{mEffects=" + mEffects + ", mDelays=" + mDelays + '}'; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(@NonNull Parcel out, int flags) { - out.writeInt(PARCEL_TOKEN_SEQUENTIAL); - out.writeInt(mEffects.size()); - for (int i = 0; i < mEffects.size(); i++) { - out.writeInt(mDelays.get(i)); - mEffects.get(i).writeToParcel(out, flags); - } - } - - @NonNull - public static final Parcelable.Creator CREATOR = - new Parcelable.Creator() { - @Override - public Sequential createFromParcel(@NonNull Parcel in) { - // Skip the type token - in.readInt(); - return new Sequential(in); - } - - @Override - @NonNull - public Sequential[] newArray(int size) { - return new Sequential[size]; - } - }; - } - - @NonNull - public static final Parcelable.Creator CREATOR = - new Parcelable.Creator() { - @Override - public CombinedVibrationEffect createFromParcel(Parcel in) { - int token = in.readInt(); - if (token == PARCEL_TOKEN_MONO) { - return new Mono(in); - } else if (token == PARCEL_TOKEN_STEREO) { - return new Stereo(in); - } else if (token == PARCEL_TOKEN_SEQUENTIAL) { - return new Sequential(in); - } else { - throw new IllegalStateException( - "Unexpected combined vibration event type token in parcel."); - } - } - - @Override - public CombinedVibrationEffect[] newArray(int size) { - return new CombinedVibrationEffect[size]; - } - }; -} diff --git a/core/java/android/os/IVibratorManagerService.aidl b/core/java/android/os/IVibratorManagerService.aidl index f9e294791cca..c58cc4f9988f 100644 --- a/core/java/android/os/IVibratorManagerService.aidl +++ b/core/java/android/os/IVibratorManagerService.aidl @@ -16,7 +16,7 @@ package android.os; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.IVibratorStateListener; import android.os.VibrationAttributes; import android.os.VibratorInfo; @@ -29,8 +29,8 @@ interface IVibratorManagerService { boolean registerVibratorStateListener(int vibratorId, in IVibratorStateListener listener); boolean unregisterVibratorStateListener(int vibratorId, in IVibratorStateListener listener); boolean setAlwaysOnEffect(int uid, String opPkg, int alwaysOnId, - in CombinedVibrationEffect effect, in VibrationAttributes attributes); - void vibrate(int uid, String opPkg, in CombinedVibrationEffect effect, + in CombinedVibration vibration, in VibrationAttributes attributes); + void vibrate(int uid, String opPkg, in CombinedVibration vibration, in VibrationAttributes attributes, String reason, IBinder token); void cancelVibrate(IBinder token); } diff --git a/core/java/android/os/SystemVibrator.java b/core/java/android/os/SystemVibrator.java index 219912c24e70..2e8ecb59b0d3 100644 --- a/core/java/android/os/SystemVibrator.java +++ b/core/java/android/os/SystemVibrator.java @@ -168,7 +168,7 @@ public class SystemVibrator extends Vibrator { return false; } VibrationAttributes attr = new VibrationAttributes.Builder(attributes, effect).build(); - CombinedVibrationEffect combinedEffect = CombinedVibrationEffect.createSynced(effect); + CombinedVibration combinedEffect = CombinedVibration.createParallel(effect); return mVibratorManager.setAlwaysOnEffect(uid, opPkg, alwaysOnId, combinedEffect, attr); } @@ -179,7 +179,7 @@ public class SystemVibrator extends Vibrator { Log.w(TAG, "Failed to vibrate; no vibrator manager."); return; } - CombinedVibrationEffect combinedEffect = CombinedVibrationEffect.createSynced(effect); + CombinedVibration combinedEffect = CombinedVibration.createParallel(effect); mVibratorManager.vibrate(uid, opPkg, combinedEffect, reason, attributes); } diff --git a/core/java/android/os/SystemVibratorManager.java b/core/java/android/os/SystemVibratorManager.java index 5d8190213119..84a1016e3364 100644 --- a/core/java/android/os/SystemVibratorManager.java +++ b/core/java/android/os/SystemVibratorManager.java @@ -117,7 +117,7 @@ public class SystemVibratorManager extends VibratorManager { @Override public boolean setAlwaysOnEffect(int uid, String opPkg, int alwaysOnId, - @Nullable CombinedVibrationEffect effect, @Nullable VibrationAttributes attributes) { + @Nullable CombinedVibration effect, @Nullable VibrationAttributes attributes) { if (mService == null) { Log.w(TAG, "Failed to set always-on effect; no vibrator manager service."); return false; @@ -131,7 +131,7 @@ public class SystemVibratorManager extends VibratorManager { } @Override - public void vibrate(int uid, String opPkg, @NonNull CombinedVibrationEffect effect, + public void vibrate(int uid, String opPkg, @NonNull CombinedVibration effect, String reason, @Nullable VibrationAttributes attributes) { if (mService == null) { Log.w(TAG, "Failed to vibrate; no vibrator manager service."); @@ -240,7 +240,7 @@ public class SystemVibratorManager extends VibratorManager { try { VibrationAttributes attr = new VibrationAttributes.Builder( attributes, effect).build(); - CombinedVibrationEffect combined = CombinedVibrationEffect.startSynced() + CombinedVibration combined = CombinedVibration.startParallel() .addVibrator(mVibratorInfo.getId(), effect) .combine(); return mService.setAlwaysOnEffect(uid, opPkg, alwaysOnId, combined, attr); @@ -259,7 +259,7 @@ public class SystemVibratorManager extends VibratorManager { return; } try { - CombinedVibrationEffect combined = CombinedVibrationEffect.startSynced() + CombinedVibration combined = CombinedVibration.startParallel() .addVibrator(mVibratorInfo.getId(), vibe) .combine(); mService.vibrate(uid, opPkg, combined, attributes, reason, mToken); diff --git a/core/java/android/os/VibratorManager.java b/core/java/android/os/VibratorManager.java index 5a01814508e1..7c911160dfa6 100644 --- a/core/java/android/os/VibratorManager.java +++ b/core/java/android/os/VibratorManager.java @@ -69,7 +69,7 @@ public abstract class VibratorManager { public abstract Vibrator getVibrator(int vibratorId); /** - * Returns the system default Vibrator service. + * Returns the default Vibrator for the device. */ @NonNull public abstract Vibrator getDefaultVibrator(); @@ -81,7 +81,7 @@ public abstract class VibratorManager { */ @RequiresPermission(android.Manifest.permission.VIBRATE_ALWAYS_ON) public boolean setAlwaysOnEffect(int uid, String opPkg, int alwaysOnId, - @Nullable CombinedVibrationEffect effect, @Nullable VibrationAttributes attributes) { + @Nullable CombinedVibration effect, @Nullable VibrationAttributes attributes) { Log.w(TAG, "Always-on effects aren't supported"); return false; } @@ -90,14 +90,14 @@ public abstract class VibratorManager { * Vibrate with a given combination of effects. * *

- * Pass in a {@link CombinedVibrationEffect} representing a combination of {@link + * Pass in a {@link CombinedVibration} representing a combination of {@link * VibrationEffect VibrationEffects} to be played on one or more vibrators. *

* * @param effect a combination of effects to be performed by one or more vibrators. */ @RequiresPermission(android.Manifest.permission.VIBRATE) - public final void vibrate(@NonNull CombinedVibrationEffect effect) { + public final void vibrate(@NonNull CombinedVibration effect) { vibrate(effect, null); } @@ -105,7 +105,7 @@ public abstract class VibratorManager { * Vibrate with a given combination of effects. * *

- * Pass in a {@link CombinedVibrationEffect} representing a combination of {@link + * Pass in a {@link CombinedVibration} representing a combination of {@link * VibrationEffect} to be played on one or more vibrators. *

* @@ -116,19 +116,19 @@ public abstract class VibratorManager { * incoming calls. */ @RequiresPermission(android.Manifest.permission.VIBRATE) - public final void vibrate(@NonNull CombinedVibrationEffect effect, + public final void vibrate(@NonNull CombinedVibration effect, @Nullable VibrationAttributes attributes) { vibrate(Process.myUid(), mPackageName, effect, null, attributes); } /** - * Like {@link #vibrate(CombinedVibrationEffect, VibrationAttributes)}, but allows the + * Like {@link #vibrate(CombinedVibration, VibrationAttributes)}, but allows the * caller to specify the vibration is owned by someone else and set reason for vibration. * * @hide */ @RequiresPermission(android.Manifest.permission.VIBRATE) - public abstract void vibrate(int uid, String opPkg, @NonNull CombinedVibrationEffect effect, + public abstract void vibrate(int uid, String opPkg, @NonNull CombinedVibration effect, String reason, @Nullable VibrationAttributes attributes); /** diff --git a/core/java/android/view/InputDevice.java b/core/java/android/view/InputDevice.java index d1f8ee9b0cc7..3b1c8ec23016 100644 --- a/core/java/android/view/InputDevice.java +++ b/core/java/android/view/InputDevice.java @@ -812,7 +812,9 @@ public final class InputDevice implements Parcelable { * {@link Context#getSystemService} with {@link Context#VIBRATOR_SERVICE} as argument. * * @return The vibrator service associated with the device, never null. + * @deprecated Use {@link #getVibratorManager()} to retrieve the default device vibrator. */ + @Deprecated public Vibrator getVibrator() { synchronized (mMotionRanges) { if (mVibrator == null) { diff --git a/core/tests/coretests/src/android/os/CombinedVibrationEffectTest.java b/core/tests/coretests/src/android/os/CombinedVibrationEffectTest.java deleted file mode 100644 index 30b2d8e47ab1..000000000000 --- a/core/tests/coretests/src/android/os/CombinedVibrationEffectTest.java +++ /dev/null @@ -1,247 +0,0 @@ -/* - * Copyright (C) 2020 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 android.os; - -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertFalse; -import static junit.framework.Assert.assertTrue; - -import static org.testng.Assert.assertThrows; - -import android.platform.test.annotations.Presubmit; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -import java.util.ArrayList; -import java.util.Arrays; - -@Presubmit -@RunWith(JUnit4.class) -public class CombinedVibrationEffectTest { - private static final VibrationEffect VALID_EFFECT = VibrationEffect.createOneShot(10, 255); - private static final VibrationEffect INVALID_EFFECT = new VibrationEffect.Composed( - new ArrayList<>(), 0); - - @Test - public void testValidateMono() { - CombinedVibrationEffect.createSynced(VALID_EFFECT); - - assertThrows(IllegalArgumentException.class, - () -> CombinedVibrationEffect.createSynced(INVALID_EFFECT)); - } - - @Test - public void testValidateStereo() { - CombinedVibrationEffect.startSynced() - .addVibrator(0, VALID_EFFECT) - .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) - .combine(); - CombinedVibrationEffect.startSynced() - .addVibrator(0, INVALID_EFFECT) - .addVibrator(0, VALID_EFFECT) - .combine(); - - assertThrows(IllegalArgumentException.class, - () -> CombinedVibrationEffect.startSynced() - .addVibrator(0, INVALID_EFFECT) - .combine()); - } - - @Test - public void testValidateSequential() { - CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT) - .addNext(CombinedVibrationEffect.createSynced(VALID_EFFECT)) - .combine(); - CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT) - .addNext(0, VALID_EFFECT, 100) - .combine(); - CombinedVibrationEffect.startSequential() - .addNext(CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT) - .combine()) - .combine(); - - assertThrows(IllegalArgumentException.class, - () -> CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT, -1) - .combine()); - assertThrows(IllegalArgumentException.class, - () -> CombinedVibrationEffect.startSequential() - .addNext(0, INVALID_EFFECT) - .combine()); - } - - @Test - public void testNestedSequentialAccumulatesDelays() { - CombinedVibrationEffect.Sequential combined = - (CombinedVibrationEffect.Sequential) CombinedVibrationEffect.startSequential() - .addNext(CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT, /* delay= */ 100) - .addNext(1, VALID_EFFECT, /* delay= */ 100) - .combine(), - /* delay= */ 10) - .addNext(CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT, /* delay= */ 100) - .combine()) - .addNext(CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT) - .addNext(0, VALID_EFFECT, /* delay= */ 100) - .combine(), - /* delay= */ 10) - .combine(); - - assertEquals(Arrays.asList(110, 100, 100, 10, 100), combined.getDelays()); - } - - @Test - public void testCombineEmptyFails() { - assertThrows(IllegalStateException.class, - () -> CombinedVibrationEffect.startSynced().combine()); - assertThrows(IllegalStateException.class, - () -> CombinedVibrationEffect.startSequential().combine()); - } - - @Test - public void testDurationMono() { - assertEquals(1, CombinedVibrationEffect.createSynced( - VibrationEffect.createOneShot(1, 1)).getDuration()); - assertEquals(-1, CombinedVibrationEffect.createSynced( - VibrationEffect.get(VibrationEffect.EFFECT_CLICK)).getDuration()); - assertEquals(Long.MAX_VALUE, CombinedVibrationEffect.createSynced( - VibrationEffect.createWaveform( - new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)).getDuration()); - } - - @Test - public void testDurationStereo() { - assertEquals(6, CombinedVibrationEffect.startSynced() - .addVibrator(1, VibrationEffect.createOneShot(1, 1)) - .addVibrator(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) - .combine() - .getDuration()); - assertEquals(-1, CombinedVibrationEffect.startSynced() - .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addVibrator(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) - .combine() - .getDuration()); - assertEquals(Long.MAX_VALUE, CombinedVibrationEffect.startSynced() - .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addVibrator(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)) - .combine() - .getDuration()); - } - - @Test - public void testDurationSequential() { - assertEquals(26, CombinedVibrationEffect.startSequential() - .addNext(1, VibrationEffect.createOneShot(10, 10), 10) - .addNext(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) - .combine() - .getDuration()); - assertEquals(-1, CombinedVibrationEffect.startSequential() - .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addNext(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) - .combine() - .getDuration()); - assertEquals(Long.MAX_VALUE, CombinedVibrationEffect.startSequential() - .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addNext(2, - VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)) - .combine() - .getDuration()); - } - - @Test - public void testHasVibratorMono_returnsTrueForAnyVibrator() { - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( - VibrationEffect.get(VibrationEffect.EFFECT_CLICK)); - assertTrue(effect.hasVibrator(0)); - assertTrue(effect.hasVibrator(1)); - } - - @Test - public void testHasVibratorStereo_returnsOnlyTheIdsSet() { - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() - .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .combine(); - assertFalse(effect.hasVibrator(0)); - assertTrue(effect.hasVibrator(1)); - assertFalse(effect.hasVibrator(2)); - } - - @Test - public void testHasVibratorSequential_returnsNestedVibrators() { - CombinedVibrationEffect effect = CombinedVibrationEffect.startSequential() - .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addNext(CombinedVibrationEffect.startSynced() - .addVibrator(2, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) - .combine()) - .combine(); - assertFalse(effect.hasVibrator(0)); - assertTrue(effect.hasVibrator(1)); - assertTrue(effect.hasVibrator(2)); - } - - @Test - public void testSerializationMono() { - CombinedVibrationEffect original = CombinedVibrationEffect.createSynced(VALID_EFFECT); - - Parcel parcel = Parcel.obtain(); - original.writeToParcel(parcel, 0); - parcel.setDataPosition(0); - CombinedVibrationEffect restored = CombinedVibrationEffect.CREATOR.createFromParcel(parcel); - assertEquals(original, restored); - } - - @Test - public void testSerializationStereo() { - CombinedVibrationEffect original = CombinedVibrationEffect.startSynced() - .addVibrator(0, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) - .addVibrator(1, VibrationEffect.createOneShot(10, 255)) - .combine(); - - Parcel parcel = Parcel.obtain(); - original.writeToParcel(parcel, 0); - parcel.setDataPosition(0); - CombinedVibrationEffect restored = CombinedVibrationEffect.CREATOR.createFromParcel(parcel); - assertEquals(original, restored); - } - - @Test - public void testSerializationSequential() { - CombinedVibrationEffect original = CombinedVibrationEffect.startSequential() - .addNext(0, VALID_EFFECT) - .addNext(CombinedVibrationEffect.createSynced(VALID_EFFECT)) - .addNext(0, VibrationEffect.get(VibrationEffect.EFFECT_CLICK), 100) - .combine(); - - Parcel parcel = Parcel.obtain(); - original.writeToParcel(parcel, 0); - parcel.setDataPosition(0); - CombinedVibrationEffect restored = CombinedVibrationEffect.CREATOR.createFromParcel(parcel); - assertEquals(original, restored); - } -} diff --git a/core/tests/coretests/src/android/os/CombinedVibrationTest.java b/core/tests/coretests/src/android/os/CombinedVibrationTest.java new file mode 100644 index 000000000000..06b5d180518f --- /dev/null +++ b/core/tests/coretests/src/android/os/CombinedVibrationTest.java @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2020 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 android.os; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertFalse; +import static junit.framework.Assert.assertTrue; + +import static org.testng.Assert.assertThrows; + +import android.platform.test.annotations.Presubmit; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.util.ArrayList; +import java.util.Arrays; + +@Presubmit +@RunWith(JUnit4.class) +public class CombinedVibrationTest { + private static final VibrationEffect VALID_EFFECT = VibrationEffect.createOneShot(10, 255); + private static final VibrationEffect INVALID_EFFECT = new VibrationEffect.Composed( + new ArrayList<>(), 0); + + @Test + public void testValidateMono() { + CombinedVibration.createParallel(VALID_EFFECT); + + assertThrows(IllegalArgumentException.class, + () -> CombinedVibration.createParallel(INVALID_EFFECT)); + } + + @Test + public void testValidateStereo() { + CombinedVibration.startParallel() + .addVibrator(0, VALID_EFFECT) + .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) + .combine(); + CombinedVibration.startParallel() + .addVibrator(0, INVALID_EFFECT) + .addVibrator(0, VALID_EFFECT) + .combine(); + + assertThrows(IllegalArgumentException.class, + () -> CombinedVibration.startParallel() + .addVibrator(0, INVALID_EFFECT) + .combine()); + } + + @Test + public void testValidateSequential() { + CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT) + .addNext(CombinedVibration.createParallel(VALID_EFFECT)) + .combine(); + CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT) + .addNext(0, VALID_EFFECT, 100) + .combine(); + CombinedVibration.startSequential() + .addNext(CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT) + .combine()) + .combine(); + + assertThrows(IllegalArgumentException.class, + () -> CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT, -1) + .combine()); + assertThrows(IllegalArgumentException.class, + () -> CombinedVibration.startSequential() + .addNext(0, INVALID_EFFECT) + .combine()); + } + + @Test + public void testNestedSequentialAccumulatesDelays() { + CombinedVibration.Sequential combined = + (CombinedVibration.Sequential) CombinedVibration.startSequential() + .addNext(CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT, /* delay= */ 100) + .addNext(1, VALID_EFFECT, /* delay= */ 100) + .combine(), + /* delay= */ 10) + .addNext(CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT, /* delay= */ 100) + .combine()) + .addNext(CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT) + .addNext(0, VALID_EFFECT, /* delay= */ 100) + .combine(), + /* delay= */ 10) + .combine(); + + assertEquals(Arrays.asList(110, 100, 100, 10, 100), combined.getDelays()); + } + + @Test + public void testCombineEmptyFails() { + assertThrows(IllegalStateException.class, + () -> CombinedVibration.startParallel().combine()); + assertThrows(IllegalStateException.class, + () -> CombinedVibration.startSequential().combine()); + } + + @Test + public void testDurationMono() { + assertEquals(1, CombinedVibration.createParallel( + VibrationEffect.createOneShot(1, 1)).getDuration()); + assertEquals(-1, CombinedVibration.createParallel( + VibrationEffect.get(VibrationEffect.EFFECT_CLICK)).getDuration()); + assertEquals(Long.MAX_VALUE, CombinedVibration.createParallel( + VibrationEffect.createWaveform( + new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)).getDuration()); + } + + @Test + public void testDurationStereo() { + assertEquals(6, CombinedVibration.startParallel() + .addVibrator(1, VibrationEffect.createOneShot(1, 1)) + .addVibrator(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) + .combine() + .getDuration()); + assertEquals(-1, CombinedVibration.startParallel() + .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addVibrator(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) + .combine() + .getDuration()); + assertEquals(Long.MAX_VALUE, CombinedVibration.startParallel() + .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addVibrator(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)) + .combine() + .getDuration()); + } + + @Test + public void testDurationSequential() { + assertEquals(26, CombinedVibration.startSequential() + .addNext(1, VibrationEffect.createOneShot(10, 10), 10) + .addNext(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) + .combine() + .getDuration()); + assertEquals(-1, CombinedVibration.startSequential() + .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addNext(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, -1)) + .combine() + .getDuration()); + assertEquals(Long.MAX_VALUE, CombinedVibration.startSequential() + .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addNext(2, + VibrationEffect.createWaveform(new long[]{1, 2, 3}, new int[]{1, 2, 3}, 0)) + .combine() + .getDuration()); + } + + @Test + public void testHasVibratorMono_returnsTrueForAnyVibrator() { + CombinedVibration effect = CombinedVibration.createParallel( + VibrationEffect.get(VibrationEffect.EFFECT_CLICK)); + assertTrue(effect.hasVibrator(0)); + assertTrue(effect.hasVibrator(1)); + } + + @Test + public void testHasVibratorStereo_returnsOnlyTheIdsSet() { + CombinedVibration effect = CombinedVibration.startParallel() + .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .combine(); + assertFalse(effect.hasVibrator(0)); + assertTrue(effect.hasVibrator(1)); + assertFalse(effect.hasVibrator(2)); + } + + @Test + public void testHasVibratorSequential_returnsNestedVibrators() { + CombinedVibration effect = CombinedVibration.startSequential() + .addNext(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addNext(CombinedVibration.startParallel() + .addVibrator(2, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) + .combine()) + .combine(); + assertFalse(effect.hasVibrator(0)); + assertTrue(effect.hasVibrator(1)); + assertTrue(effect.hasVibrator(2)); + } + + @Test + public void testSerializationMono() { + CombinedVibration original = CombinedVibration.createParallel(VALID_EFFECT); + + Parcel parcel = Parcel.obtain(); + original.writeToParcel(parcel, 0); + parcel.setDataPosition(0); + CombinedVibration restored = CombinedVibration.CREATOR.createFromParcel(parcel); + assertEquals(original, restored); + } + + @Test + public void testSerializationStereo() { + CombinedVibration original = CombinedVibration.startParallel() + .addVibrator(0, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) + .addVibrator(1, VibrationEffect.createOneShot(10, 255)) + .combine(); + + Parcel parcel = Parcel.obtain(); + original.writeToParcel(parcel, 0); + parcel.setDataPosition(0); + CombinedVibration restored = CombinedVibration.CREATOR.createFromParcel(parcel); + assertEquals(original, restored); + } + + @Test + public void testSerializationSequential() { + CombinedVibration original = CombinedVibration.startSequential() + .addNext(0, VALID_EFFECT) + .addNext(CombinedVibration.createParallel(VALID_EFFECT)) + .addNext(0, VibrationEffect.get(VibrationEffect.EFFECT_CLICK), 100) + .combine(); + + Parcel parcel = Parcel.obtain(); + original.writeToParcel(parcel, 0); + parcel.setDataPosition(0); + CombinedVibration restored = CombinedVibration.CREATOR.createFromParcel(parcel); + assertEquals(original, restored); + } +} diff --git a/services/core/java/com/android/server/input/InputManagerService.java b/services/core/java/com/android/server/input/InputManagerService.java index 0f137418a89c..0a800e9fc3a1 100644 --- a/services/core/java/com/android/server/input/InputManagerService.java +++ b/services/core/java/com/android/server/input/InputManagerService.java @@ -57,7 +57,7 @@ import android.hardware.lights.LightState; import android.media.AudioManager; import android.os.Binder; import android.os.Bundle; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.Environment; import android.os.Handler; import android.os.IBinder; @@ -2033,23 +2033,23 @@ public class InputManagerService extends IInputManager.Stub // Binder call @Override - public void vibrateCombined(int deviceId, CombinedVibrationEffect effect, IBinder token) { + public void vibrateCombined(int deviceId, CombinedVibration effect, IBinder token) { VibratorToken v = getVibratorToken(deviceId, token); synchronized (v) { - if (!(effect instanceof CombinedVibrationEffect.Mono) - && !(effect instanceof CombinedVibrationEffect.Stereo)) { + if (!(effect instanceof CombinedVibration.Mono) + && !(effect instanceof CombinedVibration.Stereo)) { Slog.e(TAG, "Only Mono and Stereo effects are supported"); return; } v.mVibrating = true; - if (effect instanceof CombinedVibrationEffect.Mono) { - CombinedVibrationEffect.Mono mono = (CombinedVibrationEffect.Mono) effect; + if (effect instanceof CombinedVibration.Mono) { + CombinedVibration.Mono mono = (CombinedVibration.Mono) effect; VibrationInfo info = new VibrationInfo(mono.getEffect()); nativeVibrate(mPtr, deviceId, info.getPattern(), info.getAmplitudes(), info.getRepeatIndex(), v.mTokenValue); - } else if (effect instanceof CombinedVibrationEffect.Stereo) { - CombinedVibrationEffect.Stereo stereo = (CombinedVibrationEffect.Stereo) effect; + } else if (effect instanceof CombinedVibration.Stereo) { + CombinedVibration.Stereo stereo = (CombinedVibration.Stereo) effect; SparseArray effects = stereo.getEffects(); long[] pattern = new long[0]; int repeat = Integer.MIN_VALUE; diff --git a/services/core/java/com/android/server/vibrator/InputDeviceDelegate.java b/services/core/java/com/android/server/vibrator/InputDeviceDelegate.java index 96f84dc65e1d..21ba87445478 100644 --- a/services/core/java/com/android/server/vibrator/InputDeviceDelegate.java +++ b/services/core/java/com/android/server/vibrator/InputDeviceDelegate.java @@ -19,7 +19,7 @@ package com.android.server.vibrator; import android.annotation.Nullable; import android.content.Context; import android.hardware.input.InputManager; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.Handler; import android.os.VibrationAttributes; import android.os.VibratorManager; @@ -94,7 +94,7 @@ final class InputDeviceDelegate implements InputManager.InputDeviceListener { * * @return {@link #isAvailable()} */ - public boolean vibrateIfAvailable(int uid, String opPkg, CombinedVibrationEffect effect, + public boolean vibrateIfAvailable(int uid, String opPkg, CombinedVibration effect, String reason, VibrationAttributes attrs) { synchronized (mLock) { for (int i = 0; i < mInputDeviceVibrators.size(); i++) { diff --git a/services/core/java/com/android/server/vibrator/Vibration.java b/services/core/java/com/android/server/vibrator/Vibration.java index cd840589475a..e447a23cf331 100644 --- a/services/core/java/com/android/server/vibrator/Vibration.java +++ b/services/core/java/com/android/server/vibrator/Vibration.java @@ -17,7 +17,7 @@ package com.android.server.vibrator; import android.annotation.Nullable; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.IBinder; import android.os.SystemClock; import android.os.VibrationAttributes; @@ -72,14 +72,14 @@ final class Vibration { /** The actual effect to be played. */ @Nullable - private CombinedVibrationEffect mEffect; + private CombinedVibration mEffect; /** * The original effect that was requested. Typically these two things differ because the effect * was scaled based on the users vibration intensity settings. */ @Nullable - private CombinedVibrationEffect mOriginalEffect; + private CombinedVibration mOriginalEffect; /** * Start/end times in unix epoch time. Only to be used for debugging purposes and to correlate @@ -90,7 +90,7 @@ final class Vibration { private long mEndTimeDebug; private Status mStatus; - Vibration(IBinder token, int id, CombinedVibrationEffect effect, + Vibration(IBinder token, int id, CombinedVibration effect, VibrationAttributes attrs, int uid, String opPkg, String reason) { this.token = token; this.mEffect = effect; @@ -142,7 +142,7 @@ final class Vibration { * effect added. */ public void updateEffects(Function updateFn) { - CombinedVibrationEffect newEffect = transformCombinedEffect(mEffect, updateFn); + CombinedVibration newEffect = transformCombinedEffect(mEffect, updateFn); if (!newEffect.equals(mEffect)) { if (mOriginalEffect == null) { mOriginalEffect = mEffect; @@ -155,29 +155,29 @@ final class Vibration { } /** - * Creates a new {@link CombinedVibrationEffect} by applying the given transformation function + * Creates a new {@link CombinedVibration} by applying the given transformation function * to each {@link VibrationEffect}. */ - private static CombinedVibrationEffect transformCombinedEffect( - CombinedVibrationEffect combinedEffect, Function fn) { - if (combinedEffect instanceof CombinedVibrationEffect.Mono) { - VibrationEffect effect = ((CombinedVibrationEffect.Mono) combinedEffect).getEffect(); - return CombinedVibrationEffect.createSynced(fn.apply(effect)); - } else if (combinedEffect instanceof CombinedVibrationEffect.Stereo) { + private static CombinedVibration transformCombinedEffect( + CombinedVibration combinedEffect, Function fn) { + if (combinedEffect instanceof CombinedVibration.Mono) { + VibrationEffect effect = ((CombinedVibration.Mono) combinedEffect).getEffect(); + return CombinedVibration.createParallel(fn.apply(effect)); + } else if (combinedEffect instanceof CombinedVibration.Stereo) { SparseArray effects = - ((CombinedVibrationEffect.Stereo) combinedEffect).getEffects(); - CombinedVibrationEffect.SyncedCombination combination = - CombinedVibrationEffect.startSynced(); + ((CombinedVibration.Stereo) combinedEffect).getEffects(); + CombinedVibration.ParallelCombination combination = + CombinedVibration.startParallel(); for (int i = 0; i < effects.size(); i++) { combination.addVibrator(effects.keyAt(i), fn.apply(effects.valueAt(i))); } return combination.combine(); - } else if (combinedEffect instanceof CombinedVibrationEffect.Sequential) { - List effects = - ((CombinedVibrationEffect.Sequential) combinedEffect).getEffects(); - CombinedVibrationEffect.SequentialCombination combination = - CombinedVibrationEffect.startSequential(); - for (CombinedVibrationEffect effect : effects) { + } else if (combinedEffect instanceof CombinedVibration.Sequential) { + List effects = + ((CombinedVibration.Sequential) combinedEffect).getEffects(); + CombinedVibration.SequentialCombination combination = + CombinedVibration.startSequential(); + for (CombinedVibration effect : effects) { combination.addNext(transformCombinedEffect(effect, fn)); } return combination.combine(); @@ -199,7 +199,7 @@ final class Vibration { /** Return the effect that should be played by this vibration. */ @Nullable - public CombinedVibrationEffect getEffect() { + public CombinedVibration getEffect() { return mEffect; } @@ -214,8 +214,8 @@ final class Vibration { static final class DebugInfo { private final long mStartTimeDebug; private final long mEndTimeDebug; - private final CombinedVibrationEffect mEffect; - private final CombinedVibrationEffect mOriginalEffect; + private final CombinedVibration mEffect; + private final CombinedVibration mOriginalEffect; private final float mScale; private final VibrationAttributes mAttrs; private final int mUid; @@ -223,8 +223,8 @@ final class Vibration { private final String mReason; private final Status mStatus; - DebugInfo(long startTimeDebug, long endTimeDebug, CombinedVibrationEffect effect, - CombinedVibrationEffect originalEffect, float scale, VibrationAttributes attrs, + DebugInfo(long startTimeDebug, long endTimeDebug, CombinedVibration effect, + CombinedVibration originalEffect, float scale, VibrationAttributes attrs, int uid, String opPkg, String reason, Status status) { mStartTimeDebug = startTimeDebug; mEndTimeDebug = endTimeDebug; @@ -289,24 +289,24 @@ final class Vibration { } private void dumpEffect( - ProtoOutputStream proto, long fieldId, CombinedVibrationEffect effect) { + ProtoOutputStream proto, long fieldId, CombinedVibration effect) { dumpEffect(proto, fieldId, - (CombinedVibrationEffect.Sequential) CombinedVibrationEffect.startSequential() + (CombinedVibration.Sequential) CombinedVibration.startSequential() .addNext(effect) .combine()); } private void dumpEffect( - ProtoOutputStream proto, long fieldId, CombinedVibrationEffect.Sequential effect) { + ProtoOutputStream proto, long fieldId, CombinedVibration.Sequential effect) { final long token = proto.start(fieldId); for (int i = 0; i < effect.getEffects().size(); i++) { - CombinedVibrationEffect nestedEffect = effect.getEffects().get(i); - if (nestedEffect instanceof CombinedVibrationEffect.Mono) { + CombinedVibration nestedEffect = effect.getEffects().get(i); + if (nestedEffect instanceof CombinedVibration.Mono) { dumpEffect(proto, CombinedVibrationEffectProto.EFFECTS, - (CombinedVibrationEffect.Mono) nestedEffect); - } else if (nestedEffect instanceof CombinedVibrationEffect.Stereo) { + (CombinedVibration.Mono) nestedEffect); + } else if (nestedEffect instanceof CombinedVibration.Stereo) { dumpEffect(proto, CombinedVibrationEffectProto.EFFECTS, - (CombinedVibrationEffect.Stereo) nestedEffect); + (CombinedVibration.Stereo) nestedEffect); } proto.write(CombinedVibrationEffectProto.DELAYS, effect.getDelays().get(i)); } @@ -314,14 +314,14 @@ final class Vibration { } private void dumpEffect( - ProtoOutputStream proto, long fieldId, CombinedVibrationEffect.Mono effect) { + ProtoOutputStream proto, long fieldId, CombinedVibration.Mono effect) { final long token = proto.start(fieldId); dumpEffect(proto, SyncVibrationEffectProto.EFFECTS, effect.getEffect()); proto.end(token); } private void dumpEffect( - ProtoOutputStream proto, long fieldId, CombinedVibrationEffect.Stereo effect) { + ProtoOutputStream proto, long fieldId, CombinedVibration.Stereo effect) { final long token = proto.start(fieldId); for (int i = 0; i < effect.getEffects().size(); i++) { proto.write(SyncVibrationEffectProto.VIBRATOR_IDS, effect.getEffects().keyAt(i)); diff --git a/services/core/java/com/android/server/vibrator/VibrationThread.java b/services/core/java/com/android/server/vibrator/VibrationThread.java index b4a95c4e281c..bc61478ec1b5 100644 --- a/services/core/java/com/android/server/vibrator/VibrationThread.java +++ b/services/core/java/com/android/server/vibrator/VibrationThread.java @@ -19,7 +19,7 @@ package com.android.server.vibrator; import android.annotation.NonNull; import android.annotation.Nullable; import android.hardware.vibrator.IVibratorManager; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.IBinder; import android.os.PowerManager; import android.os.Process; @@ -112,7 +112,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { mWakeLock.setWorkSource(mWorkSource); mBatteryStatsService = batteryStatsService; - CombinedVibrationEffect effect = vib.getEffect(); + CombinedVibration effect = vib.getEffect(); for (int i = 0; i < availableVibrators.size(); i++) { if (effect.hasVibrator(availableVibrators.keyAt(i))) { mVibrators.put(availableVibrators.keyAt(i), availableVibrators.valueAt(i)); @@ -191,7 +191,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { private Vibration.Status playVibration() { Trace.traceBegin(Trace.TRACE_TAG_VIBRATOR, "playVibration"); try { - CombinedVibrationEffect.Sequential effect = toSequential(mVibration.getEffect()); + CombinedVibration.Sequential effect = toSequential(mVibration.getEffect()); int stepsPlayed = 0; synchronized (mLock) { @@ -282,11 +282,11 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { return new AmplitudeStep(startTime, controller, effect, segmentIndex, vibratorOffTimeout); } - private static CombinedVibrationEffect.Sequential toSequential(CombinedVibrationEffect effect) { - if (effect instanceof CombinedVibrationEffect.Sequential) { - return (CombinedVibrationEffect.Sequential) effect; + private static CombinedVibration.Sequential toSequential(CombinedVibration effect) { + if (effect instanceof CombinedVibration.Sequential) { + return (CombinedVibration.Sequential) effect; } - return (CombinedVibrationEffect.Sequential) CombinedVibrationEffect.startSequential() + return (CombinedVibration.Sequential) CombinedVibration.startSequential() .addNext(effect) .combine(); } @@ -415,14 +415,14 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { * sequential effect isn't finished yet. */ private final class StartVibrateStep extends Step { - public final CombinedVibrationEffect.Sequential sequentialEffect; + public final CombinedVibration.Sequential sequentialEffect; public final int currentIndex; - StartVibrateStep(CombinedVibrationEffect.Sequential effect) { + StartVibrateStep(CombinedVibration.Sequential effect) { this(SystemClock.uptimeMillis() + effect.getDelays().get(0), effect, /* index= */ 0); } - StartVibrateStep(long startTime, CombinedVibrationEffect.Sequential effect, int index) { + StartVibrateStep(long startTime, CombinedVibration.Sequential effect, int index) { super(startTime); sequentialEffect = effect; currentIndex = index; @@ -437,7 +437,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { if (DEBUG) { Slog.d(TAG, "StartVibrateStep for effect #" + currentIndex); } - CombinedVibrationEffect effect = sequentialEffect.getEffects().get(currentIndex); + CombinedVibration effect = sequentialEffect.getEffects().get(currentIndex); DeviceEffectMap effectMapping = createEffectToVibratorMapping(effect); if (effectMapping == null) { // Unable to map effects to vibrators, ignore this step. @@ -481,12 +481,12 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { /** Create a mapping of individual {@link VibrationEffect} to available vibrators. */ @Nullable private DeviceEffectMap createEffectToVibratorMapping( - CombinedVibrationEffect effect) { - if (effect instanceof CombinedVibrationEffect.Mono) { - return new DeviceEffectMap((CombinedVibrationEffect.Mono) effect); + CombinedVibration effect) { + if (effect instanceof CombinedVibration.Mono) { + return new DeviceEffectMap((CombinedVibration.Mono) effect); } - if (effect instanceof CombinedVibrationEffect.Stereo) { - return new DeviceEffectMap((CombinedVibrationEffect.Stereo) effect); + if (effect instanceof CombinedVibration.Stereo) { + return new DeviceEffectMap((CombinedVibration.Stereo) effect); } return null; } @@ -494,11 +494,11 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { /** * Starts playing effects on designated vibrators, in sync. * - * @param effectMapping The {@link CombinedVibrationEffect} mapped to this device vibrators + * @param effectMapping The {@link CombinedVibration} mapped to this device vibrators * @param nextSteps An output list to accumulate the future {@link Step Steps} created * by this method, typically one for each vibrator that has * successfully started vibrating on this step. - * @return The duration, in millis, of the {@link CombinedVibrationEffect}. Repeating + * @return The duration, in millis, of the {@link CombinedVibration}. Repeating * waveforms return {@link Long#MAX_VALUE}. Zero or negative values indicate the vibrators * have ignored all effects. */ @@ -1041,7 +1041,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { } /** - * Map a {@link CombinedVibrationEffect} to the vibrators available on the device. + * Map a {@link CombinedVibration} to the vibrators available on the device. * *

This contains the logic to find the capabilities required from {@link IVibratorManager} to * play all of the effects in sync. @@ -1051,7 +1051,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { private final int[] mVibratorIds; private final long mRequiredSyncCapabilities; - DeviceEffectMap(CombinedVibrationEffect.Mono mono) { + DeviceEffectMap(CombinedVibration.Mono mono) { mVibratorEffects = new SparseArray<>(mVibrators.size()); mVibratorIds = new int[mVibrators.size()]; for (int i = 0; i < mVibrators.size(); i++) { @@ -1066,7 +1066,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { mRequiredSyncCapabilities = calculateRequiredSyncCapabilities(mVibratorEffects); } - DeviceEffectMap(CombinedVibrationEffect.Stereo stereo) { + DeviceEffectMap(CombinedVibration.Stereo stereo) { SparseArray stereoEffects = stereo.getEffects(); mVibratorEffects = new SparseArray<>(); for (int i = 0; i < stereoEffects.size(); i++) { @@ -1088,7 +1088,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { } /** - * Return the number of vibrators mapped to play the {@link CombinedVibrationEffect} on this + * Return the number of vibrators mapped to play the {@link CombinedVibration} on this * device. */ public int size() { @@ -1096,7 +1096,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { } /** - * Return all capabilities required to play the {@link CombinedVibrationEffect} in + * Return all capabilities required to play the {@link CombinedVibration} in * between calls to {@link IVibratorManager#prepareSynced} and * {@link IVibratorManager#triggerSynced}. */ @@ -1104,7 +1104,7 @@ final class VibrationThread extends Thread implements IBinder.DeathRecipient { return mRequiredSyncCapabilities; } - /** Return all vibrator ids mapped to play the {@link CombinedVibrationEffect}. */ + /** Return all vibrator ids mapped to play the {@link CombinedVibration}. */ public int[] getVibratorIds() { return mVibratorIds; } diff --git a/services/core/java/com/android/server/vibrator/VibratorManagerService.java b/services/core/java/com/android/server/vibrator/VibratorManagerService.java index 6bd7198f3c5b..5d2b1b169c4e 100644 --- a/services/core/java/com/android/server/vibrator/VibratorManagerService.java +++ b/services/core/java/com/android/server/vibrator/VibratorManagerService.java @@ -29,7 +29,7 @@ import android.content.pm.PackageManagerInternal; import android.hardware.vibrator.IVibrator; import android.os.BatteryStats; import android.os.Binder; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.ExternalVibration; import android.os.Handler; import android.os.IBinder; @@ -291,7 +291,7 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { @Override // Binder call public boolean setAlwaysOnEffect(int uid, String opPkg, int alwaysOnId, - @Nullable CombinedVibrationEffect effect, @Nullable VibrationAttributes attrs) { + @Nullable CombinedVibration effect, @Nullable VibrationAttributes attrs) { Trace.traceBegin(Trace.TRACE_TAG_VIBRATOR, "setAlwaysOnEffect"); try { mContext.enforceCallingOrSelfPermission( @@ -332,7 +332,7 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { } @Override // Binder call - public void vibrate(int uid, String opPkg, @NonNull CombinedVibrationEffect effect, + public void vibrate(int uid, String opPkg, @NonNull CombinedVibration effect, @Nullable VibrationAttributes attrs, String reason, IBinder token) { Trace.traceBegin(Trace.TRACE_TAG_VIBRATOR, "vibrate, reason = " + reason); try { @@ -742,14 +742,14 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { } /** - * Validate the incoming {@link CombinedVibrationEffect}. + * Validate the incoming {@link CombinedVibration}. * * We can't throw exceptions here since we might be called from some system_server component, * which would bring the whole system down. * * @return whether the CombinedVibrationEffect is non-null and valid */ - private static boolean isEffectValid(@Nullable CombinedVibrationEffect effect) { + private static boolean isEffectValid(@Nullable CombinedVibration effect) { if (effect == null) { Slog.wtf(TAG, "effect must not be null"); return false; @@ -767,18 +767,18 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { * Sets fallback effects to all prebaked ones in given combination of effects, based on {@link * VibrationSettings#getFallbackEffect}. */ - private void fillVibrationFallbacks(Vibration vib, CombinedVibrationEffect effect) { - if (effect instanceof CombinedVibrationEffect.Mono) { - fillVibrationFallbacks(vib, ((CombinedVibrationEffect.Mono) effect).getEffect()); - } else if (effect instanceof CombinedVibrationEffect.Stereo) { + private void fillVibrationFallbacks(Vibration vib, CombinedVibration effect) { + if (effect instanceof CombinedVibration.Mono) { + fillVibrationFallbacks(vib, ((CombinedVibration.Mono) effect).getEffect()); + } else if (effect instanceof CombinedVibration.Stereo) { SparseArray effects = - ((CombinedVibrationEffect.Stereo) effect).getEffects(); + ((CombinedVibration.Stereo) effect).getEffects(); for (int i = 0; i < effects.size(); i++) { fillVibrationFallbacks(vib, effects.valueAt(i)); } - } else if (effect instanceof CombinedVibrationEffect.Sequential) { - List effects = - ((CombinedVibrationEffect.Sequential) effect).getEffects(); + } else if (effect instanceof CombinedVibration.Sequential) { + List effects = + ((CombinedVibration.Sequential) effect).getEffects(); for (int i = 0; i < effects.size(); i++) { fillVibrationFallbacks(vib, effects.get(i)); } @@ -825,15 +825,15 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { @GuardedBy("mLock") @Nullable private SparseArray fixupAlwaysOnEffectsLocked( - CombinedVibrationEffect effect) { + CombinedVibration effect) { Trace.traceBegin(Trace.TRACE_TAG_VIBRATOR, "fixupAlwaysOnEffectsLocked"); try { SparseArray effects; - if (effect instanceof CombinedVibrationEffect.Mono) { - VibrationEffect syncedEffect = ((CombinedVibrationEffect.Mono) effect).getEffect(); + if (effect instanceof CombinedVibration.Mono) { + VibrationEffect syncedEffect = ((CombinedVibration.Mono) effect).getEffect(); effects = transformAllVibratorsLocked(unused -> syncedEffect); - } else if (effect instanceof CombinedVibrationEffect.Stereo) { - effects = ((CombinedVibrationEffect.Stereo) effect).getEffects(); + } else if (effect instanceof CombinedVibration.Stereo) { + effects = ((CombinedVibration.Stereo) effect).getEffects(); } else { // Only synced combinations can be used for always-on effects. return null; @@ -1465,7 +1465,7 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { private int runMono() { CommonOptions commonOptions = new CommonOptions(); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced(nextEffect()); + CombinedVibration effect = CombinedVibration.createParallel(nextEffect()); VibrationAttributes attrs = createVibrationAttributes(commonOptions); vibrate(Binder.getCallingUid(), SHELL_PACKAGE_NAME, effect, attrs, commonOptions.description, mToken); @@ -1474,8 +1474,8 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { private int runStereo() { CommonOptions commonOptions = new CommonOptions(); - CombinedVibrationEffect.SyncedCombination combination = - CombinedVibrationEffect.startSynced(); + CombinedVibration.ParallelCombination combination = + CombinedVibration.startParallel(); while ("-v".equals(getNextOption())) { int vibratorId = Integer.parseInt(getNextArgRequired()); combination.addVibrator(vibratorId, nextEffect()); @@ -1488,8 +1488,8 @@ public class VibratorManagerService extends IVibratorManagerService.Stub { private int runSequential() { CommonOptions commonOptions = new CommonOptions(); - CombinedVibrationEffect.SequentialCombination combination = - CombinedVibrationEffect.startSequential(); + CombinedVibration.SequentialCombination combination = + CombinedVibration.startSequential(); while ("-v".equals(getNextOption())) { int vibratorId = Integer.parseInt(getNextArgRequired()); combination.addNext(vibratorId, nextEffect()); diff --git a/services/tests/servicestests/src/com/android/server/vibrator/InputDeviceDelegateTest.java b/services/tests/servicestests/src/com/android/server/vibrator/InputDeviceDelegateTest.java index 3ca90603e9d2..3f9caa95df4a 100644 --- a/services/tests/servicestests/src/com/android/server/vibrator/InputDeviceDelegateTest.java +++ b/services/tests/servicestests/src/com/android/server/vibrator/InputDeviceDelegateTest.java @@ -34,7 +34,7 @@ import android.content.ContextWrapper; import android.hardware.input.IInputDevicesChangedListener; import android.hardware.input.IInputManager; import android.hardware.input.InputManager; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.Handler; import android.os.Process; import android.os.VibrationAttributes; @@ -67,8 +67,8 @@ public class InputDeviceDelegateTest { private static final String REASON = "some reason"; private static final VibrationAttributes VIBRATION_ATTRIBUTES = new VibrationAttributes.Builder().setUsage(VibrationAttributes.USAGE_ALARM).build(); - private static final CombinedVibrationEffect SYNCED_EFFECT = - CombinedVibrationEffect.createSynced(VibrationEffect.createOneShot(100, 255)); + private static final CombinedVibration SYNCED_EFFECT = + CombinedVibration.createParallel(VibrationEffect.createOneShot(100, 255)); @Rule public MockitoRule rule = MockitoJUnit.rule(); diff --git a/services/tests/servicestests/src/com/android/server/vibrator/VibrationThreadTest.java b/services/tests/servicestests/src/com/android/server/vibrator/VibrationThreadTest.java index c439b9c56e74..5743982171cb 100644 --- a/services/tests/servicestests/src/com/android/server/vibrator/VibrationThreadTest.java +++ b/services/tests/servicestests/src/com/android/server/vibrator/VibrationThreadTest.java @@ -34,7 +34,7 @@ import static org.mockito.Mockito.when; import android.hardware.vibrator.Braking; import android.hardware.vibrator.IVibrator; import android.hardware.vibrator.IVibratorManager; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.IBinder; import android.os.PowerManager; import android.os.Process; @@ -109,7 +109,7 @@ public class VibrationThreadTest { public void vibrate_noVibrator_ignoresVibration() { mVibratorProviders.clear(); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.get(VibrationEffect.EFFECT_CLICK)); VibrationThread thread = startThreadAndDispatcher(vibrationId, effect); waitForCompletion(thread); @@ -122,7 +122,7 @@ public class VibrationThreadTest { @Test public void vibrate_missingVibrators_ignoresVibration() { long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSequential() + CombinedVibration effect = CombinedVibration.startSequential() .addNext(2, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addNext(3, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) .combine(); @@ -311,7 +311,7 @@ public class VibrationThreadTest { long vibrationId = 1; VibrationEffect fallback = VibrationEffect.createOneShot(10, 100); - Vibration vibration = createVibration(vibrationId, CombinedVibrationEffect.createSynced( + Vibration vibration = createVibration(vibrationId, CombinedVibration.createParallel( VibrationEffect.get(VibrationEffect.EFFECT_CLICK))); vibration.addFallback(VibrationEffect.EFFECT_CLICK, fallback); VibrationThread thread = startThreadAndDispatcher(vibration); @@ -498,7 +498,7 @@ public class VibrationThreadTest { mVibratorProviders.get(1).setSupportedEffects(VibrationEffect.EFFECT_TICK); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(VIBRATOR_ID, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) .addVibrator(2, VibrationEffect.get(VibrationEffect.EFFECT_TICK)) .combine(); @@ -524,7 +524,7 @@ public class VibrationThreadTest { mVibratorProviders.get(3).setSupportedEffects(VibrationEffect.EFFECT_CLICK); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.get(VibrationEffect.EFFECT_CLICK)); VibrationThread thread = startThreadAndDispatcher(vibrationId, effect); waitForCompletion(thread); @@ -557,7 +557,7 @@ public class VibrationThreadTest { VibrationEffect composed = VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK) .compose(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.createOneShot(10, 100)) .addVibrator(3, VibrationEffect.createWaveform( @@ -603,7 +603,7 @@ public class VibrationThreadTest { VibrationEffect composed = VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK) .compose(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSequential() + CombinedVibration effect = CombinedVibration.startSequential() .addNext(3, VibrationEffect.get(VibrationEffect.EFFECT_CLICK), /* delay= */ 50) .addNext(1, VibrationEffect.createOneShot(10, 100), /* delay= */ 50) .addNext(2, composed, /* delay= */ 50) @@ -652,7 +652,7 @@ public class VibrationThreadTest { VibrationEffect composed = VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK, 1, 100) .compose(); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced(composed); + CombinedVibration effect = CombinedVibration.createParallel(composed); VibrationThread thread = startThreadAndDispatcher(vibrationId, effect); assertTrue(waitUntil(t -> !mVibratorProviders.get(1).getEffectSegments().isEmpty() @@ -686,7 +686,7 @@ public class VibrationThreadTest { VibrationEffect composed = VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK) .compose(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.createOneShot(10, 100)) .addVibrator(3, VibrationEffect.createWaveform(new long[]{10}, new int[]{100}, -1)) @@ -717,7 +717,7 @@ public class VibrationThreadTest { when(mThreadCallbacks.prepareSyncedVibration(anyLong(), any())).thenReturn(false); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createOneShot(10, 100)) .addVibrator(2, VibrationEffect.createWaveform(new long[]{5}, new int[]{200}, -1)) .combine(); @@ -746,7 +746,7 @@ public class VibrationThreadTest { when(mThreadCallbacks.triggerSyncedVibration(anyLong())).thenReturn(false); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createOneShot(10, 100)) .addVibrator(2, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .combine(); @@ -772,7 +772,7 @@ public class VibrationThreadTest { mVibratorProviders.get(3).setCapabilities(IVibrator.CAP_AMPLITUDE_CONTROL); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createWaveform( new long[]{5, 10, 10}, new int[]{1, 2, 3}, -1)) .addVibrator(2, VibrationEffect.createWaveform( @@ -851,7 +851,7 @@ public class VibrationThreadTest { mVibratorProviders.get(2).setCapabilities(IVibrator.CAP_COMPOSE_EFFECTS); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK, 1f, 100) @@ -885,7 +885,7 @@ public class VibrationThreadTest { mVibratorProviders.get(2).setCapabilities(IVibrator.CAP_AMPLITUDE_CONTROL); long vibrationId = 1; - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createWaveform( new long[]{100, 100}, new int[]{1, 2}, 0)) .addVibrator(2, VibrationEffect.createOneShot(100, 100)) @@ -938,11 +938,11 @@ public class VibrationThreadTest { } private VibrationThread startThreadAndDispatcher(long vibrationId, VibrationEffect effect) { - return startThreadAndDispatcher(vibrationId, CombinedVibrationEffect.createSynced(effect)); + return startThreadAndDispatcher(vibrationId, CombinedVibration.createParallel(effect)); } private VibrationThread startThreadAndDispatcher(long vibrationId, - CombinedVibrationEffect effect) { + CombinedVibration effect) { return startThreadAndDispatcher(createVibration(vibrationId, effect)); } @@ -982,7 +982,7 @@ public class VibrationThreadTest { mTestLooper.dispatchAll(); } - private Vibration createVibration(long id, CombinedVibrationEffect effect) { + private Vibration createVibration(long id, CombinedVibration effect) { return new Vibration(mVibrationToken, (int) id, effect, ATTRS, UID, PACKAGE_NAME, "reason"); } diff --git a/services/tests/servicestests/src/com/android/server/vibrator/VibratorManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/vibrator/VibratorManagerServiceTest.java index b0e8ef0bdffe..e367b7448299 100644 --- a/services/tests/servicestests/src/com/android/server/vibrator/VibratorManagerServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/vibrator/VibratorManagerServiceTest.java @@ -49,7 +49,7 @@ import android.hardware.vibrator.IVibrator; import android.hardware.vibrator.IVibratorManager; import android.media.AudioAttributes; import android.media.AudioManager; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.Handler; import android.os.IBinder; import android.os.IVibratorStateListener; @@ -231,7 +231,7 @@ public class VibratorManagerServiceTest { assertNotNull(service.getVibratorInfo(1)); assertFalse(service.isVibrating(1)); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)); vibrate(service, effect, HAPTIC_FEEDBACK_ATTRS); service.cancelVibrate(service); @@ -343,7 +343,7 @@ public class VibratorManagerServiceTest { service.registerVibratorStateListener(i, listeners[i]); } - vibrate(service, CombinedVibrationEffect.startSynced() + vibrate(service, CombinedVibration.startParallel() .addVibrator(0, VibrationEffect.createOneShot(40, 100)) .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .combine(), ALARM_ATTRS); @@ -361,7 +361,7 @@ public class VibratorManagerServiceTest { mVibratorProviders.get(1).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); mVibratorProviders.get(3).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)); assertTrue(createSystemReadyService().setAlwaysOnEffect( UID, PACKAGE_NAME, 1, effect, ALARM_ATTRS)); @@ -382,7 +382,7 @@ public class VibratorManagerServiceTest { mVibratorProviders.get(2).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); mVibratorProviders.get(4).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.createPredefined(VibrationEffect.EFFECT_TICK)) .addVibrator(3, VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)) @@ -409,7 +409,7 @@ public class VibratorManagerServiceTest { mVibratorProviders.get(1).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); mVibratorProviders.get(3).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)); assertTrue(createSystemReadyService().setAlwaysOnEffect( UID, PACKAGE_NAME, 1, effect, ALARM_ATTRS)); @@ -427,7 +427,7 @@ public class VibratorManagerServiceTest { mockVibrators(1); mVibratorProviders.get(1).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.createOneShot(100, VibrationEffect.DEFAULT_AMPLITUDE)); assertFalse(createSystemReadyService().setAlwaysOnEffect( UID, PACKAGE_NAME, 1, effect, ALARM_ATTRS)); @@ -440,7 +440,7 @@ public class VibratorManagerServiceTest { mockVibrators(1); mVibratorProviders.get(1).setCapabilities(IVibrator.CAP_ALWAYS_ON_CONTROL); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSequential() + CombinedVibration effect = CombinedVibration.startSequential() .addNext(0, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .combine(); assertFalse(createSystemReadyService().setAlwaysOnEffect( @@ -454,9 +454,9 @@ public class VibratorManagerServiceTest { mockVibrators(1); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect mono = CombinedVibrationEffect.createSynced( + CombinedVibration mono = CombinedVibration.createParallel( VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)); - CombinedVibrationEffect stereo = CombinedVibrationEffect.startSynced() + CombinedVibration stereo = CombinedVibration.startParallel() .addVibrator(0, VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)) .combine(); assertFalse(service.setAlwaysOnEffect(UID, PACKAGE_NAME, 1, mono, ALARM_ATTRS)); @@ -624,7 +624,7 @@ public class VibratorManagerServiceTest { setUserSetting(Settings.System.VIBRATE_INPUT_DEVICES, 1); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced( + CombinedVibration effect = CombinedVibration.createParallel( VibrationEffect.createOneShot(10, 10)); vibrate(service, effect, ALARM_ATTRS); verify(mIInputManagerMock).vibrateCombined(eq(1), eq(effect), any()); @@ -680,7 +680,7 @@ public class VibratorManagerServiceTest { VibrationEffect composed = VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK, 1, 100) .compose(); - CombinedVibrationEffect effect = CombinedVibrationEffect.createSynced(composed); + CombinedVibration effect = CombinedVibration.createParallel(composed); // Wait for vibration to start, it should finish right away with trigger callback. vibrate(service, effect, ALARM_ATTRS); @@ -712,7 +712,7 @@ public class VibratorManagerServiceTest { mVibratorProviders.get(2).setCapabilities(IVibrator.CAP_COMPOSE_EFFECTS); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.startComposition() .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK) @@ -738,7 +738,7 @@ public class VibratorManagerServiceTest { fakeVibrator1.setSupportedEffects(VibrationEffect.EFFECT_CLICK); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .addVibrator(2, VibrationEffect.createOneShot(10, 100)) .combine(); @@ -758,7 +758,7 @@ public class VibratorManagerServiceTest { when(mNativeWrapperMock.prepareSynced(any())).thenReturn(false); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createOneShot(10, 50)) .addVibrator(2, VibrationEffect.createOneShot(10, 100)) .combine(); @@ -779,7 +779,7 @@ public class VibratorManagerServiceTest { when(mNativeWrapperMock.triggerSynced(anyLong())).thenReturn(false); VibratorManagerService service = createSystemReadyService(); - CombinedVibrationEffect effect = CombinedVibrationEffect.startSynced() + CombinedVibration effect = CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createOneShot(10, 50)) .addVibrator(2, VibrationEffect.createOneShot(10, 100)) .combine(); @@ -809,7 +809,7 @@ public class VibratorManagerServiceTest { fakeVibrator.setSupportedEffects(VibrationEffect.EFFECT_CLICK); VibratorManagerService service = createSystemReadyService(); - vibrate(service, CombinedVibrationEffect.startSequential() + vibrate(service, CombinedVibration.startSequential() .addNext(1, VibrationEffect.createOneShot(20, 100)) .combine(), NOTIFICATION_ATTRS); assertTrue(waitUntil(s -> fakeVibrator.getEffectSegments().size() == 1, @@ -822,7 +822,7 @@ public class VibratorManagerServiceTest { assertTrue(waitUntil(s -> fakeVibrator.getEffectSegments().size() == 3, service, TEST_TIMEOUT_MILLIS)); - vibrate(service, CombinedVibrationEffect.startSynced() + vibrate(service, CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.get(VibrationEffect.EFFECT_CLICK)) .combine(), ALARM_ATTRS); assertTrue(waitUntil(s -> fakeVibrator.getEffectSegments().size() == 4, @@ -853,7 +853,7 @@ public class VibratorManagerServiceTest { mockVibrators(1, 2); VibratorManagerService service = createSystemReadyService(); vibrate(service, - CombinedVibrationEffect.startSynced() + CombinedVibration.startParallel() .addVibrator(1, VibrationEffect.createOneShot(1000, 100)) .combine(), HAPTIC_FEEDBACK_ATTRS); @@ -941,10 +941,10 @@ public class VibratorManagerServiceTest { private void vibrate(VibratorManagerService service, VibrationEffect effect, VibrationAttributes attrs) { - vibrate(service, CombinedVibrationEffect.createSynced(effect), attrs); + vibrate(service, CombinedVibration.createParallel(effect), attrs); } - private void vibrate(VibratorManagerService service, CombinedVibrationEffect effect, + private void vibrate(VibratorManagerService service, CombinedVibration effect, VibrationAttributes attrs) { service.vibrate(UID, PACKAGE_NAME, effect, attrs, "some reason", service); } diff --git a/tests/permission/src/com/android/framework/permission/tests/VibratorManagerServicePermissionTest.java b/tests/permission/src/com/android/framework/permission/tests/VibratorManagerServicePermissionTest.java index fe6854316133..7cd2c23162fb 100644 --- a/tests/permission/src/com/android/framework/permission/tests/VibratorManagerServicePermissionTest.java +++ b/tests/permission/src/com/android/framework/permission/tests/VibratorManagerServicePermissionTest.java @@ -23,7 +23,7 @@ import static junit.framework.Assert.fail; import android.Manifest; import android.content.Context; import android.os.Binder; -import android.os.CombinedVibrationEffect; +import android.os.CombinedVibration; import android.os.IVibratorManagerService; import android.os.IVibratorStateListener; import android.os.Process; @@ -50,8 +50,8 @@ import org.junit.runners.JUnit4; public class VibratorManagerServicePermissionTest { private static final String PACKAGE_NAME = "com.android.framework.permission.tests"; - private static final CombinedVibrationEffect EFFECT = - CombinedVibrationEffect.createSynced( + private static final CombinedVibration EFFECT = + CombinedVibration.createParallel( VibrationEffect.createOneShot(100, VibrationEffect.DEFAULT_AMPLITUDE)); private static final VibrationAttributes ATTRS = new VibrationAttributes.Builder() .setUsage(VibrationAttributes.USAGE_ALARM) -- cgit v1.2.3-59-g8ed1b