/// <summary> /// Returns the corresponding PathDisplayAdapter instance /// </summary> /// <returns>An instance of PathDisplayAdapter, or null</returns> public PathDisplayAdapter ToPathDisplayAdapter() { return(PathDisplayAdapter.GetAdapters() .FirstOrDefault(adapter => adapter.DevicePath.StartsWith("\\\\?\\" + DevicePath.Replace("\\", "#")) )); }
public UsbConnection(DeviceInformation deviceInfo) { UpdateRate = 1000; DevicePath = deviceInfo.Id; Serial = DevicePath.Split('#')[2]; Name = deviceInfo.Name; }
public PathTarget(PathTargetInfo targetInfo, SurroundTopology surround = null) { DevicePath = targetInfo.DisplayTarget.DevicePath; var index = DevicePath.IndexOf("{", StringComparison.InvariantCultureIgnoreCase); if (index > 0) { DevicePath = DevicePath.Substring(0, index).TrimEnd('#'); } FrequencyInMillihertz = targetInfo.FrequencyInMillihertz; Rotation = targetInfo.Rotation.ToRotation(); Scaling = targetInfo.Scaling.ToScaling(); ScanLineOrdering = targetInfo.ScanLineOrdering.ToScanLineOrdering(); try { DisplayName = targetInfo.DisplayTarget.FriendlyName; } catch { DisplayName = null; } SurroundTopology = surround ?? SurroundTopology.FromPathTargetInfo(targetInfo); }
/// <summary> /// The Get Dedicated Circuit Peering Routing Information operation /// retrieves the ARP information for specific BGP. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRoutingInfoOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// The Get Dedicated Circuit Peering Route Table Info operation /// response. /// </returns> public static DedicatedCircuitPeeringRoutingInfoGetResponse Get(this IDedicatedCircuitPeeringRoutingInfoOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return Task.Factory.StartNew((object s) => { return ((IDedicatedCircuitPeeringRoutingInfoOperations)s).GetAsync(serviceKey, accessType, devicePath); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
public override int GetHashCode() { if (DevicePath == null) { return(0); } return(DevicePath.GetHashCode()); }
internal IEnumerable <DisplayDevice> GetDisplayDevices(bool?filterByValidity) { var device = Native.DeviceContext.Structures.DisplayDevice.Initialize(); var returned = new Dictionary <string, string>(); for (uint i = 0; DeviceContextApi.EnumDisplayDevices(null, i, ref device, 0); i++) { if (DevicePath.Equals(device.DeviceId)) { DisplayDevice displayDevice = null; var display = Native.DeviceContext.Structures.DisplayDevice.Initialize(); for (uint id = 0; DeviceContextApi.EnumDisplayDevices(device.DeviceName, id, ref display, 1); id++) { var isAttached = display.StateFlags.HasFlag(DisplayDeviceStateFlags.AttachedToDesktop); if (!filterByValidity.HasValue) { yield return(DisplayDevice.FromDeviceInformation(this, device, display)); } else if (filterByValidity.Value && isAttached) { if (!returned.ContainsKey(display.DeviceId) || !returned[display.DeviceId].Equals(display.DeviceKey)) { returned.Add(display.DeviceId, display.DeviceKey); yield return(DisplayDevice.FromDeviceInformation(this, device, display)); break; } } else if (!filterByValidity.Value) { if (!isAttached) { if (!returned.ContainsKey(display.DeviceId) || !returned[display.DeviceId].Equals(display.DeviceKey)) { displayDevice = DisplayDevice.FromDeviceInformation(this, device, display); } } else { displayDevice = null; break; } } display = Native.DeviceContext.Structures.DisplayDevice.Initialize(); } if (displayDevice != null) { returned.Add(displayDevice.DevicePath, displayDevice.DeviceKey); yield return(displayDevice); } } device = Native.DeviceContext.Structures.DisplayDevice.Initialize(); } }
internal IEnumerable <DisplayDevice> GetDisplayDevices(bool?filterByAvailability) { var returned = new Dictionary <string, string>(); var adapterIndex = -1; while (true) { adapterIndex++; var adapter = Native.DeviceContext.Structures.DisplayDevice.Initialize(); if (!DeviceContextApi.EnumDisplayDevices(null, (uint)adapterIndex, ref adapter, 0)) { break; } if (!DevicePath.Equals(adapter.DeviceId)) { continue; } var displayIndex = -1; while (true) { displayIndex++; var display = Native.DeviceContext.Structures.DisplayDevice.Initialize(); if (!DeviceContextApi.EnumDisplayDevices(adapter.DeviceName, (uint)displayIndex, ref display, 1)) { break; } var displayDevice = DisplayDevice.FromDeviceInformation(this, adapter, display); if (!filterByAvailability.HasValue) { yield return(displayDevice); } else if (displayDevice.IsAvailable == filterByAvailability.Value) { if (returned.ContainsKey(display.DeviceId) && returned[display.DeviceId].Equals(display.DeviceKey) ) { continue; } returned.Add(display.DeviceId, display.DeviceKey); yield return(displayDevice); } } } }
/// <summary> /// Convert an enum of type DevicePath to a string. /// </summary> /// <param name='value'> /// The value to convert to a string. /// </param> /// <returns> /// The enum value as a string. /// </returns> internal static string DevicePathToString(DevicePath value) { if (value == DevicePath.Primary) { return("primary"); } if (value == DevicePath.Secondary) { return("secondary"); } throw new ArgumentOutOfRangeException("value"); }
/// <inheritdoc /> public override int GetHashCode() { unchecked { var hashCode = FrequencyInMillihertz.GetHashCode(); hashCode = (hashCode * 397) ^ (int)Rotation; hashCode = (hashCode * 397) ^ (int)Scaling; hashCode = (hashCode * 397) ^ (int)ScanLineOrdering; hashCode = (hashCode * 397) ^ DevicePath.GetHashCode(); hashCode = (hashCode * 397) ^ SurroundTopology?.GetHashCode() ?? 0; return(hashCode); } }
/// <summary> /// The Get Dedicated Circuit Peering Routing Information operation /// retrieves the ARP information for specific BGP. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRoutingInfoOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// The Get Dedicated Circuit Peering Route Table Info operation /// response. /// </returns> public static Task<DedicatedCircuitPeeringRoutingInfoGetResponse> GetAsync(this IDedicatedCircuitPeeringRoutingInfoOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return operations.GetAsync(serviceKey, accessType, devicePath, CancellationToken.None); }
/// <summary> /// The Get Dedicated Circuit Peering routeTableSummary operation /// retrieves the ARP information for specific BGP. /// </summary> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The Get Dedicated Circuit Peering Routing Summary operation /// response. /// </returns> public async Task <DedicatedCircuitPeeringRoutingSummaryGetResponse> GetAsync(string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath, CancellationToken cancellationToken) { // Validate if (serviceKey == null) { throw new ArgumentNullException("serviceKey"); } // Tracing bool shouldTrace = TracingAdapter.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = TracingAdapter.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("serviceKey", serviceKey); tracingParameters.Add("accessType", accessType); tracingParameters.Add("devicePath", devicePath); TracingAdapter.Enter(invocationId, this, "GetAsync", tracingParameters); } // Construct URL string url = ""; url = url + "/"; if (this.Client.Credentials.SubscriptionId != null) { url = url + Uri.EscapeDataString(this.Client.Credentials.SubscriptionId); } url = url + "/services/networking/dedicatedcircuits/"; url = url + Uri.EscapeDataString(serviceKey); url = url + "/bgppeerings/"; url = url + Uri.EscapeDataString(ExpressRouteManagementClient.BgpPeeringAccessTypeToString(accessType)); url = url + "/routeTableSummary/"; url = url + Uri.EscapeDataString(ExpressRouteManagementClient.DevicePathToString(devicePath)); List <string> queryParameters = new List <string>(); queryParameters.Add("api-version=1.0"); if (queryParameters.Count > 0) { url = url + "?" + string.Join("&", queryParameters); } string baseUrl = this.Client.BaseUri.AbsoluteUri; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; url = url.Replace(" ", "%20"); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2011-10-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { TracingAdapter.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { TracingAdapter.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { TracingAdapter.Error(invocationId, ex); } throw ex; } // Create Result DedicatedCircuitPeeringRoutingSummaryGetResponse result = null; // Deserialize Response if (statusCode == HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new DedicatedCircuitPeeringRoutingSummaryGetResponse(); XDocument responseDoc = XDocument.Parse(responseContent); XElement dedicatedCircuitPeeringRoutingSummaryElement = responseDoc.Element(XName.Get("DedicatedCircuitPeeringRoutingSummary", "http://schemas.microsoft.com/windowsazure")); if (dedicatedCircuitPeeringRoutingSummaryElement != null) { AzureDedicatedCircuitPeeringRoutingInfo dedicatedCircuitPeeringRoutingInfoInstance = new AzureDedicatedCircuitPeeringRoutingInfo(); result.DedicatedCircuitPeeringRoutingInfo = dedicatedCircuitPeeringRoutingInfoInstance; XElement networkElement = dedicatedCircuitPeeringRoutingSummaryElement.Element(XName.Get("Network", "http://schemas.microsoft.com/windowsazure")); if (networkElement != null) { string networkInstance = networkElement.Value; dedicatedCircuitPeeringRoutingInfoInstance.Network = networkInstance; } XElement nextHopElement = dedicatedCircuitPeeringRoutingSummaryElement.Element(XName.Get("NextHop", "http://schemas.microsoft.com/windowsazure")); if (nextHopElement != null) { string nextHopInstance = nextHopElement.Value; dedicatedCircuitPeeringRoutingInfoInstance.NextHop = nextHopInstance; } XElement locPrfElement = dedicatedCircuitPeeringRoutingSummaryElement.Element(XName.Get("LocPrf", "http://schemas.microsoft.com/windowsazure")); if (locPrfElement != null) { string locPrfInstance = locPrfElement.Value; dedicatedCircuitPeeringRoutingInfoInstance.LocPrf = locPrfInstance; } XElement weightElement = dedicatedCircuitPeeringRoutingSummaryElement.Element(XName.Get("Weight", "http://schemas.microsoft.com/windowsazure")); if (weightElement != null) { int weightInstance = int.Parse(weightElement.Value, CultureInfo.InvariantCulture); dedicatedCircuitPeeringRoutingInfoInstance.Weight = weightInstance; } XElement pathElement = dedicatedCircuitPeeringRoutingSummaryElement.Element(XName.Get("Path", "http://schemas.microsoft.com/windowsazure")); if (pathElement != null) { string pathInstance = pathElement.Value; dedicatedCircuitPeeringRoutingInfoInstance.Path = pathInstance; } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { TracingAdapter.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The Get Dedicated Circuit Peering Routing Information operation /// retrieves the ARP information for specific BGP. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRoutingInfoOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// The Get Dedicated Circuit Peering Route Table Info operation /// response. /// </returns> public static Task <DedicatedCircuitPeeringRoutingInfoGetResponse> GetAsync(this IDedicatedCircuitPeeringRoutingInfoOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return(operations.GetAsync(serviceKey, accessType, devicePath, CancellationToken.None)); }
/// <summary> /// The Get DedicatedCircuitPeeringRouteTableSummary operation retrives /// RouteTableSummary. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRouteTableSummaryOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static Task<ExpressRouteOperationResponse> BeginGetAsync(this IDedicatedCircuitPeeringRouteTableSummaryOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return operations.BeginGetAsync(serviceKey, accessType, devicePath, CancellationToken.None); }
/// <summary> /// The Get DedicatedCircuitPeeringRouteTableInfo operation retrives /// RouteTable. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRouteTableInfoOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static ExpressRouteOperationResponse BeginGet(this IDedicatedCircuitPeeringRouteTableInfoOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return(Task.Factory.StartNew((object s) => { return ((IDedicatedCircuitPeeringRouteTableInfoOperations)s).BeginGetAsync(serviceKey, accessType, devicePath); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
public string GetAzureDedicatedCircuitPeeringRouteTableSummary(Guid serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return(Client.DedicatedCircuitPeeringRouteTableSummary.Get(serviceKey.ToString(), accessType, devicePath).Data.ToString()); }
/// <inheritdoc/> public override int GetHashCode() { return(DevicePath.GetHashCode()); }
/// <summary> /// The Get DedicatedCircuitPeeringArpInfo operation retrives ARP Table. /// </summary> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response body contains the status of the specified asynchronous /// operation, indicating whether it has succeeded, is inprogress, or /// has failed. Note that this status is distinct from the HTTP status /// code returned for the Get Operation Status operation itself. If /// the asynchronous operation succeeded, the response body includes /// the HTTP status code for the successful request. If the /// asynchronous operation failed, the response body includes the HTTP /// status code for the failed request, and also includes error /// information regarding the failure. /// </returns> public async Task <ExpressRouteOperationStatusResponse> GetAsync(string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath, CancellationToken cancellationToken) { ExpressRouteManagementClient client = this.Client; bool shouldTrace = TracingAdapter.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = TracingAdapter.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("serviceKey", serviceKey); tracingParameters.Add("accessType", accessType); tracingParameters.Add("devicePath", devicePath); TracingAdapter.Enter(invocationId, this, "GetAsync", tracingParameters); } cancellationToken.ThrowIfCancellationRequested(); ExpressRouteOperationResponse response = await client.DedicatedCircuitPeeringArpInfo.BeginGetAsync(serviceKey, accessType, devicePath, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); ExpressRouteOperationStatusResponse result = await client.DedicatedCircuitPeeringArpInfo.GetOperationStatusAsync(response.OperationId, cancellationToken).ConfigureAwait(false); int delayInSeconds = 30; if (client.LongRunningOperationInitialTimeout >= 0) { delayInSeconds = client.LongRunningOperationInitialTimeout; } while (result.Status == ExpressRouteOperationStatus.InProgress) { cancellationToken.ThrowIfCancellationRequested(); await TaskEx.Delay(delayInSeconds * 1000, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); result = await client.DedicatedCircuitPeeringArpInfo.GetOperationStatusAsync(response.OperationId, cancellationToken).ConfigureAwait(false); delayInSeconds = 30; if (client.LongRunningOperationRetryTimeout >= 0) { delayInSeconds = client.LongRunningOperationRetryTimeout; } } if (shouldTrace) { TracingAdapter.Exit(invocationId, result); } if (result.Status != ExpressRouteOperationStatus.Successful) { if (result.Error != null) { CloudException ex = new CloudException(result.Error.Code + " : " + result.Error.Message); ex.Error = new CloudError(); ex.Error.Code = result.Error.Code; ex.Error.Message = result.Error.Message; if (shouldTrace) { TracingAdapter.Error(invocationId, ex); } throw ex; } else { CloudException ex = new CloudException(""); if (shouldTrace) { TracingAdapter.Error(invocationId, ex); } throw ex; } } return(result); }
/// <summary> /// The Get DedicatedCircuitPeeringRouteTableInfo operation retrives /// RouteTable. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.ExpressRoute.IDedicatedCircuitPeeringRouteTableInfoOperations. /// </param> /// <param name='serviceKey'> /// Required. The service key representing the circuit. /// </param> /// <param name='accessType'> /// Required. Whether the peering is private or public or microsoft. /// </param> /// <param name='devicePath'> /// Required. Whether the device is primary or secondary. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static Task <ExpressRouteOperationResponse> BeginGetAsync(this IDedicatedCircuitPeeringRouteTableInfoOperations operations, string serviceKey, BgpPeeringAccessType accessType, DevicePath devicePath) { return(operations.BeginGetAsync(serviceKey, accessType, devicePath, CancellationToken.None)); }
bool TryConnectDeviceWithSN() { bool?result = null; bool resultb = false; int device_count = 0; int size = 0; int requiredSize = 0; DevicePath = string.Empty; // Get the GUID of the HID device Class myUSB.CT_HidGuid(); // Get the device information set myUSB.CT_SetupDiGetClassDevs(); // Reset the IsConnected to false this.IsConnected = false; //search the device until you have found it or no more devices in list while (!result.HasValue || result.Value == true) { // //if (result == false) // break; //open the device result = myUSB.CT_SetupDiEnumDeviceInterfaces(device_count); //get size of device path resultb = myUSB.CT_SetupDiGetDeviceInterfaceBuffer(ref requiredSize, 0); size = requiredSize; //get device path resultb = myUSB.CT_SetupDiGetDeviceInterfaceDetail(ref requiredSize, size); if (resultb == false) { int err = Marshal.GetLastWin32Error(); } DevicePath = myUSB.DevicePathName; //is this the device i want? string deviceID = this.VID + "&" + this.PID; if (DevicePath.ToLower().IndexOf(deviceID.ToLower()) > 0) { //create HID Device Handel resultb = myUSB.CT_CreateFile(DevicePath); // Check the serial Number myUSB.CT_HidD_GetHIDSerialNumber(out string device_sn); myUSB.CT_HidD_GetNumInputBuffers(out uint numbuffers); if (SerialNumber == null || SerialNumber == string.Empty || device_sn == SerialNumber) { IntPtr myPtrToPreparsedData = default(IntPtr); if (myUSB.CT_HidD_GetPreparsedData(myUSB.hHidFile, ref myPtrToPreparsedData)) { if (myUSB.CT_HidP_GetCaps(myPtrToPreparsedData)) { // we have found our device so stop searching IsConnected = true; break; } } else { myUSB.CT_CloseFile(); break; } } else { myUSB.CT_CloseFile(); } } device_count++; } myUSB.CT_SetupDiDestroyDeviceInfoList(); //return state return(this.IsConnected); }