internal static void AddConnectionProvider(EConnectionType dbType, IConnectionProvider connectionProvider) { if (!_connectionProviders.ContainsKey(dbType)) { _connectionProviders.Add(dbType, connectionProvider); } }
void HandleReceivedBuffer(CClientSocket ClientSocket, int ConnectionIndex, EConnectionType ConnectionType, byte[] buffer) { byte packet = buffer[0]; byte[] arguments = null; if (buffer.Length > 1) { arguments = new byte[buffer.Length - 1]; Buffer.BlockCopy(buffer, 1, arguments, 0, arguments.Length); } foreach (SPacketCallback PacketCallback in PacketCallbacks) { if (PacketCallback.ConnectionType != ConnectionType) { continue; } if (PacketCallback.Packet != packet) { continue; } PacketCallback.OnPacketCallback(ClientSocket, ConnectionIndex, arguments); break; } }
/// <summary> /// Initializes a new instance of the <see cref="BaseServer{PacketEnum, classType}" /> class. /// You need to manually Load the config and set the port if you use this version! /// </summary> /// <param name="logFile">The log file.</param> /// <param name="connectionType">Type of the connection.</param> /// <param name="pingPacketInterval">The ping packet interval.</param> /// <param name="tcpTimeout">The TCP timeout.</param> public BaseServer(string logFile, EConnectionType connectionType, int pingPacketInterval, int tcpTimeout) : base(logFile, connectionType, tcpTimeout) { Clients = new Dictionary <int, ClientConnection>(); PingPacketInterval = pingPacketInterval; pingSender.PingCompleted += PingCallback; PingTimer = new Timer(new TimerCallback(PingClients), null, 0, PingPacketInterval); }
public SteamController(HidDevice device, EConnectionType connection = SteamController.EConnectionType.Unknown) { State.Buttons = new SteamControllerButtons(); _device = device; ConnectionType = connection; Initalized = false; }
public AndroidLogcat(AndroidLogcat rhs) { AdbFullPath = rhs.AdbFullPath; SelectedDevice = rhs.SelectedDevice; CaptureOutputToFile = rhs.CaptureOutputToFile; AppendOutputFile = rhs.AppendOutputFile; LogBuffers = rhs.LogBuffers.Dup(); FilterSpecs = rhs.FilterSpecs.Dup(); LogFormat = rhs.LogFormat; ConnectionType = rhs.ConnectionType; IPAddressHistory = rhs.IPAddressHistory.Dup(); ConnectionPort = rhs.ConnectionPort; }
public AndroidLogcat(XElement node) { AdbFullPath = node.Element(XmlTag.ADBPath).As <string>(); SelectedDevice = node.Element(XmlTag.Device).As <string>(); CaptureOutputToFile = node.Element(XmlTag.CaptureOutput).As <bool>(); AppendOutputFile = node.Element(XmlTag.AppendOutput).As <bool>(); LogBuffers = node.Element(XmlTag.LogBuffers).As <ELogBuffer[]>(); FilterSpecs = node.Element(XmlTag.FilterSpecs).As <FilterSpec[]>(); LogFormat = node.Element(XmlTag.LogFormat).As <ELogFormat>(); ConnectionType = node.Element(XmlTag.ConnType).As <EConnectionType>(); IPAddressHistory = node.Element(XmlTag.IPAddrHistory).As <string[]>(); ConnectionPort = node.Element(XmlTag.Port).As <int>(); }
public void Read(BinaryReader reader) { ID = reader.ReadInt32(); ConnectionType = (EConnectionType)reader.ReadInt32(); //Added 2015-12-24 communicationPort = reader.ReadInt32(); //Added 2015-12-24 Name = reader.ReadStringNative(); IP = reader.ReadStringNative(); Location = reader.ReadStringNative(); lng = reader.ReadSingle(); lat = reader.ReadSingle(); Connected = reader.ReadBoolean(); Available = reader.ReadBoolean(); }
/*private void SendReport() { { byte[] outDataFinal = null; if (_device.DevicePath.Contains(@"00001124-0000-1000-8000-00805f9b34fb")) { outDataFinal = new byte[] { 0xa2, 0x31, 0x02 }.Concat(data.Skip(1)).Concat(new byte[44]).Take(79).ToArray(); Crc32 crcE = new Crc32(); byte[] crc = crcE.ComputeHash(outDataFinal, 0, outDataFinal.Length - 4); outDataFinal[outDataFinal.Length - 1] = crc[0]; outDataFinal[outDataFinal.Length - 2] = crc[1]; outDataFinal[outDataFinal.Length - 3] = crc[2]; outDataFinal[outDataFinal.Length - 4] = crc[3]; } else { outDataFinal = new byte[] { 0x00 }.Concat(data).Concat(new byte[99]).Take(79).ToArray(); } bool success = _device.WriteReport(outDataFinal.Skip(1).ToArray()); } }*/ public DualSenseController(HidDevice device, AccessMode AccessMode, EConnectionType ConnectionType = EConnectionType.Unknown) { this.AccessMode = AccessMode; this.ConnectionType = ConnectionType; State.Controls["cluster_left"] = new ControlDPad(); State.Controls["cluster_right"] = new ControlButtonQuad(); State.Controls["bumper_left"] = new ControlButton(); State.Controls["bumper_right"] = new ControlButton(); //State.Controls["bumpers2"] = new ControlButtonPair(); State.Controls["trigger_left"] = new ControlTrigger(); State.Controls["trigger_right"] = new ControlTrigger(); State.Controls["menu_left"] = new ControlButton(); State.Controls["menu_right"] = new ControlButton(); State.Controls["home"] = new ControlButton(); State.Controls["mute"] = new ControlButtonPS5Mute(AccessMode); State.Controls["stick_left"] = new ControlStickWithClick(); State.Controls["stick_right"] = new ControlStickWithClick(); State.Controls["touch_center"] = new ControlTouch(TouchCount: 2, HasClick: true); State.Controls["motion"] = new ControlMotion(); // According to this the normalized domain of the DS4 gyro is 1024 units per rad/s: https://gamedev.stackexchange.com/a/87178 _device = device; /* //new Thread(() => { //Thread.Sleep(1); { byte oldFlags = data[2]; data[2] |= 0x08; SendReport(); data[2] = oldFlags; } //Thread.Sleep(1); { byte oldFlags = data[2]; data[2] |= 0x04; data[45] = 0xff;// (byte)random.Next(0, 255); data[46] = 0x00;// (byte)random.Next(0, 255); data[47] = 0x00;// (byte)random.Next(0, 255); SendReport(); data[2] = oldFlags; } }//).Start(); */ PollingState = EPollingState.Inactive; _device.DeviceReport += OnReport; }
/// <summary> /// Initializes a new instance of the <see cref="BaseNetworkMachine{packetsEnumType, classType}" /> class. /// </summary> /// <param name="logFile">The log file. When string.Empty dont use logfiles!</param> /// <param name="connectionType">Type of the connection.</param> /// <param name="tcpTimeout">The TCP timeout.</param> internal BaseNetworkMachine(string logFile, EConnectionType connectionType, int tcpTimeout) { if (logFile != string.Empty) { SetupLogger("Logs", logFile + "_" + DateTime.Now.ToString("ddMMyyyyHHmmssfffff") + ".txt"); } Debug.Assert(connectionType != EConnectionType.NONE, "Machine has to have a Connection Type!"); _connectionType = connectionType; string s = typeof(classType).ToString(); string s1 = typeof(BaseNetworkMachine <packetsEnumType, classType>).ToString(); InitPacketEnum(typeof(EBasePackets), ref _packetMethods); InitPacketEnum(typeof(packetsEnumType), ref _packetMethods); Console.Title = GetConsoleWindowTitle(); TCPTimeout = tcpTimeout; }
/// <summary> /// Initializes a new instance of the <see cref="Server"/> class. /// </summary> /// <param name="ip">The IP on which to listen to.</param> /// <param name="dataSize">Data size for received data.</param> public Server(EConnectionType type, IPAddress ip, int port, int dataSize = 1024) { this.port = port; this.ip = ip; this.dataSize = dataSize; this.data = new byte[dataSize]; switch (type) { case EConnectionType.Client: break; case EConnectionType.Server: this.clientsList = new Dictionary <Socket, Client>(); this.acceptIncomingConnections = true; break; } this.mainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); }
/// <summary> /// Disconnects the specified unique identifier. /// </summary> /// <param name="uniqueID">The unique identifier.</param> public void Disconnect(int uniqueID = -1) { if (Clients.ContainsKey(uniqueID)) { ClientListMutex.WaitOne(); EConnectionType et = Clients[uniqueID].ConnectionType; PacketDesc_ClientDisconnected dcPkt = new PacketDesc_ClientDisconnected(); dcPkt.OtherClientID = uniqueID; dcPkt.PacketTarget = et; dcPkt.PacketOriginClientID = UniqueID; SendPacketToAllClients(dcPkt, uniqueID); ConsoleLogger.WriteToLog("Disconnected Client ID:" + uniqueID, true); if (Clients[uniqueID].ThisClient != null) { if (Clients[uniqueID].ThisClient.Connected) { Clients[uniqueID].ThisClient.GetStream().Close(); if (Clients[uniqueID].ThisClient != null) { Clients[uniqueID].ThisClient.Close(); } } Clients[uniqueID].ThisClient = null; Clients.Remove(uniqueID); NumClientThreads--; } ClientListMutex.ReleaseMutex(); if (OnClientDisconnected != null) { OnClientDisconnected(uniqueID); } } }
public IController NewDevice(IDevice device) { HidDevice _device = device as HidDevice; if (_device == null) { return(null); } if (_device.VendorId != DualSenseController.VendorId) { return(null); } if (!new int[] { DualSenseController.ProductId, }.Contains(_device.ProductId)) { return(null); } string bt_hid_id = @"00001124-0000-1000-8000-00805f9b34fb"; string devicePath = _device.DevicePath.ToString(); EConnectionType ConType = EConnectionType.Unknown; //switch (_device.ProductId) { //case DualSenseController.ProductId: if (devicePath.Contains(bt_hid_id)) { ConType = EConnectionType.Bluetooth; } else { ConType = EConnectionType.USB; } //break; } { string deviceInstanceId = DevPKey.PnpDevicePropertyAPI.devicePathToInstanceId(_device.DevicePath); Guid? ContrainerID = DevPKey.PnpDevicePropertyAPI.GetDeviceContainerId(deviceInstanceId); if (ContrainerID.HasValue) { lock (Controllers) { DualSenseController ctrl = null; if (Controllers.ContainsKey(ContrainerID.Value)) { // TODO handle subdevices, such as the audio device //ctrl = Controllers[ContrainerID.Value]; //ctrl.AddDevice(_device); } else { Controllers[ContrainerID.Value] = new DualSenseController(_device, AccessMode, ConType); ctrl = Controllers[ContrainerID.Value]; } DeviceToControllerKeyMap[device.UniqueKey] = ContrainerID.Value; if (!ControllerToDeviceKeyMap.ContainsKey(ContrainerID.Value)) { ControllerToDeviceKeyMap[ContrainerID.Value] = new HashSet <string>(); } ControllerToDeviceKeyMap[ContrainerID.Value].Add(device.UniqueKey); return(ctrl); } } } return(null); }
public static IConnectionProvider GetConnectionProvider(EConnectionType dbType) { return(_connectionProviders[dbType]); }
public IController NewDevice(IDevice device) { HidDevice _device = device as HidDevice; if (_device == null) { return(null); } if (_device.VendorId != SteamController.VendorId) { return(null); } if (!new int[] { SteamController.ProductIdDongle, SteamController.ProductIdWired, SteamController.ProductIdBT, SteamController.ProductIdChell, }.Contains(_device.ProductId)) { return(null); } { string devicePath = _device.DevicePath.ToString(); EConnectionType ConType = EConnectionType.Unknown; SteamController.EControllerType CtrlType = SteamController.EControllerType.Gordon; switch (_device.ProductId) { case SteamController.ProductIdBT: if (!devicePath.Contains("col03")) { return(null); // skip anything that isn't the controller's custom HID device } ConType = EConnectionType.Bluetooth; break; case SteamController.ProductIdWired: if (!devicePath.Contains("mi_02")) { return(null); // skip anything that isn't the controller's custom HID device } ConType = EConnectionType.USB; break; case SteamController.ProductIdDongle: if (devicePath.Contains("mi_00")) { return(null); // skip the dongle itself } ConType = EConnectionType.Dongle; break; case SteamController.ProductIdChell: if (!devicePath.Contains("mi_02")) { return(null); // skip odd 2nd device } ConType = EConnectionType.USB; CtrlType = SteamController.EControllerType.Chell; break; } SemaphoreSlim SharedDongleLock = null; if (ConType == EConnectionType.Dongle) { string deviceInstanceId = DevPKey.PnpDevicePropertyAPI.devicePathToInstanceId(_device.DevicePath); Guid? ContrainerID = DevPKey.PnpDevicePropertyAPI.GetDeviceContainerId(deviceInstanceId); if (ContrainerID.HasValue) { lock (SharedDongleLocks) { if (!SharedDongleLocks.ContainsKey(ContrainerID.Value) || !SharedDongleLocks[ContrainerID.Value].TryGetTarget(out SharedDongleLock)) { SharedDongleLock = new SemaphoreSlim(1); SharedDongleLocks.Add(ContrainerID.Value, new WeakReference <SemaphoreSlim>(SharedDongleLock)); } Console.WriteLine(ContrainerID.Value.ToString()); // clear any dead refs foreach (Guid key in SharedDongleLocks.Keys.ToList()) // ToList to clone the key list so we can modify it { if (!SharedDongleLocks[key].TryGetTarget(out _)) { SharedDongleLocks.Remove(key); } } } } } SteamController ctrl = new SteamController(_device, SharedDongleLock, ConType, CtrlType); //ctrl.HalfInitalize(); return(ctrl); } }
public IController NewDevice(IDevice device) { HidDevice _device = device as HidDevice; if (_device == null) { return(null); } if (_device.VendorId == DualShock4Controller.VENDOR_SONY) { if (!new int[] { DualShock4Controller.PRODUCT_SONY_DONGLE, DualShock4Controller.PRODUCT_SONY_DS4V1, DualShock4Controller.PRODUCT_SONY_DS4V2, }.Contains(_device.ProductId)) { return(null); } } else if (_device.VendorId == DualShock4Controller.VENDOR_BROOK) { if (_device.ProductId == DualShock4Controller.PRODUCT_BROOK_MARS) { if (_device.DevicePath.Contains(@"&col01")) { DualShock4Controller ctrl = new DualShock4Controller(_device, EConnectionType.USB); return(ctrl); } } return(null); } else { return(null); } string deviceInstanceId = DevPKey.PnpDevicePropertyAPI.devicePathToInstanceId(_device.DevicePath); bool IsVigem = DevPKey.PnpDevicePropertyAPI.GetDeviceUINumber(deviceInstanceId).HasValue; bool IsReWasd = DevPKey.PnpDevicePropertyAPI.GetDeviceContainerId(deviceInstanceId) == CONTAINER_ID_REWASD_VIRTUAL_DS4; string bt_hid_id = @"00001124-0000-1000-8000-00805f9b34fb"; string devicePath = _device.DevicePath.ToString(); EConnectionType ConType = EConnectionType.Unknown; DualShock4Controller.DS4VirtualType VirtualType = DualShock4Controller.DS4VirtualType.NotVirtual; if (IsVigem) { ConType = EConnectionType.Virtual; VirtualType = DualShock4Controller.DS4VirtualType.ViGEm; } else if (IsReWasd) { ConType = EConnectionType.Virtual; VirtualType = DualShock4Controller.DS4VirtualType.reWASD; } else { switch (_device.ProductId) { case DualShock4Controller.PRODUCT_SONY_DS4V1: case DualShock4Controller.PRODUCT_SONY_DS4V2: if (devicePath.Contains(bt_hid_id)) { ConType = EConnectionType.Bluetooth; } else { ConType = EConnectionType.USB; } break; case DualShock4Controller.PRODUCT_SONY_DONGLE: ConType = EConnectionType.Dongle; break; } } { Guid?ContrainerID = DevPKey.PnpDevicePropertyAPI.GetDeviceContainerId(deviceInstanceId); if (ContrainerID.HasValue) { lock (Controllers) { DualShock4Controller ctrl = null; if (Controllers.ContainsKey(ContrainerID.Value)) { // TODO handle subdevices, such as the audio device //ctrl = Controllers[ContrainerID.Value]; //ctrl.AddDevice(_device); } else { Controllers[ContrainerID.Value] = new DualShock4Controller(_device, ConType, VirtualType); ctrl = Controllers[ContrainerID.Value]; } DeviceToControllerKeyMap[device.UniqueKey] = ContrainerID.Value; if (!ControllerToDeviceKeyMap.ContainsKey(ContrainerID.Value)) { ControllerToDeviceKeyMap[ContrainerID.Value] = new HashSet <string>(); } ControllerToDeviceKeyMap[ContrainerID.Value].Add(device.UniqueKey); return(ctrl); } } } return(null); }
public static void AddConnectionProvider(this IServiceCollection services, EConnectionType dbType, IConnectionProvider connectionProvider) { ConnectionFactory.AddConnectionProvider(dbType, connectionProvider); }
public void LoadXML(XmlReader r) { Name = r.GetAttribute("Name"); string type = r.GetAttribute("Type"); ConnectionType = EConnectionType.RTP; if (type == "WebRTC") { ConnectionType = EConnectionType.WebRTC; } if (type == "Ovrvision") { ConnectionType = EConnectionType.Ovrvision; } else if (type == "RTP") { ConnectionType = EConnectionType.RTP; } else if (type == "Local") { ConnectionType = EConnectionType.Local; int count; int.TryParse(r.GetAttribute("Count"), out count); for (int i = 0; i < count; ++i) { int idx; if (int.TryParse(r.GetAttribute("Index" + i.ToString()), out idx)) { CameraIndex.Add(idx); } } } else if (type == "Movie") { ConnectionType = EConnectionType.Movie; MediaPath = r.GetAttribute("Path"); } type = r.GetAttribute("StreamCodec"); StreamCodec = EStreamCodec.Coded; if (type == "Raw") { StreamCodec = EStreamCodec.Raw; } else if (type == "Coded") { StreamCodec = EStreamCodec.Coded; } else if (type == "Ovrvision") { StreamCodec = EStreamCodec.Ovrvision; } IP = r.GetAttribute("IP"); URL = r.GetAttribute("URL"); Location = r.GetAttribute("Location"); string v = r.GetAttribute("Longitude"); if (v != null && v != "") { lng = double.Parse(v); } v = r.GetAttribute("Latitude"); if (v != null && v != "") { lat = double.Parse(v); } }
public IController NewDevice(IDevice device) { HidDevice _device = device as HidDevice; XInputDevice _deviceX = device as XInputDevice; if (_device == null && _deviceX == null) { return(null); } // TODO this check system should only run if FullControl mode is enabled // this is all irrelevent if we have a system where we can get the true ProductName, VID, and PID of the XInput controller // if we ever gain access to that info, we will have to make sure the below logic is still present for if the XInput provider // doesn't have that info (check presence of Properties perhapse?) // It might be simpler to keep the XInputDevice handling as is if the VID/PID/ProductName are null but if they are known immediately rumble // In this design, if we see a HID device for the controller and we want to correct it, we'd start a count-down and if we didn't see any XInput // devices we could manually trigger within that time (inlcuding one that came through just ahead) we'd force run over all the memorized ones // Note that for some reason this doesn't work properly for an APEX2 on USB, it switches right back to XInput again. if (_device != null) { if (device.VendorId == 0x045E && device.ProductId == 0x028E) { if (this.AccessMode != AccessMode.FullControl) { return(null); } if (device.Properties["ProductName"] == "Controller (Flydigi 2.4G x360)" || device.Properties["ProductName"] == "Controller (Flydigi 2.4G Android)") // APEX2 on USB does this for some reason { lock (CandidateXInputLock) SawCandidateHidDeviceForXInput = DateTime.UtcNow; CheckXInputData(); } return(null); } } else if (_deviceX != null) { if (this.AccessMode != AccessMode.FullControl) { return(null); } lock (CandidateXInputLock) { CandidateXInputDevicesX[(byte)_deviceX.UserIndex] = new WeakReference <XInputDevice>(_deviceX); CandidateXInputDevicesLastSeen[(byte)_deviceX.UserIndex] = DateTime.UtcNow; } CheckXInputData(); return(null); } // if we are in full control mode, check for xbox here and if it is a flydigi controller send the command that changes the mode here and return null if (_device.VendorId == FlydigiController.VENDOR_FLYDIGI) { if (!new int[] { FlydigiController.PRODUCT_FLYDIGI_DONGLE_1, FlydigiController.PRODUCT_FLYDIGI_DONGLE_2, FlydigiController.PRODUCT_FLYDIGI_DONGLE_3, FlydigiController.PRODUCT_FLYDIGI_USB, }.Contains(_device.ProductId)) { return(null); } } else { return(null); } //string bt_hid_id = @"00001124-0000-1000-8000-00805f9b34fb"; string devicePath = _device.DevicePath.ToString(); uint[] Usages = device.Properties.ContainsKey("Usages") ? device.Properties["Usages"] as uint[] : null; EConnectionType ConType = EConnectionType.Unknown; switch (_device.VendorId) { case FlydigiController.VENDOR_FLYDIGI: if (_device.Properties.ContainsKey("ProductName") && (((_device.Properties["ProductName"] as string)?.ToLowerInvariant()?.Contains("flydigi") ?? false) || ((_device.Properties["ProductName"] as string)?.ToLowerInvariant()?.Contains("feizhi") ?? false))) { //&& devicePath.Contains("mi_02") if (Usages.Contains(0xffa00001u)) { } else { return(null); } //if (devicePath.Contains(bt_hid_id)) //{ // ConType = EConnectionType.Bluetooth; //} //else //{ // ConType = EConnectionType.USB; //} } //else if (_device.ProductId == FlydigiController.PRODUCT_FLYDIGI_USB && devicePath.Contains("mi_00")) //{ // //} else { return(null); } break; } lock (Controllers) { FlydigiController ctrl = new FlydigiController(_device, ConType); Controllers[_device.UniqueKey] = ctrl; //Console.WriteLine($"Controllers[\"{_device.UniqueKey}\"] = {ctrl};"); return(ctrl); } }