Conceder Autorização Para Vibrações

Antes de começar a implementar qualquer código de vibração, tem de dar à sua aplicação a permissão para vibrar.

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

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

Importar a biblioteca de vibrações

A maioria dos IDEs fará isto por ti, mas aqui está a declaração de importação se a tua não fizer:

 import android.os.Vibrator;

Certifique-se disso na atividade onde quer que a vibração ocorra.

Como Vibrar para um determinado tempo

Na maioria das circunstâncias, vais querer vibrar o dispositivo por um curto período de tempo pré-determinado. Você pode conseguir isso usando o método vibrate(long milliseconds). 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 queiras que o dispositivo continue a vibrar indefinidamente. Para isso, usamos o método vibrate(long[] pattern, int repeat):

// 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 estiveres pronto para parar a vibração, liga-me. o método cancel():

v.cancel();

Como utilizar os padrões de vibração Se quiser uma vibração mais personalizada, pode tentar criar os 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. Um que eu uso para efeitos especiais é a plataforma de desenvolvimento háptico de imersão do Android .

Resolução de problemas

Se o seu dispositivo não vibrar, primeiro faça claro que 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, certifique-se que deu ao seu pedido a permissão para vibrar! Remete para o primeiro ponto.

Update 2017 vibrate (interval) method is deprecated with Android-O(API 8.0)

Para suportar todas as versões 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);
    }
}

Tive dificuldade em compreender como fazer isto na minha primeira implementação - certifique-se que tem o seguinte:

O seu dispositivo suporta vibrações (o meu tablet Samsung não funcionou, por isso continuei a verificar o código-o código original funcionou perfeitamente no meu CM Touchpad

2) declarou-se acima do nível de aplicação no seu AndroidManifest.ficheiro xml para dar a permissão de execução do Código.

3) importou ambos os seguintes para a sua actividade principal.java com o outras importações: importar android.conteudo.Contexto; importar android.o.Vibrador;

4) Chamar a sua vibração (amplamente discutido neste segmento já) - eu fiz isso em uma função separada e chamar isso no código em outros pontos, dependendo do que você deseja usar para chamar a vibração você pode precisar de uma imagem (Android: longa clique em um botão -> executar ações) ou o botão do ouvinte, ou o link para um objeto, conforme definido em XML (imagem Clicável - android):

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

As respostas acima são perfeitas. No entanto, eu queria vibrar meu aplicativo exatamente duas vezes no botão clique e esta pequena informação está faltando aqui, portanto, postando para futuros leitores como eu. :)

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

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

Isto vai vibrar duas vezes. Como já sabemos 0 é para o atraso, 100 diz vibrar para 100MS pela primeira vez, em seguida vem o atraso de 1000MS e postar que vibrar novamente para 300m.

Pode-se continuar a mencionar o atraso e a vibração em alternativa (ex. 0, 100, 1000, 300, 1000, 300 para 3 vibrações e assim por diante.. mas lembre-se que a palavra de @Dave a usa de forma responsável. :)

Note também aqui que o parâmetro de repetição é definido para -1 o que significa que a vibração vai acontecer exatamente como mencionado no padrão. :)

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

Deve ser adicionado dentro da marca <manifest> e fora da marca <application>.

A resposta acima é muito correcta, mas estou a dar um passo fácil para o fazer:

 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 depois no seu ficheiro 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.

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 ficheiro AndroidManifest

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

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

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 te esqueças de incluir a permissão no AndroidManifest.ficheiro xml:

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