private DeviceClient InitializeDeviceClient()
{
TpmDevice device = new TpmDevice(0);
string hubUri = device.GetHostName();
string deviceId = device.GetDeviceId();
string sasToken = device.GetSASToken();
_deviceId = deviceId;
DeviceClient deviceClient = null;
try
{
deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken));
return(deviceClient);
}
catch
{
Debug.WriteLine("ERROR! Unable to create device client!");
}
return(deviceClient);
}
public static async Task SendDeviceToCloudMessageAsync(string txtSend)
{
try
{
Microsoft.Devices.Tpm.TpmDevice myDevice = new Microsoft.Devices.Tpm.TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
var str = txtSend + " from " + deviceId + " " + DateTime.Now.ToString();
var message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
}
catch (Exception ex)
{
throw ex;
}
}
public static async Task <string> ReceiveCloudToDeviceMessageAsync()
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
while (true)
{
var receivedMessage = await deviceClient.ReceiveAsync();
if (receivedMessage != null)
{
var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
await deviceClient.CompleteAsync(receivedMessage);
return(messageData);
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
}
public static async Task <bool> SendDeviceToCloudMessageAsync(string str)
{
try
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string hwID = myDevice.GetHardwareDeviceId();
string sasToken = myDevice.GetSASToken();
DeviceClient deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt_WebSocket_Only);
//string m = "{\"pkey\":\"" + deviceId + "\", \"msg\":"+ str +"}";
var message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public MainPage()
{
this.InitializeComponent();
var iotDevice = new TpmDevice(0);
string hubUri = iotDevice.GetHostName();
string deviceId = iotDevice.GetDeviceId();
string sasToken = iotDevice.GetSASToken();
deviceName = deviceId;
deviceClient = DeviceClient.Create(hubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt);
_timer.Interval = TimeSpan.FromSeconds(1);
_timer.Tick += _timer_Tick;
GpioController controller = GpioController.GetDefault();
if (controller != null)
{
_pin = GpioController.GetDefault().OpenPin(17, GpioSharingMode.Exclusive);
_dht = new Dht11(_pin, GpioPinDriveMode.Input);
_timer.Start();
_startedAt = DateTimeOffset.Now;
}
}
public Task Initialize()
{
this.CancellationTokenSource = new CancellationTokenSource();
// ***
// *** Create a TpmDevice to access the credential information. Specify
// *** a logical device ID of 0 (this is the slot we used to store the
// *** credentials).
// ***
uint logicalDeviceId = 0;
TpmDevice tpm = new TpmDevice(logicalDeviceId);
// ***
// *** Get the connection properties from the TPM.
// ***
string uri = tpm.GetHostName();
string deviceId = tpm.GetDeviceId();
string sasToken = tpm.GetSASToken();
// ***
// *** Create the device connection.
// ***
this.DeviceClient = DeviceClient.Create(uri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken));
this.ReceiveMessages(this.DeviceClient, this.CancellationTokenSource.Token);
return(Task.FromResult(0));
}
private void initDevice()
{
TpmDevice device = new TpmDevice(0);
string hubUri = device.GetHostName();
string deviceId = device.GetDeviceId();
string sasToken = device.GetSASToken();
_sendDeviceClient = DeviceClient.Create(hubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
}
/// <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 void IotHubConnectionStringBuilder_ParamHostNameAuthMethod_SharedAccessSignature()
{
IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken(DeviceId, SharedAccessSignature);
var csBuilder = IotHubConnectionStringBuilder.Create(HostName, authMethod);
csBuilder.HostName.Should().Be(HostName);
csBuilder.DeviceId.Should().Be(DeviceId);
csBuilder.SharedAccessSignature.Should().Be(SharedAccessSignature);
csBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
csBuilder.SharedAccessKey.Should().BeNull();
}
private DeviceClient InitializeDeviceClient()
{
TpmDevice device = new TpmDevice(0);
string hubUri = device.GetHostName();
string deviceId = device.GetDeviceId();
string sasToken = device.GetSASToken();
_deviceId = deviceId;
return(DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken)));
}
private static void RefreshDeviceClient()
{
var myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken((uint)SasTokenValidity.TotalSeconds);
_validityExpiryTime = DateTime.Now + SasTokenValidity;
_deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
}
public void Run(IBackgroundTaskInstance taskInstance)
{
TpmDevice device = new TpmDevice(0);
string hubUri = device.GetHostName();
string deviceId = device.GetDeviceId();
string sasToken = device.GetSASToken();
DeviceClient _sendDeviceClient = DeviceClient.Create(hubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
while (true)
{
string messageString = "Hello World";
var message = new Message(Encoding.ASCII.GetBytes(messageString));
_sendDeviceClient.SendEventAsync(message);
Task.Delay(1000).Wait();
}
}
DeviceClient Connect()
{
// Get credentials from TPM store/chip
TpmDevice device = new TpmDevice(0); // Use logical device 0 on the TPM by default
string iotHubUri = device.GetHostName();
string deviceId = device.GetDeviceId();
string sasToken = device.GetSASToken(validity: 3600);
// Connect
var deviceClient = DeviceClient.Create(
iotHubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Http1);
return(deviceClient);
}
public static async Task <string> ReceiveCloudToDeviceMessageAsync()
{
string retval = string.Empty;
try
{
Microsoft.Devices.Tpm.TpmDevice myDevice = new Microsoft.Devices.Tpm.TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
while (true)
{
try
{
Message receivedMessage = await deviceClient.ReceiveAsync();
if (receivedMessage == null)
{
continue;
}
var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
await deviceClient.CompleteAsync(receivedMessage);
//return messageData;
retval = messageData.ToString();
//MainPage.ReceiveMessage.Text = retval;
return(retval);
}
catch (Exception ex)
{
throw;
}
}
}
catch (Exception ex)
{
retval = ex.Message.ToString();
Debug.WriteLine("Error in sample: {0}", ex.Message);
}
return(retval);
}
public static async Task <string> ReceiveCloudToDeviceMessageAsync()
{
try
{
while (true)
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt_WebSocket_Only);
// while (true)
// {
Message receivedMessage = null;
Debug.Write(".");
try
{
receivedMessage = await deviceClient.ReceiveAsync();
}
catch (Exception ex)
{
Debug.WriteLine("----- ERROR awaiting ReceiveAsync");
}
if (receivedMessage != null)
{
var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
await deviceClient.CompleteAsync(receivedMessage);
deviceClient.Dispose();
return(messageData);
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
}
catch (Exception ex)
{
Debug.WriteLine("----ERROR Receive:" + ex.Message + " " + ex.InnerException.Message);
return(null);
}
}
public async Task Start()
{
#if SIMULATE
this.deviceClient = DeviceClient.CreateFromConnectionString(ConnectionStringProvider.Value, TransportType.Mqtt);
#else
this.deviceClient = DeviceClient.Create(hubUri,
AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt);
#endif
await this.deviceClient.OpenAsync();
await deviceClient.SetMethodHandlerAsync("DisplayOLED", DisplayOLED, null);
await deviceClient.SetMethodHandlerAsync("ControlMotor", ControlMotoDriver, null);
await deviceClient.SetMethodHandlerAsync("ControlRelay", ControlRelay, null);
Debug.WriteLine("Exited!\n");
}
public static async Task SendDeviceToCloudMessageAsync()
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
var str = "Hello, Cloud from a secure C# UWP app!";
var message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
}
public static async Task SendDeviceToCloudMessageAsyncUseTPM(string msg)
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
//Not using TPM
//var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, TransportType.Amqp);
var message = new Message(Encoding.ASCII.GetBytes(msg));
await deviceClient.SendEventAsync(message);
}
private async Task <bool> TryRefreshTokenAsync()
{
IAuthenticationMethod method;
try
{
var token = _tpm.GetSASToken();
if (String.IsNullOrEmpty(token))
{
throw new Exception("TPM generated empty token");
}
method = AuthenticationMethodFactory.CreateAuthenticationWithToken(_id, token);
}
catch (Exception e)
{
Debug.WriteLine("Exception authenticating with TPM token: " + e.Message);
return(false);
}
try
{
var task = _deviceClient?.CloseAsync();
if (task != null)
{
await task;
}
_deviceClient = DeviceClient.Create(_tpm.GetHostName(), method, TransportType.Mqtt_WebSocket_Only);
await _deviceClient.OpenAsync();
await _deviceClient.SetDesiredPropertyUpdateCallback(SendPropertyChange, null);
var twin = await _deviceClient.GetTwinAsync();
await SendPropertyChange(twin.Properties.Reported, null);
await SendPropertyChange(twin.Properties.Desired, null);
}
catch (Exception e)
{
Debug.WriteLine("Exception connecting to Azure: " + e.Message);
_deviceClient = null;
return(false);
}
return(true);
}
public IoTHub()
{
this.InitializeComponent();
try
{
TpmDevice device = new TpmDevice(0);
hubUri = device.GetHostName();
deviceId = device.GetDeviceId();
sasToken = device.GetSASToken();
//Todo
deviceClient = DeviceClient.Create(hubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
runtwin();
deviceClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null);
}
catch (Exception ex)
{
rootPage.NotifyUser("Connection String error", NotifyType.ErrorMessage);
return;
}
ReceiveDataFromAzure();
}
public static async Task <string> ReceiveCloudToDeviceMessageAsyncButton()
{
string retval = string.Empty;
Microsoft.Devices.Tpm.TpmDevice myDevice = new Microsoft.Devices.Tpm.TpmDevice(0); // Use logical device 0 on the TPM by default
string hubUri = myDevice.GetHostName();
string deviceId = myDevice.GetDeviceId();
string sasToken = myDevice.GetSASToken();
var deviceClient = DeviceClient.Create(
hubUri,
AuthenticationMethodFactory.
CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Amqp);
var receivedMessage = await deviceClient.ReceiveAsync();
if (receivedMessage != null)
{
var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
await deviceClient.CompleteAsync(receivedMessage);
//return messageData;
retval += messageData.ToString();
}
//while (true)
//{
// var receivedMessage = await deviceClient.ReceiveAsync();
// if (receivedMessage != null)
// {
// var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
// await deviceClient.CompleteAsync(receivedMessage);
// return messageData;
// }
// await Task.Delay(TimeSpan.FromSeconds(1));
//}
return(retval);
}
public void DeviceClientIotHubConnectionStringBuilderTest()
{
string connectionString = "HostName=acme.azure-devices.net;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
var iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
connectionString = "HostName=acme.azure-devices.net;GatewayHostName=test;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNotNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
connectionString = "HostName=acme.azure-devices.net;CredentialType=SharedAccessSignature;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
try
{
iotHubConnectionStringBuilder.HostName = "adshgfvyregferuehfiuehr";
Assert.Fail("Expected FormatException");
}
catch (FormatException)
{
}
iotHubConnectionStringBuilder.HostName = "acme.azure-devices.net";
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device4", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device4");
IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken("Device5", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme1.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme1.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device5");
authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme2.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme2.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");
authMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme3.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme3.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");
authMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme4.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme4.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");
}
private async void SensorUpdateTimerCallback(object state)
{
try
{
// Checking that SaS token isn't about to expire
if ((DateTime.UtcNow - sasTokenIssuedAtUtc) >= sasTokenValidityPeriod)
{
Debug.WriteLine($"{DateTime.UtcNow.ToString("hh:mm:ss")} SAS token needs renewing");
try
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
azureIoTHubUri = myDevice.GetHostName();
deviceId = myDevice.GetDeviceId();
sasToken = myDevice.GetSASToken((uint)sasTokenValidityPeriod.TotalSeconds);
sasTokenIssuedAtUtc = DateTime.UtcNow;
}
catch (Exception ex)
{
Debug.WriteLine($"TpmDevice.GetSASToken refresh failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient = DeviceClient.Create(azureIoTHubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt);
}
catch (Exception ex)
{
Debug.WriteLine($"DeviceClient.Create with TPM info failed:{ex.Message}");
return;
}
Debug.WriteLine($"{DateTime.UtcNow.ToString("hh:mm:ss")} SAS token renewed ");
}
UnitsNet.Temperature temperature = bme280Sensor.Temperature;
double humidity = bme280Sensor.Humidity;
UnitsNet.Pressure airPressure = bme280Sensor.Pressure;
Debug.WriteLine($"{DateTime.UtcNow.ToLongTimeString()} Timer triggered " +
$"Temperature: {temperature.DegreesCelsius:0.0}°C {temperature.DegreesFahrenheit:0.0}°F " +
$"Humidity: {humidity:0.0}% " +
$"AirPressure: {airPressure.Kilopascals:0.000}KPa ");
SensorPayloadDto sensorPayload = new SensorPayloadDto()
{
Temperature = temperature.DegreesCelsius,
Humidity = humidity,
AirPressure = airPressure.Kilopascals,
};
string payloadText = JsonConvert.SerializeObject(sensorPayload);
using (var message = new Message(Encoding.ASCII.GetBytes(payloadText)))
{
Debug.WriteLine($" {DateTime.UtcNow.ToString("hh:mm:ss.fff")} AzureIoTHubClient SendEventAsync starting");
await azureIoTHubClient.SendEventAsync(message);
Debug.WriteLine($" {DateTime.UtcNow.ToString("hh:mm:ss.fff")} AzureIoTHubClient SendEventAsync finished");
}
}
catch (Exception ex)
{
Debug.WriteLine($"Retrieving or sending sensor values failed:{ex.Message}");
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
try
{
bme280Sensor = new BME280(0x76);
}
catch (Exception ex)
{
Debug.WriteLine($"BME280 Initialisation failed:{ex.Message}");
return;
}
try
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
azureIoTHubUri = myDevice.GetHostName();
deviceId = myDevice.GetDeviceId();
sasToken = myDevice.GetSASToken((uint)sasTokenValidityPeriod.TotalSeconds);
sasTokenIssuedAtUtc = DateTime.UtcNow;
}
catch (Exception ex)
{
Debug.WriteLine($"TpmDevice.GetSASToken failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient = DeviceClient.Create(azureIoTHubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt);
}
catch (Exception ex)
{
Debug.WriteLine($"DeviceClient.Create with TPM info failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient.SetMethodHandlerAsync("Restart", RestartAsync, null);
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device method handler configuration failed:{ex.Message}");
return;
}
try
{
TwinCollection reportedProperties;
reportedProperties = new TwinCollection();
// This is from the OS
reportedProperties["Timezone"] = TimeZoneSettings.CurrentTimeZoneDisplayName;
reportedProperties["OSVersion"] = Environment.OSVersion.VersionString;
reportedProperties["MachineName"] = Environment.MachineName;
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
reportedProperties["ApplicationDisplayName"] = package.DisplayName;
reportedProperties["ApplicationName"] = packageId.Name;
reportedProperties["ApplicationVersion"] = string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}");
// Unique identifier from the hardware
SystemIdentificationInfo systemIdentificationInfo = SystemIdentification.GetSystemIdForPublisher();
using (DataReader reader = DataReader.FromBuffer(systemIdentificationInfo.Id))
{
byte[] bytes = new byte[systemIdentificationInfo.Id.Length];
reader.ReadBytes(bytes);
reportedProperties["SystemId"] = BitConverter.ToString(bytes);
}
azureIoTHubClient.UpdateReportedPropertiesAsync(reportedProperties).Wait();
}
catch (Exception ex)
{
Debug.Print($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
deviceTwin = azureIoTHubClient.GetTwinAsync().Result;
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
if (deviceTwin.Properties.Desired.Contains("TimerDue"))
{
timerDue = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerDue"].ToString());
}
if (deviceTwin.Properties.Desired.Contains("TimerPeriod"))
{
timerPeriod = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerPeriod"].ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine($"Sensor due or period configuration retrieval failed using default:{ex.Message}");
return;
}
bme280InputPollingTimer = new Timer(SensorUpdateTimerCallback, null, timerDue, timerPeriod);
// enable task to continue running in background
backgroundTaskDeferral = taskInstance.GetDeferral();
}
public void DeviceClientIotHubConnectionStringBuilderTest()
{
const string hostName = "acme.azure-devices.net";
const string gatewayHostName = "gateway.acme.azure-devices.net";
const string transparentGatewayHostName = "test";
const string deviceId = "device1";
const string deviceIdSplChar = "device1-.+%_#*?!(),=@;$'";
const string sharedAccessKey = "dGVzdFN0cmluZzE=";
const string sharedAccessKeyName = "AllAccessKey";
const string credentialScope = "Device";
const string credentialType = "SharedAccessSignature";
const string sharedAccessSignature = "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";
string connectionString = $"HostName={hostName};SharedAccessKeyName={sharedAccessKeyName};DeviceId={deviceIdSplChar};SharedAccessKey={sharedAccessKey}";
var iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessKeyName.Should().Be(sharedAccessKeyName);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();
connectionString = $"HostName={hostName};GatewayHostName={transparentGatewayHostName};SharedAccessKeyName={sharedAccessKeyName};DeviceId={deviceId};SharedAccessKey={sharedAccessKey}";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.GatewayHostName.Should().Be(transparentGatewayHostName);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessKeyName.Should().Be(sharedAccessKeyName);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();
connectionString = $"HostName={hostName};CredentialType={credentialType};DeviceId={deviceId};SharedAccessSignature={sharedAccessSignature}";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
connectionString = $"HostName={hostName};CredentialScope={credentialScope};DeviceId={deviceId};SharedAccessKey={sharedAccessKey}";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessKeyName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
connectionString = $"HostName={hostName};CredentialScope={credentialScope};DeviceId={deviceId};SharedAccessSignature={sharedAccessSignature}";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKeyName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
iotHubConnectionStringBuilder.HostName = transparentGatewayHostName;
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
iotHubConnectionStringBuilder.HostName.Should().Be(transparentGatewayHostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
iotHubConnectionStringBuilder.HostName = hostName;
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey(deviceId, sharedAccessKeyName, sharedAccessKey);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sharedAccessSignature);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey(deviceId, sharedAccessKeyName, sharedAccessKey);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();
authMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();
authMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
IAuthenticationMethod authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, gatewayHostName, authenticationMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.GatewayHostName.Should().Be(gatewayHostName);
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authenticationMethod);
iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
}
public void DeviceClientIotHubConnectionStringBuilderTest()
{
string connectionString = "HostName=acme.azure-devices.net;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
var iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
connectionString = "HostName=acme.azure-devices.net;GatewayHostName=test;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNotNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
connectionString = "HostName=acme.azure-devices.net;CredentialType=SharedAccessSignature;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
try
{
iotHubConnectionStringBuilder.HostName = "adshgfvyregferuehfiuehr";
Assert.Fail("Expected FormatException");
}
catch (FormatException)
{
}
iotHubConnectionStringBuilder.HostName = "acme.azure-devices.net";
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzE=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "dGVzdFN0cmluZzI=");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzI=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");
iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device4", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device4");
IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken("Device5", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme1.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme1.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device5");
authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "dGVzdFN0cmluZzI=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme2.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme2.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzI=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");
authMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme3.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme3.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");
authMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme4.azure-devices.net", authMethod);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme4.azure-devices.net");
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzE=");
Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");
string hostName = "acme.azure-devices.net";
string gatewayHostname = "gateway.acme.azure-devices.net";
IAuthenticationMethod authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, gatewayHostname, authenticationMethod);
Assert.AreEqual(gatewayHostname, iotHubConnectionStringBuilder.GatewayHostName);
Assert.AreEqual(hostName, iotHubConnectionStringBuilder.HostName);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
hostName = "acme.azure-devices.net";
authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authenticationMethod);
Assert.AreEqual(hostName, iotHubConnectionStringBuilder.HostName);
Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
}
public MainPage()
{
this.InitializeComponent();
Func <Task> runner = async() =>
{
var controller = await GpioController.GetDefaultAsync();
var pin17 = controller.OpenPin(17);
var pin18 = controller.OpenPin(18);
pin17.SetDriveMode(GpioPinDriveMode.Output);
pin18.SetDriveMode(GpioPinDriveMode.Output);
var myDevice = new TpmDevice(0); // Use logical device 0 on the TPM by default
var hubUri = myDevice.GetHostName();
var deviceId = myDevice.GetDeviceId();
var sasToken = myDevice.GetSASToken();
var authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken);
var deviceClient = DeviceClient.Create(hubUri, authMethod, TransportType.Amqp);
while (true)
{
var msg = await deviceClient.ReceiveAsync();
if (msg != null)
{
var body = Encoding.ASCII.GetString(msg.GetBytes());
await deviceClient.CompleteAsync(msg);
GpioPinValue redValue;
GpioPinValue greenValue;
switch (body.ToLowerInvariant())
{
case "red":
redValue = GpioPinValue.High;
greenValue = GpioPinValue.Low;
break;
case "green":
redValue = GpioPinValue.Low;
greenValue = GpioPinValue.High;
break;
default:
redValue = GpioPinValue.Low;
greenValue = GpioPinValue.Low;
break;
}
pin17.Write(redValue);
pin18.Write(greenValue);
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
};
_run = runner();
}
