Wie kann man ein Android-Gerät zum Vibrieren bringen?

499

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?

Billie
quelle

Antworten:

987

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"/>
Paresh Mayani
quelle
3
Gibt es eine Möglichkeit, die Vibration des gesamten Telefons zu unterdrücken? Vielen Dank!
Javi
14
@joshsvoss Es sind 500 Millisekunden, was nur eine halbe Sekunde ist. Schauen Sie sich Google Docs an. developer.android.com/reference/android/os/Vibrator.html
cjayem13
5
es gibt mir: Kontext kann nicht aufgelöst werden oder ist kein Feld ..?! Was ist das Problem
McLan
3
vibrieren ist jetzt veraltet. Verwenden Sie stattdessen die Lösung von Hitesh Sahu.
Ray Li
2
Diese Methode wurde in API-Level 26 nicht mehr unterstützt. Verwenden Sie vibrate(VibrationEffect)stattdessen.
Timo Bähr
651

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.

Liam George Betsworth
quelle
26
Ausgezeichnete Antwort, obwohl ich vorsichtig wäre, eine Vibration auf unbestimmte Zeit zu spielen. Bitte seien Sie verantwortlich, wenn Sie diese Funktion verwenden!
Dave
4
Tolle Antwort, aber eins. Wenn Sie "Die" 0 "sagen, bedeutet dies, auf unbestimmte Zeit zu wiederholen", obwohl dies wahr ist, ist dies ein bisschen irreführend. Diese Zahl ist der Index des Musterarrays, bei dem das Muster beim Wiederholen beginnt.
Aaronvargas
1
@aaronvargas Fairer Punkt, obwohl das außerhalb des Rahmens dessen liegt, was die meisten Menschen erreichen wollen. Ich ging für eine einfache Erklärung :)
Liam George Betsworth
@ Liam George Betsworth Wie vibriere ich, selbst wenn sich das Handy im lautlosen Modus befindet? Bitte.
Parthi
1
Der Immersions-Link ist ausgefallen und ich kann ihn nicht auf archive.org finden :(
Looper
73

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)
    }
}
Hitesh Sahu
quelle
2
Wir benötigen keine Laufzeitberechtigung für Vibration. Vibration ist keine gefährliche Erlaubnis, daher muss sie nur im Manifest deklariert werden. [ developer.android.com/guide/topics/permissions/…
Roon13
@ BugsHappen Dokumentation verschoben. Wird es aktualisieren oder löschen.
Roon13
Das einzige , was ich möchte hinzufügen, dass , wenn Sie dies in einer Aktivität verwenden und keine spezifische Kontextvariable, dann ersetzen getSystemServicemitthis.getContext().getSystemService
DrMcCleod
Sie, Sir, haben eine positive Bewertung für diesen Funktionsnamen erhalten, touché
Starwave
18

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

Atul O Holic
quelle
Warum bedeutet -1, dass die Vibration genau wie im Muster angegeben auftritt? Vielen Dank!
Ruchir Baronia
@ Rich Bitte beziehen Sie sich auf meine Antwort. Das '-1' ist der Index, bei dem die Vibration versucht, sich zu wiederholen, nachdem sie dem Muster zum ersten Mal gefolgt ist. '-1' ist außerhalb der Grenzen, daher wiederholt sich die Vibration nicht.
Liam George Betsworth
@ Rich - Liam George Betsworth ist richtig. In Android-Dokumenten heißt es: - Damit sich das Muster wiederholt, übergeben Sie den Index an das Musterarray, an dem die Wiederholung gestartet werden soll, oder -1, um die Wiederholung zu deaktivieren. Link - developer.android.com/reference/android/os/… , int)
Atul O Holic
14

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

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!

Yogesh Umesh Vaity
quelle
2
Gute und einfache Lösung!
VAdaihiep
5
<uses-permission android:name="android.permission.VIBRATE"/>

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

Sivagami Nambi
quelle
4

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.

Mahendra Liya
quelle
4

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.

Dondondon
quelle
3

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

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

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

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"/>
Ahmad
quelle
Diese Lösung ist veraltet
BekaBot