internal IndividualEnrollment(
string registrationId,
AttestationMechanism attestation,
string deviceId,
string iotHubHostName,
TwinState initialTwinState,
ProvisioningStatus?provisioningStatus,
DateTime createdDateTimeUtc,
DateTime lastUpdatedDateTimeUtc,
string eTag,
DeviceCapabilities capabilities)
{
if (attestation == null)
{
throw new ProvisioningServiceClientException("Service respond an individualEnrollment without attestation.");
}
try
{
RegistrationId = registrationId;
DeviceId = deviceId;
Attestation = attestation.GetAttestation();
IotHubHostName = iotHubHostName;
InitialTwinState = initialTwinState;
ProvisioningStatus = provisioningStatus;
CreatedDateTimeUtc = createdDateTimeUtc;
LastUpdatedDateTimeUtc = lastUpdatedDateTimeUtc;
ETag = eTag;
Capabilities = capabilities;
}
catch (ArgumentException e)
{
throw new ProvisioningServiceClientException(e);
}
}
private static DeviceRoles ReduceRolesToComplyWith(DeviceCapabilities capabilities, DeviceRoles roles)
{
var allowed = DeviceRoles.None;
if ((capabilities & DeviceCapabilities.ControlKeypad) != 0)
{
allowed |= DeviceRoles.Keypad;
}
if ((capabilities & DeviceCapabilities.StartSensor) != 0 || (capabilities & DeviceCapabilities.TimeSensor) != 0)
{
allowed |= DeviceRoles.StartTimer;
}
if ((capabilities & DeviceCapabilities.IntermediateSensor) != 0 || (capabilities & DeviceCapabilities.TimeSensor) != 0)
{
allowed |= IntermediateTimers;
}
if ((capabilities & DeviceCapabilities.FinishSensor) != 0 || (capabilities & DeviceCapabilities.TimeSensor) != 0)
{
allowed |= DeviceRoles.FinishTimer;
}
if ((capabilities & DeviceCapabilities.Display) != 0)
{
allowed |= DeviceRoles.Display;
}
return(roles & allowed);
}
public static async Task <EnrollmentGroup> CreateEnrollmentGroupAsync(
ProvisioningServiceClient provisioningServiceClient,
AttestationMechanismType attestationType,
string groupId,
ReprovisionPolicy reprovisionPolicy,
AllocationPolicy allocationPolicy,
CustomAllocationDefinition customAllocationDefinition,
ICollection <string> iothubs,
DeviceCapabilities capabilities,
MsTestLogger logger)
{
Attestation attestation;
switch (attestationType)
{
case AttestationMechanismType.Tpm:
throw new NotSupportedException("Group enrollments do not support tpm attestation");
case AttestationMechanismType.SymmetricKey:
string primaryKey = CryptoKeyGenerator.GenerateKey(32);
string secondaryKey = CryptoKeyGenerator.GenerateKey(32);
attestation = new SymmetricKeyAttestation(primaryKey, secondaryKey);
break;
case AttestationMechanismType.X509:
default:
throw new NotSupportedException("Test code has not been written for testing this attestation type yet");
}
var enrollmentGroup = new EnrollmentGroup(groupId, attestation)
{
Capabilities = capabilities,
ReprovisionPolicy = reprovisionPolicy,
AllocationPolicy = allocationPolicy,
CustomAllocationDefinition = customAllocationDefinition,
IotHubs = iothubs,
};
EnrollmentGroup createdEnrollmentGroup = null;
await RetryOperationHelper
.RetryOperationsAsync(
async() =>
{
createdEnrollmentGroup = await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(enrollmentGroup).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
logger)
.ConfigureAwait(false);
if (createdEnrollmentGroup == null)
{
throw new ArgumentException($"The enrollment entry with group Id {groupId} could not be created, exiting test.");
}
return(createdEnrollmentGroup);
}
public static IEnumerable <string> ToServiceCapabilities(this DeviceCapabilities capabilities)
{
Preconditions.CheckNotNull(capabilities, nameof(capabilities));
var serviceCapabilities = new List <string>();
if (capabilities.IotEdge)
{
serviceCapabilities.Add(Constants.IotEdgeIdentityCapability);
}
return(serviceCapabilities);
}
public Device(string ID, string friendlyname, EDeviceClass dclass, EDeviceProtocol proto,
DeviceCapabilities caps, Dictionary<string,string> args)
{
mParent = null;
mID = ID;
mFriendly = friendlyname;
mProto = proto;
mCaps = caps;
mClass = dclass;
mArgs = args;
}
private void initAllDevComp()
{
fpc = new FunctionParameterCollection();
devCap = new DeviceCapabilities();
dev = new Device();
devcol = new DeviceCollection();
devEventColl = new DeviceEventCollection();
devfuncColl = new DeviceFunctionCollection();
devPropColl = new DevicePropertyCollection();
devevent = new DeviceEvent();
devFunc = new DeviceFunction();
devProp = new DeviceProperty();
}
public void When_notify_status_operation_is_received_it_must_raise_event_for_added_device()
{
// Arrange
var deviceAddress = new WirelessNetworkAddress("AABBCC");
const bool getMembership = true;
const DeviceCapabilities capabilities = DeviceCapabilities.ControlKeypad | DeviceCapabilities.NumericKeypad | DeviceCapabilities.StartSensor |
DeviceCapabilities.FinishSensor | DeviceCapabilities.IntermediateSensor;
const DeviceRoles roles = DeviceRoles.StartTimer | DeviceRoles.FinishTimer;
const int signalStrength = 25;
const int batteryStatus = 83;
const bool isAligned = true;
const ClockSynchronizationStatus clockSynchronization = ClockSynchronizationStatus.RequiresSync;
const bool hasVersionMismatch = false;
using var testRunner = new CirceUsbLoopbackTestRunner <DeviceStatus>();
testRunner.RemoteSessionManager.ConnectionStateChanged += (_, e) =>
{
if (e.State == ControllerConnectionState.Connected)
{
testRunner.Connection.Send(new NotifyStatusOperation(deviceAddress, getMembership, capabilities, roles, signalStrength)
{
BatteryStatus = batteryStatus,
IsAligned = isAligned,
ClockSynchronization = clockSynchronization,
HasVersionMismatch = false
});
}
};
testRunner.RemoteSessionManager.DeviceTracker.DeviceAdded += (_, e) => testRunner.SignalSucceeded(e.Argument);
// Act
bool succeeded = testRunner.Start();
// Assert
succeeded.Should().Be(true, "<USB loopback cable must be connected and COM port must be correct.>");
testRunner.Result.ShouldNotBeNull();
testRunner.Result.DeviceAddress.Should().Be(deviceAddress);
testRunner.Result.IsInNetwork.Should().Be(getMembership);
testRunner.Result.Capabilities.Should().Be(capabilities);
testRunner.Result.Roles.Should().Be(roles);
testRunner.Result.SignalStrength.Should().Be(signalStrength);
testRunner.Result.BatteryStatus.Should().Be(batteryStatus);
testRunner.Result.IsAligned.Should().Be(isAligned);
testRunner.Result.ClockSynchronization.Should().Be(clockSynchronization);
testRunner.Result.HasVersionMismatch.Should().Be(hasVersionMismatch);
}
public DeviceStatus(WirelessNetworkAddress deviceAddress, bool isInNetwork, DeviceCapabilities capabilities, DeviceRoles roles, int signalStrength,
int?batteryStatus, bool?isAligned, ClockSynchronizationStatus?clockSynchronization, bool?hasVersionMismatch)
{
Guard.NotNull(deviceAddress, nameof(deviceAddress));
DeviceAddress = deviceAddress;
IsInNetwork = isInNetwork;
Capabilities = capabilities;
Roles = ReduceRolesToComplyWith(capabilities, roles);
SignalStrength = signalStrength;
BatteryStatus = batteryStatus;
IsAligned = isAligned;
ClockSynchronization = clockSynchronization;
HasVersionMismatch = hasVersionMismatch;
}
/// <summary>
/// This method checks if the access token is already present, and calls GetDeviceCapabilities() of RequestFactory.
/// Else, it redirects the user to get the OAuth consent.
/// </summary>
private void GetDeviceCapabilities()
{
if (null != Session["CSDC_ACCESS_TOKEN"])
{
this.requestFactory.AuthorizeCredential = (OAuthToken)Session["CSDC_ACCESS_TOKEN"];
}
if (this.requestFactory.AuthorizeCredential == null)
{
Response.Redirect(this.requestFactory.GetOAuthRedirect().ToString());
}
DeviceCapabilities deviceCapabilities = this.requestFactory.GetDeviceCapabilities();
this.DisplayDeviceCapabilities(deviceCapabilities);
}
public EdgeHubScopeDevice(
string deviceId,
string generationId,
DeviceStatus status,
AuthenticationMechanism authentication,
DeviceCapabilities capabilities,
string deviceScope,
IEnumerable <string> parentScopes)
{
this.Id = Preconditions.CheckNonWhiteSpace(deviceId, nameof(deviceId));
this.GenerationId = Preconditions.CheckNonWhiteSpace(generationId, nameof(generationId));
this.Status = Preconditions.CheckNotNull(status);
this.Authentication = Preconditions.CheckNotNull(authentication);
this.Capabilities = Preconditions.CheckNotNull(capabilities);
this.Scope = deviceScope;
this.ParentScopes = parentScopes;
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaPicker" /> class.
/// </summary>
public MediaPicker()
{
//if (!DeviceCapabilities.IsEnabled(DeviceCapabilities.Capability.ID_CAP_MEDIALIB_PHOTO))
//{
// throw new UnauthorizedAccessException(string.Format("Access to MediaPicker requires {0} to be defined in the manifest.", DeviceCapabilities.Capability.ID_CAP_MEDIALIB_PHOTO));
//}
_photoChooser.Completed += InternalOnPhotoChosen;
_cameraCapture.Completed += InternalOnPhotoChosen;
_photoChooser.ShowCamera = false;
IsCameraAvailable = //DeviceCapabilities.IsEnabled(DeviceCapabilities.Capability.ID_CAP_ISV_CAMERA) &&
(Camera.IsCameraTypeSupported(CameraType.Primary) || Camera.IsCameraTypeSupported(CameraType.FrontFacing));
IsPhotosSupported = DeviceCapabilities.IsEnabled(DeviceCapabilities.Capability.IdCapMedialibPhoto);
IsVideosSupported = IsCameraAvailable;
}
/// <summary>
/// This method displays the Device Capabilities.
/// </summary>
/// <param name="deviceCapabilities">Device Capabilities</param>
private void DisplayDeviceCapabilities(DeviceCapabilities deviceCapabilities)
{
if (null != deviceCapabilities)
{
lblTypeAllocationCode.Text = deviceCapabilities.deviceId.TypeAllocationCode;
lblName.Text = deviceCapabilities.capabilities.Name;
lblVendor.Text = deviceCapabilities.capabilities.Vendor;
lblModel.Text = deviceCapabilities.capabilities.Model;
lblFirmwareVersion.Text = deviceCapabilities.capabilities.FirmwareVersion;
lblUAProf.Text = deviceCapabilities.capabilities.UaProf;
lblMMSCapable.Text = deviceCapabilities.capabilities.MmsCapable;
lblAssistedGps.Text = deviceCapabilities.capabilities.AssistedGps;
lblLocationTechnology.Text = deviceCapabilities.capabilities.LocationTechnology;
lblDeviceBrowser.Text = deviceCapabilities.capabilities.DeviceBrowser;
lblWAPPush.Text = deviceCapabilities.capabilities.WapPushCapable;
tb_dc_output.Visible = true;
tbDeviceCapabilities.Visible = true;
}
}
internal IndividualEnrollment(
string registrationId,
AttestationMechanism attestation,
string deviceId,
string iotHubHostName,
TwinState initialTwinState,
ProvisioningStatus?provisioningStatus,
DateTime createdDateTimeUtc,
DateTime lastUpdatedDateTimeUtc,
string eTag,
DeviceCapabilities capabilities)
{
/* SRS_INDIVIDUAL_ENROLLMENT_21_003: [The constructor shall throws ProvisioningServiceClientException if one of the
* provided parameters in JSON is not valid.] */
if (attestation == null)
{
throw new ProvisioningServiceClientException("Service respond an individualEnrollment without attestation.");
}
try
{
/* SRS_INDIVIDUAL_ENROLLMENT_21_004: [The constructor shall store all parameters in the JSON.] */
RegistrationId = registrationId;
DeviceId = deviceId;
Attestation = attestation.GetAttestation();
IotHubHostName = iotHubHostName;
InitialTwinState = initialTwinState;
ProvisioningStatus = provisioningStatus;
CreatedDateTimeUtc = createdDateTimeUtc;
LastUpdatedDateTimeUtc = lastUpdatedDateTimeUtc;
ETag = eTag;
Capabilities = capabilities;
}
catch (ArgumentException e)
{
throw new ProvisioningServiceClientException(e);
}
}
/// <summary>
/// Initializes a new instance of the HardwareAdapterCapabilities class with the specifed Adapter.
/// </summary>
/// <param name="adapter">DirectX Adapter</param>
public HardwareAdapterCapabilities(Adapter1 adapter)
: base(adapter: adapter)
{
string adapterDescription = AdapterDescription1.Description.Trim();
int pos = adapterDescription.IndexOf('\0'); // UH: In SharpDX 3.1, some adapters report description with many zero characters
if (pos >= 0)
{
adapterDescription = adapterDescription.Substring(0, pos);
}
DisplayName = adapterDescription;
try
{
DeviceCapabilities = DeviceCapabilities.QueryAdapter(adapter);
DeviceInfoText = string.Format("Feature level: {0}; Video memory: {1:#,##0} MB",
GetFeatureLevelText(DeviceCapabilities.FeatureLevel),
AdapterDescription1.DedicatedVideoMemory / (1024 * 1024));
IsSupported = this.DeviceCapabilities.FeatureLevel >= FeatureLevel.Level_10_0;
if (!IsSupported)
{
UnsupportedReason = "Adapter not supported because it does not supported feature level 10.0 or higher";
}
}
catch (Exception ex)
{
IsSupported = false;
UnsupportedReason = "Error checking device capabilities:\r\n" + ex.Message;
}
}
private void StartListening()
{
try
{
int sampleRate = 6000;
int fftSize = SelectedFftSize;
int stepSize = fftSize / 20;
SpectrogamImageSource = null;
listener?.Dispose();
listener = new Listener(DeviceCapabilities.IndexOf(selectedDevice), sampleRate);
spec = new Spectrogram.Spectrogram(sampleRate, fftSize, stepSize);
spec.SetWindow(FftSharp.Window.Rectangular(fftSize));
SpectrogramHeight = spec.Height;
VerticalScaleImageSource = null;
VerticalScaleImageSource = ImageHelpers.BitmapToImageSource(spec.GetVerticalScale(LEGEND_WIDTH));
}
catch (Exception ex)
{
Console.WriteLine("Exeption when attempting to start to listen: " + ex.Message);
}
}
/// <summary>
/// Convert capabilities to model
/// </summary>
/// <param name="capabilities"></param>
/// <returns></returns>
public static DeviceCapabilitiesModel ToModel(this DeviceCapabilities capabilities)
{
return(new DeviceCapabilitiesModel {
IotEdge = capabilities.IotEdge
});
}
private static bool AreCapabilitiesValid(DeviceCapabilities capabilities)
{
if (capabilities == DeviceCapabilities.None)
{
return false;
}
if ((capabilities & DeviceCapabilities.TimeSensor) != 0 && (capabilities != DeviceCapabilities.TimeSensor))
{
return false;
}
if ((capabilities & DeviceCapabilities.Display) != 0 && (capabilities != DeviceCapabilities.Display))
{
return false;
}
return true;
}
/// <summary>
/// This method invokes DeviceInfo API of AT&T platform to get the device information.
/// </summary>
private void GetDeviceInfo()
{
try
{
HttpWebRequest deviceInfoRequestObject = (HttpWebRequest)System.Net.WebRequest.Create(this.endPoint + "/rest/2/Devices/Info");
deviceInfoRequestObject.Method = "GET";
deviceInfoRequestObject.Headers.Add("Authorization", "Bearer " + Session["Cs_DC_App1_AccessToken"]);
HttpWebResponse deviceInfoResponse = (HttpWebResponse)deviceInfoRequestObject.GetResponse();
using (StreamReader accessTokenResponseStream = new StreamReader(deviceInfoResponse.GetResponseStream()))
{
string deviceInfo_jsonObj = accessTokenResponseStream.ReadToEnd();
JavaScriptSerializer deserializeJsonObject = new JavaScriptSerializer();
DeviceCapabilities deserializedJsonObj = (DeviceCapabilities)deserializeJsonObject.Deserialize(deviceInfo_jsonObj, typeof(DeviceCapabilities));
if (deserializedJsonObj != null)
{
lblTypeAllocationCode.Text = deserializedJsonObj.DeviceInfo.DeviceId.TypeAllocationCode;
lblName.Text = deserializedJsonObj.DeviceInfo.Capabilities.Name;
lblVendor.Text = deserializedJsonObj.DeviceInfo.Capabilities.Vendor;
lblFirmwareVersion.Text = deserializedJsonObj.DeviceInfo.Capabilities.FirmwareVersion;
lblUAProf.Text = deserializedJsonObj.DeviceInfo.Capabilities.UaProf;
lblMMSCapable.Text = deserializedJsonObj.DeviceInfo.Capabilities.MmsCapable;
lblAGPS.Text = deserializedJsonObj.DeviceInfo.Capabilities.AssistedGps;
lblLocationTechnology.Text = deserializedJsonObj.DeviceInfo.Capabilities.LocationTechnology;
lblDeviceBrowser.Text = deserializedJsonObj.DeviceInfo.Capabilities.DeviceBrowser;
lblWAPPush.Text = deserializedJsonObj.DeviceInfo.Capabilities.WapPushCapable;
tbDeviceCapabSuccess.Visible = true;
tbDeviceCapabilities.Visible = true;
}
else
{
lblErrorMessage.Text = "No response from the platform.";
tbDeviceCapabError.Visible = true;
}
}
}
catch (WebException we)
{
string errorResponse = string.Empty;
try
{
using (StreamReader sr2 = new StreamReader(we.Response.GetResponseStream()))
{
errorResponse = sr2.ReadToEnd();
sr2.Close();
}
}
catch
{
errorResponse = "Unable to get response";
}
lblErrorMessage.Text = errorResponse + Environment.NewLine + we.Message;
tbDeviceCapabError.Visible = true;
}
catch (Exception ex)
{
lblErrorMessage.Text = ex.Message;
tbDeviceCapabError.Visible = true;
}
}
private void SetupDevice([NotNull] WirelessNetworkAddress oldAddress,
[NotNull] WirelessNetworkAddress newAddress, DeviceCapabilities capabilities)
{
IWirelessDevice device;
if (Devices.TryRemove(oldAddress, out device))
{
Devices[newAddress] = device;
deviceChangeLogger.ChangeAddress(oldAddress, newAddress, capabilities);
device.ChangeAddress(newAddress);
ResetMediatorStatusAfterSetup();
}
}
/// <summary>
/// Checks for support for a capability
/// </summary>
/// <param name="capability">The DeviceCapabilties flag(s) to check</param>
/// <returns>True if this device supports the given capabilit(y/ies), otherwise false</returns>
public bool SupportsCapability(DeviceCapabilities capability)
{
return(this.Capabilities.HasFlag(capability));
}
public NetworkCompositionBuilder WithDeviceInRoles(WirelessNetworkAddress deviceAddress, DeviceCapabilities capabilities, DeviceRoles roles)
{
composition = composition.ChangeRolesFor(deviceAddress, capabilities, roles);
return(this);
}
private async Task <SecurityProvider> CreateSecurityProviderFromName(AttestationType attestationType, EnrollmentType?enrollmentType, string groupId, ReprovisionPolicy reprovisionPolicy, AllocationPolicy allocationPolicy, CustomAllocationDefinition customAllocationDefinition, ICollection <string> iothubs, DeviceCapabilities capabilities = null)
{
_verboseLog.WriteLine($"{nameof(CreateSecurityProviderFromName)}({attestationType})");
var provisioningServiceClient = ProvisioningServiceClient.CreateFromConnectionString(Configuration.Provisioning.ConnectionString);
switch (attestationType)
{
case AttestationType.Tpm:
string registrationId = AttestationTypeToString(attestationType) + "-registration-id-" + Guid.NewGuid();
var tpmSim = new SecurityProviderTpmSimulator(registrationId);
string base64Ek = Convert.ToBase64String(tpmSim.GetEndorsementKey());
var provisioningService = ProvisioningServiceClient.CreateFromConnectionString(Configuration.Provisioning.ConnectionString);
_log.WriteLine($"Getting enrollment: RegistrationID = {registrationId}");
IndividualEnrollment individualEnrollment = new IndividualEnrollment(registrationId, new TpmAttestation(base64Ek))
{
AllocationPolicy = allocationPolicy, ReprovisionPolicy = reprovisionPolicy, IotHubs = iothubs, CustomAllocationDefinition = customAllocationDefinition, Capabilities = capabilities
};
IndividualEnrollment enrollment = await provisioningService.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
var attestation = new TpmAttestation(base64Ek);
enrollment.Attestation = attestation;
_log.WriteLine($"Updating enrollment: RegistrationID = {registrationId} EK = '{base64Ek}'");
await provisioningService.CreateOrUpdateIndividualEnrollmentAsync(enrollment).ConfigureAwait(false);
return(tpmSim);
case AttestationType.x509:
X509Certificate2 certificate = null;
X509Certificate2Collection collection = null;
switch (enrollmentType)
{
case EnrollmentType.Individual:
certificate = Configuration.Provisioning.GetIndividualEnrollmentCertificate();
break;
case EnrollmentType.Group:
certificate = Configuration.Provisioning.GetGroupEnrollmentCertificate();
collection = Configuration.Provisioning.GetGroupEnrollmentChain();
break;
default:
throw new NotSupportedException($"Unknown X509 type: '{enrollmentType}'");
}
return(new SecurityProviderX509Certificate(certificate, collection));
case AttestationType.SymmetricKey:
switch (enrollmentType)
{
case EnrollmentType.Group:
EnrollmentGroup symmetricKeyEnrollmentGroup = await CreateEnrollmentGroup(provisioningServiceClient, AttestationType.SymmetricKey, groupId, reprovisionPolicy, allocationPolicy, customAllocationDefinition, iothubs, capabilities).ConfigureAwait(false);
Assert.IsTrue(symmetricKeyEnrollmentGroup.Attestation is SymmetricKeyAttestation);
SymmetricKeyAttestation symmetricKeyAttestation = (SymmetricKeyAttestation)symmetricKeyEnrollmentGroup.Attestation;
string registrationIdSymmetricKey = IdPrefix + Guid.NewGuid();
string primaryKeyEnrollmentGroup = symmetricKeyAttestation.PrimaryKey;
string secondaryKeyEnrollmentGroup = symmetricKeyAttestation.SecondaryKey;
string primaryKeyIndividual = ProvisioningE2ETests.ComputeDerivedSymmetricKey(Convert.FromBase64String(primaryKeyEnrollmentGroup), registrationIdSymmetricKey);
string secondaryKeyIndividual = ProvisioningE2ETests.ComputeDerivedSymmetricKey(Convert.FromBase64String(secondaryKeyEnrollmentGroup), registrationIdSymmetricKey);
return(new SecurityProviderSymmetricKey(registrationIdSymmetricKey, primaryKeyIndividual, secondaryKeyIndividual));
case EnrollmentType.Individual:
IndividualEnrollment symmetricKeyEnrollment = await CreateIndividualEnrollment(provisioningServiceClient, AttestationType.SymmetricKey, reprovisionPolicy, allocationPolicy, customAllocationDefinition, iothubs, capabilities).ConfigureAwait(false);
Assert.IsTrue(symmetricKeyEnrollment.Attestation is SymmetricKeyAttestation);
symmetricKeyAttestation = (SymmetricKeyAttestation)symmetricKeyEnrollment.Attestation;
registrationIdSymmetricKey = symmetricKeyEnrollment.RegistrationId;
string primaryKey = symmetricKeyAttestation.PrimaryKey;
string secondaryKey = symmetricKeyAttestation.SecondaryKey;
return(new SecurityProviderSymmetricKey(registrationIdSymmetricKey, primaryKey, secondaryKey));
default:
throw new NotSupportedException("Unrecognized enrollment type");
}
default:
throw new NotSupportedException("Unrecognized attestation type");
}
throw new NotSupportedException($"Unknown security type: '{attestationType}'.");
}
private static string GetAdapterDetailsText(Adapter1 adapter, DeviceCapabilities deviceCapabilities, int indent = 0)
{
if (adapter == null)
{
throw new ArgumentNullException("oneAdapter");
}
var sb = new StringBuilder();
string description = adapter.Description.Description;
int pos = description.IndexOf('\0'); // UH: In SharpDX 3.1, some adapters report description with many zero characters
if (pos >= 0)
{
description = description.Substring(0, pos);
}
sb.AppendFormat("{0}<Adapter Description=\"{1}\"\r\n", new String(' ', indent), description);
sb.AppendFormat("{0}DeviceId=\"0x{1:X}\" VendorId=\"0x{2:X}\" SubSysId=\"0x{3:X}\" AdapterLuid=\"0x{4:X}\" Revision=\"{5}\" Flags=\"{6}\"\r\n{0}DedicatedVideoMemory=\"{7}\" DedicatedSystemMemory=\"{8}\" SharedSystemMemory=\"{9}\" >\r\n",
new String(' ', indent + 9),
adapter.Description.DeviceId, adapter.Description.VendorId, adapter.Description.SubsystemId, adapter.Description.Luid, adapter.Description.Revision, adapter.Description1.Flags,
adapter.Description.DedicatedVideoMemory,
adapter.Description.DedicatedSystemMemory,
adapter.Description.SharedSystemMemory);
// According to http://msdn.microsoft.com/en-us/library/windows/desktop/bb174524%28v=vs.85%29.aspx
// If you try to use CheckInterfaceSupport to check whether a Direct3D 11.x and later version interface is supported, CheckInterfaceSupport returns DXGI_ERROR_UNSUPPORTED.
//adapter.IsInterfaceSupported<>()
if (adapter.Outputs == null || adapter.Outputs.Length == 0)
{
sb.AppendFormat("{0}<Outputs />\r\n", new String(' ', indent + 4));
}
else
{
sb.AppendFormat("{0}<Outputs>\r\n", new String(' ', indent + 4));
for (int j = 0; j < adapter.Outputs.Length; j++)
{
var oneOutput = adapter.Outputs[j];
var desktopBounds = oneOutput.Description.DesktopBounds;
int width, height;
width = desktopBounds.Right - desktopBounds.Left;
height = desktopBounds.Bottom - desktopBounds.Top;
sb.AppendFormat("{0}<Output DeviceName=\"{1}\" AttachedToDesktop=\"{2}\" Width=\"{3}\" Height=\"{4}\" Rotation=\"{5}\" />\r\n",
new String(' ', indent + 8), oneOutput.Description.DeviceName, oneOutput.Description.IsAttachedToDesktop, width, height, oneOutput.Description.Rotation);
}
sb.AppendFormat("{0}</Outputs>\r\n", new String(' ', indent + 4));
}
if (deviceCapabilities != null)
{
sb.AppendFormat("{0}<DeviceCapabilities IsDirectX11Supported=\"{1}\" FeatureLevel=\"{2}\" MaxSupportedMultisamplingCount=\"{3}\" />\r\n",
new String(' ', indent + 4), deviceCapabilities.IsDirectX11Supported, deviceCapabilities.FeatureLevel, deviceCapabilities.MaxSupportedMultisamplingCount);
}
sb.AppendFormat("{0}</Adapter>\r\n", new String(' ', indent));
return(sb.ToString());
}
private static extern ErrorCode GetDriverCaps(IntPtr system, int id, out DeviceCapabilities caps, out int minfrequency, out int maxfrequency, out SpeakerMode controlpanelspeakermode);
public static async Task<IndividualEnrollment> CreateIndividualEnrollment(ProvisioningServiceClient provisioningServiceClient, AttestationMechanismType attestationType, ReprovisionPolicy reprovisionPolicy, AllocationPolicy allocationPolicy, CustomAllocationDefinition customAllocationDefinition, ICollection<string> iotHubsToProvisionTo, DeviceCapabilities capabilities)
{
string registrationId = AttestationTypeToString(attestationType) + "-registration-id-" + Guid.NewGuid();
Attestation attestation;
IndividualEnrollment individualEnrollment;
switch (attestationType)
{
case AttestationMechanismType.Tpm:
using (var tpmSim = new SecurityProviderTpmSimulator(registrationId))
{
string base64Ek = Convert.ToBase64String(tpmSim.GetEndorsementKey());
var provisioningService = ProvisioningServiceClient.CreateFromConnectionString(Configuration.Provisioning.ConnectionString);
individualEnrollment = new IndividualEnrollment(registrationId, new TpmAttestation(base64Ek))
{
Capabilities = capabilities,
AllocationPolicy = allocationPolicy,
ReprovisionPolicy = reprovisionPolicy,
CustomAllocationDefinition = customAllocationDefinition,
IotHubs = iotHubsToProvisionTo
};
IndividualEnrollment enrollment = await provisioningService.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
attestation = new TpmAttestation(base64Ek);
enrollment.Attestation = attestation;
return await provisioningService.CreateOrUpdateIndividualEnrollmentAsync(enrollment).ConfigureAwait(false);
}
case AttestationMechanismType.SymmetricKey:
string primaryKey = CryptoKeyGenerator.GenerateKey(32);
string secondaryKey = CryptoKeyGenerator.GenerateKey(32);
attestation = new SymmetricKeyAttestation(primaryKey, secondaryKey);
break;
case AttestationMechanismType.X509:
default:
throw new NotSupportedException("Test code has not been written for testing this attestation type yet");
}
individualEnrollment = new IndividualEnrollment(registrationId, attestation);
individualEnrollment.Capabilities = capabilities;
individualEnrollment.CustomAllocationDefinition = customAllocationDefinition;
individualEnrollment.ReprovisionPolicy = reprovisionPolicy;
individualEnrollment.IotHubs = iotHubsToProvisionTo;
individualEnrollment.AllocationPolicy = allocationPolicy;
return await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
}
public DeviceCapabilityNotSupportedException(DeviceCapabilities capability, string message) : base(message)
{
Capability = capability;
}
public DeviceCapabilityNotSupportedException(DeviceCapabilities capability) : base()
{
Capability = capability;
}
/// <summary>
/// Create a Device instance from a config
/// </summary>
/// <param name="deviceConfig">The configuration of the device</param>
/// <returns>The parsed device</returns>
/// <exception cref="InvalidDeviceConfigException">If the configuration is invalid</exception>
static Device Parse(dynamic deviceConfig)
{
Device device = null;
// Collect values from config
string type = deviceConfig.type;
string name = deviceConfig.name;
dynamic caps = deviceConfig.capabilities;
IEnumerable <string> capabilitiesStrings = caps is IList?caps.Values <string>() : new string[0];
// Check if we have a type
if (type == null)
{
throw new InvalidDeviceConfigException("Invalid Device config: supplying a type is required");
}
// Find the type
var fullTypeString = "Touchee.Devices." + type.ToTitleCase() + "Device";
var deviceType = typeof(Device);
foreach (var ass in AppDomain.CurrentDomain.GetAssemblies())
{
var t = ass.GetType(fullTypeString);
if (t != null)
{
deviceType = t;
break;
}
}
// Collect capabilities
DeviceCapabilities capabilities = 0;
foreach (var c in capabilitiesStrings)
{
try {
capabilities = capabilities | (DeviceCapabilities)Enum.Parse(typeof(DeviceCapabilities), c.ToCamelCase());
}
catch (ArgumentException) {
Logger.Log("Unknown DeviceCapability: " + c + ". Skipping it", Logger.LogLevel.Error);
}
}
// Construct the device
try {
device = (Device)Activator.CreateInstance(deviceType, new object[] { type, name, capabilities });
}
catch (Exception e) {
throw new InvalidDeviceConfigException("The device could not be instantiated. Is there a (string, string, DeviceCapabilities) constructor?", e);
}
// Apply config
try {
device.ApplyConfigBase(deviceConfig);
device.ApplyConfig(deviceConfig);
}
catch (Exception e) {
throw new InvalidDeviceConfigException("The configuration for the device " + device.Name + " could not be applied.", e);
}
// Save it
device.Save();
return(device);
}
private void LoadAllDevices()
{
if (File.Exists(@"\\192.168.0.37\MY101-Product X\07-Product Line\CSL\ComponentManager\Devices.xml"))
{
XElement root = XElement.Load(@"\\192.168.0.37\MY101-Product X\07-Product Line\CSL\ComponentManager\Devices.xml");
root.Elements("Device").All <XElement>(xeDevices =>
{
DeviceCapabilities devCap = new DeviceCapabilities();
DeviceEventCollection devEventColl = new DeviceEventCollection();
DeviceFunctionCollection devfuncColl = new DeviceFunctionCollection();
DevicePropertyCollection devPropColl = new DevicePropertyCollection();
xeDevices.Elements("Capabilities").Elements("events").Elements("event").All <XElement>(xe =>
{
devEventColl.AddDeviceEvent(xe.Attribute("id").Value, xe.Attribute("name").Value);
return(true);
});
xeDevices.Elements("Capabilities").Elements("functions").Elements("function").All <XElement>(xe =>
{
devfuncColl.AddDeviceFunctions(xe.Attribute("id").Value,
xe.Attribute("functionname").Value,
fpc, /* this will taken care later*/
(ACTDataType)Enum.Parse(typeof(ACTDataType), "dt" + xe.Attribute("returntype").Value.ToLower()));
return(true);
});
xeDevices.Elements("Capabilities").Elements("properties").Elements("property").All <XElement>(xe =>
{
devPropColl.AddDeviceProperties(xe.Attribute("id").Value,
xe.Attribute("name").Value,
(ACTDataType)Enum.Parse(typeof(ACTDataType), "dt" + xe.Attribute("type").Value.ToLower()),
Convert.ToBoolean(xe.Attribute("Readonly").Value));
return(true);
});
devCap.Events = devEventColl;
devCap.Functions = devfuncColl;
devCap.Properties = devPropColl;
devcol.AddDevice(xeDevices.Attribute("id").Value,
xeDevices.Attribute("name").Value, devCap);
return(true);
});
}
if (File.Exists(@"\\192.168.0.37\MY101-Product X\07-Product Line\CSL\ComponentManager\SOA.xml"))
{
XElement root = XElement.Load(@"\\192.168.0.37\MY101-Product X\07-Product Line\CSL\ComponentManager\SOA.xml");
root.Elements("Device").All <XElement>(xeDevices =>
{
DeviceCapabilities devCap = new DeviceCapabilities();
DeviceEventCollection devEventColl = new DeviceEventCollection();
DeviceFunctionCollection devfuncColl = new DeviceFunctionCollection();
DevicePropertyCollection devPropColl = new DevicePropertyCollection();
xeDevices.Elements("Capabilities").Elements("events").Elements("event").All <XElement>(xe =>
{
devEventColl.AddDeviceEvent(xe.Attribute("id").Value, xe.Attribute("name").Value);
return(true);
});
xeDevices.Elements("Capabilities").Elements("functions").Elements("function").All <XElement>(xe =>
{
devfuncColl.AddDeviceFunctions(xe.Attribute("id").Value,
xe.Attribute("functionname").Value,
fpc, /* this will taken care later*/
(ACTDataType)Enum.Parse(typeof(ACTDataType), "dt" + xe.Attribute("returntype").Value.ToLower()));
return(true);
});
xeDevices.Elements("Capabilities").Elements("properties").Elements("property").All <XElement>(xe =>
{
devPropColl.AddDeviceProperties(xe.Attribute("id").Value,
xe.Attribute("name").Value,
(ACTDataType)Enum.Parse(typeof(ACTDataType), "dt" + xe.Attribute("type").Value.ToLower()),
Convert.ToBoolean(xe.Attribute("Readonly").Value));
return(true);
});
devCap.Events = devEventColl;
devCap.Functions = devfuncColl;
devCap.Properties = devPropColl;
devcol.AddDevice(xeDevices.Attribute("id").Value,
xeDevices.Attribute("name").Value, devCap);
return(true);
});
}
AMAActionableObjects.FixedDeviceCollection = devcol;
}
string JSGFActionsFromCapabilities(DeviceCapabilities caps, CMUSphinx_GrammarDict cgd)
{
string capsName = "<caps_" + caps.CapsAsIntString + ">";
if (caps_rules_jsgf.Keys.Contains(caps.Caps))
{
return caps_rules_jsgf[caps.Caps];
}
else
{
StringBuilder b = new StringBuilder();
cgd.JSGFRuleStart(capsName, b);
List<string> capsAsString = caps.Actions;
if (capsAsString == null || capsAsString.Count == 0)
{
cgd.JSGFRuleCancel(capsName, b);
return null;
}
cgd.JSGFRuleAddChoicesStart(b, capsAsString);
cgd.JSGFRuleAddChoicesEnd(b);
cgd.JSGFRuleEnd(capsName, b);
caps_rules_jsgf.Add(caps.Caps, capsName);
}
//return new SrgsRuleRef(r, "action");
return capsName;
}
/// <devdoc>
/// Retrieves device-specific information for this device.
/// </devdoc>
public int GetDeviceCapabilities(DeviceCapabilities capabilityIndex)
{
return(IntUnsafeNativeMethods.GetDeviceCaps(new HandleRef(this, this.Hdc), (int)capabilityIndex));
}
private void GetOutputDriverCapabilities(int Id, out DeviceCapabilities caps, out int minfrequency, out int maxfrequency, out SpeakerMode controlpanelspeakermode)
{
Errors.ThrowIfError(GetDriverCaps(DangerousGetHandle(), Id, out caps, out minfrequency, out maxfrequency, out controlpanelspeakermode));
}
private async Task ConfirmExpectedDeviceCapabilities(DeviceRegistrationResult result, Client.IAuthenticationMethod auth, DeviceCapabilities capabilities)
{
if (capabilities != null)
{
//hardcoding amqp since http does not support twin, but tests that call into this may use http
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, Client.TransportType.Amqp))
{
//Confirm that the device twin reflects what the enrollment dictated
Twin twin = await iotClient.GetTwinAsync().ConfigureAwait(false);
Assert.AreEqual(capabilities.IotEdge, twin.Capabilities.IotEdge);
}
}
}
/// <summary>
/// Constructs a new Device instance
/// </summary>
/// <param name="type">The type of the device</param>
/// <param name="name">The name of the device</param>
/// <param name="capabilities">The capabilities of the device</param>
public Device(string type, string name, DeviceCapabilities capabilities)
{
this.Type = type;
this.Name = name;
this.Capabilities = capabilities;
}
bool FSGActionsFromCapabilities(DeviceCapabilities caps, CMUSphinx_GrammarDict cgd,
ref CMUSphinx_FSGState startState, ref CMUSphinx_FSGState endState)
{
string capsName = "<caps_" + caps.CapsAsIntString + ">";
if (caps_rules_fsg.Keys.Contains(caps.Caps))
{
startState = caps_rules_fsg[caps.Caps].Item1;
endState = caps_rules_fsg[caps.Caps].Item2;
return true;
}
List<string> capsAsString = caps.Actions;
if (capsAsString == null || capsAsString.Count == 0)
{
startState = null;
endState = null;
return false;
}
CMUSphinx_FSGState start = cgd.FSGCreateOrphanState();
CMUSphinx_FSGState end = cgd.FSGCreateOrphanState();
foreach (string s in capsAsString)
{
cgd.FSGLinkStates(start, end, s);
}
caps_rules_fsg.Add(caps.Caps, new Tuple<CMUSphinx_FSGState,CMUSphinx_FSGState>(start, end));
startState = start;
endState = end;
//return new SrgsRuleRef(r, "action");
return true;
}
public static extern int HidP_GetCaps(IntPtr preparsed, out DeviceCapabilities caps);
SrgsRuleRef SrgsActionsFromCapabilities(DeviceCapabilities caps, SrgsDocument doc)
{
SrgsRule r;
if (caps_rules.Keys.Contains(caps.Caps))
{
r = caps_rules[caps.Caps];
}
else
{
List<string> capsAsString = caps.Actions;
if (capsAsString == null || capsAsString.Count == 0) return null;
SrgsOneOf actions = new SrgsOneOf();
foreach (string s in capsAsString)
{
SrgsItem si = new SrgsItem(s);
//si.Add(new SrgsSemanticInterpretationTag(" out = \"" + s + "\";"));
si.Add(new SrgsNameValueTag("action", s));
actions.Add(si);
}
r = new SrgsRule(AudioRecog_SAPI.SrgsCleanupID("caps_" + caps.CapsAsIntString), actions);
doc.Rules.Add(r);
caps_rules.Add(caps.Caps, r);
}
//return new SrgsRuleRef(r, "action");
return new SrgsRuleRef(r);
}
public DeviceRolesWithCapabilities(DeviceCapabilities capabilities, DeviceRoles roles)
{
Capabilities = capabilities;
Roles = roles;
}
private void GetRecordDriverCapabilities(int id, out DeviceCapabilities caps, out int minfrequency, out int maxfrequency)
{
Errors.ThrowIfError(GetRecordDriverCaps(DangerousGetHandle(), id, out caps, out minfrequency, out maxfrequency));
}
public int GetDeviceCapabilities(DeviceCapabilities capabilityIndex)
{
return IntUnsafeNativeMethods.GetDeviceCaps(new HandleRef(this, this.Hdc), (int) capabilityIndex);
}
private static extern ErrorCode GetRecordDriverCaps(IntPtr system, int id, out DeviceCapabilities caps, out int minfrequency, out int maxfrequency);
/// <summary>
/// This method displays the Device Capabilities.
/// </summary>
/// <param name="deviceCapabilities">Device Capabilities</param>
private void DisplayDeviceCapabilities(DeviceCapabilities deviceCapabilities)
{
if (null != deviceCapabilities)
{
lblTypeAllocationCode.Text = deviceCapabilities.deviceId.TypeAllocationCode;
lblName.Text = deviceCapabilities.capabilities.Name;
lblVendor.Text = deviceCapabilities.capabilities.Vendor;
lblModel.Text = deviceCapabilities.capabilities.Model;
lblFirmwareVersion.Text = deviceCapabilities.capabilities.FirmwareVersion;
lblUAProf.Text = deviceCapabilities.capabilities.UaProf;
lblMMSCapable.Text = deviceCapabilities.capabilities.MmsCapable;
lblAssistedGps.Text = deviceCapabilities.capabilities.AssistedGps;
lblLocationTechnology.Text = deviceCapabilities.capabilities.LocationTechnology;
lblDeviceBrowser.Text = deviceCapabilities.capabilities.DeviceBrowser;
lblWAPPush.Text = deviceCapabilities.capabilities.WapPushCapable;
tb_dc_output.Visible = true;
tbDeviceCapabilities.Visible = true;
}
}
public static async Task<EnrollmentGroup> CreateEnrollmentGroup(ProvisioningServiceClient provisioningServiceClient, AttestationMechanismType attestationType, string groupId, ReprovisionPolicy reprovisionPolicy, AllocationPolicy allocationPolicy, CustomAllocationDefinition customAllocationDefinition, ICollection<string> iothubs, DeviceCapabilities capabilities)
{
Attestation attestation;
switch (attestationType)
{
case AttestationMechanismType.Tpm:
throw new NotSupportedException("Group enrollments do not support tpm attestation");
case AttestationMechanismType.SymmetricKey:
string primaryKey = CryptoKeyGenerator.GenerateKey(32);
string secondaryKey = CryptoKeyGenerator.GenerateKey(32);
attestation = new SymmetricKeyAttestation(primaryKey, secondaryKey);
break;
case AttestationMechanismType.X509:
default:
throw new NotSupportedException("Test code has not been written for testing this attestation type yet");
}
var enrollmentGroup = new EnrollmentGroup(groupId, attestation)
{
Capabilities = capabilities,
ReprovisionPolicy = reprovisionPolicy,
AllocationPolicy = allocationPolicy,
CustomAllocationDefinition = customAllocationDefinition,
IotHubs = iothubs,
};
return await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(enrollmentGroup).ConfigureAwait(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="NotifyStatusOperation" /> class with required parameters.
/// </summary>
/// <param name="originatingAddress">
/// The originating address of the device in the wireless network.
/// </param>
/// <param name="getMembership">
/// Indicates whether the device is part of the logical network configuration.
/// </param>
/// <param name="capabilities">
/// The capabilities that the device can perform.
/// </param>
/// <param name="roles">
/// The subset of <paramref name="capabilities" /> that the device currently performs in the logical network.
/// </param>
/// <param name="signalStrength">
/// The wireless signal strength. Higher values indicate a better signal.
/// </param>
public NotifyStatusOperation([NotNull] WirelessNetworkAddress originatingAddress, bool getMembership,
DeviceCapabilities capabilities, DeviceRoles roles, int signalStrength)
: this()
{
Guard.NotNull(originatingAddress, nameof(originatingAddress));
OriginatingAddress = originatingAddress;
GetMembership = getMembership;
Capabilities = capabilities;
Roles = roles;
SignalStrength = signalStrength;
}
