* Go directly from ConsoleListPage to StreamPage (solves issue #17)

* Add PowerOn functionality (solves issue #16)
* Preparation for adding StreamPage as regular navigatable page (issue #19)

xnano/App.xaml.cs

@@ -30,7 +30,6 @@ protected override void RegisterTypes(IContainerRegistry containerRegistry)
             containerRegistry.RegisterForNavigation<AuthenticationPage>();
             containerRegistry.RegisterForNavigation<ConsoleListPage>();
             containerRegistry.RegisterForNavigation<EnterIpAddressPopup>();
-            containerRegistry.RegisterForNavigation<ConnectionPage>();
             containerRegistry.RegisterForNavigation<StreamPage>();
 
             containerRegistry.RegisterPopupNavigationService();

xnano/ViewModels/ConsoleListPageViewModel.cs

@@ -9,6 +9,8 @@
 using Prism.Services;
 
 using xnano.Models;
+using SmartGlass;
+using SmartGlass.Nano;
 
 namespace xnano.ViewModels
 {
@@ -30,6 +32,9 @@ public string StatusMessage
         public ICommand DeleteItemCommand { get; }
         public ICommand ItemTappedCommand { get; }
 
+        public ICommand PowerOnCommand { get; }
+        public ICommand ConnectCommand { get; }
+
         public ConsoleListPageViewModel(INavigationService navigationService,
                                         IPageDialogService dialogService)
             : base(navigationService)
@@ -54,9 +59,48 @@ public ConsoleListPageViewModel(INavigationService navigationService,
                 IsBusy = false;
             });
 
-            ItemTappedCommand = new Command<SmartGlass.Device>(async (selectedItem) =>
+            PowerOnCommand = new Command<SmartGlass.Device>(async dev =>
+            {
+                var doPoweron = await _dialogService.DisplayAlertAsync(
+                    "Console unavailable", "Do you want to poweron?", "Yes", "No");
+
+                if (!doPoweron)
+                    return;
+
+                IsBusy = true;
+                StatusMessage = "Powering on console...";
+                await dev.PowerOnAsync();
+                StatusMessage = "Idle";
+                IsBusy = false;
+            });
+
+            ConnectCommand = new Command<SmartGlass.Device>(async dev =>
             {
-                await NavigateToConnectionPage(selectedItem);
+                IsBusy = true;
+                StatusMessage = "Connecting to console...";
+                var success = await Task.Run<bool>(
+                    async () => await ConnectToConsole(dev));
+
+                StatusMessage = "Idle";
+                IsBusy = false;
+
+                if (!success)
+                    return;
+
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await NavigateToStreamPage(dev));
+            });
+
+            ItemTappedCommand = new Command<SmartGlass.Device>(dev =>
+            {
+                if (dev.State == DeviceState.Available)
+                {
+                    ConnectCommand.Execute(dev);
+                }
+                else
+                {
+                    PowerOnCommand.Execute(dev);
+                }
             });
 
             DeleteItemCommand = new Command<SmartGlass.Device>(DeleteConsoleEntry);
@@ -116,16 +160,118 @@ await _dialogService.DisplayAlertAsync(
             }
         }
 
+        async Task<bool> InitializeSmartGlass(string address)
+        {
+            string lastStatus = String.Empty;
+            try
+            {
+                lastStatus = "Connecting to console";
+                var client = await SmartGlassClient.ConnectAsync(address);
+
+                lastStatus = "Waiting for Broadcast channel";
+                await client.BroadcastChannel.WaitForEnabledAsync(
+                    TimeSpan.FromSeconds(5));
+
+                if (!client.BroadcastChannel.Enabled)
+                {
+                    throw new NotSupportedException("Broadcast channel is not enabled");
+                }
+
+                lastStatus = "Starting gamestream via Broadcast channel";
+                var config = Services.SmartGlassConnection.Instance.GamestreamConfiguration;
+                var session = await client.BroadcastChannel
+                                    .StartGamestreamAsync(config);
+
+                Services.SmartGlassConnection.Instance.Session = session;
+                Services.SmartGlassConnection.Instance.SgClient = client;
+            }
+            catch (TimeoutException)
+            {
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await ShowErrorDisplayAlert($"{lastStatus} timed out!"));
+                return false;
+            }
+            catch (NotSupportedException e)
+            {
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await ShowErrorDisplayAlert($"{e.Message}"));
+                return false;
+            }
+            catch (Exception)
+            {
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await ShowErrorDisplayAlert($"Unknown error: {lastStatus}"));
+                return false;
+            }
+
+            return true;
+        }
+
+        async Task<bool> InitializeGamestreaming(string address)
+        {
+            string lastStatus = String.Empty;
+            var client = new NanoClient(address,
+                Services.SmartGlassConnection.Instance.Session);
+
+            try
+            {
+                lastStatus = "Initializing Nano protocol";
+                await client.InitializeProtocolAsync();
+
+                var videoFmt = client.VideoFormats[0];
+                var audioFmt = client.AudioFormats[0];
+
+                lastStatus = "Initializing Nano stream";
+                await client.InitializeStreamAsync(audioFmt, videoFmt);
+
+                Services.SmartGlassConnection.Instance.NanoClient = client;
+            }
+            catch (TimeoutException)
+            {
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await ShowErrorDisplayAlert($"{lastStatus} timed out!"));
+                return false;
+            }
+            catch (Exception)
+            {
+                Xamarin.Forms.Device.BeginInvokeOnMainThread(
+                    async () => await ShowErrorDisplayAlert($"Unknown error: {lastStatus}"));
+                return false;
+            }
+
+            return true;
+        }
+
+        async Task<bool> ConnectToConsole(SmartGlass.Device device)
+        {
+            var address = device.Address.ToString();
+            if(!await InitializeSmartGlass(address))
+            {
+                return false;
+            }
+
+            if (!await InitializeGamestreaming(address))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        async Task ShowErrorDisplayAlert(string message)
+        {
+            await _dialogService.DisplayAlertAsync("Error", message, "OK");
+        }
+
         async Task ShowAddConsolePopup()
         {
             await _navigationService.NavigateAsync(nameof(Views.EnterIpAddressPopup));
         }
 
-        async Task NavigateToConnectionPage(SmartGlass.Device device)
+        async Task NavigateToStreamPage(SmartGlass.Device device)
         {
-            var parameters = new NavigationParameters();
-            parameters.Add("console", device);
-            await _navigationService.NavigateAsync(nameof(Views.ConnectionPage), parameters);
+            Services.SmartGlassConnection.Instance.IPAddress = device.Address.ToString();
+            await _navigationService.NavigateAsync(nameof(Views.StreamPage));
         }
     }
 }

xnano/xnano.csproj

@@ -15,9 +15,6 @@
     <EmbeddedResource Update="Views\AuthenticationPage.xaml">
       <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
     </EmbeddedResource>
-    <EmbeddedResource Update="Views\ConnectionPage.xaml">
-      <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
-    </EmbeddedResource>
     <EmbeddedResource Update="Views\ConsoleListPage.xaml">
       <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
     </EmbeddedResource>