public void Start()
{
if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
{
_publisher.Start();
}
}
private void btnStartAdvertisement_Click(object sender, RoutedEventArgs e)
{
_publisher = new WiFiDirectAdvertisementPublisher();
_publisher.StatusChanged += OnStatusChanged;
_listener = new WiFiDirectConnectionListener();
try
{
// This can raise an exception if the machine does not support WiFi. Sorry.
_listener.ConnectionRequested += OnConnectionRequested;
}
catch (Exception ex)
{
//rootPage.NotifyUser($"Error preparing Advertisement: {ex}", NotifyType.ErrorMessage);
return;
}
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
_publisher.Advertisement.IsAutonomousGroupOwnerEnabled = false;
//// Legacy settings are meaningful only if IsAutonomousGroupOwnerEnabled is true.
//if (_publisher.Advertisement.IsAutonomousGroupOwnerEnabled && chkLegacySetting.IsChecked.Value)
//{
// _publisher.Advertisement.LegacySettings.IsEnabled = true;
// if (!string.IsNullOrEmpty(txtPassphrase.Text))
// {
// Windows.Security.Credentials.PasswordCredential creds = new Windows.Security.Credentials.PasswordCredential
// {
// Password = txtPassphrase.Text
// };
// _publisher.Advertisement.LegacySettings.Passphrase = creds;
// }
// if (!string.IsNullOrEmpty(txtSsid.Text))
// {
// _publisher.Advertisement.LegacySettings.Ssid = txtSsid.Text;
// }
//}
// Add the information elements.
foreach (WiFiDirectInformationElement informationElement in _informationElements)
{
_publisher.Advertisement.InformationElements.Add(informationElement);
}
_publisher.Start();
if (_publisher.Status == WiFiDirectAdvertisementPublisherStatus.Started)
{
//btnStartAdvertisement.IsEnabled = false;
btnStopAdvertisement.IsEnabled = true;
//rootPage.NotifyUser("Advertisement started.", NotifyType.StatusMessage);
}
else
{
// rootPage.NotifyUser($"Advertisement failed to start. Status is {_publisher.Status}", NotifyType.ErrorMessage);
}
}
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 void Start()
{
if (!_active)
{
_publisher.Start();
}
}
// Initialize advertizing and if Receiver handle connetion request
public void Init(bool IsReceiver)
{
// Create an instance of Wifi Direct advertiser
if (publisher == null)
{
publisher = new WiFiDirectAdvertisementPublisher();
}
// Listen to connection request if receiver
if (IsReceiver)
{
WiFiDirectConnectionListener listener = new WiFiDirectConnectionListener();
listener.ConnectionRequested += (WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs connectionEventArgs) =>
{
// Because HandleConnectionRequestAsync generates a connection dialog window It request UI Thread
WiFiDirectConnectionRequest connectionRequest = connectionEventArgs.GetConnectionRequest();
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
// Request a connection to given device
var id = connectionRequest.DeviceInformation.Id;
//connectionRequest.Dispose();
await WifiDirectHandler.ConnectAsync(id, IsReceiver);
});
};
}
// Start advertisement with Intensive parameter so that WifiDirect stay enabled even if app is in background
publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Intensive;
publisher.Start();
}
/// <summary>
/// Wi-Fi直连广播者开始广播
/// </summary>
public void StartAdvertising()
{
publisher = new WiFiDirectAdvertisementPublisher();
listener = new WiFiDirectConnectionListener();
publisher.StatusChanged += OnPublisherStatusChanged;
publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Intensive;
listener.ConnectionRequested += OnConnectionRequested;
publisher.Start();
//TextBlock_ConnectedState.Text = "开始广播……";
}
public void StartServer()
{
publisher = new WiFiDirectAdvertisementPublisher();
listener = new WiFiDirectConnectionListener();
publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
listener.ConnectionRequested += OnConnectionRequested;
_ConnectionEstablishState = ConnectionEstablishState.Connecting;
OnConnectionEstalblishResult(this, _ConnectionEstablishState);
publisher.Start();
StartUDP(50001);
//TextBlock_ConnectedState.Text = "开始广播……";
}
private async void OnPublisherStatusChanged(WiFiDirectAdvertisementPublisher sender, WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)
{
if (args.Status == WiFiDirectAdvertisementPublisherStatus.Aborted)
{
Debug.WriteLine("因错误终止广播");
publisher.Start();
}
else if (args.Status == WiFiDirectAdvertisementPublisherStatus.Started)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { TextBlock_ConnectedState.Text = "开始广播……"; });
}
}
private static void StartWiFiHotspot()
{
wifiPublisher = new WiFiDirectAdvertisementPublisher();
wifiConnectionListener = new WiFiDirectConnectionListener();
wifiConnectionListener.ConnectionRequested += WifiConnectionListener_ConnectionRequested;
wifiPublisher.Advertisement.IsAutonomousGroupOwnerEnabled = true;
wifiPublisher.Advertisement.LegacySettings.Ssid = SSID;
wifiPublisher.Advertisement.LegacySettings.IsEnabled = true;
wifiPublisher.Advertisement.LegacySettings.Passphrase.Password = PASSWORD;
wifiPublisher.StatusChanged += WifiPublisher_StatusChanged;
wifiPublisher.Start();
}
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);
}
}
public void Init()
{
// Create an Advertisement Publisher
WiFiDirectAdvertisementPublisher publisher = new WiFiDirectAdvertisementPublisher();
// Turn on Listen state
publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
// Register for connection requests
WiFiDirectConnectionListener listener = new WiFiDirectConnectionListener();
listener.ConnectionRequested += OnConnectionRequested;
// Start the advertiser
publisher.Start();
}
void advertise()
{
if (mAdvertiser == null)
{
mAdvertiser = new WiFiDirectAdvertisementPublisher();
}
if (mConnectionListener == null)
{
mConnectionListener = new WiFiDirectConnectionListener();
}
mConnectionListener.ConnectionRequested += OnConnectionRequested;
mAdvertiser.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
mAdvertiser.StatusChanged += OnStatusChanged;
mAdvertiser.Start();
}
private void StartPublisher(WlanSetting setting)
{
_publisher = new WiFiDirectAdvertisementPublisher();
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
_publisher.Advertisement.IsAutonomousGroupOwnerEnabled = true;
_publisher.StatusChanged += OnStatusChanged;
_publisher.Advertisement.LegacySettings.IsEnabled = true;
var creds = new Windows.Security.Credentials.PasswordCredential();
_publisher.Advertisement.LegacySettings.Ssid = setting.Name;
creds.Password = setting.Password;
_publisher.Advertisement.LegacySettings.Passphrase = creds;
_publisher.Start();
}
private void btnStartAdvertisement_Click(object sender, RoutedEventArgs e)
{
try
{
if (_publisher == null)
{
_publisher = new WiFiDirectAdvertisementPublisher();
}
if (chkListener.IsChecked == true)
{
if (_listener == null)
{
_listener = new WiFiDirectConnectionListener();
}
_listener.ConnectionRequested += OnConnectionRequested;
}
_publisher.Advertisement.IsAutonomousGroupOwnerEnabled = (chkPreferGroupOwnerMode.IsChecked == true);
if (cmbListenState.SelectionBoxItem.ToString().Equals("Normal") == true)
{
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
}
else if (cmbListenState.SelectionBoxItem.ToString().Equals("Intensive") == true)
{
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Intensive;
}
else if (cmbListenState.SelectionBoxItem.ToString().Equals("None") == true)
{
_publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.None;
}
_publisher.StatusChanged += OnStatusChanged;
_publisher.Start();
rootPage.NotifyUser("Advertisement started, waiting for StatusChanged callback...", NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser("Error starting Advertisement: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
public void Start()
{
// Clean up old state
Reset();
// Create WiFiDirectAdvertisementPublisher
_publisher = new WiFiDirectAdvertisementPublisher();
// Add event handler for advertisement StatusChanged
_publisher.StatusChanged += OnStatusChanged;
// Set Advertisement required settings
_advertisement = _publisher.Advertisement;
// Must set the autonomous group owner (GO) enabled flag
// Legacy Wi-Fi Direct advertisement uses a Wi-Fi Direct GO to act as an access point to legacy settings
_advertisement.IsAutonomousGroupOwnerEnabled = true;
_legacySettings = _advertisement.LegacySettings;
// Must enable legacy settings so that non-Wi-Fi Direct peers can connect in legacy mode
_legacySettings.IsEnabled = true;
// Either specify an SSID, or read the randomly generated one
if (_ssidProvided)
{
_legacySettings.Ssid = _ssid;
}
else
{
_ssid = _legacySettings.Ssid;
}
// Either specify a passphrase, or read the randomly generated one
if (_passPhraseProvided)
{
_legacySettings.Passphrase.Password = _passPhrase;
}
else
{
_passPhrase = _legacySettings.Passphrase.Password;
}
_publisher.Start();
}
private void btnStartAdvertisement_Click(object sender, RoutedEventArgs e)
{
_publisher = new WiFiDirectAdvertisementPublisher();
_publisher.StatusChanged += OnStatusChanged;
_listener = new WiFiDirectConnectionListener();
if (chkListener.IsChecked.Value)
{
try
{
// This can raise an exception if the machine does not support WiFi. Sorry.
_listener.ConnectionRequested += OnConnectionRequested;
}
catch (Exception ex)
{
rootPage.NotifyUser($"Error preparing Advertisement: {ex}", NotifyType.ErrorMessage);
return;
}
}
var discoverability = Utils.GetSelectedItemTag<WiFiDirectAdvertisementListenStateDiscoverability>(cmbListenState);
_publisher.Advertisement.ListenStateDiscoverability = discoverability;
_publisher.Advertisement.IsAutonomousGroupOwnerEnabled = chkPreferGroupOwnerMode.IsChecked.Value;
// Legacy settings are meaningful only if IsAutonomousGroupOwnerEnabled is true.
if (_publisher.Advertisement.IsAutonomousGroupOwnerEnabled && chkLegacySetting.IsChecked.Value)
{
_publisher.Advertisement.LegacySettings.IsEnabled = true;
if (!String.IsNullOrEmpty(txtPassphrase.Text))
{
var creds = new Windows.Security.Credentials.PasswordCredential();
creds.Password = txtPassphrase.Text;
_publisher.Advertisement.LegacySettings.Passphrase = creds;
}
if (!String.IsNullOrEmpty(txtSsid.Text))
{
_publisher.Advertisement.LegacySettings.Ssid = txtSsid.Text;
}
}
// Add the information elements.
foreach (WiFiDirectInformationElement informationElement in _informationElements)
{
_publisher.Advertisement.InformationElements.Add(informationElement);
}
_publisher.Start();
if (_publisher.Status == WiFiDirectAdvertisementPublisherStatus.Started)
{
btnStartAdvertisement.IsEnabled = false;
btnStopAdvertisement.IsEnabled = true;
rootPage.NotifyUser("Advertisement started.", NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser($"Advertisement failed to start. Status is {_publisher.Status}", NotifyType.ErrorMessage);
}
}
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();
}