async internal void testconnectAsync()
{
string result = "";
string deviceSelector = WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.AssociationEndpoint);
DeviceInformationCollection devInfoCollection = await DeviceInformation.FindAllAsync(deviceSelector);
String deviceId = devInfoCollection[0].Id;
wfdDevice = await Windows.Devices.WiFiDirect.WiFiDirectDevice.FromIdAsync(deviceId);
if (wfdDevice == null)
{
result = "Connection to " + deviceId + " failed.";
}
// Register for connection status change notification.
wfdDevice.ConnectionStatusChanged += new TypedEventHandler <Windows.Devices.WiFiDirect.WiFiDirectDevice, object>(OnConnectionChanged);
// Get the EndpointPair information.
var EndpointPairCollection = wfdDevice.GetConnectionEndpointPairs();
if (EndpointPairCollection.Count > 0)
{
var endpointPair = EndpointPairCollection[0];
result = "Local IP address " + endpointPair.LocalHostName.ToString() +
" connected to remote IP address " + endpointPair.RemoteHostName.ToString();
}
else
{
result = "Connection to " + deviceId + " failed.";
}
}
public bool StartScan(string searchForDevice = null)
{
_searchingFor = searchForDevice;
_publisher.Start();
if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
{
LastErrorMessage = "Failed to start advertisement.";
return(false);
}
_discoveredDevices.Clear();
LastErrorMessage = "Finding Devices...";
String deviceSelector = WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.DeviceInterface);
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
_scanning = true;
return(true);
}
public static async System.Threading.Tasks.Task ConnectAsync(string deviceId, bool IsReceiver)
{
try
{
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
WiFiDirectDevice wfdDevice = null;
connectionParams.GroupOwnerIntent = (short)(IsReceiver ? 15 : 0);
connectionParams.PreferredPairingProcedure = WiFiDirectPairingProcedure.GroupOwnerNegotiation;
connectionParams.PreferenceOrderedConfigurationMethods.Clear();
connectionParams.PreferenceOrderedConfigurationMethods.Add(WiFiDirectConfigurationMethod.PushButton);
wfdDevice = await WiFiDirectDevice.FromIdAsync(deviceId, connectionParams);
// Register for the ConnectionStatusChanged event handler
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
var endpointPairs = wfdDevice.GetConnectionEndpointPairs();
MessagingCenter.Send("P2PShare", "WFDConnectError", "Connected IP Address: " + endpointPairs[0].RemoteHostName);
MessagingCenter.Send("P2PShare", "WFDConnected", endpointPairs[0].RemoteHostName.ToString());
}
catch (Exception)
{
/*MessagingCenter.Send("P2PShare", "WFDConnectError", "Connection to " + deviceId + " failed " + err.Message);
* DependencyService.Get<IPlatformDependent>().Dispose();
* DependencyService.Get<IPlatformDependent>().Init(true);
* System.Threading.Thread.Sleep(1000);
*
* if (--ConnectionAttempt > 0)
* await ConnectAsync(deviceId, IsReceiver);
* else
* {
* ConnectionAttempt = 50;
* }*/
}
MessagingCenter.Send("P2PShare", "WFDConnectIsEnabled", true);
}
/// <summary>
/// 建立连接
/// </summary>
public async void Connecting()
{
//连接参数
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
connectionParams.GroupOwnerIntent = 1;
WiFiDirectDevice wfdDevice;
string deviceId = TextBox_SelectedIP.Text;
try
{
wfdDevice = await WiFiDirectDevice.FromIdAsync(deviceId, connectionParams);
Invoke(() =>
{
TextBlock_ConnectedState.Text = "连接到设备" + deviceId;
});
EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
EstablishSocketFromConnector(EndpointPairs[0].RemoteHostName, "50001");
}
catch (Exception exp)
{
Invoke(() => { TextBlock_ConnectedState.Text = exp.Message; });
}
}
private async void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs args)
{
WiFiDirectConnectionRequest ConnectionRequest = args.GetConnectionRequest();
WiFiDirectDevice wfdDevice = await WiFiDirectDevice.FromIdAsync(ConnectionRequest.DeviceInformation.Id);
EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
_ConnectionEstablishState = ConnectionEstablishState.Succeeded;
OnConnectionEstalblishResult?.Invoke(this, _ConnectionEstablishState);
}
private void Disconnect()
{
if (_wfdDevice != null)
{
var device = _wfdDevice;
_wfdDevice = null;
device.Dispose();
}
}
private async Task <bool> HandleConnectionRequestAsync(WiFiDirectConnectionRequest connectionRequest)
{
string deviceName = connectionRequest.DeviceInformation.Name;
bool isPaired = (connectionRequest.DeviceInformation.Pairing?.IsPaired == true) ||
(await IsAepPairedAsync(connectionRequest.DeviceInformation.Id));
//rootPage.NotifyUser($"Connecting to {deviceName}...", NotifyType.StatusMessage);
// Pair device if not already paired and not using legacy settings
if (!isPaired && !_publisher.Advertisement.LegacySettings.IsEnabled)
{
if (!await connectionSettingsPanel.RequestPairDeviceAsync(connectionRequest.DeviceInformation.Pairing))
{
return(false);
}
}
WiFiDirectDevice wfdDevice = null;
try
{
// IMPORTANT: FromIdAsync needs to be called from the UI thread
wfdDevice = await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id);
}
catch (Exception ex)
{
//rootPage.NotifyUser($"Exception in FromIdAsync: {ex}", NotifyType.ErrorMessage);
return(false);
}
// Register for the ConnectionStatusChanged event handler
//wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
StreamSocketListener listenerSocket = new StreamSocketListener();
// Save this (listenerSocket, wfdDevice) pair so we can hook it up when the socket connection is made.
_pendingConnections[listenerSocket] = wfdDevice;
IReadOnlyList <Windows.Networking.EndpointPair> EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
listenerSocket.ConnectionReceived += OnSocketConnectionReceived;
try
{
await listenerSocket.BindEndpointAsync(EndpointPairs[0].LocalHostName, Globals.strServerPort);
}
catch (Exception ex)
{
//rootPage.NotifyUser($"Connect operation threw an exception: {ex.Message}", NotifyType.ErrorMessage);
return(false);
}
//rootPage.NotifyUser($"Devices connected on L2, listening on IP Address: {EndpointPairs[0].LocalHostName}" +
//$" Port: {Globals.strServerPort}", NotifyType.StatusMessage);
return(true);
}
private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
rootPage.NotifyUserFromBackground($"Connection status changed: {sender.ConnectionStatus}", NotifyType.StatusMessage);
if (sender.ConnectionStatus == WiFiDirectConnectionStatus.Disconnected)
{
// TODO: Should we remove this connection from the list?
// (Yes, probably.)
}
}
private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
StatusBlock.Text = $"Connection status changed: {sender.ConnectionStatus}";
if (sender.ConnectionStatus == WiFiDirectConnectionStatus.Disconnected)
{
// TODO: Should we remove this connection from the list?
// (Yes, probably.)
}
}
public static async void GetDevices()
{
string deviceSelector = WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.AssociationEndpoint);
DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(deviceSelector);
foreach (DeviceInformation device in devices)
{
Send.Devices.Add(new Device(device.Name, device.Id));
}
MessagingCenter.Send("P2PShare", "WFDSearchIsEnabled", true);
}
void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
JSONObject eventData = createEventData(EVENT_CONNECTION_CHANGED);
((JSONObject)eventData[TAG_DATA])[TAG_CONNECTED] = (sender.ConnectionStatus == WiFiDirectConnectionStatus.Connected) ? TAG_TRUE : TAG_FALSE;
if (sender.ConnectionStatus == WiFiDirectConnectionStatus.Disconnected)
{
mConnected.Remove(extractMAC(sender.DeviceId));
}
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(createEventData(EVENT_PEERS_CHANGED)));
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(eventData));
}
private void btnWatcher_Click(object sender, RoutedEventArgs e)
{
if (_fWatcherStarted == false)
{
_publisher.Start();
if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
{
rootPage.NotifyUser("Failed to start advertisement.", NotifyType.ErrorMessage);
return;
}
DiscoveredDevices.Clear();
rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage);
String deviceSelector = WiFiDirectDevice.GetDeviceSelector(
Utils.GetSelectedItemTag <WiFiDirectDeviceSelectorType>(cmbDeviceSelector));
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
btnWatcher.Content = "Stop Watcher";
_fWatcherStarted = true;
}
else
{
_publisher.Stop();
btnWatcher.Content = "Start Watcher";
_fWatcherStarted = false;
_deviceWatcher.Added -= OnDeviceAdded;
_deviceWatcher.Removed -= OnDeviceRemoved;
_deviceWatcher.Updated -= OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
_deviceWatcher.Stopped -= OnStopped;
_deviceWatcher.Stop();
rootPage.NotifyUser("Device watcher stopped.", NotifyType.StatusMessage);
}
}
private async void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs args)
{
WiFiDirectConnectionRequest ConnectionRequest = args.GetConnectionRequest();
// Prompt the user to accept/reject the connection request
// If rejected, exit
// Connect to the remote device
WiFiDirectDevice wfdDevice = await WiFiDirectDevice.FromIdAsync(ConnectionRequest.DeviceInformation.Id);
// Get the local and remote IP addresses
IReadOnlyList <Windows.Networking.EndpointPair> EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
// Establish standard WinRT socket with above IP addresses
}
private async void GetData(WiFiDirectConnectionRequest connectionRequest)
{
try
{
var wfdDevice = await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id);
var endPoint = wfdDevice.GetConnectionEndpointPairs();
string result = string.Empty;
foreach (var item in endPoint)
{
result = item.LocalHostName + "\r\n";
}
}
catch (Exception ex)
{
}
}
private async void PairWithSelectedDevice(DeviceInformation selectedDevice)
{
//set the group owner intent to indicate that we want the receiver to be the owner
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
connectionParams.GroupOwnerIntent = 1;
//connect to the selected device
try
{
var wfdDevice = await WiFiDirectDevice.FromIdAsync(selectedDevice.Id, connectionParams);
}
catch (Exception e)
{
StatusBlock.Text = "Unable to connect";
}
}
/// <summary>
/// 广播者接收到请求连接消息后的操作
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs args)
{
try
{
WiFiDirectConnectionRequest ConnectionRequest = args.GetConnectionRequest();
WiFiDirectDevice wfdDevice = await WiFiDirectDevice.FromIdAsync(ConnectionRequest.DeviceInformation.Id);
//与之连接过的列表
EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
//StartUDPServer("50001");
//EstablishSocketFromAdvertiser(EndpointPairs[0].LocalHostName, "50001");
//Invoke(() => { TextBlock_ConnectedState.Text = "连接到" + EndpointPairs[0].LocalHostName.ToString(); });
}
catch (Exception exp)
{
Invoke(() => { TextBlock_ConnectedState.Text = exp.Message; });
}
}
void discoverPeers(Dictionary <String, Object> jsonOutput)
{
try {
advertise();
mDiscovered.Clear();
mDeviceWatcher = DeviceInformation.CreateWatcher(
WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.AssociationEndpoint),
new string[] { "System.Devices.WiFiDirect.InformationElements" });
mDeviceWatcher.Added += OnDeviceAdded;
mDeviceWatcher.Removed += OnDeviceRemoved;
mDeviceWatcher.Updated += OnDeviceUpdated;
mDeviceWatcher.Stopped += OnStopped;
mDeviceWatcher.Start();
jsonOutput[TAG_DATA] = TAG_TRUE;
} catch (Exception ex) {
setError(jsonOutput, ex.ToString(), ex.HResult);
}
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(jsonOutput));
}
void connect(JSONObject response)
{
WiFiDirectDevice wfdDevice = null;
try {
JSONObject device = (JSONObject)response[TAG_DATA];
if (device == null)
{
setError(response, ERROR_INVALID_CALL_NO_DATA_MSG, 0);
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(response));
return;
}
DeviceInformation deviceInfo = findDiscoveredById((string)device[TAG_MAC]);
if (deviceInfo == null)
{
setError(response, ERROR_INVALID_CALL_DEVICE_NOT_AVAILABLE + device[TAG_MAC], 0);
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(response));
return;
}
wfdDevice = WiFiDirectDevice.FromIdAsync(deviceInfo.Id).AsTask().Result;
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
var endpointPairs = wfdDevice.GetConnectionEndpointPairs();
mConnected[extractMAC(wfdDevice.DeviceId)] = wfdDevice;
response[TAG_DATA] = TAG_TRUE;
response[TAG_SERVER_IP] = endpointPairs[0].RemoteHostName;
mGroupOwner = false;
} catch (Exception ex) {
setError(response, ex.ToString(), ex.HResult);
wfdDevice = null;
}
native_.PostMessageToJS(new JavaScriptSerializer().Serialize(response));
if (wfdDevice != null)
{
OnConnectionStatusChanged(wfdDevice, null);
}
}
private void btnWatcher_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
if (_fWatcherStarted == false)
{
btnWatcher.Content = "Stop Watcher";
_fWatcherStarted = true;
_discoveredDevices.Clear();
rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage);
_deviceWatcher = null;
String deviceSelector = WiFiDirectDevice.GetDeviceSelector((cmbDeviceSelector.ToString().Equals("Device Interface") == true) ?
WiFiDirectDeviceSelectorType.DeviceInterface : WiFiDirectDeviceSelectorType.AssociationEndpoint);
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
}
else
{
btnWatcher.Content = "Start Watcher";
_fWatcherStarted = false;
_deviceWatcher.Added -= OnDeviceAdded;
_deviceWatcher.Removed -= OnDeviceRemoved;
_deviceWatcher.Updated -= OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
_deviceWatcher.Stopped -= OnStopped;
_deviceWatcher.Stop();
}
}
void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs connectionEventArgs)
{
WiFiDirectDevice wfdDevice;
try {
var connectionRequest = connectionEventArgs.GetConnectionRequest();
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
connectionParams.GroupOwnerIntent = 15;
wfdDevice = WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id, connectionParams).AsTask().Result;
// Register for the ConnectionStatusChanged event handler
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
mConnected[extractMAC(wfdDevice.DeviceId)] = wfdDevice;
mGroupOwner = true;
} catch (Exception ex) {
Debug.WriteLine("Connect operation threw an exception: " + ex.Message);
wfdDevice = null;
}
if (wfdDevice != null)
{
OnConnectionStatusChanged(wfdDevice, null);
}
}
/// <summary>
/// 连接者开始搜索发出广播的设备
/// </summary>
public async void StartConnecting()
{
string deviceSelector = WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.AssociationEndpoint);
//获取所有检测到的Wi-Fi直连设备
DeviceInformationCollection devInfoCollection = await DeviceInformation.FindAllAsync(deviceSelector);
Invoke(() =>
{
if (devInfoCollection.Count == 0)
{
TextBlock_ConnectedState.Text = "找不到设备";
}
else
{
TextBlock_ConnectedState.Text = "";
foreach (var devInfo in devInfoCollection)
{
TextBlock_ConnectedState.Text += devInfo.Id + '\n';
}
TextBox_SelectedIP.Text = devInfoCollection[0].Id;
}
});
}
private void OnConnectionStatusChanged(WiFiDirectDevice wfdDeviceSender, object obj)
{
try
{
switch (wfdDeviceSender.ConnectionStatus)
{
case WiFiDirectConnectionStatus.Disconnected:
{
string deviceId = wfdDeviceSender.DeviceId;
if (_connectedDevices.ContainsKey(deviceId))
{
_connectedDevices[deviceId].ConnectionStatusChanged -= OnConnectionStatusChanged;
_connectedDevices.Remove(deviceId);
}
// Notify listener of disconnect
if (_listener != null)
{
_listener.OnDeviceDisconnected(deviceId);
}
break;
}
case WiFiDirectConnectionStatus.Connected:
//ignored
break;
}
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.OnAsyncException(ex.ToString());
}
return;
}
}
private async void OnConnectionRequested(WiFiDirectConnectionListener listener, WiFiDirectConnectionRequestedEventArgs eventArgs)
{
if (_listener != null)
{
_listener.LogMessage("Connection Requested...");
}
bool acceptConnection = true;
if (!AutoAccept && _prompt != null)
{
acceptConnection = _prompt.AcceptIncommingConnection();
}
try
{
WiFiDirectConnectionRequest request = eventArgs.GetConnectionRequest();
if (acceptConnection)
{
DeviceInformation deviceInformation = request.DeviceInformation;
string deviceId = deviceInformation.Id;
// Must call FromIdAsync first
var tcsWiFiDirectDevice = new TaskCompletionSource <WiFiDirectDevice>();
var wfdDeviceTask = tcsWiFiDirectDevice.Task;
tcsWiFiDirectDevice.SetResult(await WiFiDirectDevice.FromIdAsync(deviceId));
// Get the WiFiDirectDevice object
WiFiDirectDevice wfdDevice = await wfdDeviceTask;
// Now retrieve the endpoint pairs, which includes the IP address assigned to the peer
var endpointPairs = wfdDevice.GetConnectionEndpointPairs();
string remoteHostName = "";
if (endpointPairs.Any())
{
EndpointPair endpoint = endpointPairs[0];
remoteHostName = endpoint.RemoteHostName.DisplayName;
}
else
{
throw new Exception("Can't retrieve endpoint pairs");
}
// Add handler for connection status changed
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
// Store the connected peer
lock (_threadObject)
{
_connectedDevices.Add(wfdDevice.DeviceId, wfdDevice);
}
// Notify Listener
if (_listener != null)
{
_listener.OnDeviceConnected(remoteHostName);
}
}
else
{
if (_listener != null)
{
_listener.LogMessage("Declined");
}
}
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.OnAsyncException(ex.ToString());
}
return;
}
}
private async void SetupWifiDirect()
{
ListenForIncomingConnections();
if (_fWatcherStarted == false)
{
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
//make this device known
_publisher.Start();
if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
{
NotifyUser("Failed to start advertisement.", NotifyType.ErrorMessage);
return;
}
//detect other devices
DiscoveredDevices.Clear();
NotifyUser("Finding Devices...", NotifyType.StatusMessage);
String deviceSelector = WiFiDirectDevice.GetDeviceSelector(WiFiDirectDeviceSelectorType.AssociationEndpoint);//WiFiDirectDevice.GetDeviceSelector(
//Utils.GetSelectedItemTag<WiFiDirectDeviceSelectorType>(cmbDeviceSelector));
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
//btnWatcher.Content = "Stop Watcher";
_fWatcherStarted = true;
}
else
{
_publisher.Stop();
//btnWatcher.Content = "Start Watcher";
_fWatcherStarted = false;
_deviceWatcher.Added -= OnDeviceAdded;
_deviceWatcher.Removed -= OnDeviceRemoved;
_deviceWatcher.Updated -= OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
_deviceWatcher.Stopped -= OnStopped;
_deviceWatcher.Stop();
NotifyUser("Device watcher stopped.", NotifyType.StatusMessage);
}
string ServiceSelector = WiFiDirectService.GetSelector("WalkieTalkie");
// Get all WiFiDirect services that are advertising and in range
//DeviceInformationCollection devInfoCollection = await DeviceInformation.FindAllAsync(ServiceSelector);
//// Get a Service Seeker object
//WiFiDirectService Service = await WiFiDirectService.FromIdAsync(devInfoCollection[0].Id);
//// Connect to the Advertiser
//WiFiDirectServiceSession Session = await Service.ConnectAsync();
//// Get the local and remote IP addresses
//var EndpointPairs = Session.GetConnectionEndpointPairs();
}
public WiFiDirectDeviceEvents(WiFiDirectDevice This)
{
this.This = This;
}
static private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
//rootPage.NotifyUserFromBackground("Connection status changed: " + sender.ConnectionStatus, NotifyType.StatusMessage);
}
public ConnectedDevice(string displayName, WiFiDirectDevice wfdDevice, SocketReaderWriter socketRW)
{
this.socketRW = socketRW;
this.wfdDevice = wfdDevice;
this.displayName = displayName;
}
private async void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs connectionEventArgs)
{
try
{
var connectionRequest = connectionEventArgs.GetConnectionRequest();
var tcs = new TaskCompletionSource <bool>();
var dialogTask = tcs.Task;
var messageDialog = new MessageDialog("Connection request received from " + connectionRequest.DeviceInformation.Name, "Connection Request");
// Add commands and set their callbacks; both buttons use the same callback function instead of inline event handlers
messageDialog.Commands.Add(new UICommand("Accept", null, 0));
messageDialog.Commands.Add(new UICommand("Decline", null, 1));
// Set the command that will be invoked by default
messageDialog.DefaultCommandIndex = 1;
// Set the command to be invoked when escape is pressed
messageDialog.CancelCommandIndex = 1;
await Dispatcher.RunAsync(CoreDispatcherPriority.High, async() =>
{
// Show the message dialog
var commandChosen = await messageDialog.ShowAsync();
tcs.SetResult((commandChosen.Label == "Accept") ? true : false);
});
var fProceed = await dialogTask;
if (fProceed == true)
{
var tcsWiFiDirectDevice = new TaskCompletionSource <WiFiDirectDevice>();
var wfdDeviceTask = tcsWiFiDirectDevice.Task;
await Dispatcher.RunAsync(CoreDispatcherPriority.High, async() =>
{
try
{
rootPage.NotifyUser("Connecting to " + connectionRequest.DeviceInformation.Name + "...", NotifyType.StatusMessage);
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
connectionParams.GroupOwnerIntent = Convert.ToInt16(txtGOIntent.Text);
// IMPORTANT: FromIdAsync needs to be called from the UI thread
tcsWiFiDirectDevice.SetResult(await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id, connectionParams));
}
catch (Exception ex)
{
rootPage.NotifyUser("FromIdAsync task threw an exception: " + ex.ToString(), NotifyType.ErrorMessage);
}
});
WiFiDirectDevice wfdDevice = await wfdDeviceTask;
// Register for the ConnectionStatusChanged event handler
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
ConnectedDevice connectedDevice = new ConnectedDevice("Waiting for client to connect...", wfdDevice, null);
_connectedDevices.Add(connectedDevice);
});
var EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
_listenerSocket = null;
_listenerSocket = new StreamSocketListener();
_listenerSocket.ConnectionReceived += OnSocketConnectionReceived;
await _listenerSocket.BindEndpointAsync(EndpointPairs[0].LocalHostName, Globals.strServerPort);
rootPage.NotifyUserFromBackground("Devices connected on L2, listening on IP Address: " + EndpointPairs[0].LocalHostName.ToString() +
" Port: " + Globals.strServerPort, NotifyType.StatusMessage);
}
else
{
// Decline the connection request
rootPage.NotifyUserFromBackground("Connection request from " + connectionRequest.DeviceInformation.Name + " was declined", NotifyType.ErrorMessage);
connectionRequest.Dispose();
}
}
catch (Exception ex)
{
rootPage.NotifyUserFromBackground("Connect operation threw an exception: " + ex.Message, NotifyType.ErrorMessage);
}
}
private async void btnFromId_Click(object sender, RoutedEventArgs e)
{
var discoveredDevice = (DiscoveredDevice)lvDiscoveredDevices.SelectedItem;
if (discoveredDevice == null)
{
rootPage.NotifyUser("No device selected, please select one.", NotifyType.ErrorMessage);
return;
}
rootPage.NotifyUser($"Connecting to {discoveredDevice.DeviceInfo.Name}...", NotifyType.StatusMessage);
if (!discoveredDevice.DeviceInfo.Pairing.IsPaired)
{
if (!await connectionSettingsPanel.RequestPairDeviceAsync(discoveredDevice.DeviceInfo.Pairing))
{
return;
}
}
WiFiDirectDevice wfdDevice = null;
try
{
// IMPORTANT: FromIdAsync needs to be called from the UI thread
wfdDevice = await WiFiDirectDevice.FromIdAsync(discoveredDevice.DeviceInfo.Id);
}
catch (TaskCanceledException)
{
rootPage.NotifyUser("FromIdAsync was canceled by user", NotifyType.ErrorMessage);
return;
}
// Register for the ConnectionStatusChanged event handler
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
IReadOnlyList <EndpointPair> endpointPairs = wfdDevice.GetConnectionEndpointPairs();
HostName remoteHostName = endpointPairs[0].RemoteHostName;
rootPage.NotifyUser($"Devices connected on L2 layer, connecting to IP Address: {remoteHostName} Port: {Globals.strServerPort}",
NotifyType.StatusMessage);
// Wait for server to start listening on a socket
await Task.Delay(2000);
// Connect to Advertiser on L4 layer
StreamSocket clientSocket = new StreamSocket();
try
{
await clientSocket.ConnectAsync(remoteHostName, Globals.strServerPort);
rootPage.NotifyUser("Connected with remote side on L4 layer", NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser($"Connect operation threw an exception: {ex.Message}", NotifyType.ErrorMessage);
return;
}
SocketReaderWriter socketRW = new SocketReaderWriter(clientSocket, rootPage);
string sessionId = Path.GetRandomFileName();
ConnectedDevice connectedDevice = new ConnectedDevice(sessionId, wfdDevice, socketRW);
ConnectedDevices.Add(connectedDevice);
// The first message sent over the socket is the name of the connection.
await socketRW.WriteMessageAsync(sessionId);
while (await socketRW.ReadMessageAsync() != null)
{
// Keep reading messages
}
}
private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
rootPage.NotifyUserFromBackground($"Connection status changed: {sender.ConnectionStatus}", NotifyType.StatusMessage);
if (sender.ConnectionStatus == WiFiDirectConnectionStatus.Disconnected)
{
// TODO: Should we remove this connection from the list?
// (Yes, probably.)
}
}
public ConnectedDevice(string displayName, WiFiDirectDevice wfdDevice, SocketReaderWriter socketRW)
{
DisplayName = displayName;
WfdDevice = wfdDevice;
SocketRW = socketRW;
}
private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
{
rootPage.NotifyUserFromBackground("Connection status changed: " + sender.ConnectionStatus, NotifyType.StatusMessage);
}
public ConnectedDevice(string displayName, WiFiDirectDevice wfdDevice, SocketReaderWriter socketRW)
{
this.socketRW = socketRW;
this.wfdDevice = wfdDevice;
this.displayName = displayName;
}
public ConnectedDevice(string displayName, WiFiDirectDevice wfdDevice, SocketReaderWriter socketRW)
{
DisplayName = displayName;
WfdDevice = wfdDevice;
SocketRW = socketRW;
}
private async Task <bool> HandleConnectionRequestAsync(WiFiDirectConnectionRequest connectionRequest)
{
string deviceName = connectionRequest.DeviceInformation.Name;
bool isPaired = (connectionRequest.DeviceInformation.Pairing?.IsPaired == true) ||
(await IsAepPairedAsync(connectionRequest.DeviceInformation.Id));
// Show the prompt only in case of WiFiDirect reconnection or Legacy client connection.
if (isPaired || _publisher.Advertisement.LegacySettings.IsEnabled)
{
var messageDialog = new MessageDialog($"Connection request received from {deviceName}", "Connection Request");
// Add two commands, distinguished by their tag.
// The default command is "Decline", and if the user cancels, we treat it as "Decline".
messageDialog.Commands.Add(new UICommand("Accept", null, true));
messageDialog.Commands.Add(new UICommand("Decline", null, null));
messageDialog.DefaultCommandIndex = 1;
messageDialog.CancelCommandIndex = 1;
// Show the message dialog
var commandChosen = await messageDialog.ShowAsync();
if (commandChosen.Id == null)
{
return(false);
}
}
rootPage.NotifyUser($"Connecting to {deviceName}...", NotifyType.StatusMessage);
// Pair device if not already paired and not using legacy settings
if (!isPaired && !_publisher.Advertisement.LegacySettings.IsEnabled)
{
if (!await connectionSettingsPanel.RequestPairDeviceAsync(connectionRequest.DeviceInformation.Pairing))
{
return(false);
}
}
WiFiDirectDevice wfdDevice = null;
try
{
// IMPORTANT: FromIdAsync needs to be called from the UI thread
wfdDevice = await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id);
}
catch (Exception ex)
{
rootPage.NotifyUser($"Exception in FromIdAsync: {ex}", NotifyType.ErrorMessage);
return(false);
}
// Register for the ConnectionStatusChanged event handler
wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;
var listenerSocket = new StreamSocketListener();
// Save this (listenerSocket, wfdDevice) pair so we can hook it up when the socket connection is made.
_pendingConnections[listenerSocket] = wfdDevice;
var EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
listenerSocket.ConnectionReceived += this.OnSocketConnectionReceived;
try
{
await listenerSocket.BindServiceNameAsync(Globals.strServerPort);
}
catch (Exception ex)
{
rootPage.NotifyUser($"Connect operation threw an exception: {ex.Message}", NotifyType.ErrorMessage);
return(false);
}
rootPage.NotifyUser($"Devices connected on L2, listening on IP Address: {EndpointPairs[0].LocalHostName}" +
$" Port: {Globals.strServerPort}", NotifyType.StatusMessage);
return(true);
}
