Ich habe eine Android-Anwendung geschrieben. Jetzt möchte ich das Gerät vibrieren lassen, wenn eine bestimmte Aktion ausgeführt wird. Wie kann ich das machen?

Versuchen:

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

Hinweis:

Vergessen Sie nicht, die Berechtigung in die Datei AndroidManifest.xml aufzunehmen:

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

Vibrationserlaubnis erteilen

Bevor Sie mit der Implementierung eines Vibrationscodes beginnen, müssen Sie Ihrer Anwendung die Berechtigung zum Vibrieren erteilen:

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

Stellen Sie sicher, dass diese Zeile in Ihre AndroidManifest.xml-Datei aufgenommen wird.

Importieren Sie die Vibrationsbibliothek

Die meisten IDEs erledigen dies für Sie, aber hier ist die Importanweisung, wenn Ihre dies nicht tut:

 import android.os.Vibrator;

Stellen Sie dies in der Aktivität sicher, in der die Vibration auftreten soll.

Wie man für eine bestimmte Zeit vibriert

In den meisten Fällen möchten Sie das Gerät für eine kurze, vorgegebene Zeit vibrieren lassen. Sie können dies mit der vibrate(long milliseconds)Methode erreichen. Hier ist ein kurzes Beispiel:

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

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

Das war's, einfach!

Wie man auf unbestimmte Zeit vibriert

Möglicherweise möchten Sie, dass das Gerät unbegrenzt weiter vibriert. Dafür verwenden wir die vibrate(long[] pattern, int repeat)Methode:

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

Wenn Sie bereit sind, die Vibration zu stoppen, rufen Sie einfach die folgende cancel()Methode auf:

v.cancel();

Verwendung von Vibrationsmustern

Wenn Sie eine maßgeschneiderte Vibration wünschen, können Sie versuchen, Ihre eigenen Vibrationsmuster zu erstellen:

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

Komplexere Schwingungen

Es gibt mehrere SDKs, die ein umfassenderes Spektrum an haptischem Feedback bieten. Eine, die ich für Spezialeffekte verwende, ist Immersions Haptic Development Platform für Android .

Fehlerbehebung

Wenn Ihr Gerät nicht vibriert, stellen Sie zunächst sicher, dass es vibrieren kann:

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

Zweitens stellen Sie bitte sicher, dass Sie Ihrer Anwendung die Erlaubnis zum Vibrieren gegeben haben! Beziehen Sie sich auf den ersten Punkt.

Die Vibrationsmethode (Intervall) für das Update 2017 ist mit Android-O (API 8.0) veraltet.

Verwenden Sie diese Methode, um alle Android-Versionen zu unterstützen.

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

Die obigen Antworten sind perfekt. Ich wollte meine App jedoch genau zweimal beim Klicken auf die Schaltfläche vibrieren lassen, und diese kleinen Informationen fehlen hier, sodass sie für zukünftige Leser wie mich veröffentlicht werden. :) :)

Wir müssen wie oben erwähnt folgen und die einzige Änderung wird im Vibrationsmuster wie unten sein.

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

Dies wird genau zweimal vibrieren . Wie wir bereits wissen

1. 0 steht für Verzögerung
2. 100 sagt, zum ersten Mal 100 ms lang vibrieren
3. Als nächstes kommt eine Verzögerung von 1000ms
4. und poste das wieder für 300ms vibrieren

Man kann Verzögerung und Vibration alternativ weiter erwähnen (z. B. 0, 100, 1000, 300, 1000, 300 für 3 Vibrationen usw.), aber denken Sie daran, dass @ Daves Wort es verantwortungsbewusst verwendet. :) :)

Beachten Sie auch hier, dass der Wiederholungsparameter auf -1 gesetzt ist, was bedeutet, dass die Vibration genau wie im Muster angegeben auftritt . :) :)

Bei meiner ersten Implementierung hatte ich Probleme zu verstehen, wie dies zu tun ist. Stellen Sie sicher, dass Sie Folgendes haben:

1) Ihr Gerät unterstützt Vibrationen (mein Samsung-Tablet funktionierte nicht, daher habe ich den Code immer wieder überprüft - der ursprüngliche Code funktionierte perfekt auf meinem CM Touchpad

2) Sie haben in Ihrer AndroidManifest.xml-Datei über der Anwendungsebene deklariert, um dem Code die Berechtigung zum Ausführen zu erteilen.

3) Sie haben beide der folgenden Elemente zusammen mit den anderen Importen in Ihre MainActivity.java importiert: import android.content.Context; android.os.Vibrator importieren;

4) Rufen Sie Ihre Vibration auf (in diesem Thread bereits ausführlich besprochen) - Ich habe es in einer separaten Funktion ausgeführt und dies an anderen Stellen im Code aufgerufen - je nachdem, was Sie zum Aufrufen der Vibration verwenden möchten, benötigen Sie möglicherweise ein Bild ( Android: langer Klick auf eine Schaltfläche -> Aktionen ausführen ) oder einen Schaltflächen-Listener oder ein anklickbares Objekt, wie in XML definiert ( anklickbares Bild - Android ):

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

Ohne Erlaubnis vibrieren

Wenn Sie das Gerät einfach einmal vibrieren möchten, um eine Rückmeldung zu einer Benutzeraktion zu erhalten. Sie können die performHapticFeedback()Funktion von a verwenden View. Dies erfordert nicht die VIBRATEBerechtigung, im Manifest deklariert zu werden.

Verwenden Sie die folgende Funktion als Funktion der obersten Ebene in einer allgemeinen Klasse wie Utils.kt Ihres Projekts:

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

Und dann verwenden Sie es überall in Ihrem Fragmentoder Activitywie folgt:

vibrate(requireView())

So einfach ist das!

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

sollte innerhalb <manifest>und außerhalb des <application>Tags hinzugefügt werden .

Ich benutze die folgende Utils-Methode:

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

Fügen Sie der AndroidManifest-Datei die folgende Berechtigung hinzu

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

Sie können überladene Methoden verwenden, wenn Sie verschiedene Arten von Vibrationen (Muster / unbestimmt) verwenden möchten, wie oben vorgeschlagen.

Die obige Antwort ist sehr richtig, aber ich gebe einen einfachen Schritt, um dies zu tun:

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

Und dann in Ihrer XML-Datei:

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

Das ist der einfachste Weg.

Vibrieren in Mustern / Wellen :

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

Die notwendige Erlaubnis in AndroidManifest.xml:

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

Kotlin-Update für mehr Typensicherheit

Verwenden Sie es als Funktion der obersten Ebene in einer allgemeinen Klasse Ihres Projekts, z. B. 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)
        }
    }
}

Rufen Sie es dann an einer beliebigen Stelle in Ihrem Code wie folgt auf:

vibrateDevice(requireContext())

Erläuterung

Die Verwendung Vibrator::class.javaist typsicherer als die Verwendung von StringKonstanten.

Wir überprüfen die vibratorNullbarkeit mit let { }, denn wenn die Vibration für das Gerät nicht verfügbar ist, vibratorwird dies der Fall sein null.

Es ist in Ordnung, die Ablehnung zu unterdrücken else Klausel , da die Warnung vom neueren SDK stammt.

Wir müssen zur Laufzeit nicht um Erlaubnis bitten, um Vibrationen verwenden zu können. Aber wir müssen es AndroidManifest.xmlwie folgt deklarieren :

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

Benutze das:

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

Hinweis:

Vergessen Sie nicht, die Berechtigung in die Datei AndroidManifest.xml aufzunehmen:

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

Sie können das Gerät und seine Arbeit vibrieren lassen

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

Die Berechtigung ist erforderlich, jedoch nicht zur Laufzeit

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