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