public async Task <IHttpActionResult> ProvisionDevice(string deviceId) { var info = await _registry.FindAsync(deviceId); if (info == null) { return(NotFound()); } // If the device was revoked, restore it. if (info.Status.Equals(DeviceStateConstants.RevokedState, StringComparison.Ordinal)) { await _provisioner.RestoreDeviceAsync(deviceId); } var token = await _provisioner.GetTokenAsync(deviceId); var endpoint = new DeviceEndpoint { Uri = _provisioner.EndpointUri.AbsoluteUri, EventHubName = _provisioner.EventHubName, AccessToken = token }; // Update registry with new provisioning state. info.Status = DeviceStateConstants.ProvisionedState; await _registry.AddOrUpdateAsync(info); return(Ok(endpoint)); }
private static ICommunicationChannel GetChannelFromEndpoint(DeviceEndpoint endpoint) { if (endpoint is SerialDeviceEndpoint) { return(new SerialCommunicationChannel(endpoint)); } throw new NotSupportedException("The requested communications method is not supported by the device"); }
public static DeviceLayer GetDeviceLayer() { Log.Info("Composing device layer from connection string: {0}", Settings.Default.ConnectionString); var endpoint = DeviceEndpoint.FromConnectionString(Settings.Default.ConnectionString); var channel = GetChannelFromEndpoint(endpoint); var device = new DeviceLayer(channel); return(device); }
public static ICommunicationChannel BuildChannel(DeviceEndpoint endpoint) { if (endpoint is SerialDeviceEndpoint) { return(new SerialCommunicationChannel(endpoint)); } throw new NotSupportedException($"There is no supported channel type for the endpoint: {endpoint}") { Data = { ["endpoint"] = endpoint } }; }
/// <summary> /// Creates the transaction processor ready for use. Also creates and initialises the /// device endpoint and the communications channel and opens the channel. /// </summary> /// <returns>ITransactionProcessor.</returns> public ITransactionProcessor CreateTransactionProcessor() { Endpoint = DeviceEndpoint.FromConnectionString(ConnectionString); Channel = CommunicationsStackBuilder.BuildChannel(Endpoint); observer = new TransactionObserver(Channel); processor = new ReactiveTransactionProcessor(); processor.SubscribeTransactionObserver(observer, TimeSpan.FromMilliseconds(100)); Channel.Open(); //Task.Delay(TimeSpan.FromSeconds(2)).Wait(); // Arduino needs 2 seconds to initialize Thread.Sleep(TimeSpan.FromSeconds(3)); return(processor); }
private void InitializeEndpoints() { Cards = new CardEndpoint(this); CustomerStatements = new CustomerStatementEndpoint(this); Devices = new DeviceEndpoint(this); DeviceServers = new DeviceServerEndpoint(this); Installations = new InstallationEndpoint(this); Invoices = new InvoiceEndpoint(this); MonetaryAccountBanks = new MonetaryAccountBankEndpoint(this); Payments = new PaymentEndpoint(this); Sessions = new SessionEndpoint(this); }
public ReactiveTransactionProcessorFactory(string connectionString) { this.ConnectionString = connectionString; // Endpoint will be InvalidEndpoint if the connection string is invalid. Endpoint = DeviceEndpoint.FromConnectionString(connectionString); }
public UnitTestChannel(DeviceEndpoint endpoint) { Endpoint = endpoint; }
private string TalkWithAxis(AXISID axis, char cmd, string cmdDataStr) { string response = string.Empty; DeviceEndpoint endPoint = SerialDeviceEndpoint.FromConnectionString(ConnectionString); const int BufferSize = 20; StringBuilder sb = new StringBuilder(BufferSize); sb.Append(cStartChar_Out); // 0: Leading char sb.Append(cmd); // 1: Length of command( Source, distination, command char, data ) // Target Device sb.Append(((int)axis + 1).ToString()); // 2: Target Axis // Copy command data to buffer sb.Append(cmdDataStr); sb.Append(cEndChar); // CR Character string cmdString = sb.ToString(); var cmdTransaction = new EQTransaction(cmdString) { Timeout = TimeSpan.FromSeconds(TimeOut) }; using (ICommunicationChannel channel = new SerialCommunicationChannel(endPoint)) using (var processor = new ReactiveTransactionProcessor()) { var transactionObserver = new TransactionObserver(channel); processor.SubscribeTransactionObserver(transactionObserver); try { channel.Open(); // prepare to communicate for (int i = 0; i < Retry; i++) { Task.Run(() => processor.CommitTransaction(cmdTransaction)); cmdTransaction.WaitForCompletionOrTimeout(); if (!cmdTransaction.Failed) { response = cmdTransaction.Value; break; } else { Trace.TraceError(cmdTransaction.ErrorMessage.Single()); } } } catch (Exception ex) { Trace.TraceError("Connnection Lost"); throw new Exception("AstroEQ not responding", ex); } finally { // To clean up, we just need to dispose the TransactionObserver and the channel is closed automatically. // Not strictly necessary, but good practice. transactionObserver.OnCompleted(); // There will be no more transactions. transactionObserver = null; // not necessary, but good practice. endPoint = null; } } return(response); }
public void AddEndpoint(DeviceEndpoint endpoint) { Endpoints.Add(endpoint); ShowNoResultsMessage = false; }
static void Main(string[] args) { // Uncomment this line of code to allow for debugging while (!System.Diagnostics.Debugger.IsAttached) { System.Threading.Thread.Sleep(100); } // Test Bed //SpeakerMode.SpeakerModeExternal; //Possibly SPDIF out? //SpeakerMode.SpeakerModeHeadPhone; //Possible headset out? ManagementObjectSearcher objSearcher = new ManagementObjectSearcher( "SELECT * FROM Win32_SoundDevice"); ManagementObjectCollection objCollection = objSearcher.Get(); ManagementObject soundblaster = null; foreach (ManagementObject obj in objCollection) { foreach (PropertyData property in obj.Properties) { Console.Out.WriteLine(String.Format("{0}:{1}", property.Name, property.Value)); if (property.Name.Equals("Name") && property.Value.ToString().Contains("Sound Blaster")) { soundblaster = obj; } } } Creative.Platform.Devices.Models.DeviceManager dm = DeviceManager.Instance; //.Collections.Concurrent.ConcurrentDictionary<string, DeviceEndpoint> des = dm.MixerDiscoveredDeviceEndpoints; //DeviceEndpoint mixerDevice = dm.GetMixerDeviceEndpoints(new Device {d }); // Define an IMM Device Creative.Platform.CoreAudio.Interfaces.IMMDeviceEnumerator imde = (Creative.Platform.CoreAudio.Interfaces.IMMDeviceEnumerator) new Creative.Platform.CoreAudio.Classes.MMDeviceEnumerator(); IMMDevice imd = null; foreach (DeviceEndpoint de in dm.MixerDiscoveredDeviceEndpoints.Values) { int device_id = imde.GetDevice(de.DeviceEndpointId, out imd); if (imd != null) { break; } } // Generate a DeviceEndpoint DefaultDeviceEndpointFactory ddef = new Creative.Platform.Devices.Models.DefaultDeviceEndpointFactory(); DeviceEndpoint dep = ddef.CreateDeviceEndPoint(imd); List <IDeviceRepository> dev_reps = dep.GetDeviceRepositories(); // Create the SoundCore //Creative.Platform.Devices.Features.SoundCore.SoundCoreRepository scr = Creative.Platform.Devices.Features.Apo.ApoInfoWrapper aiw = new Creative.Platform.Devices.Features.Apo.ApoInfoWrapper(dep); Creative.Platform.Devices.Features.Apo.ApoFeatureChecker apc = new Creative.Platform.Devices.Features.Apo.ApoFeatureChecker(aiw); Creative.Platform.Devices.Features.Apo.PropStoreRepository psr = new Creative.Platform.Devices.Features.Apo.PropStoreRepository(dep.DeviceEndpointId, apc); IPropertyStore properties; imd.OpenPropertyStore(0u, out properties); CDCDeviceRepositoryInitializer cdcri = new CDCDeviceRepositoryInitializer(); cdcri.Initialize(dep, properties); psr.GetSpeakerConfig(); //Creative.Platform.Devices.Features.SpeakerConfigs.SpeakerConfigService scs = new SpeakerConfigService(dep); //Creative.Platform.Devices.Features.SpeakerConfigs.SoundCoreSpeakerConfigFeature scsrf = new SoundCoreSpeakerConfigFeature(dep,,, scs); //Creative.Platform.Devices.Features.SoundCore.SoundCoreRepository scr = new Creative.Platform.Devices.Features.SoundCore.SoundCoreRepository() try { psr.SetSpeakerConfig((int)SpeakerMode.SpeakerModeHeadPhone); } catch (Exception e) { } //scr.SetSpeakerConfig((int)SpeakerMode.SpeakerModeHeadPhone); //SDWrapper.Run(args); }