Comment faire vibrer un appareil Android?


499

J'ai écrit une application Android. Maintenant, je veux faire vibrer l'appareil lorsqu'une certaine action se produit. Comment puis-je faire ceci?

Réponses:


989

Essayer:

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);
}

Remarque:

N'oubliez pas d'inclure l'autorisation dans le fichier AndroidManifest.xml:

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

3
Existe-t-il un moyen d'annuler les vibrations de tout le téléphone? Merci!
Javi

14
@joshsvoss C'est 500 millisecondes, ce qui ne représente qu'une demi-seconde. Consultez google docs. developer.android.com/reference/android/os/Vibrator.html
cjayem13

5
cela me donne: le contexte ne peut pas être résolu ou n'est pas un champ ..?! quel est le problème
McLan

3
vibrate est désormais obsolète. Utilisez plutôt la solution de Hitesh Sahu.
Ray Li

2
Cette méthode est déconseillée au niveau de l'API 26. Utilisez-la à la vibrate(VibrationEffect)place.
Timo Bähr

651

Accorder l'autorisation de vibration

Avant de commencer à implémenter un code de vibration, vous devez donner à votre application la permission de vibrer:

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

Assurez-vous d'inclure cette ligne dans votre fichier AndroidManifest.xml.

Importer la bibliothèque de vibrations

La plupart des IDE le feront pour vous, mais voici l'instruction d'importation si la vôtre ne le fait pas:

 import android.os.Vibrator;

Assurez-vous que dans l'activité où vous souhaitez que la vibration se produise.

Comment vibrer pendant un temps donné

Dans la plupart des cas, vous souhaiterez faire vibrer l'appareil pendant une courte période de temps prédéterminée. Vous pouvez y parvenir en utilisant la vibrate(long milliseconds)méthode. Voici un petit exemple:

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

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

Voilà, c'est simple!

Comment vibrer indéfiniment

Il se peut que vous souhaitiez que l'appareil continue de vibrer indéfiniment. Pour cela, nous utilisons la vibrate(long[] pattern, int repeat)méthode:

// 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);

Lorsque vous êtes prêt à arrêter la vibration, appelez simplement la cancel()méthode:

v.cancel();

Comment utiliser les modèles de vibration

Si vous voulez une vibration plus sur mesure, vous pouvez essayer de créer vos propres modèles de vibration:

// 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);

Des vibrations plus complexes

Il existe plusieurs SDK qui offrent une gamme plus complète de commentaires haptiques. L'une que j'utilise pour les effets spéciaux est la plate-forme de développement Haptic d'Immersion pour Android .

Dépannage

Si votre appareil ne vibre pas, assurez-vous d'abord qu'il peut vibrer:

// 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");
}

Deuxièmement, assurez-vous d'avoir donné à votre application la permission de vibrer! Reportez-vous au premier point.


26
Excellente réponse, même si je me méfierais de jouer une vibration indéfiniment. Soyez responsable lorsque vous utilisez cette fonction!
Dave

4
Excellente réponse, mais une chose. Lorsque vous dites «le 0» signifie ici répéter indéfiniment », bien que vrai, est un peu trompeur. Ce nombre est l'indice du tableau de motifs auquel le motif commencera lors de la répétition.
aaronvargas

1
@aaronvargas Bon point, bien que cela dépasse la portée de ce que la plupart des gens essaient de réaliser. Je suis allé pour une explication simple :)
Liam George Betsworth

@Liam George Betsworth Comment puis-je vibrer même si le mobile est en mode silencieux? S'il vous plaît.
Parthi

1
Le lien d'immersion est en panne et je ne le trouve pas sur archive.org :(
looper

73

La méthode de vibration (intervalle) de la mise à jour 2017 est déconseillée avec Android-O (API 8.0)

Pour prendre en charge toutes les versions d'Android, utilisez cette méthode.

// 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)
    }
}

2
Nous n'avons pas besoin d'une autorisation d'exécution pour Vibration. La vibration n'est pas une autorisation dangereuse, elle ne doit donc être déclarée que dans le manifeste. [ developer.android.com/guide/topics/permissions/…
Roon13

La documentation de @BugsHappen a été déplacée. Le mettra à jour ou le supprimera.
Roon13

La seule chose que j'ajouterais, c'est que si vous l'utilisez dans une activité et que vous n'avez pas de variable de contexte spécifique, remplacez-la getSystemServiceparthis.getContext().getSystemService
DrMcCleod

vous monsieur a gagné un vote positif à cause de ce nom de fonction, touché
Starwave

18

Les réponses ci-dessus sont parfaites. Cependant, je voulais faire vibrer mon application exactement deux fois sur le bouton et cette petite information manque ici, d'où la publication pour de futurs lecteurs comme moi. :)

Nous devons suivre comme mentionné ci-dessus et le seul changement sera dans le modèle de vibration comme ci-dessous,

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

Cela vibrera exactement deux fois . Comme nous le savons déjà

  1. 0 est pour le retard
  2. 100 dit vibrer pendant 100 ms pour la première fois
  3. vient ensuite un retard de 1000 ms
  4. et postez cette vibration à nouveau pendant 300 ms

On peut continuer encore et encore en mentionnant le retard et les vibrations (par exemple 0, 100, 1000, 300, 1000, 300 pour 3 vibrations et ainsi de suite ..) mais rappelez-vous que le mot de @ Dave l'utilise de manière responsable. :)

Notez également ici que le paramètre de répétition est défini sur -1, ce qui signifie que la vibration se produira exactement comme mentionné dans le motif . :)


Pourquoi -1 signifie que la vibration se produira exactement comme mentionné dans le motif? Merci!
Ruchir Baronia

@Rich Veuillez vous référer à ma réponse. Le «-1» est l'indice auquel la vibration tentera de se répéter, après avoir suivi le modèle pour la première fois. '-1' est hors limites, donc la vibration ne se répète pas.
Liam George Betsworth

@Rich - Liam George Betsworth a raison. Les documents Android disent: pour que le motif se répète, passez l'index dans le tableau de motifs à partir duquel commencer la répétition, ou -1 pour désactiver la répétition. Lien - developer.android.com/reference/android/os/… , int)
Atul O Holic

14

J'ai eu du mal à comprendre comment procéder sur ma première mise en œuvre - assurez-vous que vous disposez des éléments suivants:

1) Votre appareil prend en charge les vibrations (ma tablette Samsung ne fonctionnait pas, j'ai donc revérifié le code - le code d'origine fonctionnait parfaitement sur mon CM Touchpad

2) Vous avez déclaré au-dessus du niveau d'application dans votre fichier AndroidManifest.xml pour donner au code l'autorisation de s'exécuter.

3) Ont importé les deux éléments suivants dans votre MainActivity.java avec les autres importations: import android.content.Context; importer android.os.Vibrator;

4) Appelez votre vibration (discuté en détail dans ce fil déjà) - Je l'ai fait dans une fonction distincte et appelez cela dans le code à d'autres points - selon ce que vous voulez utiliser pour appeler la vibration, vous aurez peut-être besoin d'une image ( Android: clic long sur un bouton -> effectuer des actions ) ou un écouteur de bouton, ou un objet cliquable tel que défini en XML ( Image cliquable - android ):

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

10

Vibrer sans utiliser l'autorisation

Si vous souhaitez simplement faire vibrer l'appareil une fois pour fournir un retour sur une action de l'utilisateur. Vous pouvez utiliser la performHapticFeedback()fonction d'un View. Cela n'a pas besoin de l' VIBRATEautorisation pour être déclaré dans le manifeste.

Utilisez la fonction suivante en tant que fonction de niveau supérieur dans une classe courante comme Utils.kt de votre projet:

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

Et puis utilisez-le n'importe où dans votre Fragmentou Activitycomme suit:

vibrate(requireView())

Aussi simple que cela!


2
Bonne et simple solution!
VAdaihiep

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

doit être ajouté à l'intérieur de la <manifest>balise et à l'extérieur de la <application>balise.


4

J'utilise la méthode utils suivante:

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

Ajoutez l'autorisation suivante au fichier AndroidManifest

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

Vous pouvez utiliser des méthodes surchargées au cas où vous souhaiteriez utiliser différents types de vibrations (motifs / indéfinis) comme suggéré ci-dessus.


4

La réponse ci-dessus est très correcte mais je donne une étape simple pour le faire:

 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);
  }

Et puis dans votre fichier xml:

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

C'est le moyen le plus simple.


3

Vibrant en motifs / vagues :

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);
}

Plus

L'autorisation nécessaire dans AndroidManifest.xml:

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

3

Mise à jour Kotlin pour plus de sécurité de type

Utilisez-la comme fonction de niveau supérieur dans une classe courante de votre projet telle que 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)
        }
    }
}

Et puis appelez-le n'importe où dans votre code comme suit:

vibrateDevice(requireContext())

Explication

L'utilisation Vibrator::class.javaest plus sûre de type que l'utilisation de Stringconstantes.

Nous vérifions la vibratornullité à l'aide let { }, car si la vibration n'est pas disponible pour l'appareil, elle le vibratorsera null.

Il est correct de supprimer la dépréciation dans la elseclause, car l'avertissement provient d'un SDK plus récent.

Nous n'avons pas besoin de demander la permission lors de l'exécution pour utiliser les vibrations. Mais nous devons le déclarer AndroidManifest.xmlcomme suit:

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

2

Utilisez ceci:

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);
     }

Remarque:

N'oubliez pas d'inclure l'autorisation dans le fichier AndroidManifest.xml:

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

1

Vous pouvez faire vibrer l'appareil et son travail

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

L'autorisation est nécessaire mais pas sur l'autorisation d'exécution requise

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

cette solution est déconseillée
BekaBot
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.