Napisałem aplikację na Androida. Teraz chcę sprawić, aby urządzenie wibrowało, gdy nastąpi określone działanie. W jaki sposób mogę to zrobić?

Próbować:

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

Uwaga:

Nie zapomnij dołączyć uprawnienia do pliku AndroidManifest.xml:

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

Udziel pozwolenia na wibracje

Zanim zaczniesz implementować kod wibracyjny, musisz zezwolić aplikacji na wibrowanie:

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

Pamiętaj, aby dołączyć ten wiersz do pliku AndroidManifest.xml.

Zaimportuj bibliotekę wibracji

Większość IDE zrobi to za Ciebie, ale oto instrukcja importu, jeśli nie:

 import android.os.Vibrator;

Upewnij się, że jest to czynność, w której ma wystąpić wibracja.

Jak wibrować przez określony czas

W większości przypadków będziesz chciał wibrować urządzenie przez krótki, z góry określony czas. Możesz to osiągnąć za pomocą vibrate(long milliseconds)metody. Oto szybki przykład:

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

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

To wszystko, proste!

Jak wibrować w nieskończoność

Może się zdarzyć, że chcesz, aby urządzenie nadal wibrowało bez końca. W tym celu używamy vibrate(long[] pattern, int repeat)metody:

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

Kiedy jesteś gotowy, aby zatrzymać wibracje, po prostu wywołaj cancel()metodę:

v.cancel();

Jak używać wzorów wibracji

Jeśli chcesz uzyskać bardziej dostosowane wibracje, możesz spróbować stworzyć własne wzorce wibracji:

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

Bardziej złożone wibracje

Istnieje wiele zestawów SDK, które oferują bardziej wszechstronny zakres dotykowych informacji zwrotnych. Jednym z nich, którego używam do efektów specjalnych, jest Haptic Development Platform Immersion na Androida .

Rozwiązywanie problemów

Jeśli urządzenie nie wibruje, najpierw upewnij się, że może wibrować:

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

Po drugie, upewnij się, że dałeś swojej aplikacji pozwolenie na wibrowanie! Wróć do pierwszego punktu.

Metoda aktualizacji wibracji (interwał) aktualizacji 2017 jest przestarzała w przypadku Androida-O (API 8.0)

Aby obsłużyć wszystkie wersje Androida, użyj tej metody.

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

Powyższe odpowiedzi są idealne. Chciałem jednak wibrować moją aplikację dokładnie dwa razy po kliknięciu przycisku i brakuje tutaj tych drobnych informacji, dlatego zamieszczam posty dla przyszłych czytelników takich jak ja. :)

Musimy postępować, jak wspomniano powyżej, a jedyną zmianą będzie wzór wibracji, jak poniżej,

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

To dokładnie wibruje dwa razy . Jak już wiemy

1. 0 oznacza opóźnienie
2. 100 mówi wibrować dla 100ms po raz pierwszy
3. następnie przychodzi opóźnienie 1000 ms
4. i opublikuj wibracje ponownie przez 300 ms

Można mówić naprzemiennie o opóźnieniu i wibracjach (np. 0, 100, 1000, 300, 1000, 300 dla 3 wibracji itd.), Ale pamiętaj, że słowo @ Dave'a używa go odpowiedzialnie. :)

Zauważ też, że parametr powtarzania jest ustawiony na -1, co oznacza, że ​​wibracje będą występować dokładnie tak , jak wspomniano we wzorze . :)

Podczas pierwszego wdrożenia miałem problem ze zrozumieniem, jak to zrobić - upewnij się, że masz następujące elementy:

1) Twoje urządzenie obsługuje wibracje (mój tablet Samsung nie działał, więc ciągle sprawdzałem kod - oryginalny kod działał idealnie na moim CM Touchpad

2) W pliku AndroidManifest.xml zadeklarowałeś powyżej poziomu aplikacji, aby dać kodowi pozwolenie na uruchomienie.

3) Zaimportowałem oba poniższe elementy do MainActivity.java wraz z innymi importami: import android.content.Context; import android.os.Vibrator;

4) Wywołaj swoją wibrację (już obszernie omówione w tym wątku) - Zrobiłem to w osobnej funkcji i wywołaj to w kodzie w innych punktach - w zależności od tego, czego chcesz użyć do wywołania wibracji, możesz potrzebować obrazu ( Android: długie kliknięcie przycisku -> wykonywanie akcji ) lub detektora przycisku lub klikalnego obiektu zdefiniowanego w XML (klikalny obraz - Android ):

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

Wibracje bez użycia uprawnień

Jeśli chcesz po prostu wibrować urządzenie raz, aby przekazać opinię na temat działania użytkownika. Możesz użyć performHapticFeedback()funkcji View. Nie wymaga to VIBRATEzgody na zadeklarowanie w manifeście.

Użyj następującej funkcji jako funkcji najwyższego poziomu w niektórych popularnych klasach, takich jak Utils.kt twojego projektu:

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

A następnie użyj go w dowolnym miejscu Fragmentlub Activityw następujący sposób:

vibrate(requireView())

Proste!

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

należy dodać wewnątrz <manifest>tagu i <application>tagu zewnętrznego .

Używam następującej metody utils:

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

Dodaj następujące uprawnienie do pliku AndroidManifest

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

Możesz użyć przeciążonych metod w przypadku, gdy chcesz użyć różnych rodzajów wibracji (wzorów / nieokreślonych), jak sugerowano powyżej.

Powyższa odpowiedź jest bardzo poprawna, ale daję łatwy krok, aby to zrobić:

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

A następnie w pliku xml:

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

To najłatwiejszy sposób.

Wibrowanie we wzorach / falach :

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

Niezbędne pozwolenie w AndroidManifest.xml:

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

Aktualizacja Kotlin dla większego bezpieczeństwa typu

Użyj go jako funkcji najwyższego poziomu w niektórych popularnych klasach swojego projektu, takich jak 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)
        }
    }
}

A następnie wywołaj go w dowolnym miejscu kodu:

vibrateDevice(requireContext())

Wyjaśnienie

Korzystanie Vibrator::class.javajest bardziej bezpieczne dla typu niż używanieString stałych.

Sprawdzamy vibratorzerowalność za pomocą let { }, ponieważ jeśli wibracja nie jest dostępna dla urządzenia, vibratorbędzie null.

Można ukryć deprecjację w else klauzule, ponieważ ostrzeżenie pochodzi z nowszego SDK.

W czasie wykonywania nie musimy prosić o zgodę na używanie wibracji. Ale musimy to zadeklarować w AndroidManifest.xmlnastępujący sposób:

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

Użyj tego:

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

Uwaga:

Nie zapomnij dołączyć uprawnienia do pliku AndroidManifest.xml:

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

Możesz wibrować urządzenie i jego działanie

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

Zezwolenie jest konieczne, ale nie wymaga zezwolenia

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