Eu escrevi um aplicativo Android. Agora, quero fazer o dispositivo vibrar quando uma determinada ação ocorrer. Como posso fazer isso?

Tentar:

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:

Não se esqueça de incluir permissão no arquivo AndroidManifest.xml:

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

Conceder permissão de vibração

Antes de começar a implementar qualquer código de vibração, você deve dar ao seu aplicativo a permissão para vibrar:

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

Certifique-se de incluir esta linha no seu arquivo AndroidManifest.xml.

Importar a biblioteca de vibração

A maioria dos IDEs fará isso por você, mas aqui está a declaração de importação, se a sua não:

 import android.os.Vibrator;

Certifique-se disso na atividade em que deseja que a vibração ocorra.

Como vibrar por um tempo determinado

Na maioria das circunstâncias, você deseja vibrar o dispositivo por um período curto e predeterminado. Você pode conseguir isso usando o vibrate(long milliseconds)método Aqui está um exemplo rápido:

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

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

É isso, simples!

Como vibrar indefinidamente

Pode ser que você queira que o dispositivo continue vibrando indefinidamente. Para isso, usamos o vibrate(long[] pattern, int repeat)método:

// 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 estiver pronto para parar a vibração, basta chamar o cancel()método:

v.cancel();

Como usar padrões de vibração

Se você deseja uma vibração mais personalizada, tente criar seus próprios padrões de vibração:

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

Vibrações mais complexas

Existem vários SDKs que oferecem uma gama mais abrangente de feedback háptico. Uma que eu uso para efeitos especiais é a Plataforma de Desenvolvimento Tátil da Immersion para Android .

Solução de problemas

Se o seu dispositivo não vibrar, primeiro verifique se ele pode vibrar:

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

Em segundo lugar, verifique se você concedeu ao seu aplicativo a permissão para vibrar! Consulte o primeiro ponto.

O método de vibração (intervalo) da atualização 2017 foi descontinuado com o Android-O (API 8.0)

Para oferecer suporte a todas as versões do Android, use este método.

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

As respostas acima são perfeitas. No entanto, eu queria vibrar meu aplicativo exatamente duas vezes ao clicar no botão e essas pequenas informações estão faltando aqui, postando assim para futuros leitores como eu. :)

Temos que seguir como mencionado acima e a única mudança será no padrão de vibração, como abaixo,

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

Isso vibrará exatamente duas vezes . Como já sabemos

1. 0 é para atraso
2. 100 diz vibrar por 100ms pela primeira vez
3. vem em seguida um atraso de 1000ms
4. e poste que vibre novamente por 300ms

Pode-se continuar mencionando atraso e vibração alternativamente (por exemplo, 0, 100, 1000, 300, 1000, 300 para 3 vibrações e assim por diante ..), mas lembre-se da palavra de Dave, use-a com responsabilidade. :)

Observe também aqui que o parâmetro de repetição está definido como -1, o que significa que a vibração ocorrerá exatamente como mencionado no padrão . :)

Eu lutei para entender como fazer isso na minha primeira implementação - verifique se você tem o seguinte:

1) Seu dispositivo suporta vibração (meu tablet Samsung não funcionou, então eu continuei verificando novamente o código - o código original funcionou perfeitamente no meu CM Touchpad

2) Você declarou acima do nível do aplicativo no seu arquivo AndroidManifest.xml para dar permissão ao código para execução.

3) Importou os dois itens a seguir para o MainActivity.java com as outras importações: import android.content.Context; importar android.os.Vibrator;

4) Chame sua vibração (já discutimos extensivamente neste tópico) - eu fiz isso em uma função separada e chamei isso no código em outros pontos - dependendo do que você deseja usar para chamar a vibração, talvez seja necessário uma imagem ( Android: clique longo em um botão -> executar ações ) ou em um ouvinte de botão ou em um objeto clicável, conforme definido em XML ( imagem clicável - android ):

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

Vibrar sem usar permissão

Se você deseja simplesmente vibrar o dispositivo uma vez para fornecer um feedback sobre a ação do usuário. Você pode usar a performHapticFeedback()função de a View. Isso não precisa da VIBRATEpermissão para ser declarada no manifesto.

Use a seguinte função como uma função de nível superior em algumas classes comuns como Utils.kt do seu projeto:

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

E use-o em qualquer lugar do seu Fragmentou da Activityseguinte maneira:

vibrate(requireView())

Simples assim!

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

deve ser adicionado <manifest>tag interna e externa <application>.

Eu uso o seguinte método utils:

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

Adicione a seguinte permissão ao arquivo AndroidManifest

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

Você pode usar métodos sobrecarregados, caso deseje usar diferentes tipos de vibrações (padrões / indefinido), conforme sugerido acima.

A resposta acima está muito correta, mas estou dando um passo fácil para fazer isso:

 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 então no seu arquivo xml:

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

Essa é a maneira mais fácil.

Vibrando em padrões / ondas :

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

Mais

A permissão necessária em AndroidManifest.xml:

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

Atualização Kotlin para mais segurança de tipo

Use-o como uma função de nível superior em algumas classes comuns do seu projeto, como 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, em seguida, chame-o em qualquer lugar do seu código da seguinte maneira:

vibrateDevice(requireContext())

Explicação

Usar Vibrator::class.javaé mais seguro do que usar Stringconstantes.

Verificamos a vibratornulidade usando let { }, porque, se a vibração não estiver disponível para o dispositivo, vibratorserá null.

Não há problema em suprimir a descontinuação na elsecláusula, porque o aviso é do SDK mais recente.

Não precisamos pedir permissão em tempo de execução para usar vibração. Mas precisamos declarar da AndroidManifest.xmlseguinte forma:

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

Usa isto:

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:

Não se esqueça de incluir permissão no arquivo AndroidManifest.xml:

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

Você pode vibrar o dispositivo e seu trabalho

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

A permissão é necessária, mas não a permissão de tempo de execução necessária

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