Réponses:
Essayer:
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);
}
Remarque:
N'oubliez pas d'inclure l'autorisation dans le fichier AndroidManifest.xml:
<uses-permission android:name="android.permission.VIBRATE"/>
vibrate(VibrationEffect)
place.
Avant de commencer à implémenter un code de vibration, vous devez donner à votre application la permission de vibrer:
<uses-permission android:name="android.permission.VIBRATE"/>
Assurez-vous d'inclure cette ligne dans votre fichier AndroidManifest.xml.
La plupart des IDE le feront pour vous, mais voici l'instruction d'importation si la vôtre ne le fait pas:
import android.os.Vibrator;
Assurez-vous que dans l'activité où vous souhaitez que la vibration se produise.
Dans la plupart des cas, vous souhaiterez faire vibrer l'appareil pendant une courte période de temps prédéterminée. Vous pouvez y parvenir en utilisant la vibrate(long milliseconds)
méthode. Voici un petit exemple:
// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
// Vibrate for 400 milliseconds
v.vibrate(400);
Voilà, c'est simple!
Il se peut que vous souhaitiez que l'appareil continue de vibrer indéfiniment. Pour cela, nous utilisons la vibrate(long[] pattern, int repeat)
méthode:
// 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);
Lorsque vous êtes prêt à arrêter la vibration, appelez simplement la cancel()
méthode:
v.cancel();
Si vous voulez une vibration plus sur mesure, vous pouvez essayer de créer vos propres modèles de vibration:
// 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);
Il existe plusieurs SDK qui offrent une gamme plus complète de commentaires haptiques. L'une que j'utilise pour les effets spéciaux est la plate-forme de développement Haptic d'Immersion pour Android .
Si votre appareil ne vibre pas, assurez-vous d'abord qu'il peut vibrer:
// 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");
}
Deuxièmement, assurez-vous d'avoir donné à votre application la permission de vibrer! Reportez-vous au premier point.
La méthode de vibration (intervalle) de la mise à jour 2017 est déconseillée avec Android-O (API 8.0)
Pour prendre en charge toutes les versions d'Android, utilisez cette méthode.
// 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)
}
}
getSystemService
parthis.getContext().getSystemService
Les réponses ci-dessus sont parfaites. Cependant, je voulais faire vibrer mon application exactement deux fois sur le bouton et cette petite information manque ici, d'où la publication pour de futurs lecteurs comme moi. :)
Nous devons suivre comme mentionné ci-dessus et le seul changement sera dans le modèle de vibration comme ci-dessous,
long[] pattern = {0, 100, 1000, 300};
v.vibrate(pattern, -1); //-1 is important
Cela vibrera exactement deux fois . Comme nous le savons déjà
On peut continuer encore et encore en mentionnant le retard et les vibrations (par exemple 0, 100, 1000, 300, 1000, 300 pour 3 vibrations et ainsi de suite ..) mais rappelez-vous que le mot de @ Dave l'utilise de manière responsable. :)
Notez également ici que le paramètre de répétition est défini sur -1, ce qui signifie que la vibration se produira exactement comme mentionné dans le motif . :)
J'ai eu du mal à comprendre comment procéder sur ma première mise en œuvre - assurez-vous que vous disposez des éléments suivants:
1) Votre appareil prend en charge les vibrations (ma tablette Samsung ne fonctionnait pas, j'ai donc revérifié le code - le code d'origine fonctionnait parfaitement sur mon CM Touchpad
2) Vous avez déclaré au-dessus du niveau d'application dans votre fichier AndroidManifest.xml pour donner au code l'autorisation de s'exécuter.
3) Ont importé les deux éléments suivants dans votre MainActivity.java avec les autres importations: import android.content.Context; importer android.os.Vibrator;
4) Appelez votre vibration (discuté en détail dans ce fil déjà) - Je l'ai fait dans une fonction distincte et appelez cela dans le code à d'autres points - selon ce que vous voulez utiliser pour appeler la vibration, vous aurez peut-être besoin d'une image ( Android: clic long sur un bouton -> effectuer des actions ) ou un écouteur de bouton, ou un objet cliquable tel que défini en XML ( Image cliquable - android ):
public void vibrate(int duration)
{
Vibrator vibs = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
vibs.vibrate(duration);
}
Si vous souhaitez simplement faire vibrer l'appareil une fois pour fournir un retour sur une action de l'utilisateur. Vous pouvez utiliser la performHapticFeedback()
fonction d'un View
. Cela n'a pas besoin de l' VIBRATE
autorisation pour être déclaré dans le manifeste.
Utilisez la fonction suivante en tant que fonction de niveau supérieur dans une classe courante comme Utils.kt de votre projet:
/**
* Vibrates the device. Used for providing feedback when the user performs an action.
*/
fun vibrate(view: View) {
view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS)
}
Et puis utilisez-le n'importe où dans votre Fragment
ou Activity
comme suit:
vibrate(requireView())
Aussi simple que cela!
<uses-permission android:name="android.permission.VIBRATE"/>
doit être ajouté à l'intérieur de la <manifest>
balise et à l'extérieur de la <application>
balise.
J'utilise la méthode utils suivante:
public static final void vibratePhone(Context context, short vibrateMilliSeconds) {
Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
vibrator.vibrate(vibrateMilliSeconds);
}
Ajoutez l'autorisation suivante au fichier AndroidManifest
<uses-permission android:name="android.permission.VIBRATE"/>
Vous pouvez utiliser des méthodes surchargées au cas où vous souhaiteriez utiliser différents types de vibrations (motifs / indéfinis) comme suggéré ci-dessus.
La réponse ci-dessus est très correcte mais je donne une étape simple pour le faire:
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);
}
Et puis dans votre fichier xml:
<button android:layout_height="wrap_content"
android:layout_width ="wrap_content"
android:onclick ="longVibrate"
android:text ="VibrateThrice">
</button>
Vibrant en motifs / vagues :
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
L'autorisation nécessaire dans AndroidManifest.xml
:
<uses-permission android:name="android.permission.VIBRATE"/>
Utilisez-la comme fonction de niveau supérieur dans une classe courante de votre projet telle que 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)
}
}
}
Et puis appelez-le n'importe où dans votre code comme suit:
vibrateDevice(requireContext())
L'utilisation Vibrator::class.java
est plus sûre de type que l'utilisation de String
constantes.
Nous vérifions la vibrator
nullité à l'aide let { }
, car si la vibration n'est pas disponible pour l'appareil, elle le vibrator
sera null
.
Il est correct de supprimer la dépréciation dans la else
clause, car l'avertissement provient d'un SDK plus récent.
Nous n'avons pas besoin de demander la permission lors de l'exécution pour utiliser les vibrations. Mais nous devons le déclarer AndroidManifest.xml
comme suit:
<uses-permission android:name="android.permission.VIBRATE"/>
Utilisez ceci:
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);
}
Remarque:
N'oubliez pas d'inclure l'autorisation dans le fichier AndroidManifest.xml:
<uses-permission android:name="android.permission.VIBRATE"/>
Vous pouvez faire vibrer l'appareil et son travail
Vibrator v = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
v.vibrate(100);
L'autorisation est nécessaire mais pas sur l'autorisation d'exécution requise
<uses-permission android:name="android.permission.VIBRATE"/>