public bool SendDevice(IVirtualDevice device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
if (!Created)
{
return(false);
}
IntPtr handle;
if (!deviceHandles.TryGetValue(device, out handle))
{
return(false);
}
switch (device.DeviceType)
{
case VirtualDeviceType.Keyboard:
return(SendKeyboard(device, handle));
case VirtualDeviceType.TrackingInterface:
return(SendFreetrackInterface(device, handle));
default:
throw new NotImplementedException();
}
}
protected virtual void Dispose(bool disposing)
{
if (!mDisposed)
{
if (disposing)
{
// dispose of managed resources
if (mDevice != null)
{
mDevice = null;
}
mDeviceSet = null;
// the Program class will dispose of the streams
//if (mTopOfPipeline != null)
//{
// mTopOfPipeline.Dispose();
// mTopOfPipeline = null;
//}
}
// There are no unmanaged resources to release, but
// if we add them, they need to be released here.
}
mDisposed = true;
// If it is available, make the call to the
// base class's Dispose(Boolean) method
//base.Dispose(disposing);
}
public void Initialize(bool isBackup, Stream topOfPipeline, IVirtualDevice device, IVirtualDeviceSet deviceSet)
{
mIsBackup = isBackup;
mTopOfPipeline = topOfPipeline;
mDevice = device;
mDeviceSet = deviceSet;
}
public bool DisconnectDevice(IVirtualDevice device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
if (!Created)
{
return(false);
}
IntPtr handle;
if (!deviceHandles.TryGetValue(device, out handle))
{
return(true);
}
switch (device.DeviceType)
{
case VirtualDeviceType.Keyboard:
Ivj.DisconnectKeyboard(contextHandle, handle);
break;
case VirtualDeviceType.TrackingInterface:
Ivj.DisconnectFreetrackInterface(contextHandle, handle);
break;
default:
throw new NotImplementedException();
}
deviceHandles.Remove(device);
return(true);
}
/// <summary>
/// Disconnects the device with the given ID from this instance.
/// </summary>
/// <returns><c>true</c>, if the operation wass successful, <c>false</c> otherwise.</returns>
/// <param name="deviceId">Device identifier.</param>
public bool DisconnectDevice(int deviceId)
{
IVirtualDevice device = null;
lock (deviceSync) {
if (deviceId < 0 || deviceId >= devices.Count)
{
return(false);
}
device = devices[deviceId];
}
lock (contextSync) {
if (!context.DisconnectDevice(device))
{
return(false);
}
}
lock (deviceSync) {
if (deviceId == devices.Count - 1)
{
devices.RemoveAt(deviceId);
}
else
{
devices[deviceId] = null;
}
}
if (device.DeviceType == VirtualDeviceType.TrackingInterface)
{
Interlocked.Decrement(ref ftRequestNo);
}
return(true);
}
/// <summary>
/// Reconnects the device with the given ID.
/// This method can be used to disconnect and connect a device without changing its ID.
/// </summary>
/// <returns><c>true</c>, if the operation was successful, <c>false</c> otherwise.</returns>
/// <param name="deviceId">Device identifier.</param>
/// <param name="device">New device specification.</param>
public bool ReconnectDevice(int deviceId, IVirtualDevice device)
{
Process process = new Process();
if (deviceId < 0)
{
throw new ArgumentOutOfRangeException("deviceId");
}
if (device == null)
{
throw new ArgumentOutOfRangeException("device");
}
// find the old device
IVirtualDevice oldDevice;
lock (deviceSync) {
if (deviceId < 0 || deviceId >= devices.Count)
{
return(false);
}
if (devices[deviceId] == null)
{
return(false);
}
oldDevice = devices[deviceId];
}
// internal reconnect
lock (contextSync) {
if (!context.DisconnectDevice(oldDevice))
{
return(false);
}
if (oldDevice.DeviceType == VirtualDeviceType.TrackingInterface)
{
Interlocked.Decrement(ref ftRequestNo);
}
if (!context.ConnectDevice(device))
{
return(false);
}
if (device.DeviceType == VirtualDeviceType.TrackingInterface)
{
Interlocked.Increment(ref ftRequestNo);
}
}
// exchange the devices
// since the old device is still officially connected the device id has not been reassigned
lock (deviceSync) {
devices[deviceId] = device;
}
return(true);
}
private void Port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
while (port.BytesToRead >= 4 && port.BytesToRead % 4 == 0)
{
byte[] packet = new byte[4];
int read = port.Read(packet, 0, 4);
InterfaceDebugger.DataReceived(packet);
switch (packet[0])
{
case 0x00:
{
break;
}
case 0x01:
{
IVirtualDevice device = GetDevice(packet);
bool found = false;
for (int i = 0; i < Subdevices.Count; i++)
{
if (Subdevices[i].Id == packet[2]) //if the device already exists, update it
{
Subdevices[i] = device;
found = true;
}
}
//if the device doesn't already exist, add it
if (!found)
{
devices.Add(device);
}
//sort the list on the device ID
devices = devices.OrderBy(o => o.Id).ToList();
DeviceAttached?.Invoke(this, new VirtualDeviceEventArgs(device));
break;
}
case 0x02:
{
//device sends a report
if (packet[1] > devices.Count - 1)
{
break;
}
devices[packet[1]].ReceivePacket(packet);
break;
}
}
}
}
private bool FindDevice(IVirtualDevice device, out TreeIter iter)
{
for (int i = 0; i < IterNChildren (); i++) {
IterNthChild (out iter, i);
IVirtualDevice device2 = (IVirtualDevice) GetValue (iter, 0);
if (device == device2) {
return true;
}
}
iter = TreeIter.Zero;
return false;
}
private bool SendKeyboard(IVirtualDevice device, IntPtr handle)
{
object[] modifiedKeys = device.GetModifiedKeys(VirtualDeviceCapability.Key);
foreach (object key in modifiedKeys)
{
KeyState state = device.GetKeyState(VirtualDeviceCapability.Key, key);
int keyIndex = Ivj.GetKeyboardKeyIndex(key);
if (keyIndex > -1)
{
Ivj.SetKeyboardKey(handle, keyIndex, state.SmoothPressed);
}
}
bool result = Ivj.SendKeyboard(handle);
device.Send();
return(result);
}
private bool SendFreetrackInterface(IVirtualDevice device, IntPtr handle)
{
object[] modifiedKeys = device.GetModifiedKeys(VirtualDeviceCapability.Axis);
foreach (object key in modifiedKeys)
{
KeyState state = device.GetKeyState(VirtualDeviceCapability.Axis, key);
int axisIndex = Ivj.GetFreetrackAxisIndex(key);
if (axisIndex > -1)
{
Ivj.SetFreetrackAxis(handle, axisIndex, state.SmoothAxis, state.RawAxis);
}
}
bool result = Ivj.SendFreetrackInterface(handle);
device.Send();
return(result);
}
public bool ConnectDevice(IVirtualDevice device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
if (!Created)
{
return(false);
}
if (deviceHandles.ContainsKey(device))
{
return(true);
}
IntPtr handle = IntPtr.Zero;
IntPtr constructionInfo;
switch (device.DeviceType)
{
case VirtualDeviceType.Keyboard:
constructionInfo = Ivj.AllocKeyboardConstructionInfo();
handle = Ivj.ConnectKeyboard(contextHandle, constructionInfo);
Ivj.FreeKeyboardConstructionInfo(constructionInfo);
break;
case VirtualDeviceType.TrackingInterface:
constructionInfo = Ivj.AllocFreetrackConstructionInfo();
handle = Ivj.ConnectFreetrackInterface(contextHandle, constructionInfo);
Ivj.FreeFreetrackConstructionInfo(constructionInfo);
break;
default:
throw new NotImplementedException();
}
if (handle == IntPtr.Zero)
{
return(false);
}
deviceHandles.Add(device, handle);
return(true);
}
/// <summary>
/// Connects the given device.
/// </summary>
/// <returns>Id to reference the device.</returns>
/// <param name="device">Device specification.</param>
public int ConnectDevice(IVirtualDevice device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
lock (contextSync) {
if (!context.ConnectDevice(device))
{
return(-1);
}
}
int result = -1;
lock (deviceSync) {
// find empty device index
for (int i = 0; i < devices.Count; i++)
{
if (devices[i] == null)
{
result = i;
break;
}
}
// add at empty index or append to end
if (result < 0)
{
result = devices.Count;
devices.Add(device);
}
else
{
devices[result] = device;
}
}
if (device.DeviceType == VirtualDeviceType.TrackingInterface)
{
Interlocked.Increment(ref ftRequestNo);
}
return(result);
}
/// <summary>
/// Sends device state updates to the OS or HID backend.
/// </summary>
private void SendState()
{
var toSend = new Queue <IVirtualDevice>();
lock (deviceSync) {
for (int i = 0; i < devices.Count; i++)
{
if (devices[i] != null && devices[i].SendRequired)
{
toSend.Enqueue(devices[i]);
}
}
}
lock (contextSync) {
while (toSend.Count > 0)
{
IVirtualDevice device = toSend.Dequeue();
context.SendDevice(device);
}
}
}
public void PositionChanged(object sender, PositionDetectedEventArgs args)
{
// TODO: protect with locks
var configCopy = config;
VirtualDeviceManager.Instance.Invoke(delegate {
VirtualDeviceManager.Instance.BeginUpdate();
var toRemove = new Queue <int>();
foreach (var pair in configCopy)
{
List <Binding> bindings = pair.Value;
int deviceIndex = pair.Key;
int deviceId = EquipmentMaster.Instance.VirtualDevice.GetEquipment(deviceIndex, -1);
if (deviceId < 0)
{
LogManager.Instance.Log(LogEntry.CreateWarning(this, "Missing device " + deviceIndex));
continue;
}
IVirtualDevice device = VirtualDeviceManager.Instance.GetDevice(deviceId);
if (device == null)
{
LogManager.Instance.Log(LogEntry.CreateWarning(this, "Missing device with id " + deviceId));
continue;
}
device.BeginUpdate();
foreach (Binding bind in pair.Value)
{
KeyState state = args.Position.GetAxis(bind.Axis);
// TODO: apply mapping
if (!device.SetKeyState(bind.Capability, bind.PosKey, state))
{
string message = string.Format("Cannot set device {0} key state {1}|{2}", deviceIndex, bind.PosKey, bind.NegKey);
LogManager.Instance.Log(LogEntry.CreateWarning(this, message));
}
}
device.EndUpdate();
}
VirtualDeviceManager.Instance.EndUpdate();
});
}
public VirtualDeviceEventArgs(IVirtualDevice device)
{
Device = device;
}
private static void ReadWriteData(IVirtualDevice device, ICommandBuffer buff, Stream stream, bool isBackup)
{
while (device.GetCommand(null, buff))
{
if (!buff.TimedOut)
{
CompletionCode completionCode = CompletionCode.DiskFull;
uint bytesTransferred = 0;
try
{
switch (buff.CommandType)
{
case DeviceCommandType.Write:
if (!isBackup)
{
throw new InvalidOperationException("Cannot write in 'restore' mode");
}
bytesTransferred = (uint)buff.WriteToStream(stream);
completionCode = CompletionCode.Success;
break;
case DeviceCommandType.Read:
if (isBackup)
{
throw new InvalidOperationException("Cannot read in 'backup' mode");
}
bytesTransferred = (uint)buff.ReadFromStream(stream);
if (bytesTransferred > 0)
{
completionCode = CompletionCode.Success;
}
else
{
completionCode = CompletionCode.HandleEof;
}
break;
case DeviceCommandType.ClearError:
completionCode = CompletionCode.Success;
break;
case DeviceCommandType.Flush:
stream.Flush();
completionCode = CompletionCode.Success;
break;
default:
throw new ArgumentException(string.Format("Unknown command: {0}", buff.CommandType));
}
}
finally
{
device.CompleteCommand(buff, completionCode, bytesTransferred, (ulong)0);
}
}
}
}
private void AddDevice(IVirtualDevice device)
{
AppendValues (device);
}
private void RemoveDevice(IVirtualDevice device)
{
TreeIter iter;
if (FindDevice (device, out iter)) {
Remove (ref iter);
}
}
