コード例 #1
0
        private async void Picker_DeviceSelected(DialDevicePicker sender, DialDeviceSelectedEventArgs 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() =>
            {
                try {
                    rootPage.NotifyUser(string.Format("Picker DeviceSelected event fired"), NotifyType.StatusMessage);

                    // Set the status to connecting
                    picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Connecting);

                    rootPage.NotifyUser(string.Format("Resolving DialDevice'"), NotifyType.StatusMessage);

                    //Get the DialApp object for the specific application on the selected device
                    DialApp app = args.SelectedDialDevice.GetDialApp(this.dial_appname_textbox.Text);

                    if (app == null)
                    {
                        //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                        //rootPage.NotifyUser(string.Format("'{0}' cannot find app with ID '{1}'", selectedDeviceInformation.Name, this.dial_appname_textbox.Text), NotifyType.StatusMessage);
                        picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Error);
                    }
                    else
                    {
                        rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                        //Launch the application on the 1st screen device
                        DialAppLaunchResult result = await app.RequestLaunchAsync(this.dial_launch_args_textbox.Text);

                        //Verify to see whether the application was launched
                        if (result == DialAppLaunchResult.Launched)
                        {
                            rootPage.NotifyUser(string.Format("Launched '{0}'", app.AppName), NotifyType.StatusMessage);
                            activeDialDevice = args.SelectedDialDevice;
                            DeviceInformation selectedDeviceInformation = await DeviceInformation.CreateFromIdAsync(args.SelectedDialDevice.Id);

                            activeDeviceInformation = selectedDeviceInformation;

                            //This is where you will need to add you application specific communication between your 1st and 2nd screen applications
                            //...
                            //...
                            //...

                            picker.SetDisplayStatus(activeDialDevice, DialDeviceDisplayStatus.Connected);
                            picker.Hide();
                        }
                        else
                        {
                            rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                            picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Error);
                        }
                    }
                }
                catch (Exception ex)
                {
                    UnhandledExceptionPage.ShowUnhandledException(ex);
                }
            });
        }
コード例 #2
0
        private async void Picker_DialDeviceSelected(DialDevicePicker sender, DialDeviceSelectedEventArgs 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() =>
            {
                // 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.
                DialDevice selectedDevice = await DialDevice.FromIdAsync(args.SelectedDialDevice.Id);

                // Set the status to connecting
                try { picker.SetDisplayStatus(selectedDevice, DialDeviceDisplayStatus.Connecting); } catch { }

                // Get the DeviceInformation instance for the the selected device
                DeviceInformation selectedDeviceInfo = await DeviceInformation.CreateFromIdAsync(selectedDevice.Id);

                //Get the DialApp object for the specific application on the selected device
                DialApp app = selectedDevice.GetDialApp(this.dial_appname_textbox.Text);

                if (app == null)
                {
                    //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                    rootPage.NotifyUser(string.Format("'{0}' cannot find app with ID '{1}'", selectedDeviceInfo.Name, this.dial_appname_textbox.Text), NotifyType.StatusMessage);
                    try { picker.SetDisplayStatus(selectedDevice, DialDeviceDisplayStatus.Error); } catch { }
                }
                else
                {
                    //Get the current application state
                    DialAppStateDetails stateDetails = await app.GetAppStateAsync();
                    if (stateDetails.State == DialAppState.NetworkFailure)
                    {
                        // In case getting the application state failed because of a network failure
                        rootPage.NotifyUser("Network Failure while getting application state", NotifyType.ErrorMessage);
                        try { picker.SetDisplayStatus(selectedDevice, DialDeviceDisplayStatus.Error); } catch { }
                    }
                    else
                    {
                        rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                        //Launch the application on the 1st screen device
                        DialAppLaunchResult result = await app.RequestLaunchAsync(this.dial_launch_args_textbox.Text);

                        //Verify to see whether the application was launched
                        if (result == DialAppLaunchResult.Launched)
                        {
                            rootPage.NotifyUser(string.Format("Launched '{0}'", app.AppName), NotifyType.StatusMessage);
                            //This is where you will need to add you application specific communication between your 1st and 2nd screen applications
                            //...
                            try { picker.SetDisplayStatus(selectedDevice, DialDeviceDisplayStatus.Connected); } catch { }
                        }
                        else
                        {
                            rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                            try { picker.SetDisplayStatus(selectedDevice, DialDeviceDisplayStatus.Error); } catch { }
                        }
                    }
                }
            });
        }
コード例 #3
0
        private async void Picker_DialDeviceSelected(DialDevicePicker sender, DialDeviceSelectedEventArgs args)
        {
            // casting 必須在 UI Thread 下執行
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
            {
                try
                {
                    // 設定遠端設備現在要準備連綫
                    picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Connecting);

                    // 取得遠端設備中支援指定 app name 的 App
                    DialApp app = args.SelectedDialDevice.GetDialApp(txtAppName.Text);

                    if (app == null)
                    {
                        // 嘗試建立 DIAL device,如果失敗代表那個設備不支援 DIAL
                        picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Error);
                    }
                    else
                    {
                        // 請求送出參數到遠端設備的 App
                        DialAppLaunchResult result = await app.RequestLaunchAsync(txtArgument.Text);

                        if (result == DialAppLaunchResult.Launched)
                        {
                            activeDialDevice = args.SelectedDialDevice;
                            DeviceInformation selectedDeviceInformation = await DeviceInformation.CreateFromIdAsync(args.SelectedDialDevice.Id);

                            activeDeviceInformation = selectedDeviceInformation;
                            picker.SetDisplayStatus(activeDialDevice, DialDeviceDisplayStatus.Connected);
                            picker.Hide();
                            tblMsg.Text += "device connected";
                        }
                        else
                        {
                            picker.SetDisplayStatus(args.SelectedDialDevice, DialDeviceDisplayStatus.Error);
                            tblMsg.Text += "device error";
                        }
                    }
                }
                catch (Exception ex)
                {
                    tblMsg.Text += ex.Message;
                }
            });
        }
コード例 #4
0
        private async Task SendDialParameter(DevicePicker sender, DeviceSelectedEventArgs args)
        {
            try
            {
                // 設定遠端設備現在要準備連綫
                sender.SetDisplayStatus(args.SelectedDevice, "connecting", DevicePickerDisplayStatusOptions.ShowProgress);

                // 取得遠端設備中支援指定 app name 的 App
                DialDevice dialDevice = await DialDevice.FromIdAsync(args.SelectedDevice.Id);

                DialApp app = dialDevice.GetDialApp("castingsample");

                if (app == null)
                {
                    // 嘗試建立 DIAL device,如果失敗代表那個設備不支援 DIAL
                    sender.SetDisplayStatus(args.SelectedDevice, "The app is not exist in the device.", DevicePickerDisplayStatusOptions.ShowRetryButton);
                }
                else
                {
                    // 請求送出參數到遠端設備的 App
                    DialAppLaunchResult result = await app.RequestLaunchAsync("Test");

                    if (result == DialAppLaunchResult.Launched)
                    {
                        activeDevice = args.SelectedDevice;
                        sender.SetDisplayStatus(args.SelectedDevice, "connected", DevicePickerDisplayStatusOptions.ShowDisconnectButton);
                        sender.Hide();
                    }
                    else
                    {
                        sender.SetDisplayStatus(args.SelectedDevice, "Device Error", DevicePickerDisplayStatusOptions.ShowRetryButton);
                    }
                }
            }
            catch (Exception ex)
            {
                sender.SetDisplayStatus(args.SelectedDevice, ex.Message, DevicePickerDisplayStatusOptions.None);
            }
        }
コード例 #5
0
        private async Task <bool> TryLaunchDialAppAsync(DeviceInformation device)
        {
            bool dialAppLaunchSucceeded = false;

            if (device.Id.IndexOf("dial", StringComparison.OrdinalIgnoreCase) > -1)
            {
                //Update the launch arguments to include the Position
                this.dial_launch_args_textbox.Text = string.Format("v={0}&t={1}&pairingCode=E4A8136D-BCD3-45F4-8E49-AE01E9A46B5F", video.Id, player.Position.Ticks);

                //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                rootPage.NotifyUser(string.Format("Checking to see if device {0} supports DIAL", device.Name), NotifyType.StatusMessage);
                //BUG: Takes too long. Workaround, just try to create the DialDevice
                //if (await DialDevice.DeviceInfoSupportsDialAsync(device))
                //{
                DialDevice dialDevice = null;

                //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                rootPage.NotifyUser(string.Format("Attempting to resolve DIAL device for '{0}'", device.Name), NotifyType.StatusMessage);
                try { dialDevice = await DialDevice.FromIdAsync(device.Id); } catch { }

                if (dialDevice == 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 DIAL", device.Name), NotifyType.StatusMessage);
                }
                else
                {
                    //Get the DialApp object for the specific application on the selected device
                    DialApp app = dialDevice.GetDialApp(this.dial_appname_textbox.Text);

                    if (app == null)
                    {
                        //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                        rootPage.NotifyUser(string.Format("'{0}' cannot find app with ID '{1}'", device.Name, this.dial_appname_textbox.Text), NotifyType.StatusMessage);
                    }
                    else
                    {
                        //Get the current application state
                        DialAppStateDetails stateDetails = await app.GetAppStateAsync();

                        if (stateDetails.State == DialAppState.NetworkFailure)
                        {
                            // In case getting the application state failed because of a network failure
                            rootPage.NotifyUser("Network Failure while getting application state", NotifyType.ErrorMessage);
                        }
                        else
                        {
                            rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                            //Launch the application on the 1st screen device
                            DialAppLaunchResult result = await app.RequestLaunchAsync(this.dial_launch_args_textbox.Text);

                            //Verify to see whether the application was launched
                            if (result == DialAppLaunchResult.Launched)
                            {
                                //Remember the device to which casting succeeded
                                activeDevice = device;
                                //DIAL is sessionsless but the DIAL app allows us to get the state and "disconnect".
                                //Disconnect in the case of DIAL is equivalenet to stopping the app.
                                activeCastConnectionHandler = app;
                                rootPage.NotifyUser(string.Format("Launched '{0}'", app.AppName), NotifyType.StatusMessage);
                                //This is where you will need to add you application specific communication between your 1st and 2nd screen applications
                                //...
                                dialAppLaunchSucceeded = true;
                            }
                        }
                    }
                }
                //}
                //else
                //{
                //    rootPage.NotifyUser(string.Format("'{0}' does not support DIAL", device.Name), NotifyType.StatusMessage);
                //}
            }
            else
            {
                rootPage.NotifyUser(string.Format("'{0}' does not support DIAL", device.Name), NotifyType.StatusMessage);
            }
            return(dialAppLaunchSucceeded);
        }
コード例 #6
0
        private async Task <bool> TryLaunchDialAppAsync(DeviceInformation device)
        {
            bool dialAppLaunchSucceeded = false;

            //Update the launch arguments to include the Position
            this.dial_launch_args_textbox.Text = string.Format("v={0}&t={1}&pairingCode=E4A8136D-BCD3-45F4-8E49-AE01E9A46B5F", video.Id, player.Position.Ticks);

            //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
            rootPage.NotifyUser(string.Format("Checking to see if device {0} supports DIAL", device.Name), NotifyType.StatusMessage);

            DialDevice dialDevice = null;

            //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
            rootPage.NotifyUser(string.Format("Attempting to resolve DIAL device for '{0}'", device.Name), NotifyType.StatusMessage);

            string[] newIds = (string[])device.Properties["{0BBA1EDE-7566-4F47-90EC-25FC567CED2A} 2"];

            if (newIds.Length > 0)
            {
                string deviceId = newIds[0];
                try { dialDevice = await DialDevice.FromIdAsync(deviceId); } catch { }
            }

            if (dialDevice == 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 DIAL", device.Name), NotifyType.StatusMessage);
            }
            else
            {
                //Get the DialApp object for the specific application on the selected device
                DialApp app = dialDevice.GetDialApp(this.dial_appname_textbox.Text);

                if (app == null)
                {
                    //Try to create a DIAL device. If it doesn't succeed, the selected device does not support DIAL.
                    rootPage.NotifyUser(string.Format("'{0}' cannot find app with ID '{1}'", device.Name, this.dial_appname_textbox.Text), NotifyType.StatusMessage);
                }
                else
                {
                    rootPage.NotifyUser(string.Format("Attempting to launch '{0}'", app.AppName), NotifyType.StatusMessage);
                    //Launch the application on the 1st screen device
                    DialAppLaunchResult result = await app.RequestLaunchAsync(this.dial_launch_args_textbox.Text);

                    //Verify to see whether the application was launched
                    if (result == DialAppLaunchResult.Launched)
                    {
                        //Remember the device to which casting succeeded
                        activeDevice = device;
                        //DIAL is sessionsless but the DIAL app allows us to get the state and "disconnect".
                        //Disconnect in the case of DIAL is equivalenet to stopping the app.
                        activeCastConnectionHandler = app;
                        rootPage.NotifyUser(string.Format("Launched '{0}'", app.AppName), NotifyType.StatusMessage);
                        //This is where you will need to add you application specific communication between your 1st and 2nd screen applications
                        //...


                        dialAppLaunchSucceeded = true;
                    }
                }
            }

            return(dialAppLaunchSucceeded);
        }