Ho scritto un'applicazione Android. Ora, voglio far vibrare il dispositivo quando si verifica una determinata azione. Come posso fare questo?

Provare:

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:

Non dimenticare di includere l'autorizzazione nel file AndroidManifest.xml:

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

Concedere l'autorizzazione alle vibrazioni

Prima di iniziare a implementare qualsiasi codice di vibrazione, devi autorizzare l'applicazione a vibrare:

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

Assicurati di includere questa riga nel tuo file AndroidManifest.xml.

Importa la Libreria vibrazioni

La maggior parte degli IDE lo farà per te, ma ecco la dichiarazione di importazione se il tuo non lo fa:

 import android.os.Vibrator;

Assicurati di farlo nell'attività in cui desideri che avvenga la vibrazione.

Come vibrare per un determinato tempo

Nella maggior parte dei casi, ti consigliamo di far vibrare il dispositivo per un breve periodo di tempo predeterminato. È possibile ottenere ciò utilizzando il vibrate(long milliseconds)metodo Ecco un breve esempio:

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

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

È tutto semplice!

Come vibrare indefinitamente

È possibile che si desideri che il dispositivo continui a vibrare indefinitamente. Per questo, usiamo il vibrate(long[] pattern, int repeat)metodo:

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

Quando sei pronto per fermare la vibrazione, chiama semplicemente il cancel()metodo:

v.cancel();

Come utilizzare i modelli di vibrazione

Se desideri una vibrazione più personalizzata, puoi provare a creare i tuoi schemi di vibrazione:

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

Vibrazioni più complesse

Esistono più SDK che offrono una gamma più completa di feedback tattile. Uno che uso per effetti speciali è Immersion's Haptic Development Platform per Android .

Risoluzione dei problemi

Se il tuo dispositivo non vibra, assicurati innanzitutto che possa vibrare:

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

In secondo luogo, assicurati di aver autorizzato l'applicazione a vibrare! Fare riferimento al primo punto.

Il metodo di vibrazione (intervallo) dell'aggiornamento 2017 è obsoleto con Android-O (API 8.0)

Per supportare tutte le versioni di Android utilizzare questo metodo.

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

Le risposte sopra sono perfette. Tuttavia, volevo far vibrare la mia app esattamente due volte con un clic sul pulsante e queste piccole informazioni mancano qui, quindi pubblicando per futuri lettori come me. :)

Dobbiamo seguire come menzionato sopra e l'unico cambiamento sarà nel modello di vibrazione come di seguito,

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

Questo vibrerà esattamente due volte . Come già sappiamo

1. 0 è per ritardo
2. 100 dice vibrare per 100ms per la prima volta
3. segue il ritardo di 1000ms
4. e post che vibrano di nuovo per 300ms

Si può continuare a menzionare alternativamente ritardo e vibrazione (ad es. 0, 100, 1000, 300, 1000, 300 per 3 vibrazioni e così via ..) ma ricordare che la parola di @ Dave lo usa responsabilmente. :)

Notare anche qui che il parametro repeat è impostato su -1, il che significa che la vibrazione avverrà esattamente come indicato nel modello . :)

Ho faticato a capire come farlo nella mia prima implementazione - assicurati di avere i seguenti:

1) Il tuo dispositivo supporta le vibrazioni (il mio tablet Samsung non ha funzionato, quindi ho continuato a ricontrollare il codice - il codice originale ha funzionato perfettamente sul mio CM Touchpad

2) Hai dichiarato sopra il livello dell'applicazione nel tuo file AndroidManifest.xml per autorizzare l'esecuzione del codice.

3) Hanno importato entrambi i seguenti elementi nel tuo MainActivity.java con le altre importazioni: import android.content.Context; import android.os.Vibrator;

4) Chiama la tua vibrazione (già ampiamente discusso in questo thread) - L'ho fatto in una funzione separata e l'ho chiamato nel codice in altri punti - a seconda di ciò che vuoi usare per chiamare la vibrazione potresti aver bisogno di un'immagine ( Android: lungo clic su un pulsante -> esegui azioni ) o listener di pulsanti o un oggetto cliccabile come definito in XML ( Immagine cliccabile - android ):

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

Vibrare senza usare l'autorizzazione

Se vuoi semplicemente vibrare il dispositivo una volta per fornire un feedback su un'azione dell'utente. È possibile utilizzare la performHapticFeedback()funzione di a View. Questo non ha bisogno delVIBRATE permesso per essere dichiarato nel manifest.

Utilizzare la seguente funzione come funzione di primo livello in alcune classi comuni come Utils.kt del progetto:

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

E poi usalo ovunque nel tuo Fragmento Activitycome segue:

vibrate(requireView())

Semplice come quella!

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

dovrebbe essere aggiunto all'interno del <manifest>tag e all'esterno del <application>tag.

Uso il seguente metodo utils:

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

Aggiungi la seguente autorizzazione al file AndroidManifest

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

È possibile utilizzare metodi sovraccaricati nel caso in cui si desideri utilizzare diversi tipi di vibrazioni (modelli / indefiniti) come suggerito sopra.

La risposta sopra è molto corretta ma sto facendo un semplice passo per farlo:

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

E poi nel tuo file XML:

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

Questo è il modo più semplice.

Vibrazione in motivi / onde :

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

Più

L'autorizzazione necessaria in AndroidManifest.xml:

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

Aggiornamento di Kotlin per una maggiore sicurezza del tipo

Usalo come funzione di primo livello in alcune classi comuni del tuo progetto come 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)
        }
    }
}

E quindi chiamalo ovunque nel tuo codice come segue:

vibrateDevice(requireContext())

Spiegazione

L'uso Vibrator::class.javaè più sicuro del tipo rispetto all'usoString costanti.

Controlliamo la vibratornullità usando let { }, perché se la vibrazione non è disponibile per il dispositivo, lo vibratorsarànull .

Va bene sopprimere la deprecazione else clausola, perché l'avviso proviene dal SDK più recente.

Non è necessario richiedere l'autorizzazione in fase di esecuzione per l'utilizzo della vibrazione. Ma dobbiamo dichiararlo AndroidManifest.xmlcome segue:

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

Usa questo:

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:

Non dimenticare di includere l'autorizzazione nel file AndroidManifest.xml:

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

Puoi vibrare il dispositivo e il suo lavoro

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

È necessaria l'autorizzazione ma non è richiesta l'autorizzazione di runtime

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