private async Task CastingVideoToScreen(DevicePicker sender, DeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
activeDevice = args.SelectedDevice;
CastingDevice device = await CastingDevice.FromIdAsync(args.SelectedDevice.Id);
castingConnection = device.CreateCastingConnection();
//Hook up the casting events
//castingConnection.ErrorOccurred += Connection_ErrorOccurred;
//castingConnection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
CastingConnectionErrorStatus status = await castingConnection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
}
}
catch
{
}
});
}
private async void Picker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
connection = args.SelectedCastingDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
}
}
catch
{
}
});
}
private async void Picker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
try
{
//rootPage.NotifyUser(string.Format("Picker DeviceSelected event fired for device '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
DateTime t1 = DateTime.Now;
DeviceInformation mydevice = await DeviceInformation.CreateFromIdAsync(args.SelectedCastingDevice.Id);
DateTime t2 = DateTime.Now;
TimeSpan ts = new TimeSpan(t2.Ticks - t1.Ticks);
//System.Diagnostics.Debug.WriteLine(string.Format("DeviceInformation.CreateFromIdAsync took '{0} seconds'", ts.TotalSeconds));
//Create a casting conneciton from our selected casting device
//rootPage.NotifyUser(string.Format("Creating connection for '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
connection = args.SelectedCastingDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
//rootPage.NotifyUser(string.Format("Starting casting to '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
//rootPage.NotifyUser(string.Format("Starting casting to '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
}
}
catch
{
//rootPage.NotifyUser(string.Format("Failed to get casting source for video '{0}'", video.Title), NotifyType.ErrorMessage);
}
}
catch (Exception ex)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(ex.Message);
#endif
}
});
}
private async void CastingPicker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
//Casting must occur from the UI thread. This dispatches the casting calls to the UI thread.
await DispatchManager.RunOnDispatcherAsync(async() =>
{
//Create a casting connection from our selected casting device
CastingConnection connection = args.SelectedCastingDevice.CreateCastingConnection();
//Cast the content loaded in the media element to the selected casting device
await connection.RequestStartCastingAsync(MediaPlayerHost.CastingSource);
});
}
// </SnippetCastPickerButtonClick>
// <SnippetCastingDeviceSelected>
private async void CastingPicker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
//Casting must occur from the UI thread. This dispatches the casting calls to the UI thread.
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
//Create a casting conneciton from our selected casting device
CastingConnection connection = args.SelectedCastingDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
//Cast the content loaded in the media element to the selected casting device
await connection.RequestStartCastingAsync(mediaElement.GetAsCastingSource());
});
}
private async void CastToDevice(object sender, Windows.UI.Xaml.Controls.ItemClickEventArgs e)
{
// Ensure we stop looking for devices before casting
if (_deviceWatcher.Status != DeviceWatcherStatus.Stopped)
{
_deviceWatcher.Stop();
}
// Create the connection
_castingConnection = (e.ClickedItem as CastingDevice).CreateCastingConnection();
// Bind events
_castingConnection.ErrorOccurred += OnCastingError;
_castingConnection.StateChanged += OnCastingStateChange;
await _castingConnection.RequestStartCastingAsync(SimpleIoc.Default.GetInstance <IPlaybackService>().GetMediaPlayer().GetAsCastingSource());
}
private async void Picker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
// The args.SelectedCastingDevice is proxied from the picker process. The picker process is
// dismissmed as soon as you break into the debugger. Creating a non-proxied version
// allows debugging since the proxied version stops working once the picker is dismissed.
CastingDevice selectedDevice = await CastingDevice.FromIdAsync(args.SelectedCastingDevice.Id);
//Create a casting conneciton from our selected casting device
rootPage.NotifyUser(string.Format("Creating connection for '{0}'", selectedDevice.FriendlyName), NotifyType.StatusMessage);
CastingConnection connection = selectedDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
rootPage.NotifyUser(string.Format("Starting casting to '{0}'", selectedDevice.FriendlyName), NotifyType.StatusMessage);
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
rootPage.NotifyUser(string.Format("Starting casting to '{0}'", selectedDevice.FriendlyName), NotifyType.StatusMessage);
}
}
catch
{
rootPage.NotifyUser(string.Format("Failed to get casting source for video '{0}'", video.Title), NotifyType.ErrorMessage);
}
});
}
private async void castingDevicesList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (castingDevicesList.SelectedItem != null)
{
//When a device is selected, first thing we do is stop the watcher so it's search doesn't conflict with streaming
if (watcher.Status != DeviceWatcherStatus.Stopped)
{
progressText.Text = "";
watcher.Stop();
}
//Create a new casting connection to the device that's been selected
connection = ((CastingDevice)castingDevicesList.SelectedItem).CreateCastingConnection();
//Register for events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
//Cast the loaded video to the selected casting device.
await connection.RequestStartCastingAsync(video.GetAsCastingSource());
}
}
// </SnippetWatcherStopped>
// <SnippetSelectionChanged>
private async void castingDevicesListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (castingDevicesListBox.SelectedItem != null)
{
//When a device is selected, first thing we do is stop the watcher so it's search doesn't conflict with streaming
if (deviceWatcher.Status != DeviceWatcherStatus.Stopped)
{
deviceWatcher.Stop();
}
//Create a new casting connection to the device that's been selected
castingConnection = ((CastingDevice)castingDevicesListBox.SelectedItem).CreateCastingConnection();
//Register for events
castingConnection.ErrorOccurred += Connection_ErrorOccurred;
castingConnection.StateChanged += Connection_StateChanged;
//Cast the loaded video to the selected casting device.
await castingConnection.RequestStartCastingAsync(mediaPlayerElement.MediaPlayer.GetAsCastingSource());
disconnectButton.Visibility = Visibility.Visible;
}
}
private async Task <bool> TryCastMediaElementAsync(DeviceInformation device)
{
bool castMediaElementSucceeded = false;
//Verify whether the selected device supports DLNA, Bluetooth, or Miracast.
rootPage.NotifyUser(string.Format("Checking to see if device {0} supports Miracast, Bluetooth, or DLNA", device.Name), NotifyType.StatusMessage);
//BUG: Takes too long. Workaround, just try to create the CastingDevice
//if (await CastingDevice.DeviceInfoSupportsCastingAsync(device))
//{
CastingConnection connection = null;
//Check to see whether we are casting to the same device
if (activeDevice != null && device.Id == activeDevice.Id)
{
connection = activeCastConnectionHandler as CastingConnection;
}
else // if not casting to the same device reset the active device related variables.
{
activeDevice = null;
activeCastConnectionHandler = null;
}
// If we can re-use the existing connection
if (connection == null || connection.State == CastingConnectionState.Disconnected || connection.State == CastingConnectionState.Disconnecting)
{
CastingDevice castDevice = null;
activeDevice = null;
//Try to create a CastingDevice instannce. If it doesn't succeed, the selected device does not support playback of the video source.
rootPage.NotifyUser(string.Format("Attempting to resolve casting device for '{0}'", device.Name), NotifyType.StatusMessage);
try { castDevice = await CastingDevice.FromIdAsync(device.Id); } catch { }
if (castDevice == null)
{
//Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
rootPage.NotifyUser(string.Format("'{0}' does not support playback of this media", device.Name), NotifyType.StatusMessage);
}
else
{
//Create a casting conneciton from our selected casting device
rootPage.NotifyUser(string.Format("Creating connection for '{0}'", device.Name), NotifyType.StatusMessage);
connection = castDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
}
//Cast the content loaded in the media element to the selected casting device
rootPage.NotifyUser(string.Format("Casting to '{0}'", device.Name), NotifyType.StatusMessage);
CastingSource source = null;
// Get the casting source
try { source = player.GetAsCastingSource(); } catch { }
if (source == null)
{
rootPage.NotifyUser(string.Format("Failed to get casting source for video '{0}'", video.Title), NotifyType.ErrorMessage);
}
else
{
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
//Remember the device to which casting succeeded
activeDevice = device;
//Remember the current active connection.
activeCastConnectionHandler = connection;
castMediaElementSucceeded = true;
player.Play();
}
else
{
rootPage.NotifyUser(string.Format("Failed to cast to '{0}'", device.Name), NotifyType.ErrorMessage);
}
}
//}
}
return(castMediaElementSucceeded);
}
private async void CastingPicker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
CastingConnection connection = args.SelectedCastingDevice.CreateCastingConnection();
await connection.RequestStartCastingAsync(PlayingSound.MediaPlayer.GetAsCastingSource());
}
private async Task CastingVideoToScreen(DevicePicker sender, DeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
{
activeDevice = args.SelectedDevice;
CastingDevice device =await CastingDevice.FromIdAsync(args.SelectedDevice.Id);
castingConnection = device.CreateCastingConnection();
//Hook up the casting events
//castingConnection.ErrorOccurred += Connection_ErrorOccurred;
//castingConnection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
CastingConnectionErrorStatus status = await castingConnection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
}
}
catch
{
}
});
}
private async void castingDevicesList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (castingDevicesList.SelectedItem != null)
{
//When a device is selected, first thing we do is stop the watcher so it's search doesn't conflict with streaming
if (watcher.Status != DeviceWatcherStatus.Stopped)
{
progressText.Text = "";
watcher.Stop();
}
//Create a new casting connection to the device that's been selected
connection = ((CastingDevice)castingDevicesList.SelectedItem).CreateCastingConnection();
//Register for events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
//Cast the loaded video to the selected casting device.
await connection.RequestStartCastingAsync(video.GetAsCastingSource());
}
}
private async void Picker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
{
try
{
rootPage.NotifyUser(string.Format("Picker DeviceSelected event fired for device '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
//DateTime t1 = DateTime.Now;
//DeviceInformation mydevice = await DeviceInformation.CreateFromIdAsync(args.SelectedCastingDevice.Id);
//DateTime t2 = DateTime.Now;
//TimeSpan ts = new TimeSpan(t2.Ticks - t1.Ticks);
//System.Diagnostics.Debug.WriteLine(string.Format("DeviceInformation.CreateFromIdAsync took '{0} seconds'", ts.TotalSeconds));
//Create a casting conneciton from our selected casting device
rootPage.NotifyUser(string.Format("Creating connection for '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
connection = args.SelectedCastingDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
rootPage.NotifyUser(string.Format("Starting casting to '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
rootPage.NotifyUser(string.Format("Starting casting to '{0}'", args.SelectedCastingDevice.FriendlyName), NotifyType.StatusMessage);
}
}
catch
{
rootPage.NotifyUser(string.Format("Failed to get casting source for video '{0}'", video.Title), NotifyType.ErrorMessage);
}
}
catch (Exception ex)
{
UnhandledExceptionPage.ShowUnhandledException(ex);
}
});
}
private async void Picker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
{
connection = args.SelectedCastingDevice.CreateCastingConnection();
//Hook up the casting events
connection.ErrorOccurred += Connection_ErrorOccurred;
connection.StateChanged += Connection_StateChanged;
// Get the casting source from the MediaElement
CastingSource source = null;
try
{
// Get the casting source from the Media Element
source = player.GetAsCastingSource();
// Start Casting
CastingConnectionErrorStatus status = await connection.RequestStartCastingAsync(source);
if (status == CastingConnectionErrorStatus.Succeeded)
{
player.Play();
}
}
catch
{
}
});
}
