Escribí una aplicación de Android. Ahora, quiero hacer que el dispositivo vibre cuando ocurra cierta acción. ¿Cómo puedo hacer esto?

Tratar:

import android.os.Vibrator;
...
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
// Vibrate for 500 milliseconds
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    v.vibrate(VibrationEffect.createOneShot(500, VibrationEffect.DEFAULT_AMPLITUDE));
} else {
    //deprecated in API 26 
    v.vibrate(500);
}

Nota:

No olvide incluir el permiso en el archivo AndroidManifest.xml:

<uses-permission android:name="android.permission.VIBRATE"/>

Conceder permiso de vibración

Antes de comenzar a implementar cualquier código de vibración, debe otorgar a su aplicación el permiso para vibrar:

<uses-permission android:name="android.permission.VIBRATE"/>

Asegúrese de incluir esta línea en su archivo AndroidManifest.xml.

Importar la biblioteca de vibraciones

La mayoría de los IDEs lo harán por usted, pero aquí está la declaración de importación si la suya no lo hace:

 import android.os.Vibrator;

Asegúrese de esto en la actividad donde desea que ocurra la vibración.

Cómo vibrar por un tiempo dado

En la mayoría de los casos, deseará hacer vibrar el dispositivo durante un período de tiempo corto y predeterminado. Puede lograr esto utilizando el vibrate(long milliseconds)método Aquí hay un ejemplo rápido:

// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

// Vibrate for 400 milliseconds
v.vibrate(400);

Eso es todo, simple!

Cómo vibrar indefinidamente

Es posible que desee que el dispositivo continúe vibrando indefinidamente. Para esto, utilizamos el vibrate(long[] pattern, int repeat)método:

// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

// Start without a delay
// Vibrate for 100 milliseconds
// Sleep for 1000 milliseconds
long[] pattern = {0, 100, 1000};

// The '0' here means to repeat indefinitely
// '0' is actually the index at which the pattern keeps repeating from (the start)
// To repeat the pattern from any other point, you could increase the index, e.g. '1'
v.vibrate(pattern, 0);

Cuando esté listo para detener la vibración, simplemente llame al cancel()método:

v.cancel();

Cómo usar patrones de vibración

Si desea una vibración más personalizada, puede intentar crear sus propios patrones de vibración:

// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

// Start without a delay
// Each element then alternates between vibrate, sleep, vibrate, sleep...
long[] pattern = {0, 100, 1000, 300, 200, 100, 500, 200, 100};

// The '-1' here means to vibrate once, as '-1' is out of bounds in the pattern array
v.vibrate(pattern, -1);

Vibraciones más complejas

Hay varios SDK que ofrecen una gama más completa de comentarios táctiles. Una que uso para efectos especiales es la plataforma de desarrollo háptico de Immersion para Android .

Solución de problemas

Si su dispositivo no vibra, primero asegúrese de que pueda vibrar:

// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

// Output yes if can vibrate, no otherwise
if (v.hasVibrator()) {
    Log.v("Can Vibrate", "YES");
} else {
    Log.v("Can Vibrate", "NO");
}

En segundo lugar, asegúrese de haber otorgado a su aplicación el permiso para vibrar. Refiérase al primer punto.

El método de actualización 2017 de vibración (intervalo) está en desuso con Android-O (API 8.0)

Para admitir todas las versiones de Android, use este método.

// Vibrate for 150 milliseconds
private void shakeItBaby() {
    if (Build.VERSION.SDK_INT >= 26) {
        ((Vibrator) getSystemService(VIBRATOR_SERVICE)).vibrate(VibrationEffect.createOneShot(150, VibrationEffect.DEFAULT_AMPLITUDE));
    } else {
        ((Vibrator) getSystemService(VIBRATOR_SERVICE)).vibrate(150);
    }
}

Kotlin:

// Vibrate for 150 milliseconds
private fun shakeItBaby(context: Context) {
    if (Build.VERSION.SDK_INT >= 26) {
        (context.getSystemService(VIBRATOR_SERVICE) as Vibrator).vibrate(VibrationEffect.createOneShot(150, VibrationEffect.DEFAULT_AMPLITUDE))
    } else {
        (context.getSystemService(VIBRATOR_SERVICE) as Vibrator).vibrate(150)
    }
}

Las respuestas anteriores son perfectas. Sin embargo, quería hacer vibrar mi aplicación exactamente dos veces al hacer clic en el botón y esta pequeña información falta aquí, por lo tanto, la publicación para futuros lectores como yo. :)

Tenemos que seguir como se mencionó anteriormente y el único cambio será en el patrón de vibración como se muestra a continuación,

long[] pattern = {0, 100, 1000, 300};
v.vibrate(pattern, -1); //-1 is important

Esto vibrará exactamente dos veces . Como ya sabemos

1. 0 es por retraso
2. 100 dice vibre por 100 ms por primera vez
3. a continuación viene Luego retraso de 1000ms
4. y publicar eso vibrar de nuevo por 300 ms

Uno puede seguir y mencionar el retraso y la vibración alternativamente (por ejemplo, 0, 100, 1000, 300, 1000, 300 para 3 vibraciones, etc.), pero recuerde que la palabra de @ Dave lo usa responsablemente. :)

También tenga en cuenta aquí que el parámetro de repetición se establece en -1, lo que significa que la vibración ocurrirá exactamente como se menciona en el patrón . :)

Me costó entender cómo hacer esto en mi primera implementación; asegúrese de tener lo siguiente:

1) Su dispositivo admite vibración (mi tableta Samsung no funcionaba, así que seguí revisando el código; el código original funcionó perfectamente en mi panel táctil CM

2) Ha declarado por encima del nivel de aplicación en su archivo AndroidManifest.xml para dar permiso al código para ejecutarse.

3) Ha importado los dos siguientes en su MainActivity.java con las otras importaciones: import android.content.Context; importar android.os.Vibrator;

4) Llame a su vibración (ya se discutió ampliamente en este hilo): lo hice en una función separada y llamo a esto en el código en otros puntos, dependiendo de lo que quiera usar para llamar a la vibración, puede necesitar una imagen ( Android: clic largo en un botón -> realizar acciones ) o escucha de botón, o un objeto en el que se puede hacer clic como se define en XML ( imagen en la que se puede hacer clic - android ):

 public void vibrate(int duration)
 {
    Vibrator vibs = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
    vibs.vibrate(duration);    
 }

Vibrar sin usar permiso

Si desea simplemente hacer vibrar el dispositivo una vez para proporcionar comentarios sobre una acción del usuario. Puedes usar la performHapticFeedback()función de a View. Esto no necesita el VIBRATEpermiso para ser declarado en el manifiesto.

Utilice la siguiente función como función de nivel superior en alguna clase común como Utils.kt de su proyecto:

/**
 * Vibrates the device. Used for providing feedback when the user performs an action.
 */
fun vibrate(view: View) {
    view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS)
}

Y luego úsalo en cualquier lugar de tu Fragmento de la Activitysiguiente manera:

vibrate(requireView())

¡Simple como eso!

<uses-permission android:name="android.permission.VIBRATE"/>

debe agregarse dentro de la <manifest>etiqueta y fuera de la <application>etiqueta.

Yo uso el siguiente método de utilidades:

public static final void vibratePhone(Context context, short vibrateMilliSeconds) {
    Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
    vibrator.vibrate(vibrateMilliSeconds);
}

Agregue el siguiente permiso al archivo AndroidManifest

<uses-permission android:name="android.permission.VIBRATE"/>

Puede utilizar métodos sobrecargados en caso de que desee utilizar diferentes tipos de vibraciones (patrones / indefinidos) como se sugirió anteriormente.

La respuesta anterior es muy correcta, pero estoy dando un paso fácil para hacerlo:

 private static final long[] THREE_CYCLES = new long[] { 100, 1000, 1000,  1000, 1000, 1000 };

  public void longVibrate(View v) 
  {
     vibrateMulti(THREE_CYCLES);
  }

  private void vibrateMulti(long[] cycles) {
      NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); 
      Notification notification = new Notification();

      notification.vibrate = cycles; 
      notificationManager.notify(0, notification);
  }

Y luego en tu archivo xml:

<button android:layout_height="wrap_content" 
        android:layout_width ="wrap_content" 
        android:onclick      ="longVibrate" 
        android:text         ="VibrateThrice">
</button>

Esa es la forma más fácil .

Vibrando en patrones / ondas :

import android.os.Vibrator;
...
// Vibrate for 500ms, pause for 500ms, then start again
private static final long[] VIBRATE_PATTERN = { 500, 500 };

mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    // API 26 and above
    mVibrator.vibrate(VibrationEffect.createWaveform(VIBRATE_PATTERN, 0));
} else {
    // Below API 26
    mVibrator.vibrate(VIBRATE_PATTERN, 0);
}

Más

El permiso necesario en AndroidManifest.xml:

<uses-permission android:name="android.permission.VIBRATE"/>

Actualización de Kotlin para mayor seguridad de tipo

Úselo como una función de nivel superior en alguna clase común de su proyecto, como Utils.kt

// Vibrates the device for 100 milliseconds.
fun vibrateDevice(context: Context) {
    val vibrator = getSystemService(context, Vibrator::class.java)
    vibrator?.let {
        if (Build.VERSION.SDK_INT >= 26) {
            it.vibrate(VibrationEffect.createOneShot(100, VibrationEffect.DEFAULT_AMPLITUDE))
        } else {
            @Suppress("DEPRECATION")
            it.vibrate(100)
        }
    }
}

Y luego llámalo a cualquier parte de tu código de la siguiente manera:

vibrateDevice(requireContext())

Explicación

Usar Vibrator::class.javaes más seguro de tipo que usar Stringconstantes.

Verificamos el vibratoruso de nulabilidad let { }, porque si la vibración no está disponible para el dispositivo, lo vibratorestará null.

Está bien suprimir la degradación en else cláusula, porque la advertencia es de un SDK más reciente.

No necesitamos pedir permiso en tiempo de ejecución para usar la vibración. Pero tenemos que declararlo de la AndroidManifest.xmlsiguiente manera:

<uses-permission android:name="android.permission.VIBRATE"/>

Utilizar este:

import android.os.Vibrator;
     ...
     Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
     // Vibrate for 1000 milliseconds
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            v.vibrate(VibrationEffect.createOneShot(1000,VibrationEffect.DEFAULT_AMPLITUDE));
     }else{
     //deprecated in API 26 
            v.vibrate(1000);
     }

Nota:

No olvide incluir el permiso en el archivo AndroidManifest.xml:

<uses-permission android:name="android.permission.VIBRATE"/>

Puedes vibrar el dispositivo y su trabajo

   Vibrator v = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
           v.vibrate(100);

El permiso es necesario pero no en tiempo de ejecución.

<uses-permission android:name="android.permission.VIBRATE"/>