private void DoWatcherDiscovery()
{
List <ServiceAdvertiserInfo> servicesExpected = new List <ServiceAdvertiserInfo>();
int adIdx = 0;
foreach (var handle in discoveryParameters.AdvertisersToMatch)
{
ServiceAdvertiserInfo advertiser = advertiserTestController.GetAdvertiserInfo(handle);
if (discoveryParameters.AdvertiserServiceInfoMatch == null ||
discoveryParameters.AdvertiserServiceInfoMatch.Count < adIdx ||
!discoveryParameters.AdvertiserServiceInfoMatch[adIdx])
{
// Clear the service info if not expected
advertiser.ServiceInfo = "";
}
servicesExpected.Add(advertiser);
adIdx++;
}
Stopwatch discoveryStopwatch = new Stopwatch();
discoveryStopwatch.Start();
discoveryHandles = discoveryTestController.WatcherDiscoverServices(
discoveryParameters.Query,
servicesExpected,
discoveryParameters.ServiceInfoRequest
);
discoveryStopwatch.Stop();
WiFiDirectTestLogger.Log("Services Discovery (watcher) completed in {0} ms.", discoveryStopwatch.ElapsedMilliseconds);
succeeded = true;
}
public ReconnectScenarioResult Execute()
{
try
{
bool pairingSucceeded = Pair();
if (!pairingSucceeded)
{
return(new ReconnectScenarioResult(false));
}
Disconnect();
bool discoverySucceeded = Discover();
if (!discoverySucceeded)
{
return(new ReconnectScenarioResult(false));
}
Reconnect();
WiFiDirectTestUtilities.RunDataPathValidation(localWFDController, remoteWFDController);
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing reconnect scenario: {0}", e);
return(new ReconnectScenarioResult(false));
}
return(new ReconnectScenarioResult(true));
}
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));
}
public async Task <AsyncResult> SendMessageAsync(
SocketWrapper socket,
string message
)
{
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log(
"SendMessageAsync... (Socket={0})",
socket.Handle
);
await socket.SendMessageAsync(message);
socket.WaitForSend();
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Log("Exception in SendMessageAsync (this may be expected)");
error = ex;
}
return(new AsyncResult(success, error));
}
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));
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting Discovery for \"{0}\" on device {1} ({2})",
discoveryParameters.Query,
discoveryTestController.DeviceAddress,
discoveryTestController.MachineName
);
if (discoveryParameters.Type == ServicesDiscoveryType.FindAllAsync)
{
DoFindAllDiscovery();
}
else if (discoveryParameters.Type == ServicesDiscoveryType.Watcher)
{
DoWatcherDiscovery();
}
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service discovery scenario: {0}", e);
}
}
public void Start()
{
Logger.SetAdditionalLogger(WEX.Logging.Interop.Log.Comment);
WiFiDirectTestLogger.Log("Starting remote server on port {0}", listenPort);
RemoteCommandServer remoteCommandServer = new RemoteCommandServer(
new Type[]
{
typeof(DOT11_MAC_ADDRESS),
typeof(WFDSvcWrapperHandle),
typeof(WiFiDirectServiceStatus),
typeof(List <WiFiDirectServiceConfigurationMethod>),
typeof(List <WFDSvcWrapperHandle>),
typeof(ServiceAdvertiserInfo),
typeof(DiscoveredServiceInfo),
typeof(ProvisioningInfoWrapper),
typeof(ServiceSessionInfo),
typeof(DOT11_WPS_CONFIG_METHOD),
typeof(List <ServiceAdvertiserInfo>),
typeof(List <String>)
},
new object[]
{
new WiFiDirectTestController(testContext, true),
}
);
remoteCommandServer.Run(listenPort);
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log("Beginning Discover/Connect scenario");
// Do all discovers
foreach (var discoveryParams in discoveryConnectParameters.DiscoveryParameters)
{
var discoveryScenario = new ServicesDiscoveryScenario(seekerTestController, advertiserTestController, discoveryParams);
ServicesDiscoveryScenarioResult discoveryResult = discoveryScenario.Execute();
discoveryResults.Add(discoveryResult);
if (!discoveryResult.ScenarioSucceeded)
{
throw new Exception("Discovery failed!");
}
}
// BUG: [TH2] Fix race on back-to-back discoveries
Task.Delay(500).Wait();
// Do all connects
foreach (var connectPreParams in discoveryConnectParameters.ConnectParameters)
{
// Need to translate indices to handles
if (connectPreParams.DiscoveryResultIndex > discoveryResults.Count ||
connectPreParams.DiscoveryResultIndex < 0 ||
connectPreParams.DiscoveredHandleIndex > discoveryResults[connectPreParams.DiscoveryResultIndex].DiscoveryHandles.Count ||
connectPreParams.DiscoveredHandleIndex < 0)
{
throw new Exception("Bad connect parameters! Index out of range for discovered device");
}
WFDSvcWrapperHandle discoveredDevice = discoveryResults[connectPreParams.DiscoveryResultIndex].DiscoveryHandles[connectPreParams.DiscoveredHandleIndex];
// Now run scenario
ServicesConnectParameters connectParams = new ServicesConnectParameters(
discoveredDevice,
connectPreParams.AdvertiserHandle,
connectPreParams.Options
);
var connectScenario = new ServicesConnectScenario(seekerTestController, advertiserTestController, connectParams);
ServicesConnectScenarioResult connectResult = connectScenario.Execute();
connectResults.Add(connectResult);
if (!connectResult.ScenarioSucceeded)
{
throw new Exception("Connect failed!");
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service discover/connect scenario: {0}", e);
}
}
private void Reconnect()
{
WiFiDirectTestLogger.Log("Reconnecting to {0} ({1})", this.remoteWFDController.DeviceAddress, this.remoteWFDController.MachineName);
this.remoteWFDController.AcceptNextConnectRequest();
this.localWFDController.OpenSessionToLastPairedDevice();
}
public async Task <AsyncHandleResult> AddDatagramSocketAsync(
ServiceSession session,
UInt16 port
)
{
WFDSvcWrapperHandle socketHandle = null;
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log(
"AddDatagramSocketAsync... (port={0}) (Session={1})",
port.ToString(),
session.Handle
);
SocketWrapper socket = await session.AddDatagramSocketListenerAsync(port);
socketHandle = socket.Handle;
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Log("Exception in AddDatagramSocketAsync (this may be expected)");
error = ex;
}
return(new AsyncHandleResult(socketHandle, success, error));
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestController disconnectTestController = localWFDController;
WiFiDirectTestController otherTestController = remoteWFDController;
WiFiDirectTestLogger.Log(
"Starting Disconnect for session with handle {0} on device {1} ({2}), expect session with handle {3} to close on device {4} ({5})",
disconnectParameters.SessionHandle,
disconnectTestController.DeviceAddress,
disconnectTestController.MachineName,
disconnectParameters.OtherSessionHandle,
otherTestController.DeviceAddress,
otherTestController.MachineName
);
disconnectTestController.DisconnectServiceSession(disconnectParameters.SessionHandle);
otherTestController.WaitForDisconnectServiceSession(disconnectParameters.OtherSessionHandle);
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service session disconnect scenario: {0}", e);
}
}
public void ClearPin()
{
WiFiDirectTestLogger.Log("Clearing PIN state");
pinDisplayedEvent.Reset();
pinEnteredEvent.Reset();
this.pin = "";
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting Publish for service \"{0}\" on device {1} ({2})",
publishParameters.ServiceName,
advertisingWFDController.DeviceAddress,
advertisingWFDController.MachineName
);
List <WiFiDirectServiceConfigurationMethod> configMethods = null;
if (publishParameters.ConfigMethods != ServicePublishConfigMethods.NotSet)
{
configMethods = new List <WiFiDirectServiceConfigurationMethod>();
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplayKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.PinDisplay);
}
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplayKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.PinEntry);
}
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.Default);
}
}
handle = advertisingWFDController.PublishService(
publishParameters.ServiceName,
publishParameters.AutoAccept,
publishParameters.PreferGO,
configMethods,
WiFiDirectServiceStatus.Available, // TODO status
0, // TODO custom status
publishParameters.ServiceInfo,
publishParameters.SessionInfo,
publishParameters.PrefixList
);
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service publish scenario: {0}", e);
}
}
public async Task <AsyncStringResult> ReceiveMessageAsync(
SocketWrapper socket
)
{
Exception error = null;
bool success = false;
string message = "";
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log(
"ReceiveMessageAsync... (Socket={0})",
socket.Handle
);
// TCP explicitly receives a message, UDP has a callback
if (socket.IsTCP)
{
// Wait to receive a message for up to 20 seconds
Task receiveMessageTask = socket.ReceiveMessageAsync();
if (receiveMessageTask == await Task.WhenAny(receiveMessageTask, Task.Delay(20000)))
{
WiFiDirectTestLogger.Log(
"ReceiveMessageAsync DONE (Socket={0})",
socket.Handle
);
}
else
{
throw new Exception("Timeout waiting for socket to receive message!");
}
}
socket.WaitForReceive();
if (!socket.HasReceivedMessages())
{
throw new Exception("Did not actually receive message over socket!");
}
while (socket.HasReceivedMessages())
{
WiFiDirectTestLogger.Log("Reading message...");
message += socket.GetNextReceivedMessage();
}
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Log("Exception in SendMessageAsync (this may be expected)");
error = ex;
}
return(new AsyncStringResult(message, success, error));
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log("Beginning Publish/Discover scenario");
// Do all publications
foreach (var publishParams in publishDiscoveryParameters.PublishParameters)
{
var publishScenario = new ServicesPublishScenario(advertiserTestController, publishParams);
ServicesPublishScenarioResult publishResult = publishScenario.Execute();
publishResults.Add(publishResult);
if (!publishResult.ScenarioSucceeded)
{
throw new Exception("Publication failed!");
}
}
// Do all discoveries
foreach (var discoveryPreParams in publishDiscoveryParameters.DiscoveryParameters)
{
// Need to translate indices to handles
List <WFDSvcWrapperHandle> advertisersToMatch = new List <WFDSvcWrapperHandle>();
foreach (int i in discoveryPreParams.AdvertisersToMatchIndices)
{
if (i > publishResults.Count || i < 0)
{
throw new Exception("Bad discovery parameters! Index out of range");
}
advertisersToMatch.Add(publishResults[i].AdvertiserHandle);
}
ServicesDiscoveryParameters discoveryParams = new ServicesDiscoveryParameters(
discoveryPreParams.Parameters.Query,
discoveryPreParams.Parameters.ExpectedMatchCount,
advertisersToMatch,
discoveryPreParams.Parameters.Type,
discoveryPreParams.Parameters.ServiceInfoRequest,
discoveryPreParams.Parameters.AdvertiserServiceInfoMatch
);
var discoveryScenario = new ServicesDiscoveryScenario(discoveryTestController, advertiserTestController, discoveryParams);
ServicesDiscoveryScenarioResult discoveryResult = discoveryScenario.Execute();
discoveryResults.Add(discoveryResult);
if (!discoveryResult.ScenarioSucceeded)
{
throw new Exception("Discovery failed!");
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service publish/discovery scenario: {0}", e);
}
}
public void EnterPin(string pin)
{
ThrowIfDisposed();
this.pin = pin;
WiFiDirectTestLogger.Log("Entered PIN: {0}", this.pin);
pinEnteredEvent.Set();
}
public void RemoveSession(WFDSvcWrapperHandle handle)
{
bool fRemoved = sessionCollection.Remove(handle);
if (!fRemoved)
{
WiFiDirectTestLogger.Error("Remove session failed to find session in list! (Session={0})", handle);
throw new Exception("Failed to remove session");
}
}
public void RemoveDiscovery(WFDSvcWrapperHandle handle)
{
bool fRemoved = discoveryCollection.Remove(handle);
if (!fRemoved)
{
WiFiDirectTestLogger.Error("Remove discovery failed to find discovery in list! (Session={0})", handle);
throw new Exception("Failed to remove discovery");
}
}
public WFDSvcWrapperHandle GetLastRemoteSocketAdded(
ServiceSession session
)
{
WiFiDirectTestLogger.Log("Waiting for session to get RemotePortAdded event and setup socket (Session={0})", session.Handle);
session.WaitForRemotePortAdded();
WFDSvcWrapperHandle socketHandle = session.LastRemoteSocketAdded;
return(socketHandle);
}
public void TestMethodCleanup()
{
try
{
localWFDController.CheckServicesManagerErrors();
remoteWFDController.CheckServicesManagerErrors();
}
catch (Exception ex)
{
WiFiDirectTestLogger.Error("Found error in Wi-Fi Direct Services manager: {0}", ex);
}
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Sending data ({6} char string) from socket with handle {0} on device {1} ({2}), expect received on socket with handle {3} on device {4} ({5})",
dataParameters.SenderSocketHandle,
senderWFDController.DeviceAddress,
senderWFDController.MachineName,
dataParameters.ReceiverSocketHandle,
receiverWFDController.DeviceAddress,
receiverWFDController.MachineName,
dataParameters.DataSize
);
// Generate message of "DataSize" characters
StringBuilder builder = new StringBuilder();
for (int i = 0; i < dataParameters.DataSize; i++)
{
builder.Append(s_chars[rng.Next(s_chars.Length)]);
}
string msg = builder.ToString();
senderWFDController.SendServiceSocketMessage(
dataParameters.SenderSessionHandle,
dataParameters.SenderSocketHandle,
msg
);
string rcv = receiverWFDController.ReceiveServiceSocketMessage(
dataParameters.ReceiverSessionHandle,
dataParameters.ReceiverSocketHandle
);
// Validate
if (msg != rcv)
{
WiFiDirectTestLogger.Error("Sent: '{0}', Received: '{1}'",
WiFiDirectTestUtilities.GetTruncatedString(msg, 32),
WiFiDirectTestUtilities.GetTruncatedString(rcv, 32)
);
throw new Exception("Received Message was not the same as expected!");
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service send data scenario: {0}", e);
}
}
public void StartConnectionListener(string localAddress, string remoteAddress, string localPort)
{
if (localAddress == null)
{
throw new ArgumentNullException("localAddress");
}
if (remoteAddress == null)
{
throw new ArgumentNullException("remoteAddress");
}
if (localPort == null)
{
throw new ArgumentNullException("localPort");
}
lock (this.criticalSection)
{
if (this.streamSocketListener != null)
{
throw new InvalidOperationException("The stream socket listener is already running");
}
if (this.streamSocket != null)
{
throw new InvalidOperationException("A stream socket is already connected");
}
WiFiDirectTestLogger.Log("Listening for incoming TCP connection. Local Address = {0}, Remote Address = {1}, Local Port={2}", localAddress, remoteAddress, localPort);
this.expectedRemoteHost = new HostName(remoteAddress);
StreamSocketListener streamSocketListener = new StreamSocketListener();
try
{
streamSocketListener.ConnectionReceived += this.ConnectionReceived;
streamSocketListener.BindEndpointAsync(new HostName(localAddress), localPort).AsTask().Wait();
this.streamSocketListener = streamSocketListener;
streamSocketListener = null;
}
finally
{
if (streamSocketListener != null)
{
streamSocketListener.Dispose();
}
}
}
}
public void ConnectASPOverExistingP2PGroup()
{
using (RemoteControllerLogGroup lg = new RemoteControllerLogGroup(remoteWFDController))
{
// Start by doing WFD pairing
// NOTE: use invitation (not used for services) and config method push button (not used for services)
ExecutePairingScenario(PairingScenarioType.Invitation, DOT11_WPS_CONFIG_METHOD.DOT11_WPS_CONFIG_METHOD_PUSHBUTTON);
// Make sure we close this session on cleanup
needToCloseSession = true;
// Connect, auto accept
string serviceName = remoteWFDController.GenerateUniqueServiceName();
ServicesPublishDiscoverConnectParameters connectParams = new ServicesPublishDiscoverConnectParameters(
serviceName,
new ServicesConnectOptions(validateData: true)
);
var pairResults = ExecutePublishDiscoverConnectScenario(connectParams);
Verify.AreEqual(1, pairResults.ConnectResults.Count);
// Disconnect
ExecuteDisconnectScenario(
new ServicesDisconnectParameters(
pairResults.ConnectResults[0].AdvertiserSessionHandle,
pairResults.ConnectResults[0].SeekerSessionHandle
),
false
);
// WFD connection should stay up
WiFiDirectTestLogger.Log("Closed ASP Session, waiting to make sure WFD session stays active...");
Task.Delay(8000).Wait();
WfdGlobalSessionState globalSessionStateLocal = localWFDController.QueryGlobalSessionState();
if (globalSessionStateLocal.Sessions.Length != 1)
{
WiFiDirectTestLogger.Error("Expected a single active session. Current session count = {0}", globalSessionStateLocal.Sessions.Length);
throw new Exception("Local machine session is closed");
}
WiFiDirectTestUtilities.RunDataPathValidation(localWFDController, remoteWFDController, "6001");
// Close WFD connection
localWFDController.CloseSession();
needToCloseSession = false;
}
}
public LegacyPairingScenarioResult Execute()
{
try
{
ExecuteInternal();
this.scenarioSucceeded = true;
}
catch (Exception exception)
{
WiFiDirectTestLogger.Error("Caught exception while running legacy pairing scenario: {0}", exception);
}
return(new LegacyPairingScenarioResult(this.scenarioSucceeded));
}
private WfdDeviceDescriptor PerformWildcardDiscovery()
{
WfdDeviceDescriptor discoveredDeviceDescriptor = null;
//
// Perform the discovery
//
WiFiDirectTestLogger.Log("Performing wildcard discovery for device {0} ({1}) as {2}, Timeout: {3} ms, Discovery Type: {4}",
remoteWFDController.DeviceAddress,
remoteWFDController.MachineName,
GetFriendlyStringForDiscoveryScenarioType(discoveryScenarioType),
searchTimeoutMs,
GetFriendlyStringForDiscoverType(discoverType)
);
List <WfdDeviceDescriptor> discoveryResults = localWFDController.DiscoverDevices(searchTimeoutMs, discoverType);
WiFiDirectTestLogger.Log("Discovery returned {0} results.", discoveryResults == null ? 0 : discoveryResults.Count);
if (discoveryResults != null)
{
foreach (WfdDeviceDescriptor discoveryResult in discoveryResults)
{
if (discoveryResult.DeviceAddress == remoteWFDController.DeviceAddress)
{
WiFiDirectTestLogger.Log("Target device {0} ({1}) found in discovery results", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
if (discoveryScenarioType == DiscoveryScenarioType.DiscoverAsGo &&
!discoveryResult.GroupCapabilities.GroupOwner)
{
WiFiDirectTestLogger.Error("Expected to find device {0} ({1}) as a group owner, but there's no GO running on the device.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
else
{
discoveredDeviceDescriptor = discoveryResult;
}
break;
}
}
}
if (discoveredDeviceDescriptor == null)
{
WiFiDirectTestLogger.Error("Target device {0} ({1}) not found.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
return(discoveredDeviceDescriptor);
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting open socket ({6} {7}) from session with handle {0} on device {1} ({2}), expect socket added on session with handle {3} on device {4} ({5})",
socketParameters.SenderSessionHandle,
senderWFDController.DeviceAddress,
senderWFDController.MachineName,
socketParameters.ReceiverSessionHandle,
receiverWFDController.DeviceAddress,
receiverWFDController.MachineName,
socketParameters.Protocol.ToString(),
socketParameters.Port
);
if (socketParameters.Protocol == WiFiDirectServiceIPProtocol.Tcp)
{
senderSocketHandle = senderWFDController.AddServiceStreamSocket(
socketParameters.SenderSessionHandle,
socketParameters.Port
);
receiverSocketHandle = receiverWFDController.GetServiceRemoteSocketAdded(
socketParameters.ReceiverSessionHandle
);
}
else if (socketParameters.Protocol == WiFiDirectServiceIPProtocol.Udp)
{
senderSocketHandle = senderWFDController.AddServiceDatagramSocket(
socketParameters.SenderSessionHandle,
socketParameters.Port
);
receiverSocketHandle = receiverWFDController.GetServiceRemoteSocketAdded(
socketParameters.ReceiverSessionHandle
);
}
else
{
throw new Exception("Unsupported Protocol!");
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service open socket scenario: {0}", e);
}
}
public void GeneratePin()
{
ThrowIfDisposed();
const string s_chars = "1234567890";
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 8; i++)
{
builder.Append(s_chars[rng.Next(s_chars.Length)]);
}
this.pin = builder.ToString();
WiFiDirectTestLogger.Log("Generated PIN for display: {0}", this.pin);
pinDisplayedEvent.Set();
}
public List <WFDSvcWrapperHandle> WatchServices(string serviceName, string serviceInfo = "")
{
if (!watcher.HasExpectations())
{
WiFiDirectTestLogger.Error("Watcher needs expected services to run");
throw new Exception("Cannot use watcher without a condition to stop");
}
watcher.Start(serviceName, serviceInfo);
watcher.WaitForFindAll();
watcher.Stop();
List <WFDSvcWrapperHandle> results = discoveryCollection.Keys.ToList();
return(results);
}
private WfdDeviceDescriptor PerformTargetedDiscovery()
{
DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK deviceFilterBitmask;
switch (discoveryScenarioType)
{
case DiscoveryScenarioType.DiscoverAsDevice:
deviceFilterBitmask = DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK.Device;
break;
case DiscoveryScenarioType.DiscoverAsGo:
deviceFilterBitmask = DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK.GO;
break;
default:
throw new Exception("Unable to map from discovery scenario type to discovery filter bitmask");
}
//
// Perform the discovery
//
WiFiDirectTestLogger.Log("Performing targetted discovery for device {0} ({1}) as {2}, Timeout: {3} ms, Discovery Type: {4}",
remoteWFDController.DeviceAddress,
remoteWFDController.MachineName,
GetFriendlyStringForDiscoveryScenarioType(discoveryScenarioType),
searchTimeoutMs,
GetFriendlyStringForDiscoverType(discoverType)
);
WfdDeviceDescriptor discoveredDeviceDescriptor = localWFDController.PerformTargetedDiscovery(
remoteWFDController.DeviceAddress,
deviceFilterBitmask,
searchTimeoutMs,
discoverType
);
if (discoveredDeviceDescriptor == null)
{
WiFiDirectTestLogger.Error("Target device {0} ({1}) not found.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
return(discoveredDeviceDescriptor);
}
public WFDSvcWrapperHandle GetLastAdvertiserSession(
ServiceAdvertiser advertiser,
bool autoAccept
)
{
WiFiDirectTestLogger.Log("Waiting for Advertiser to get session connection (Advertiser={0})", advertiser.Handle);
if (autoAccept)
{
advertiser.WaitForAutoAcceptSessionConnected();
}
else
{
advertiser.WaitForSessionRequested();
}
WFDSvcWrapperHandle sessionHandle = advertiser.LastConnectedSession;
return(sessionHandle);
}
