// Requests a vibration on Android for the specified pattern and optional repeat // Straight out of the Android documentation : // Pass in an array of ints that are the durations for which to turn on or off the vibrator in milliseconds. // The first value indicates the number of milliseconds to wait before turning the vibrator on. // The next value indicates the number of milliseconds for which to keep the vibrator on before turning it off. // Subsequent values alternate between durations in milliseconds to turn the vibrator off or to turn the vibrator on. // repeat: the index into pattern at which to repeat, or -1 if you don't want to repeat. public static void AndroidVibrate(long[] pattern, int repeat) { if (!MMNVPlatform.Android()) { return; } if (pattern == null) { return; } if ((AndroidSDKVersion() < 26)) { AndroidVibrator.Call("vibrate", pattern, repeat); } else { AndroidVibrationEffectClassInitialization(); try { VibrationEffect = VibrationEffectClass.CallStatic <AndroidJavaObject>("createWaveform", new object[] { pattern, repeat }); AndroidVibrator.Call("vibrate", VibrationEffect); } catch (Exception e) { Debug.LogException(e); } } }
/// <summary> /// Returns true if the device running the game has vibrations /// </summary> /// <returns></returns> public static bool AndroidHasVibrator() { if (!MMNVPlatform.Android()) { return(false); } return(AndroidVibrator.Call <bool>("hasVibrator")); }
/// <summary> /// Stops all Android vibrations that may be active /// </summary> public static void AndroidCancelVibrations() { if (!MMNVPlatform.Android()) { return; } AndroidVibrator.Call("cancel"); }
/// <summary> /// Releases the feedback generators, usually you'll want to call this at OnDisable(); or anytime you know you won't need /// vibrations anymore. /// </summary> public static void iOSReleaseHaptics() { if (!MMNVPlatform.iOS()) { return; } MMNViOS_ReleaseFeedbackGenerators(); }
/// <summary> /// Requests a default vibration on Android, for the specified duration, in milliseconds /// </summary> /// <param name="milliseconds">Milliseconds.</param> public static void AndroidVibrate(long milliseconds) { if (!MMNVPlatform.Android()) { return; } AndroidVibrateMethodRawClassParameters[0].j = milliseconds; AndroidJNI.CallVoidMethod(AndroidVibrator.GetRawObject(), AndroidVibrateMethodRawClass, AndroidVibrateMethodRawClassParameters); }
/// <summary> /// Call this method to initialize the haptics. If you forget to do it, Nice Vibrations will do it for you the first time you /// call iOSTriggerHaptics. It's better if you do it though. /// </summary> public static void iOSInitializeHaptics() { if (!MMNVPlatform.iOS()) { return; } MMNViOS_InstantiateFeedbackGenerators(); iOSHapticsInitialized = true; }
/// <summary> /// Returns true if the device running the game has amplitude control /// </summary> /// <returns></returns> public static bool AndroidHasAmplitudeControl() { if ((AndroidSDKVersion() < 26)) { return(false); } if (!MMNVPlatform.Android()) { return(false); } return(AndroidVibrator.Call <bool>("hasAmplitudeControl")); }
/// <summary> /// Requests a vibration on Android for the specified pattern, amplitude and optional repeat /// </summary> /// <param name="pattern">Pattern.</param> /// <param name="amplitudes">Amplitudes.</param> /// <param name="repeat">Repeat : -1 : no repeat, 0 : infinite, 1 : repeat once, 2 : repeat twice, etc</param> public static void AndroidVibrate(long[] pattern, int[] amplitudes, int repeat) { if (!MMNVPlatform.Android()) { return; } if ((AndroidSDKVersion() < 26)) { AndroidVibrator.Call("vibrate", pattern, repeat); } else { AndroidVibrationEffectClassInitialization(); VibrationEffect = VibrationEffectClass.CallStatic <AndroidJavaObject>("createWaveform", new object[] { pattern, amplitudes, repeat }); AndroidVibrator.Call("vibrate", VibrationEffect); } }
/// <summary> /// Requests a vibration of the specified amplitude and duration. If amplitude is not supported by the device's SDK, a default vibration will be requested /// </summary> /// <param name="milliseconds">Milliseconds.</param> /// <param name="amplitude">Amplitude.</param> public static void AndroidVibrate(long milliseconds, int amplitude) { if (!MMNVPlatform.Android()) { return; } // amplitude is only supported after API26 if ((AndroidSDKVersion() < 26)) { AndroidVibrate(milliseconds); } else { AndroidVibrationEffectClassInitialization(); VibrationEffect = VibrationEffectClass.CallStatic <AndroidJavaObject>("createOneShot", new object[] { milliseconds, amplitude }); AndroidVibrator.Call("vibrate", VibrationEffect); } }
/// <summary> /// Requests a vibration on Android for the specified pattern, amplitude and optional repeat /// </summary> /// <param name="pattern">Pattern.</param> /// <param name="amplitudes">Amplitudes.</param> /// <param name="repeat">Repeat : -1 : no repeat, 0 : infinite, 1 : repeat once, 2 : repeat twice, etc</param> public static void AndroidVibrate(long[] pattern, int[] amplitudes, int repeat, bool threaded = false) { if (!MMNVPlatform.Android()) { return; } if ((pattern == null) || (amplitudes == null)) { return; } if ((pattern.Length == 0) || (amplitudes.Length == 0)) { return; } if ((AndroidSDKVersion() < 26)) { AndroidVibrator.Call("vibrate", pattern, repeat); } else { if (threaded) { if (_androidVibrateThread == null) { _androidVibrateThread = new MMNVAltThread <MMNVAndroidVibrateThreadData>(); _androidVibrateThreadData = new MMNVAndroidVibrateThreadData(); } _androidVibrateThreadData.Pattern = pattern; _androidVibrateThreadData.Amplitudes = amplitudes; _androidVibrateThreadData.Repeat = repeat; _androidVibrateThread.Run(AndroidVibrateThread, _androidVibrateThreadData); } else { AndroidVibrateNoThread(pattern, amplitudes, repeat); } } }
/// <summary> /// Returns true if the current platform is iOS, false otherwise /// </summary> /// <returns><c>true</c>, if O was ied, <c>false</c> otherwise.</returns> public static bool iOS() { return(MMNVPlatform.iOS()); }
/// <summary> /// Returns true if the current platform is Android, false otherwise. /// </summary> public static bool Android() { return(MMNVPlatform.Android()); }
/// <summary> /// iOS only : triggers a haptic feedback of the specified type /// </summary> /// <param name="type">Type.</param> public static void iOSTriggerHaptics(HapticTypes type, bool defaultToRegularVibrate = false) { if (!MMNVPlatform.iOS()) { return; } if (!iOSHapticsInitialized) { iOSInitializeHaptics(); } // this will trigger a standard vibration on all the iOS devices that don't support haptic feedback if (iOSHapticsSupported()) { switch (type) { case HapticTypes.Selection: MMNViOS_SelectionHaptic(); break; case HapticTypes.Success: MMNViOS_SuccessHaptic(); break; case HapticTypes.Warning: MMNViOS_WarningHaptic(); break; case HapticTypes.Failure: MMNViOS_FailureHaptic(); break; case HapticTypes.LightImpact: MMNViOS_LightImpactHaptic(); break; case HapticTypes.MediumImpact: MMNViOS_MediumImpactHaptic(); break; case HapticTypes.HeavyImpact: MMNViOS_HeavyImpactHaptic(); break; case HapticTypes.RigidImpact: MMNViOS_RigidImpactHaptic(); break; case HapticTypes.SoftImpact: MMNViOS_SoftImpactHaptic(); break; } } else if (defaultToRegularVibrate) { #if UNITY_IOS Handheld.Vibrate(); #endif } }