private void Start()
{
try
{
deviceClient = DeviceClient.Create(Properties.AzureSettings.Default.Host,
new DeviceAuthenticationWithRegistrySymmetricKey(Properties.AzureSettings.Default.DeviceId,
Properties.AzureSettings.Default.AccessKey), TransportType.Mqtt);
}
catch { ErrorText = "Error: Can't create cloud client"; }
SendTimer.Start();
CloudButtonContent = "Stop";
}
/// <summary>
/// attempt to create a device client with the user credentials stored in the tpm
/// </summary>
public void initializeWithProvisionedDevice()
{
TpmDevice myDevice = new TpmDevice(0);
string hubUri = myDevice.GetHostName();
devID = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
deviceClient = DeviceClient.Create(hubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(devID, sasToken),
TransportType.Amqp);
}
public MainPage()
{
this.InitializeComponent();
StatusNormalBrush = StatusIndicator.Fill;
if (!TryInitGPIO().Result)
{
WriteMessage("GPIO initialization failed").Wait();
}
deviceClient = DeviceClient.Create(HubEndpoint,
AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(DeviceId, DeviceKey), TransportType.Mqtt_WebSocket_Only);
deviceClient.SetMethodHandlerAsync("ToggleLED", new MethodCallback(ToggleLEDMethod), null);
}
public IoTHub()
{
string connectionStringIoT = GetIoTConnectionString();
string eventHubName = ConfigurationManager.AppSettings["EventHubName"];
string iotHubUri = ConfigurationManager.AppSettings["IotHubUri"];
registryManager = RegistryManager.CreateFromConnectionString(connectionStringIoT);
AddDeviceAsync().Wait();
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(DeviceId, DeviceKey));
}
static void Main(string[] args)
{
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
AddDeviceAsync().Wait();
Console.ReadLine();
Console.WriteLine(deviceKey);
Console.WriteLine("Simulated device\n");
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey("myFirstDevice", deviceKey), Microsoft.Azure.Devices.Client.TransportType.Mqtt);
SendDeviceToCloudMessagesAsync();
Console.ReadLine();
}
public async Task ProvisioningDeviceClient_ValidRegistrationId_Register_Ok(
string transportType,
string securityType,
X509EnrollmentType?x509EnrollmentType,
TransportFallbackType?transportFallback,
bool setCustomProxy,
string proxyServerAddress = null)
{
using (ProvisioningTransportHandler transport = CreateTransportHandlerFromName(transportType, transportFallback))
using (SecurityProvider security = await CreateSecurityProviderFromName(securityType, x509EnrollmentType).ConfigureAwait(false))
{
_verboseLog.WriteLine("Creating device");
if (ImplementsWebProxy(transportType, transportFallback) && setCustomProxy)
{
transport.Proxy = (proxyServerAddress != null) ? new WebProxy(proxyServerAddress) : null;
}
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
s_globalDeviceEndpoint,
Configuration.Provisioning.IdScope,
security,
transport);
var cts = new CancellationTokenSource(PassingTimeoutMiliseconds);
_log.WriteLine("ProvisioningDeviceClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync(cts.Token).ConfigureAwait(false);
Assert.IsNotNull(result);
_log.WriteLine($"{result.Status} (Error Code: {result.ErrorCode}; Error Message: {result.ErrorMessage})");
_log.WriteLine($"ProvisioningDeviceClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
Assert.AreEqual(ProvisioningRegistrationStatusType.Assigned, result.Status);
Assert.IsNotNull(result.AssignedHub);
Assert.IsNotNull(result.DeviceId);
Client.IAuthenticationMethod auth = CreateAuthenticationMethodFromSecurityProvider(security, result.DeviceId);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, GetDeviceTransportType(transportType, transportFallback)))
{
_log.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
_log.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(
new Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
_log.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
}
public void sendMessage()
{
try
{
DeviceClient deviceClient = DeviceClient.Create(iotHubHostName, new DeviceAuthenticationWithRegistrySymmetricKey(_deviceId, _deviceKey));
sendCloudToDeviceMessageAsync(deviceClient, _deviceId, _messageString);
}
catch (Exception e)
{
log.Fatal(e.ToString());
}
}
static void Main(string[] args)
{
Console.WriteLine("Simulated device\n");
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey));
SendDeviceToCloudMessagesAsync();
ReceiveC2dAsync();
SendDeviceToCloudInteractiveMessagesAsync();
Console.ReadLine();
}
public DataProcessor()
{
System.Threading.TimerCallback cb = new System.Threading.TimerCallback(ProcessData);
_timerDbLog = new System.Threading.Timer(cb, null, _dbLogTimerDueTime, _dbLogTimerPeriod);
InitDataTable();
System.Threading.TimerCallback cba = new System.Threading.TimerCallback(SendToAzure);
_timerAzure = new System.Threading.Timer(cba, null, _azureTimerDueTime, _azureTimerPeriod);
_deviceClient = DeviceClient.Create(_iotHubUri,
AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(_deviceId, _deviceKey), TransportType.Http1);
}
static private DeviceClient CreateDeviceClient(string deviceId, string deviceKey)
{
#if false
//AMQP (default)
return(DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey),
Microsoft.Azure.Devices.Client.TransportType.Amqp_WebSocket_Only));
#else
//HTTPS
return(DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey),
Microsoft.Azure.Devices.Client.TransportType.Http1));
#endif
}
static void Main()
{
var myDevice = GetOrCreateDevice();
var client = DeviceClient.Create("azure-iot-demo.azure-devices.net",
new DeviceAuthenticationWithRegistrySymmetricKey(myDevice.Id.ToString(), myDevice.Key),
TransportType.Amqp);
SendDummyUpdates(client);
ListenForCommands(client);
Console.ReadLine();
client.CloseAsync().Wait();
}
public static void Main(string[] args)
{
// Register Device with Azure
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
RegisterDeviceAsync().Wait();
Console.WriteLine("Simulated device\n");
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey));
SendDeviceToCloudMessagesAsync();
Console.ReadLine();
}
static async void SendDeviceToCloudMessagesAsync()
{
var deviceClient = DeviceClient.Create(iotHubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey),
TransportType.Http1);
var str = "Hello, Cloud!";
var message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
}
public MainPage()
{
this.InitializeComponent();
var key = AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(Config.Default.DeviceName, Config.Default.DeviceKey);
deviceClient = DeviceClient.Create(Config.Default.IotHubUri, key, TransportType.Http1);
init();
CancellationTokenSource t = new CancellationTokenSource();
startMessageReceiver(t.Token);
Logger.LogReceived += log;
}
public MainPage()
{
this.InitializeComponent();
this.Loaded += MainPage_Loaded;
// Chose a temperature provider
//temperatureProvider = new FezHatTemperatureProvider(); // GHI FEZ HAT
//temperatureProvider = new FezCreamTemperatureProvider(4); // GHI FEZ Cream with TempHumidSI70 socket
temperatureProvider = new RandomTemperatureProvider(); // Use the random provider, if no temperature sensor is connected
deviceClient = DeviceClient.Create("<IOTHUB_HOSTNAME>", new DeviceAuthenticationWithRegistrySymmetricKey("<DEVICE_ID>", "<PRIMARY_KEY>"));
}
static async Task Main(string[] args)
{
Console.WriteLine("Simulated Bowl \n");
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(DeviceId, DeviceKey), TransportType.Mqtt);
var twin = await deviceClient.GetTwinAsync();
maxDoses = Convert.ToDouble(twin.DesiredProperty("dosesCounter"));
if (twin.IsReportedPropertyEmpty("dosesCounter"))
{
doses = maxDoses;
Console.WriteLine($"Doses {doses}");
}
else
{
doses = Convert.ToDouble(twin.ReportedProperty("dosesCounter"));
}
while (true)
{
Console.WriteLine($"Doses {doses}");
Console.WriteLine($"[enter command (type 'i' for instructions)]");
string input = Console.ReadLine();
switch (input.ToLower())
{
case "cat wants to eat":
await CatEats(deviceClient);
break;
case "add dose":
await AddDose(deviceClient);
break;
case "refill":
await Refill(deviceClient);
break;
case "i":
Console.WriteLine("- cat wants to eat: a dose gets eaten");
Console.WriteLine("- add dose: add a dose");
Console.WriteLine("- refill: restore doses quantity");
break;
default:
Console.WriteLine("Syntax error");
break;
}
}
}
public void X509Certificate_MutipleClientAuthMechanism()
{
string hostName = "acme.azure-devices.net";
var amqpConnectionPoolSettings = new AmqpConnectionPoolSettings();
var transportSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only, 200, amqpConnectionPoolSettings);
var authMethod1 = new DeviceAuthenticationWithRegistrySymmetricKey("device1", "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
var deviceClient = DeviceClient.Create(hostName, authMethod1, new ITransportSettings[] { transportSetting });
var cert = CertificateHelper.InstallCertificateFromFile(LocalCertFilename, LocalCertPasswordFile);
var authMethod2 = new DeviceAuthenticationWithX509Certificate("device2", cert);
var device2Client = DeviceClient.Create(hostName, authMethod2, new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only, 100) });
}
public static async Task RunSample()
{
// Replace the following type with SecurityClientTpm() to use a real TPM2.0 device.
Console.WriteLine("Starting TPM simulator.");
SecurityClientTpmSimulator.StartSimulatorProcess();
using (var security = new SecurityClientTpmSimulator(RegistrationId))
using (var transport = new ProvisioningTransportHandlerHttp())
{
// Note that the TPM simulator will create a NVChip file containing the simulated TPM state.
Console.WriteLine("Extracting endorsement key.");
string base64EK = Convert.ToBase64String(security.GetEndorsementKey());
Console.WriteLine(
"In your Azure Device Provisioning Service please go to 'Manage enrollments' and select " +
"'Individual Enrollments'. Select 'Add' then fill in the following:");
Console.WriteLine("\tMechanism: TPM");
Console.WriteLine($"\tRegistration ID: {RegistrationId}");
Console.WriteLine($"\tEndorsement key: {base64EK}");
Console.WriteLine("\tDevice ID: iothubtpmdevice1 (or any other valid DeviceID)");
Console.WriteLine();
Console.WriteLine("Press ENTER when ready.");
Console.ReadLine();
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(s_idScope, security, transport);
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync();
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
var auth = new DeviceAuthenticationWithTpm(result.DeviceId, security);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync();
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage")));
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync();
}
}
}
public MainPage()
{
this.InitializeComponent();
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey("GrovePiSoundSensor", deviceKey), TransportType.Http1);
soundsensor = DeviceFactory.Build.SoundSensor(Pin.AnalogPin0);
lcd = DeviceFactory.Build.RgbLcdDisplay().SetText("Hello").SetBacklightRgb(0, 0, 255);
timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromMilliseconds(5000);
timer.Tick += Timer_Tick;
timer.Start();
}
static async void SendDeviceToCloudMessagesAsync()
{
string iotHubUri = "BuchRaspberryHub.azure-devices.net";
string deviceId = "MeinRaspberry";
string deviceKey = "<Key>";
var deviceClient = DeviceClient.Create(iotHubUri, AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey), TransportType.Http1);
string str = String.Format("Temperatur um {0} : {1} Grad Celsius", DateTime.Now, GetTemperature());
Message message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
}
public async Task RunAsync()
{
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
// Register the Device with DPS
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"Device Registration Status: {result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
deviceId = result.DeviceId;
// Verify Device Registration Status
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
// Create x509 DeviceClient Authentication
Console.WriteLine("Creating X509 DeviceClient authentication.");
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (security as SecurityProviderX509).GetAuthenticationCertificate());
Console.WriteLine("Simulated Device. Ctrl-C to exit.");
using (iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
// Explicitly open DeviceClient to communicate with Azure IoT Hub
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
// TODO 1: Setup OnDesiredPropertyChanged Event Handling to receive Desired Properties changes
Console.WriteLine("Connecting SetDesiredPropertyUpdateCallbackAsync event handler...");
await iotClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false);
// TODO 2: Load Device Twin Properties since device is just starting up
Console.WriteLine("Loading Device Twin Properties...");
var twin = await iotClient.GetTwinAsync().ConfigureAwait(false);
// Use OnDesiredPropertyChanged event handler to set the loaded Device Twin Properties (re-use!)
await OnDesiredPropertyChanged(twin.Properties.Desired, null);
// Start reading and sending device telemetry
Console.WriteLine("Start reading and sending device telemetry...");
await SendDeviceToCloudMessagesAsync(iotClient);
// Explicitly close DeviceClient
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
static void Main(string[] args)
{
Console.WriteLine("Simulated device\n");
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey("myFirstDevice", deviceKey), TransportType.Mqtt);
deviceClient.ProductInfo = "HappyPath_Simulated-CSharp";
SendDeviceToCloudMessagesAsync();
ReceiveC2DAsync();
Console.ReadLine();
}
//// This function create a device with x509 cert and send a message to the iothub on the transport specified.
//// It then verifies the message is received at the eventHubClient.
internal async Task SendSingleMessageX509(Client.TransportType transport)
{
// TODO: Update Jenkins Config
string endpoint = Configuration.IoTHub.EventHubString;
if (endpoint.IsNullOrWhiteSpace())
{
return;
}
Tuple <string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
PartitionReceiver eventHubReceiver = await CreateEventHubReceiver(deviceInfo.Item1).ConfigureAwait(false);
X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey();
var auth = new DeviceAuthenticationWithX509Certificate(deviceInfo.Item1, cert);
var deviceClient = DeviceClient.Create(deviceInfo.Item2, auth, transport);
try
{
await deviceClient.OpenAsync().ConfigureAwait(false);
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5)).ConfigureAwait(false);
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
Assert.IsTrue(isReceived, "Message is not received.");
}
finally
{
await deviceClient.CloseAsync().ConfigureAwait(false);
await eventHubReceiver.CloseAsync().ConfigureAwait(false);
await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager).ConfigureAwait(false);
}
}
private async Task SendDeviceToCloudMessagesAsync(Device device, string deviceId)
{
string iotHubUri = _connectionstring.Split(';')
.First(x => x.StartsWith("HostName=", StringComparison.InvariantCultureIgnoreCase))
.Replace("HostName=", "").Trim();
if (device == null)
{
ServiceEventSource.Current.ServiceMessage(Context, "Device '{0}' doesn't exist.", deviceId);
}
var deviceClient = DeviceClient.Create(
iotHubUri,
new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, device.Authentication.SymmetricKey.PrimaryKey));
List <object> events = new List <object>();
for (int i = 0; i < 10; ++i)
{
var body = new
{
Timestamp = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(i))
};
events.Add(body);
}
Microsoft.Azure.Devices.Client.Message message;
var serializer = new JsonSerializer();
using (var stream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(stream))
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
serializer.Serialize(jsonWriter, events);
}
}
message = new Microsoft.Azure.Devices.Client.Message(stream.GetBuffer());
message.Properties.Add("DeviceID", deviceId);
message.Properties.Add("Temparature", _temperature == 0 ? "50" : _temperature.ToString());
message.Properties.Add("FanSpeed", "256");
message.Properties.Add("IsOnline", "true");
//message.Properties.Add("GatewayId", "1234"); --> SiteId (RegistrationMessage)
await deviceClient.SendEventAsync(message);
ServiceEventSource.Current.ServiceMessage(Context, $"Sent message: {Encoding.UTF8.GetString(stream.GetBuffer())}");
}
}
public async Task ProvisioningDeviceClient_ValidRegistrationId_Register_Ok(
string transportType,
string securityType,
X509EnrollmentType?x509EnrollmentType,
TransportFallbackType?transportFallback)
{
if (!ConfigurationFound())
{
_log.WriteLine("Provisioning test configuration not found. Result inconclusive.");
return;
}
using (ProvisioningTransportHandler transport = CreateTransportHandlerFromName(transportType, transportFallback))
using (SecurityProvider security = CreateSecurityProviderFromName(securityType, x509EnrollmentType))
{
_verboseLog.WriteLine("Creating device");
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
s_globalDeviceEndpoint,
Configuration.Provisioning.IdScope,
security,
transport);
var cts = new CancellationTokenSource(PassingTimeoutMiliseconds);
_log.WriteLine("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync(cts.Token).ConfigureAwait(false);
Assert.IsNotNull(result);
_log.WriteLine($"{result.Status} (Error Code: {result.ErrorCode}; Error Message: {result.ErrorMessage})");
_log.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
Assert.AreEqual(ProvisioningRegistrationStatusType.Assigned, result.Status);
Assert.IsNotNull(result.AssignedHub);
Assert.IsNotNull(result.DeviceId);
Client.IAuthenticationMethod auth = CreateAuthenticationMethodFromSecurityProvider(security, result.DeviceId);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, Client.TransportType.Mqtt_Tcp_Only))
{
_log.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
_log.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(
new Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
_log.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
}
private async Task UploadFileGranularAsync(Stream source, string filename, Http1TransportSettings fileUploadTransportSettings, bool useX509auth = false)
{
using TestDevice testDevice = await TestDevice.GetTestDeviceAsync(
Logger,
_devicePrefix,
useX509auth?TestDeviceType.X509 : TestDeviceType.Sasl).ConfigureAwait(false);
DeviceClient deviceClient;
var clientOptions = new ClientOptions()
{
FileUploadTransportSettings = fileUploadTransportSettings
};
X509Certificate2 cert = null;
DeviceAuthenticationWithX509Certificate x509Auth = null;
if (useX509auth)
{
cert = s_selfSignedCertificate;
x509Auth = new DeviceAuthenticationWithX509Certificate(testDevice.Id, cert);
deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, x509Auth, Client.TransportType.Http1);
}
else
{
deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, Client.TransportType.Http1, clientOptions);
}
var fileUploadSasUriRequest = new FileUploadSasUriRequest()
{
BlobName = filename
};
using (deviceClient)
{
FileUploadSasUriResponse fileUploadSasUriResponse = await deviceClient.GetFileUploadSasUriAsync(fileUploadSasUriRequest).ConfigureAwait(false);
var blob = new CloudBlockBlob(fileUploadSasUriResponse.GetBlobUri());
Task uploadTask = blob.UploadFromStreamAsync(source);
await uploadTask.ConfigureAwait(false);
var notification = new FileUploadCompletionNotification
{
CorrelationId = fileUploadSasUriResponse.CorrelationId,
IsSuccess = uploadTask.IsCompleted
};
await deviceClient.CompleteFileUploadAsync(notification).ConfigureAwait(false);
}
x509Auth?.Dispose();
}
static void Main(string[] args)
{
var deviceId = "aircraft101";
Console.WriteLine("Simulated device => {0} \n", deviceId);
//deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, deviceThumbprint));
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithX509Certificate(deviceId, new X509Certificate2("sample.pfx", "password here")));
//SendDeviceToCloudMessagesAsync(deviceId);
SendDeviceToCloudWithCriticalMessagesAsync(deviceId);
Console.ReadLine();
}
private async Task Reset()
{
_device = await _registryManager.GetDeviceAsync(_deviceId);
if (_device == null)
{
_logger.Warning($"Could not find device '{_deviceId}' registered in IoT Hub", GetType().Name);
return;
}
_deviceClient = DeviceClient.Create(_iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(_deviceId, _device.Authentication.SymmetricKey.PrimaryKey), Microsoft.Azure.Devices.Client.TransportType.Amqp);
}
// Initialize the device client instance using symmetric key based authentication, over Mqtt protocol
//(TCP, with fallback over Websocket) and setting the ModelId into ClientOptions.
// This method also sets a connection status change callback, that will get triggered any time the device's
//connection status changes.
private static DeviceClient InitializeDeviceClient(string hostname,
IAuthenticationMethod authenticationMethod)
{
var options = new ClientOptions {
ModelId = ModelId,
};
DeviceClient deviceClient = DeviceClient.Create(hostname, authenticationMethod, TransportType.Mqtt, options);
deviceClient.SetConnectionStatusChangesHandler((status, reason) => {
s_logger.LogDebug($"Connection status change registered - status={status}, reason={reason}.");
});
return(deviceClient);
}
private static void Main(string[] args)
{
string DeviceId = ConfigurationManager.AppSettings["DeviceId"];
string DeviceKey = ConfigurationManager.AppSettings["DeviceKey"];
string IotHubUri = ConfigurationManager.AppSettings["IotHubUri"];
Console.WriteLine("Simulated device\n");
_deviceClient = DeviceClient.Create(IotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(DeviceId, DeviceKey), TransportType.Mqtt);
SendDeviceToCloudMessagesAsync();
ReceiveC2dAsync();
Console.ReadLine();
}