private Band.Notifications.VibrationType ToVibrationType(VibrationType vibrationType) { switch (vibrationType) { case VibrationType.NotificationAlarm: return(Band.Notifications.VibrationType.NotificationAlarm); case VibrationType.NotificationOneTone: return(Band.Notifications.VibrationType.NotificationOneTone); case VibrationType.NotificationTimer: return(Band.Notifications.VibrationType.NotificationTimer); case VibrationType.NotificationTwoTone: return(Band.Notifications.VibrationType.NotificationTwoTone); case VibrationType.OneToneHigh: return(Band.Notifications.VibrationType.OneToneHigh); case VibrationType.RampDown: return(Band.Notifications.VibrationType.RampDown); case VibrationType.RampUp: return(Band.Notifications.VibrationType.RampUp); case VibrationType.ThreeToneHigh: return(Band.Notifications.VibrationType.ThreeToneHigh); case VibrationType.TwoToneHigh: return(Band.Notifications.VibrationType.TwoToneHigh); default: throw new ArgumentOutOfRangeException("vibrationType"); } }
public VibrationAction(string action) { //actionからTypeに変更 string first = action[0].ToString(); int type; if (int.TryParse(first, out type)) { actionType = ActionType.Vibrate; vibrateType = (VibrationType)type; } else { string v = action.Remove(0, 1); if (first == "t") { actionType = ActionType.WaitTime; float.TryParse(v, out waitTime); } else if (first == "f") { actionType = ActionType.WaitFrame; int.TryParse(v, out waitFrameCount); } } }
public static Task VibrateTaskAsync(this IBandNotificationManager manager, VibrationType vibrationType) { var tcs = new TaskCompletionSource <object> (); manager.VibrateAsync(vibrationType, tcs.AttachCompletionHandler()); return(tcs.Task); }
public MyoResult Vibrate64(IntPtr myo, VibrationType type, out IntPtr error) { // Contract.Requires<ArgumentException>(myo != IntPtr.Zero, "The pointer to the Myo must be set."); error = default(IntPtr); return(default(MyoResult)); }
VibrationManager.VibrationType ToHyperCommonVivrationType(VibrationType type) { switch (type) { case VibrationType.SelectionChange: return(VibrationManager.VibrationType.SelectionChange); case VibrationType.ImpactLight: return(VibrationManager.VibrationType.ImpactLight); case VibrationType.ImpactMedium: return(VibrationManager.VibrationType.ImpactMedium); case VibrationType.ImpactHeavy: return(VibrationManager.VibrationType.ImpactHeavy); case VibrationType.NotificationSuccess: return(VibrationManager.VibrationType.NotificationSuccess); case VibrationType.NotificationWarning: return(VibrationManager.VibrationType.NotificationWarning); case VibrationType.NotificationFailure: return(VibrationManager.VibrationType.NotificationFailure); case VibrationType.UnityVibrate: return(VibrationManager.VibrationType.UnityVibrate); } return(0); }
public void VibrateAll(VibrationType vibrationType = VibrationType.Short) { foreach (var myo in Myos) { myo.Vibrate(vibrationType); } }
/// <summary> /// Vibrates the device /// </summary> /// <param name="vibrationType">Type of vibration to start</param> public static void Vibrate(VibrationType vibrationType) { if (vibrationType == VibrationType.Selection) { #if UNITY_ANDROID Vibrate_Android(LIGHT_DURATION, LIGHT_AMPLITUDE); #elif UNITY_IOS iOS_Selection(); #endif } else if (vibrationType == VibrationType.SuccessNotification) { #if UNITY_ANDROID VibratePattern_Android(SUCCESS_PATTERN, SUCCESS_AMPLITUDE); #elif UNITY_IOS iOS_Success(); #endif } else if (vibrationType == VibrationType.WarningNotification) { #if UNITY_ANDROID VibratePattern_Android(WARNING_PATTERN, WARNING_AMPLITUDE); #elif UNITY_IOS iOS_Warning(); #endif } else if (vibrationType == VibrationType.FailureNotification) { #if UNITY_ANDROID VibratePattern_Android(FAILURE_PATTERN, FAILURE_AMPLITUDE); #elif UNITY_IOS iOS_Failure(); #endif } else if (vibrationType == VibrationType.LightImpact) { #if UNITY_ANDROID Vibrate_Android(LIGHT_DURATION, LIGHT_AMPLITUDE); #elif UNITY_IOS iOS_LightImpact(); #endif } else if (vibrationType == VibrationType.MediumImpact) { #if UNITY_ANDROID Vibrate_Android(MEDIUM_DURATION, MEDIUM_AMPLITUDE); #elif UNITY_IOS iOS_MediumImpact(); #endif } else if (vibrationType == VibrationType.HeavyImpact) { #if UNITY_ANDROID Vibrate_Android(HEAVY_DURATION, HEAVY_AMPLITUDE); #elif UNITY_IOS iOS_HeavyImpact(); #endif } }
//public event EventHandler<OrientationDataEventArgs> OrientationDataAcquired; //public event EventHandler<AccelerometerDataEventArgs> AccelerometerDataAcquired; //public event EventHandler<GyroscopeDataEventArgs> GyroscopeDataAcquired; public void Vibrate(VibrationType vibrationType = VibrationType.Short, int myoId = 0) { if (myoId < 0 || myoId >= Myos.Count) { return; } Myos.ElementAt(myoId).Vibrate(vibrationType); }
public async Task VibrateAsync(VibrationType vibrationType) { #if __ANDROID__ || __IOS__ await Native.VibrateTaskAsync(vibrationType.ToNative()); #elif WINDOWS_PHONE_APP await Native.VibrateAsync(vibrationType.ToNative()); #endif }
/// <summary> /// Causes the Myo to vibrate. /// </summary> /// <param name="type">The type of vibration.</param> public void Vibrate(VibrationType type) { if (PlatformInvocation.Running32Bit) { vibrate_32(_handle, type, IntPtr.Zero); } else { vibrate_64(_handle, type, IntPtr.Zero); } }
public void vibrate(VibrationType vibrationType) { float vibrationFrequency, vibrationAmplitude; if (vibrationType == VibrationType.Gentle) { vibrationFrequency = gentleVibrationFrequency; vibrationAmplitude = gentleVibrationAmplitude; } else { vibrationFrequency = strongVibrationFrequency; vibrationAmplitude = strongVibrationAmplitude; } OVRInput.SetControllerVibration(vibrationFrequency, vibrationAmplitude, controller); StartCoroutine("stopVibrating", controller); }
//calling custom vibration public void CustomVibration(int playerId, VibrationType vT) { #if UNITY_SWITCH VibrationTypeClass vibrationToFire = VibrationType.Where(r => r.VibrationT == vT).First(); foreach (Joystick joystick in ReInput.players.GetPlayer(playerId).controllers.Joysticks) { // Get the Switch Gamepad Extension from the Joystick ISwitchVibrationDevice ext = joystick.GetExtension <ISwitchVibrationDevice>(); if (ext != null) { for (int i = 0; i < ext.vibrationMotorCount; i++) { ext.SetVibration(i, vibrationToFire.vibFile); // Pass the BNVIB file as a byte array } } } #endif }
public void Vibrate(VibrationType type, bool vibrateUnSupported = false) { #if !IMPORT_HYPERCOMMON Debug.Log("Vibrate " + type); #else if (IsSupported) { VibrationManager.Instance.Vibrate(ToHyperCommonVivrationType(type)); } else { if (vibrateUnSupported) { VibrationManager.Instance.Vibrate(ToHyperCommonVivrationType(type)); } } #endif }
/// <inheritdoc /> public void Vibrate(VibrationType type) { var command = MyoCommand.Create( _myoErrorHandlerDriver, () => { IntPtr errorHandle; var result = PlatformInvocation.Running32Bit ? _myoDeviceBridge.Vibrate32(_handle, type, out errorHandle) : _myoDeviceBridge.Vibrate64(_handle, type, out errorHandle); return(MyoCommandResult.Create( result, errorHandle)); }); command.Execute(); }
/// <summary> /// 振動させる /// </summary> /// <param name="vibrationType">振動タイプ</param> /// <returns>Task</returns> public Task VibrateAsync(VibrationType vibrationType) { var nativeType = Native.Notifications.VibrationType.RampDown; switch (vibrationType) { case VibrationType.RampDown: nativeType = Native.Notifications.VibrationType.RampDown; break; case VibrationType.RampUp: nativeType = Native.Notifications.VibrationType.RampUp; break; case VibrationType.NotificationOneTone: nativeType = Native.Notifications.VibrationType.NotificationOneTone; break; case VibrationType.NotificationTwoTone: nativeType = Native.Notifications.VibrationType.NotificationTwoTone; break; case VibrationType.NotificationAlarm: nativeType = Native.Notifications.VibrationType.NotificationAlarm; break; case VibrationType.NotificationTimer: nativeType = Native.Notifications.VibrationType.NotificationTimer; break; case VibrationType.OneToneHigh: nativeType = Native.Notifications.VibrationType.OneToneHigh; break; case VibrationType.TwoToneHigh: nativeType = Native.Notifications.VibrationType.TwoToneHigh; break; case VibrationType.ThreeToneHigh: nativeType = Native.Notifications.VibrationType.ThreeToneHigh; break; } return(Native.Notifications.BandNotificationManagerExtensions.VibrateTaskAsync(this.manager, nativeType)); }
internal static NativeVibrationType ToNative(this VibrationType vibrationType) { // can't use switch on Android as this is not an enum if (vibrationType == VibrationType.RampDown) { return(NativeVibrationType.RampDown); } if (vibrationType == VibrationType.RampUp) { return(NativeVibrationType.RampUp); } if (vibrationType == VibrationType.NotificationOneTone) { return(NativeVibrationType.NotificationOneTone); } if (vibrationType == VibrationType.NotificationTwoTone) { return(NativeVibrationType.NotificationTwoTone); } if (vibrationType == VibrationType.NotificationAlarm) { return(NativeVibrationType.NotificationAlarm); } if (vibrationType == VibrationType.NotificationTimer) { return(NativeVibrationType.NotificationTimer); } if (vibrationType == VibrationType.OneToneHigh) { return(NativeVibrationType.OneToneHigh); } if (vibrationType == VibrationType.ThreeToneHigh) { return(NativeVibrationType.ThreeToneHigh); } if (vibrationType == VibrationType.TwoToneHigh) { return(NativeVibrationType.TwoToneHigh); } throw new ArgumentOutOfRangeException("vibrationType", "Invalid VibrationType specified."); }
private async void OnVibratePatternClick(object sender, EventArgs e) { using (var builder = new AlertDialog.Builder(Activity)) { VibrationType[] values = VibrationType.Values(); string[] names = new string[values.Length]; for (int i = 0; i < names.Length; i++) { names[i] = values[i].ToString(); } builder.SetItems(names, (dialog, args) => { mSelectedVibrationType = values[args.Which]; ((Dialog)dialog).Dismiss(); RefreshControls(); }); builder.SetTitle("Select vibration type:"); builder.Show(); } }
public static void Vibrate(VibrationType vibrationType) { switch (vibrationType) { case VibrationType.Light: if (PlayerDataController.data.isVibrationOpen) { Taptic.Light(); } break; case VibrationType.Medium: if (PlayerDataController.data.isVibrationOpen) { Taptic.Medium(); } break; case VibrationType.Success: if (PlayerDataController.data.isVibrationOpen) { Taptic.Success(); } break; case VibrationType.Failure: if (PlayerDataController.data.isVibrationOpen) { Taptic.Failure(); } break; default: break; } }
public Task VibrateAsync(VibrationType vibrationType) { throw new NotImplementedException(); }
public static Task VibrateTaskAsync (this IBandNotificationManager manager, VibrationType vibrationType) { var tcs = new TaskCompletionSource<object> (); manager.VibrateAsync (vibrationType, tcs.AttachCompletionHandler ()); return tcs.Task; }
public Task VibrateAsync(VibrationType vibrationType, CancellationToken token) { return(this.VibrateAsync(vibrationType)); }
private static extern void vibrate_64(IntPtr myo, VibrationType type, IntPtr error);
public void Vibrate(VibrationType type) { libmyo.vibrate(_handle, (libmyo.VibrationType)type, IntPtr.Zero); }
IAsyncAction IBandNotificationManager.VibrateAsync(VibrationType vibrationType) { return(AsyncInfo.Run(cancellationToken => this.bandClient.NotificationManager.VibrateAsync(ToVibrationType(vibrationType), cancellationToken))); }
/// <inheritdoc /> public void Vibrate(VibrationType type) { var command = MyoCommand.Create( _myoErrorHandlerDriver, () => { IntPtr errorHandle; var result = PlatformInvocation.Running32Bit ? _myoDeviceBridge.Vibrate32(_handle, type, out errorHandle) : _myoDeviceBridge.Vibrate64(_handle, type, out errorHandle); return MyoCommandResult.Create( result, errorHandle); }); command.Execute(); }
public static extern void vibrate(IntPtr myo, VibrationType type, IntPtr error);
private static extern MyoResult vibrate_64(IntPtr myo, VibrationType type, out IntPtr error);
public void Vibrate(VibrationType type) { #if !UNITY_ANDROID || UNITY_EDITOR libmyo.vibrate(_handle, (libmyo.VibrationType)type, IntPtr.Zero); #endif }
public MyoResult Vibrate64(IntPtr myo, VibrationType type, out IntPtr error) { Contract.Requires<ArgumentException>(myo != IntPtr.Zero, "The pointer to the Myo must be set."); error = default(IntPtr); return default(MyoResult); }
public void IssueCommand_Vibrate (VibrationType vibration) { this.IssueCommand (new ProtocolCommandVibrateType ((ProtocolVibration) vibration)); }
/// <inheritdoc /> public MyoResult Vibrate64(IntPtr myo, VibrationType type, out IntPtr error) { return(vibrate_64(myo, type, out error)); }
public static Task VibrateTaskAsync(this IBandNotificationManager manager, VibrationType type) { return manager.VibrateAsync(type).AsTask(); }
/// <summary> /// Vibrates the connected Band device using the specified vibration type. /// </summary> /// <param name="vibrationType">Type of vibration to use.</param> public async Task VibrateAsync(VibrationType vibrationType) { #if __ANDROID__ || __IOS__ await Native.VibrateTaskAsync(vibrationType.ToNative()); #elif WINDOWS_PHONE_APP await Native.VibrateAsync(vibrationType.ToNative()); #endif }
public void Vibrate(VibrationType type) { libmyo.vibrate(_handle, (libmyo.VibrationType)type, IntPtr.Zero); }
public async Task VibrateAsync(VibrationType vibrationType) { await Task.Delay(300); }
public void Vibrate(VibrationType type) { }
public async Task VibrateAsync(VibrationType vibrationType, CancellationToken token) { await Task.Delay(300, token); }
/// <inheritdoc /> public void Vibrate(VibrationType type) { _myoDeviceDriver.Vibrate(type); }
private async void OnVibratePatternClick(object sender, EventArgs e) { using (var builder = new AlertDialog.Builder(Activity)) { VibrationType[] values = VibrationType.Values(); string[] names = new string[values.Length]; for (int i = 0; i < names.Length; i++) { names[i] = values[i].ToString(); } builder.SetItems(names, (dialog, args) => { mSelectedVibrationType = values[args.Which]; ((Dialog) dialog).Dismiss(); RefreshControls(); }); builder.SetTitle("Select vibration type:"); builder.Show(); } }
public static extern void vibrate(IntPtr myo, VibrationType type, IntPtr error);
public Task VibrateAsync(VibrationType vibrationType, CancellationToken token) { throw new NotImplementedException(); }
public static Task VibrateTaskAsync(this IBandNotificationManager manager, VibrationType type) { return(manager.VibrateAsync(type).AsTask()); }
public void Vibrate(VibrationType type) { Handler.Call("myoVibrate", type.ToString()); }