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); }