public async Task <AsyncProvisioningInfoResult> GetProvisioningInfoAsync(
DiscoveredService discovered,
WiFiDirectServiceConfigurationMethod configMethod
)
{
WiFiDirectServiceProvisioningInfo provisioningInfo = null;
ProvisioningInfoWrapper provisioningWrapper = null;
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log(
"GetProvisioningInfoAsync... (config method={0}) (Discovery={1})",
configMethod.ToString(),
discovered.Handle
);
provisioningInfo = await discovered.GetProvisioningInfoAsync(configMethod);
provisioningWrapper = new ProvisioningInfoWrapper(provisioningInfo);
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Log("Exception in GetProvisioningInfoAsync (this may be expected)");
error = ex;
}
return(new AsyncProvisioningInfoResult(provisioningWrapper, success, error));
}
public async Task <AsyncHandleResult> ConnectAsync(
DiscoveredService discovered
)
{
WFDSvcWrapperHandle sessionHandle = null;
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log("ConnectAsync... (Discovery={0})", discovered.Handle);
sessionHandle = await discovered.ConnectAsync();
ServiceSession session = GetSession(sessionHandle);
if (session.Session.Status != WiFiDirectServiceSessionStatus.Open)
{
throw new Exception("Session did not start successfully");
}
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Log("Exception in ConnectAsync (this may be expected)");
error = ex;
}
return(new AsyncHandleResult(sessionHandle, success, error));
}
private async Task <bool> IsServiceRegistered()
{
try
{
var res = await _client.Health.Service(
_consulServiceInstance.ServiceName,
$"serviceid={_consulServiceInstance.Id} time={DateTime.Now}", true);
if (res == null || res.Response == null || res.StatusCode != HttpStatusCode.OK)
{
throw new Exception();
}
foreach (var serviceEntry in res.Response)
{
var discoveredService = new DiscoveredService(serviceEntry);
if (discoveredService != null &&
discoveredService.Version.ToString() == _consulServiceInstance.Version)
{
return(true);
}
}
return(false);
}
catch
{
_logger.LogWarning("There was a problem accessing Consul.");
return(false);
}
}
private IDiscoveredService ConvertFromProto(DiscoveredService proto)
{
return(_messageFactory.CreateDiscoveredService(
ConvertFromProtoStrict(proto.ConsumedService),
ConvertFromProtoStrict(proto.ProvidedService),
proto.ServiceTitle.ConvertFromProto(),
proto.Methods.Select(ConvertFromProtoStrict).ToList()));
}
private DiscoveredService ConvertToProto(IDiscoveredService service)
{
var proto = DiscoveredService.Rent();
proto.ProvidedService = ConvertToProtoStrict(service.ProvidedService);
proto.ConsumedService = ConvertToProtoStrict(service.ConsumedService);
proto.ServiceTitle = service.ServiceTitle.ConvertToProto();
proto.Methods.AddRange(service.Methods.Select(ConvertToProto));
return(proto);
}
public DiscoveredService GetDiscoveredService(WFDSvcWrapperHandle handle)
{
ThrowIfDisposed();
DiscoveredService service = discoveryCollection[handle];
if (service == null)
{
throw new Exception(String.Format(CultureInfo.InvariantCulture, "Discovered service not found for handle={0}", handle));
}
return(service);
}
public IDiscoveredService CreateDiscoveredService(
IConsumedServiceReference consumedService,
IProvidedServiceReference providedService,
Maybe <string> serviceTitle,
IReadOnlyCollection <IDiscoveredServiceMethod> methods)
{
var obj = DiscoveredService.Rent();
obj.ConsumedService = consumedService;
obj.ProvidedService = providedService;
obj.ServiceTitle = serviceTitle;
obj.Methods = methods;
return(obj);
}
public void AddDiscovery(DiscoveredService service)
{
discoveryCollection.Add(service.Handle, service);
}
public async Task <AsyncHandleListResult> DiscoverServicesAsync(string serviceName, bool fExpectResults = true, string serviceInfo = "")
{
List <WFDSvcWrapperHandle> results = new List <WFDSvcWrapperHandle>();
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log("Discover Services... (ServiceName={0}, ServiceInfo={1})", serviceName, serviceInfo);
string serviceSelector = "";
if (serviceInfo == "")
{
serviceSelector = WiFiDirectService.GetSelector(serviceName);
}
else
{
using (var serviceInfoDataWriter = new Windows.Storage.Streams.DataWriter(new Windows.Storage.Streams.InMemoryRandomAccessStream()))
{
serviceInfoDataWriter.WriteString(serviceInfo);
serviceSelector = WiFiDirectService.GetSelector(serviceName, serviceInfoDataWriter.DetachBuffer());
}
}
WiFiDirectTestLogger.Log("FindAllAsync... Using Selector: {0}", serviceSelector);
List <string> additionalProperties = new List <string>();
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceAddress");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceName");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceInformation");
additionalProperties.Add("System.Devices.WiFiDirectServices.AdvertisementId");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceConfigMethods");
DeviceInformationCollection deviceInfoCollection = await DeviceInformation.FindAllAsync(serviceSelector, additionalProperties);
WiFiDirectTestLogger.Log(
"FindAllAsync...DONE Got {0} results",
(deviceInfoCollection == null) ? 0 : deviceInfoCollection.Count
);
if (deviceInfoCollection == null || deviceInfoCollection.Count == 0)
{
if (fExpectResults)
{
WiFiDirectTestLogger.Error("No services found!");
throw new Exception("Expected services discovered, found none!");
}
else
{
WiFiDirectTestLogger.Log("No services found (expected)");
}
}
else
{
if (!fExpectResults)
{
WiFiDirectTestLogger.Error("Services found, none expected!");
throw new Exception("Expected no services discovered, found at least 1!");
}
else
{
// NOTE: we don't clear this list
// Possible to discover A, discover B, then connect to A because its entry still exists
foreach (DeviceInformation deviceInfo in deviceInfoCollection)
{
WiFiDirectTestLogger.Log(
"Adding discovered service (Id={0}, Name={1})",
deviceInfo.Id,
deviceInfo.Name
);
DiscoveredService discovered = new DiscoveredService(deviceInfo, this, this, this);
discoveryCollection.Add(discovered.Handle, discovered);
results.Add(discovered.Handle);
}
}
}
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Error("Exception in DiscoverServicesAsync");
error = ex;
}
return(new AsyncHandleListResult(results, success, error));
}
public KnownServicesChangedArgs(KnownServicesChangedAction _Action, DiscoveredService _Service)
{
Action = _Action;
Service = _Service;
}
private void addService(IServiceCollection serviceCollection, DiscoveredService service)
{
ServiceRegistryHandlers.GetServiceRegistryHandler(service.Configuration.Scope)(serviceCollection, service);
}
