CODEWITHSUNDEEP
javaandroidkotlinvibrationandroid-vibration
Billie
Billie

Reputation: 9146

How to make an Android device vibrate? with different frequency?

I wrote an Android application. Now, I want to make the device vibrate when a certain action occurs. How can I do this?

Upvotes: 615

Views: 429587

Answers (15)

Kevin ABRIOUX
Kevin ABRIOUX

Reputation: 17735

There is the Kotlin version for this for SDK version 26 minimum:

val vibrator: Vibrator? = when {
    Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> (context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager)?.defaultVibrator
    else -> context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
}
val timings = LongArray(size = 2).apply {
    this[0] = 500
    this[1] = 500
}
vibrator?.vibrate(VibrationEffect.createWaveform(timings, -1))

For changing vibration type, edit the timings variable

To loop on vibration, replace the -1 (which is no repetition) by your count.

Don't forget the manifest

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

Upvotes: 0

Sarun1001
Sarun1001

Reputation: 381

VIBRATOR_SERVICE is deprecated.

So use VIBRATOR_MANAGER_SERVICE in SDK 31 & Above

Make sure you added this permission in AndroidManifest.xml

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

Vibrator vibrator;
VibratorManager vibratorManager;
private static final long[] VIBRATE_PATTERN = {500, 500};


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (Build.VERSION.SDK_INT>=31) {
        vibratorManager = (VibratorManager) getSystemService(Context.VIBRATOR_MANAGER_SERVICE);
        vibrator = vibratorManager.getDefaultVibrator();
    }
    else {
        vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
    }

    if (Build.VERSION.SDK_INT >= 26) {
        vibrator.vibrate(VibrationEffect.createWaveform(VIBRATE_PATTERN,0));
    }
    else {
        vibrator.vibrate(VIBRATE_PATTERN,0);
    }
}

Upvotes: 12

Maksim Ivanov
Maksim Ivanov

Reputation: 4321

Vibrating in Patterns/Waves:

import android.os.Vibrator;
...
// Pause for 500ms, vibrate 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

The necessary permission in AndroidManifest.xml:

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

Upvotes: 14

Atul O Holic
Atul O Holic

Reputation: 6792

Above answers are perfect. However I wanted to vibrate my app exactly twice on button click and this small information is missing here, hence posting for future readers like me. :)

We have to follow as mentioned above and the only change will be in the vibrate pattern as below,

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

This will exactly vibrate twice. As we already know

  1. 0 is for delay
  2. 100 says vibrate for 100ms for the first time
  3. next comes delay of 1000ms
  4. and post that vibrate again for 300ms

One can go on and on mentioning delay and vibration alternatively (e.g. 0, 100, 1000, 300, 1000, 300 for 3 vibrations and so on..) but remember @Dave's word use it responsibly. :)

Also note here that the repeat parameter is set to -1 which means the vibration will happen exactly as mentioned in the pattern. :)

Upvotes: 33

Yogesh Umesh Vaity
Yogesh Umesh Vaity

Reputation: 48289

Vibrate without using permission

If you want to simply vibrate the device once to provide a feedback on a user action. You can use performHapticFeedback() function of a View. This doesn't need the VIBRATE permission to be declared in the manifest.

Use the following function as a top level function in some common class like Utils.kt of your project:

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

And then use it anywhere in your Fragment or Activity as following:

vibrate(requireView())

Simple as that!

Upvotes: 38

Yogesh Umesh Vaity
Yogesh Umesh Vaity

Reputation: 48289

Kotlin update for more type safety

Use it as a top level function in some common class of your project such as 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)
        }
    }
}

And then call it anywhere in your code as following:

vibrateDevice(requireContext())

Explanation

Using Vibrator::class.java is more type safe than using String constants.

We check the vibrator for nullability using let { }, because if the vibration is not available for the device, the vibrator will be null.

It's ok to supress deprecation in else clause, because the warning is from newer SDK.

We don't need to ask for permission at runtime for using vibration. But we need to declare it in AndroidManifest.xml as following:

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

Upvotes: 16

Ahmad
Ahmad

Reputation: 201

You can Vibrate the Device and its work

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

Permission is necessary but not on runtime permission required

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

Upvotes: 3

Hitesh Sahu
Hitesh Sahu

Reputation: 45140

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

To support all Android versions use this method.

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

Upvotes: 112

Paresh Mayani
Paresh Mayani

Reputation: 128438

Try:

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

Note:

Don't forget to include permission in AndroidManifest.xml file: 

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

Upvotes: 1139

Prakhar Gupta
Prakhar Gupta

Reputation: 131

Use this:

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

Note:

Don't forget to include permission in AndroidManifest.xml file:

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

Upvotes: 2

dondondon
dondondon

Reputation: 901

Above answer is very correct but I'm giving an easy step to do it:

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

And then in your xml file: 

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

That's the easiest way.

Upvotes: 4

Liam George Betsworth
Liam George Betsworth

Reputation: 18513

Grant Vibration Permission

Before you start implementing any vibration code, you have to give your application the permission to vibrate:

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

Make sure to include this line in your AndroidManifest.xml file.

Import the Vibration Library

Most IDEs will do this for you, but here is the import statement if yours doesn't:

 import android.os.Vibrator;

Make sure this in the activity where you want the vibration to occur.

How to Vibrate for a Given Time

In most circumstances, you'll be wanting to vibrate the device for a short, predetermined amount of time. You can achieve this by using the vibrate(long milliseconds) method. Here is a quick example:

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

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

That's it, simple!

How to Vibrate Indefinitely

It may be the case that you want the device to continue vibrating indefinitely. For this, we use the vibrate(long[] pattern, int repeat) method:

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

When you're ready to stop the vibration, just call the cancel() method:

v.cancel();

How to use Vibration Patterns

If you want a more bespoke vibration, you can attempt to create your own vibration patterns:

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

More Complex Vibrations

There are multiple SDKs that offer a more comprehensive range of haptic feedback. One that I use for special effects is Immersion's Haptic Development Platform for Android.

Troubleshooting

If your device won't vibrate, first make sure that it can vibrate:

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

Secondly, please ensure that you've given your application the permission to vibrate! Refer back to the first point.

Upvotes: 708

Mahendra Liya
Mahendra Liya

Reputation: 13218

I use the following utils method:

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

Add the following permission to the AndroidManifest file

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

You can use overloaded methods in case if you wish to use different types of vibrations (patterns / indefinite) as suggested above.

Upvotes: 4

Sivagami Nambi
Sivagami Nambi

Reputation: 352

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

should be added inside <manifest> tag and outside <application> tag.

Upvotes: 5

mklopfer
mklopfer

Reputation: 341

I struggled understanding how to do this on my first implementation - make sure you have the following:

1) Your device supports vibration (my Samsung tablet did not work so I kept re-checking the code - the original code worked perfectly on my CM Touchpad

2) You have declared above the application level in your AndroidManifest.xml file to give the code permission to run.

3) Have imported both of the following in to your MainActivity.java with the other imports: import android.content.Context; import android.os.Vibrator;

4) Call your vibration (discussed extensively in this thread already) - I did it in a separate function and call this in the code at other points - depending on what you want to use to call the vibration you may need an image (Android: long click on a button -> perform actions) or button listener, or a clickable object as defined in XML (Clickable image - android):

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

Upvotes: 14

Related Questions