public void SubscribeOutput(OutputSubscriptionRequest subReq)
{
if (!_subscriptions.ContainsKey(subReq.SubscriptionDescriptor.SubscriberGuid))
{
_subscriptions.TryAdd(subReq.SubscriptionDescriptor.SubscriberGuid, subReq);
}
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
var devId = _subscriptionToDevice[subReq.SubscriptionDescriptor.SubscriberGuid];
if (!_vJoyDevices[devId].IsAcquired)
{
return(false);
}
switch (bindingDescriptor.Type)
{
case BindingType.Axis:
return(vJ.SetAxis((state + 32768) / 2, devId + 1, AxisIdToUsage[bindingDescriptor.Index]));
case BindingType.Button:
return(vJ.SetBtn(state == 1, devId + 1, (uint)(bindingDescriptor.Index + 1)));
case BindingType.POV:
int pov = (int)(Math.Floor((decimal)(bindingDescriptor.Index / 4)));
int dir = bindingDescriptor.Index % 4;
//Log("vJoy POV output requested - POV {0}, Dir {1}, State {2}", pov, dir, state);
_vJoyDevices[devId].SetPovState(pov, dir, state);
break;
default:
break;
}
return(false);
}
private void LogOutputSubReq(string title, OutputSubscriptionRequest subReq)
{
Log("{0}: Provider {1}, Device {2}, Guid {3}",
title,
subReq.ProviderDescriptor.ProviderName,
subReq.DeviceDescriptor.DeviceHandle,
subReq.SubscriptionDescriptor.SubscriberGuid);
}
public bool UnSubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
if (!isLive)
{
return(false);
}
return(devicesHandler.UnsubscribeOutput(subReq));
}
public void Add(OutputSubscriptionRequest subReq)
{
if (_subReqs.Count == 0)
{
Acquire();
}
_subReqs.Add(subReq.SubscriptionDescriptor.SubscriberGuid, subReq);
}
public bool AddSubscription(OutputSubscriptionRequest subReq)
{
subscriptions.Add(subReq.SubscriptionDescriptor.SubscriberGuid, subReq);
logger.Log("Adding subscription to controller # {0}", subReq.DeviceDescriptor.DeviceInstance);
IsRequested = true;
SetAcquireState();
return(true);
}
public bool UnsubscribeOutput(OutputSubscriptionRequest subReq)
{
if (HasHandler(subReq.DeviceDescriptor))
{
return(deviceHandlers[subReq.DeviceDescriptor.DeviceHandle][subReq.DeviceDescriptor.DeviceInstance].RemoveSubscription(subReq));
}
return(false);
}
public void Remove(OutputSubscriptionRequest subReq)
{
_subReqs.Remove(subReq.SubscriptionDescriptor.SubscriberGuid);
if (_subReqs.Count == 0)
{
Relinquish();
}
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
if (!isLive)
{
return(false);
}
return(devicesHandler.SetOutputState(subReq, bindingDescriptor, state));
}
public bool UnSubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
uint devId = _subscriptionToDevice[subReq.SubscriptionDescriptor.SubscriberGuid];
_vJoyDevices[devId].Remove(subReq);
_subscriptionToDevice.Remove(subReq.SubscriptionDescriptor.SubscriberGuid);
return(true);
}
public bool SubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
var devId = DevIdFromHandle(subReq.DeviceDescriptor.DeviceHandle);
_vJoyDevices[devId].Add(subReq);
_subscriptionToDevice.Add(subReq.SubscriptionDescriptor.SubscriberGuid, devId);
return(true);
}
public bool UnSubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
if (_activeOutputDevices.TryGetValue(subReq.DeviceDescriptor, out var deviceHandler))
{
deviceHandler.UnsubscribeOutput(subReq);
return(true);
}
return(false);
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
if (_activeOutputDevices.TryGetValue(subReq.DeviceDescriptor, out var deviceHandler))
{
deviceHandler.SetOutputState(subReq, bindingDescriptor, state);
return(true);
}
return(false);
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
var handler = GetHandler(subReq.DeviceDescriptor);
if (handler != null)
{
return(handler.SetOutputState(subReq, bindingDescriptor, state));
}
return(false);
}
public bool UnSubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
var deviceInfo = DiscoveryManager.FindDeviceInfo(subReq.DeviceDescriptor.DeviceHandle);
if (deviceInfo == null)
{
return(false);
}
return(DescriptorManager.StopOutputDevice(deviceInfo));
}
public bool RemoveSubscription(OutputSubscriptionRequest subReq)
{
if (subscriptions.ContainsKey(subReq.SubscriptionDescriptor.SubscriberGuid))
{
subscriptions.Remove(subReq.SubscriptionDescriptor.SubscriberGuid);
}
logger.Log("Removing subscription to controller # {0}", subReq.DeviceDescriptor.DeviceInstance);
IsRequested = HasSubscriptions();
SetAcquireState();
return(true);
}
public bool SubscribeOutputDevice(OutputSubscriptionRequest subReq)
{
if (!_activeOutputDevices.TryGetValue(subReq.DeviceDescriptor, out var deviceHandler))
{
deviceHandler = new MidiOutputDeviceHandler(subReq.DeviceDescriptor, _deviceLibrary.GetOutputDeviceIdentifier(subReq.DeviceDescriptor), OutputDeviceEmptyHandler);
_activeOutputDevices.TryAdd(subReq.DeviceDescriptor, deviceHandler);
}
_activeOutputDevices[subReq.DeviceDescriptor].SubscribeOutput(subReq);
return(true);
}
public void UnsubscribeOutput(OutputSubscriptionRequest subReq)
{
if (_subscriptions.ContainsKey(subReq.SubscriptionDescriptor.SubscriberGuid))
{
_subscriptions.TryRemove(subReq.SubscriptionDescriptor.SubscriberGuid, out _);
}
if (_subscriptions.IsEmpty)
{
_deviceEmptyHandler?.Invoke(this, _deviceDescriptor);
}
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
if (outputHandlers.ContainsKey(subReq.DeviceDescriptor.DeviceHandle))
{
var slot = outputHandlers[subReq.DeviceDescriptor.DeviceHandle].GetSlot(bindingDescriptor);
if (slot != null)
{
var value = OutputHandler.GetValue(bindingDescriptor, state);
outputState[(int)slot] = value;
Write(outputState);
return(true);
}
}
return(false);
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
switch (bindingDescriptor.Type)
{
case BindingType.Axis:
SetAxisState(bindingDescriptor, state);
break;
case BindingType.Button:
SetButtonState(bindingDescriptor, state);
break;
case BindingType.POV:
SetPovState(bindingDescriptor, state);
break;
}
return(false);
}
public bool UnsubscribeOutput(OutputSubscriptionRequest _subReq)
{
var subReq = _subReq.Clone();
LogOutputSubReq("UnsubscribeOutput", subReq);
var ret = false;
if (ActiveOutputSubscriptions.ContainsKey(subReq.SubscriptionDescriptor.SubscriberGuid))
{
var provider = GetProvider <IOutputProvider>(subReq.ProviderDescriptor.ProviderName);
ret = provider.UnSubscribeOutputDevice(subReq);
if (ret)
{
ActiveOutputSubscriptions.Remove(subReq.SubscriptionDescriptor.SubscriberGuid);
}
}
return(ret);
}
public void SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
var channel = (bindingDescriptor.Index & 0xf) + 1;
var commandCode = (MidiCommandCode)(bindingDescriptor.Index & 0xf0);
MidiEvent evt;
switch (commandCode)
{
case MidiCommandCode.ControlChange:
var value = (int)((state + 32768) / 516.0236220472441);
evt = new ControlChangeEvent(0, channel, (MidiController)bindingDescriptor.SubIndex, value);
break;
default:
return;
}
_midiOut.Send(evt.GetAsShortMessage());
}
public bool SubscribeOutput(OutputSubscriptionRequest _subReq)
{
var subReq = _subReq.Clone();
LogOutputSubReq("SubscribeOutput", subReq);
if (ActiveOutputSubscriptions.ContainsKey(subReq.SubscriptionDescriptor.SubscriberGuid))
{
// If this Subscriber has an existing subscription...
// ... then remove the old subscription first.
// unsub output here
UnsubscribeOutput(ActiveOutputSubscriptions[subReq.SubscriptionDescriptor.SubscriberGuid]);
}
var provider = GetProvider <IOutputProvider>(subReq.ProviderDescriptor.ProviderName);
bool ret = false;
ret = provider.SubscribeOutputDevice(subReq);
if (ret)
{
ActiveOutputSubscriptions.Add(subReq.SubscriptionDescriptor.SubscriberGuid, subReq);
}
return(ret);
}
public InterceptionMouseOutputTester()
{
var interceptionMouseSubReq = new OutputSubscriptionRequest
{
DeviceDescriptor = Library.Devices.Interception.LogitechWeelMouseUSB,
ProviderDescriptor = Library.Providers.Interception,
SubscriptionDescriptor = new SubscriptionDescriptor
{
ProfileGuid = Library.Profiles.Default,
SubscriberGuid = Guid.NewGuid()
}
};
IOW.Instance.SubscribeOutput(interceptionMouseSubReq);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.LButton, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.LButton, 0);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.RButton, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.RButton, 0);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.MButton, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.MButton, 0);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.XButton1, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.XButton1, 0);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.XButton2, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.XButton2, 0);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.WheelUp, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.WheelDown, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.WheelLeft, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseButton.WheelRight, 1);
IOW.Instance.SetOutputstate(interceptionMouseSubReq, Library.Bindings.Interception.MouseAxis.X, 100);
}
public InterceptionKeyboardOutputTester()
{
var interceptionKeyboardSubReq = new OutputSubscriptionRequest
{
DeviceDescriptor = Library.Devices.Interception.ChiconyKeyboard,
ProviderDescriptor = Library.Providers.Interception,
SubscriptionDescriptor = new SubscriptionDescriptor
{
ProfileGuid = Library.Profiles.Default,
SubscriberGuid = Guid.NewGuid()
}
};
IOW.Instance.SubscribeOutput(interceptionKeyboardSubReq);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Alt, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Alt, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.RightAlt, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.RightAlt, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Up, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Up, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.NumUp, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.NumUp, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Delete, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Delete, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.NumDelete, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.NumDelete, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Shift, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.Shift, 0);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.RightShift, 1);
IOW.Instance.SetOutputstate(interceptionKeyboardSubReq, Library.Bindings.Interception.Keyboard.RightShift, 0);
}
public VigemDs4OutputTester()
{
var vds4 = new OutputSubscriptionRequest
{
DeviceDescriptor = Library.Devices.Console.DS4_1,
ProviderDescriptor = Library.Providers.ViGEm,
SubscriptionDescriptor = new SubscriptionDescriptor
{
ProfileGuid = Library.Profiles.Default,
SubscriberGuid = Guid.NewGuid()
}
};
IOW.Instance.SubscribeOutput(vds4);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.DpadRight, 1);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.POV1Up, 1);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.DpadRight, 0);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.DpadUp, 0);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.POV1Up, 0);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.Button2, 1);
Thread.Sleep(500);
IOW.Instance.SetOutputstate(vds4, Library.Bindings.Generic.Button1, 0);
}
public void WriteOutput(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
var subscribedDevice = _subscribedDevices[subReq.DeviceDescriptor.DeviceHandle];
switch (EspUtility.GetBindingCategory(bindingDescriptor))
{
case BindingCategory.Momentary:
subscribedDevice.DataMessage.SetButton(bindingDescriptor.Index, (short)state);
break;
case BindingCategory.Event:
subscribedDevice.DataMessage.SetEvent(bindingDescriptor.Index, (short)state);
break;
case BindingCategory.Signed:
case BindingCategory.Unsigned:
subscribedDevice.DataMessage.SetAxis(bindingDescriptor.Index, (short)state);
break;
case BindingCategory.Delta:
subscribedDevice.DataMessage.SetDelta(bindingDescriptor.Index, (short)state);
break;
}
}
protected bool SubscribeOutput(OutputSubscriptionRequest subReq)
{
return(false);
}
public bool SetOutputState(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
int devId;
try
{
devId = _deviceLibrary.GetInputDeviceIdentifier(subReq.DeviceDescriptor);
}
catch
{
return(false);
}
//Log("SetOutputState. Type: {0}, Index: {1}, State: {2}, Device: {3}", inputType, inputIndex, state, devId);
var stroke = new ManagedWrapper.Stroke();
if (HelperFunctions.IsKeyboard(devId))
{
var st = (ushort)(1 - state);
var code = (ushort)(bindingDescriptor.Index + 1);
if (code > 255)
{
st += 2;
code -= 256;
}
stroke.key.code = code;
stroke.key.state = st;
}
else
{
switch (bindingDescriptor.Type)
{
case BindingType.Axis:
var mouse = new ManagedWrapper.MouseStroke
{
//ToDo: This only implements mouse relative mode - can we allow absolute mode too?
flags = (ushort)ManagedWrapper.MouseFlag.MouseMoveRelative
};
if (bindingDescriptor.Index != 0)
{
if (bindingDescriptor.Index == 1)
{
mouse.y = state;
}
else
{
throw new NotImplementedException();
}
}
else
{
mouse.x = state;
}
stroke.mouse = mouse;
break;
case BindingType.Button:
var btn = bindingDescriptor.Index;
var flag = (int)ManagedWrapper.MouseButtonFlags[btn];
if (btn < 5)
{
// Regular buttons
if (state == 0)
{
flag *= 2;
}
}
else
{
// Wheel
stroke.mouse.rolling = (short)((btn == 5 || btn == 8) ? 120 : -120);
}
stroke.mouse.state = (ushort)flag;
break;
case BindingType.POV:
default:
throw new NotImplementedException();
}
}
ManagedWrapper.Send(_deviceContext, devId, ref stroke, 1);
return(true);
}
public bool SetOutputstate(OutputSubscriptionRequest subReq, BindingDescriptor bindingDescriptor, int state)
{
var provider = GetProvider <IOutputProvider>(subReq.ProviderDescriptor.ProviderName);
return(provider.SetOutputState(subReq, bindingDescriptor, state));
}
