Conceder Permiso de vibración

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

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

Asegúrate de incluir esta línea en tu AndroidManifest.archivo xml.

Importa la Biblioteca de Vibraciones

La mayoría de los IDE harán esto 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 las circunstancias, querrá vibrar el dispositivo durante un período de tiempo corto y predeterminado. Puede lograr esto usando el método vibrate(long milliseconds). He aquí 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

Puede ser el caso de que desee que el dispositivo continúe vibrando indefinidamente. Para esto, usamos el método vibrate(long[] pattern, int repeat):

// 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és listo para detener la vibración, solo llama el método cancel():

v.cancel();

Cómo usar Patrones de Vibración

Si quieres una vibración más personalizada, puedes intentar crear tus propios patrones de vibración: {[13]]}

// 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 retroalimentación háptica. Uno 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 haga seguro que puede 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, por favor asegúrese de que usted ha dado a su solicitud el permiso para vibrar! Refiérase al primer punto.

Actualización 2017 vibrar (intervalo) método 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);
    }
}

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

1) Su dispositivo es compatible con la vibración (mi tableta Samsung no funcionó, así que seguí revisando el código-el código original funcionó perfectamente en mi CM Touchpad

2) Has declarado por encima del nivel de aplicación en tu AndroidManifest.archivo xml para dar permiso de ejecución al código.

3) Ha importado ambos de los siguientes en su MainActivity.java con el otro importar: importar android.contenido.Contexto; importar android.operativo.Vibrador;

4) Llame a su vibración (discutido ampliamente en este hilo ya) - Lo hice en una función separada y llamar a esto en el código en otros puntos - dependiendo de lo que desea utilizar para llamar a la vibración que puede necesitar una imagen (Android: haga clic largo en un botón -> realizar acciones) o un oyente de botón, o un objeto clicable como se define en XML ():

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

Las respuestas anteriores son perfectas. Sin embargo, quería 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, publicar 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, 0 es para delay, 100 dice vibrar para 100MS por primera vez, luego viene el delay de 1000MS y el post que vibra nuevamente para 300 MS

Uno puede seguir y seguir mencionando retardo y vibración alternativamente (e. g. 0, 100, 1000, 300, 1000, 300 para 3 vibraciones y así sucesivamente..) pero recuerda la palabra de @ Dave úsala 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. :)

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

Debe añadirse dentro de la etiqueta <manifest> y fuera de la etiqueta <application>.

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 su archivo xml:

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

Esa es la manera más fácil.

Utilizo el siguiente método utils:

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 usar métodos sobrecargados en caso de que desee usar diferentes tipos de vibraciones (patrones / indefinidos) como se sugirió anteriormente.

Usa esto:

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 olvides incluir permisos en AndroidManifest.archivo xml:

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