¿Cómo hacer que un dispositivo Android vibre?

Respuestas:

989

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"/>
Paresh Mayani
fuente
3
¿Hay alguna forma de cancelar la vibración de todo el teléfono? ¡Gracias!
Javi
14
@joshsvoss Son 500 milisegundos, que es solo medio segundo. Echa un vistazo a los documentos de google. developer.android.com/reference/android/os/Vibrator.html
cjayem13
55
me da: el contexto no se puede resolver o no es un campo ..?! cuál es el problema
McLan
3
vibrar ahora está en desuso. Utilice la solución de Hitesh Sahu en su lugar.
Ray Li
2
Este método fue desaprobado en el nivel 26 de API. En su vibrate(VibrationEffect)lugar, úselo.
Timo Bähr
651

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.

Liam George Betsworth
fuente
26
Excelente respuesta, aunque desconfiaría de tocar una vibración indefinidamente. ¡Sea responsable al usar esta función!
Dave
44
Gran respuesta, pero una cosa. Cuando dices 'El' 0 'aquí significa repetir indefinidamente', aunque es cierto, es un poco engañoso. Este número es el índice de la matriz de patrones en el que el patrón comenzará cuando se repita.
aaronvargas
1
@aaronvargas Punto justo, aunque eso está fuera del alcance de lo que la mayoría de la gente está tratando de lograr. Fui por una explicación simple :)
Liam George Betsworth
@Liam George Betsworth ¿Cómo vibro incluso si el móvil está en modo silencioso? Por favor.
Parthi
1
El enlace de inmersión está inactivo y no puedo encontrarlo en archive.org :(
looper
73

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)
    }
}
Hitesh Sahu
fuente
2
No necesitamos permiso de tiempo de ejecución para Vibration. La vibración no es un permiso peligroso, por lo que solo debe declararse en el manifiesto. [ developer.android.com/guide/topics/permissions/…
Roon13
@BugsHappen documentación movida. Lo actualizará o lo eliminará.
Roon13
Lo único que agregaría es que si está usando esto en una Actividad y no tiene una variable de Contexto específica, entonces reemplace getSystemServiceconthis.getContext().getSystemService
DrMcCleod
Señor, ganó un voto a favor porque ese nombre funciona, toque
Starwave
18

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 . :)

Atul O Holic
fuente
¿Por qué -1 significa que la vibración ocurrirá exactamente como se menciona en el patrón? ¡Gracias!
Ruchir Baronia
@ Rich Por favor, consulte mi respuesta. El '-1' es el índice en el que la vibración intentará repetirse, después de seguir el patrón por primera vez. '-1' está fuera de límites, por lo tanto, la vibración no se repite.
Liam George Betsworth el
@Rich - Liam George Betsworth tiene razón. Los documentos de Android dicen: para hacer que el patrón se repita, pase el índice a la matriz de patrones en la que comenzará la repetición, o -1 para desactivar la repetición. Enlace - developer.android.com/reference/android/os/… , int)
Atul O Holic
14

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);    
 }
mklopfer
fuente
10

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!

Yogesh Umesh Vaity
fuente
2
Buena y simple solución!
VAdaihiep
5
<uses-permission android:name="android.permission.VIBRATE"/>

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

Sivagami Nambi
fuente
4

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.

Mahendra Liya
fuente
4

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 .

dondondon
fuente
3

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"/>
Maksim Ivanov
fuente
3

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"/>
Yogesh Umesh Vaity
fuente
2

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"/>
Prakhar Gupta
fuente
1

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"/>
Ahmad
fuente
esta solución está en desuso
BekaBot