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

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"/>

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.

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

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

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

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!

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

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.

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.

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"/>

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"/>

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"/>

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"/>