os/cts/VibratorManagerTest.java

/*
 * Copyright (C) 2021 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.cts;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;

import static org.junit.Assume.assumeTrue;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;

import android.content.Context;
import android.os.CombinedVibration;
import android.os.SystemClock;
import android.os.VibrationAttributes;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.os.Vibrator.OnVibratorStateChangedListener;
import android.os.VibratorManager;
import android.provider.Settings;
import android.util.SparseArray;

import androidx.test.filters.LargeTest;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import com.android.compatibility.common.util.AdoptShellPermissionsRule;

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;

import java.util.Arrays;

@RunWith(AndroidJUnit4.class)
public class VibratorManagerTest {

    @Rule
    public final AdoptShellPermissionsRule mAdoptShellPermissionsRule =
            new AdoptShellPermissionsRule(
                    InstrumentationRegistry.getInstrumentation().getUiAutomation(),
                    android.Manifest.permission.ACCESS_VIBRATOR_STATE,
                    android.Manifest.permission.WRITE_SETTINGS);

    @Rule
    public final MockitoRule mMockitoRule = MockitoJUnit.rule();

    private static final long CALLBACK_TIMEOUT_MILLIS = 5_000;
    private static final VibrationAttributes VIBRATION_ATTRIBUTES =
            new VibrationAttributes.Builder()
                    .setUsage(VibrationAttributes.USAGE_TOUCH)
                    .build();

    /**
     * These listeners are used for test helper methods like asserting it starts/stops vibrating.
     * It's not strongly required that the interactions with these mocks are validated by all tests.
     */
    private final SparseArray<OnVibratorStateChangedListener> mStateListeners = new SparseArray<>();

    private VibratorManager mVibratorManager;

    @Before
    public void setUp() {
        Context context = InstrumentationRegistry.getInstrumentation().getContext();
        Settings.System.putInt(context.getContentResolver(), Settings.System.VIBRATE_ON, 1);

        mVibratorManager = context.getSystemService(VibratorManager.class);
        for (int vibratorId : mVibratorManager.getVibratorIds()) {
            OnVibratorStateChangedListener listener = mock(OnVibratorStateChangedListener.class);
            mVibratorManager.getVibrator(vibratorId).addVibratorStateListener(listener);
            mStateListeners.put(vibratorId, listener);
            // Adding a listener to the Vibrator should trigger the callback once with the current
            // vibrator state, so reset mocks to clear it for tests.
            assertVibratorStateChangesTo(vibratorId, false);
            clearInvocations(listener);
        }
    }

    @After
    public void cleanUp() {
        // Clearing invocations so we can use these listeners to wait for the vibrator to
        // asynchronously cancel the ongoing vibration, if any was left pending by a test.
        for (int i = 0; i < mStateListeners.size(); i++) {
            clearInvocations(mStateListeners.valueAt(i));
        }
        mVibratorManager.cancel();

        for (int i = 0; i < mStateListeners.size(); i++) {
            int vibratorId = mStateListeners.keyAt(i);

            // Wait for cancel to take effect, if device is still vibrating.
            if (mVibratorManager.getVibrator(vibratorId).isVibrating()) {
                assertStopsVibrating(vibratorId);
            }

            // Remove all listeners added by the tests.
            mVibratorManager.getVibrator(vibratorId).removeVibratorStateListener(
                    mStateListeners.valueAt(i));
        }
    }

    @Test
    public void testGetVibratorIds() {
        // Just make sure it doesn't crash or return null when this is called; we don't really have
        // a way to test which vibrators will be returned.
        assertThat(mVibratorManager.getVibratorIds()).isNotNull();
        assertThat(mVibratorManager.getVibratorIds()).asList().containsNoDuplicates();
    }

    @Test
    public void testGetNonExistentVibratorId() {
        int missingId = Arrays.stream(mVibratorManager.getVibratorIds()).max().orElse(0) + 1;
        Vibrator vibrator = mVibratorManager.getVibrator(missingId);
        assertThat(vibrator).isNotNull();
        assertThat(vibrator.hasVibrator()).isFalse();
    }

    @Test
    public void testGetDefaultVibratorIsSameAsVibratorService() {
        // Note that VibratorTest parameterization relies on these two vibrators being identical.
        // It only runs vibrator tests on the result of one of the APIs.
        Vibrator systemVibrator =
                InstrumentationRegistry.getInstrumentation().getContext().getSystemService(
                        Vibrator.class);
        assertThat(mVibratorManager.getDefaultVibrator()).isSameInstanceAs(systemVibrator);
    }

    @Test
    public void testCancel() {
        mVibratorManager.vibrate(CombinedVibration.createParallel(
                VibrationEffect.createOneShot(10_000, VibrationEffect.DEFAULT_AMPLITUDE)));
        assertStartsVibrating();

        mVibratorManager.cancel();
        assertStopsVibrating();
    }

    @LargeTest
    @Test
    public void testCombinedVibrationOneShotStartsAndFinishesVibration() {
        VibrationEffect oneShot =
                VibrationEffect.createOneShot(300, VibrationEffect.DEFAULT_AMPLITUDE);
        mVibratorManager.vibrate(CombinedVibration.createParallel(oneShot));
        assertStartsThenStopsVibrating(300);
    }

    @Test
    public void testCombinedVibrationOneShotMaxAmplitude() {
        VibrationEffect oneShot = VibrationEffect.createOneShot(500, 255 /* Max amplitude */);
        mVibratorManager.vibrate(CombinedVibration.createParallel(oneShot));
        assertStartsVibrating();

        mVibratorManager.cancel();
        assertStopsVibrating();
    }

    @Test
    public void testCombinedVibrationOneShotMinAmplitude() {
        VibrationEffect oneShot = VibrationEffect.createOneShot(100, 1 /* Min amplitude */);
        mVibratorManager.vibrate(CombinedVibration.createParallel(oneShot),
                VIBRATION_ATTRIBUTES);
        assertStartsVibrating();
    }

    @LargeTest
    @Test
    public void testCombinedVibrationWaveformStartsAndFinishesVibration() {
        final long[] timings = new long[]{100, 200, 300, 400, 500};
        final int[] amplitudes = new int[]{64, 128, 255, 128, 64};
        VibrationEffect waveform = VibrationEffect.createWaveform(timings, amplitudes, -1);
        mVibratorManager.vibrate(CombinedVibration.createParallel(waveform));
        assertStartsThenStopsVibrating(1500);
    }

    @LargeTest
    @Test
    public void testCombinedVibrationWaveformRepeats() {
        final long[] timings = new long[]{100, 200, 300, 400, 500};
        final int[] amplitudes = new int[]{64, 128, 255, 128, 64};
        VibrationEffect waveform = VibrationEffect.createWaveform(timings, amplitudes, 0);
        mVibratorManager.vibrate(CombinedVibration.createParallel(waveform));
        assertStartsVibrating();

        SystemClock.sleep(2000);
        int[] vibratorIds = mVibratorManager.getVibratorIds();
        for (int vibratorId : vibratorIds) {
            assertWithMessage(
                    "Expected repeating parallel waveform to continue vibrating on vibrator %s"
                            + " after initial duration", vibratorId)
                    .that(mVibratorManager.getVibrator(vibratorId).isVibrating()).isTrue();
        }

        mVibratorManager.cancel();
        assertStopsVibrating();
    }

    @Test
    public void testCombinedVibrationTargetingSingleVibrator() {
        int[] vibratorIds = mVibratorManager.getVibratorIds();
        assumeTrue(vibratorIds.length >= 2);

        VibrationEffect oneShot =
                VibrationEffect.createOneShot(10_000, VibrationEffect.DEFAULT_AMPLITUDE);

        // Vibrate each vibrator in turn, and assert that all the others are off.
        for (int vibratorId : vibratorIds) {
            Vibrator vibrator = mVibratorManager.getVibrator(vibratorId);
            mVibratorManager.vibrate(
                    CombinedVibration.startParallel()
                            .addVibrator(vibratorId, oneShot)
                            .combine());
            assertStartsVibrating(vibratorId);

            for (int otherVibratorId : vibratorIds) {
                if (otherVibratorId != vibratorId) {
                    assertWithMessage(
                            "Expected vibrator %s not vibrating when combined vibration started"
                                    + " on vibrator %s", otherVibratorId, vibratorId)
                            .that(mVibratorManager.getVibrator(otherVibratorId).isVibrating())
                            .isFalse();
                }
            }

            vibrator.cancel();
            assertStopsVibrating(vibratorId);
        }
    }

    private void assertStartsThenStopsVibrating(long duration) {
        for (int i = 0; i < mStateListeners.size(); i++) {
            assertStartsVibrating(mStateListeners.keyAt(i));
        }
        SystemClock.sleep(duration);
        assertStopsVibrating();
    }

    private void assertStartsVibrating() {
        assertVibratorStateChangesTo(true);
    }

    private void assertStartsVibrating(int vibratorId) {
        assertVibratorStateChangesTo(vibratorId, true);
    }

    private void assertStopsVibrating() {
        assertVibratorStateChangesTo(false);
    }

    private void assertStopsVibrating(int vibratorId) {
        assertVibratorStateChangesTo(vibratorId, false);
    }

    private void assertVibratorStateChangesTo(boolean expected) {
        for (int i = 0; i < mStateListeners.size(); i++) {
            assertVibratorStateChangesTo(mStateListeners.keyAt(i), expected);
        }
    }

    private void assertVibratorStateChangesTo(int vibratorId, boolean expected) {
        OnVibratorStateChangedListener listener = mStateListeners.get(vibratorId);
        verify(listener,
                timeout(CALLBACK_TIMEOUT_MILLIS).atLeastOnce().description(
                        "Vibrator " + vibratorId + " expected to turn "
                                + (expected ? "on" : "off")))
                .onVibratorStateChanged(eq(expected));
    }
}