Update to MobileShell Alpha r709

- Battery status (charging, normal, saving)
- Detects (like w10m):
Focus Assist
Location usage
WiFi (partially broken)
Cellular (+ dual sim) -> WIP, expected to be broken
Tablet mode or Desktop mode (expected to be broken)

Author: ADeltaX

src/App.xaml.cs

@@ -1,10 +1,25 @@
 using MobileShell.Classes;
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Forms;
 using System.Windows.Media;
+using Windows.ApplicationModel.Background;
+using Windows.ApplicationModel.Calls;
+using Windows.ApplicationModel.Calls.Provider;
+using Windows.ApplicationModel.CommunicationBlocking;
+using Windows.Devices.Radios;
+using Windows.Networking.Connectivity;
+using Windows.Networking.NetworkOperators;
+using Windows.Phone.Notification.Management;
+using Windows.System.Power;
 using static MobileShell.Classes.NativeMethods;
+using MessageBox = System.Windows.MessageBox;
 
 namespace MobileShell
 {
@@ -14,13 +29,17 @@ namespace MobileShell
     public partial class App : System.Windows.Application
     {
         public static float DPI { get; private set; } = 1F;
+        public static bool IsTabletMode { get; set; }
         public static HookEngine Kbh { get; set; }
 
+        //We don't wanna GC to collect this, right? *yells*
+        private WnfQueries.WnfUserCallback wnfCallback;
+
         #region Main instances of Window(s)
 
-        private StatusBarWindow stBar;
-        private TaskbarWindow tkBar;
-        private VolumeAudioFlyout vlFly;
+        private static StatusBarWindow stBar;
+        private static TaskbarWindow tkBar;
+        private static VolumeAudioFlyout vlFly;
 
         #endregion
 
@@ -32,31 +51,125 @@ private void Application_Startup(object sender, StartupEventArgs e)
 
             AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
 
-            Kbh = new HookEngine();
-            Kbh.OnKeyPressed += kbh_OnKeyPressed;
-            Kbh.OnKeyUnpressed += kbh_OnKeyUnpressed;
-            Kbh.HookKeyboard();
+            //Kbh = new HookEngine();
+            //Kbh.OnKeyPressed += kbh_OnKeyPressed;
+            //Kbh.OnKeyUnpressed += kbh_OnKeyUnpressed;
+            //Kbh.HookKeyboard();
+
+            ShutdownMode = ShutdownMode.OnExplicitShutdown;
 
-            
             stBar = new StatusBarWindow();
             tkBar = new TaskbarWindow();
-            vlFly = new VolumeAudioFlyout();
-
-            DPI = (float)VisualTreeHelper.GetDpi(stBar).DpiScaleX;
+            //vlFly = new VolumeAudioFlyout();
 
             stBar.Show();
             tkBar.Show();
 
-            Configure();
+
+            //TODO: REMOVE
+            //stBar.SetVisibility(Visibility.Visible);
+            //tkBar.SetVisibility(Visibility.Visible);
+            ////stBar.UpdateAppBar(); //STACK OVERFLOW EXCEPTION !!!!111!!!11!
+            //stBar.SetupAppBar();
+            ////tkBar.UpdateAppBar();
+            //tkBar.SetupAppBar();
+            //HideExplorerTaskbar();
+            ////END TODO.
+
+
+            DPI = (float)VisualTreeHelper.GetDpi(stBar).DpiScaleX;
+
+            PowerManager.BatteryStatusChanged += (_, __) => stBar?.UpdateBatteryIconAndPercentage();
+            PowerManager.EnergySaverStatusChanged += (_, __) => stBar?.UpdateBatteryIconAndPercentage();
+            PowerManager.RemainingChargePercentChanged += (_, __) => stBar?.UpdateBatteryIconAndPercentage();
+            NetworkInformation.NetworkStatusChanged += (_) => stBar?.UpdateNetworkState();
+
+            //RadioAsync();
+
+            //It will hang if we await it.
+            NotifAsync();
+
+            wnfCallback = WnfStateUpdates;
+
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_SHEL_QUIETHOURS_ACTIVE_PROFILE_CHANGED, wnfCallback);
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_SHEL_NOTIFICATIONS, wnfCallback);
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_LFS_STATE, wnfCallback);
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_TMCN_ISTABLETMODE, wnfCallback);
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_CELL_SIGNAL_STRENGTH_BARS_CAN0, wnfCallback);
+            WnfQueries.SubscribeWnf(WnfQueries.WNF_CELL_SIGNAL_STRENGTH_BARS_CAN1, wnfCallback);
         }
 
-        static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
+        private async Task NotifAsync()
         {
+            var phoneLines = await GetPhoneLinesAsync();
+            var isDualSim = phoneLines.Count > 1;
+
+            //PhoneCallManager.CallStateChanged += PhoneCallManager_CallStateChanged;
+
+            foreach (var phoneLine in phoneLines)
+            {
+                stBar.AddPhoneLine(phoneLine, isDualSim);
+                //phoneLine.LineChanged += PhoneLine_LineChanged;
+            }
+        }
+
+        private void PhoneCallManager_CallStateChanged(object sender, object e)
+        {
+            //throw new NotImplementedException();
 
         }
+
+        private void PhoneLine_LineChanged(PhoneLine sender, object args)
+        {
+            
+        }
+
+        private async Task<List<PhoneLine>> GetPhoneLinesAsync()
+        {
+            PhoneCallStore store = await PhoneCallManager.RequestStoreAsync();
+            var watcher = store.RequestLineWatcher();
+            var phoneLines = new List<PhoneLine>();
+            var lineEnumerationCompletion = new TaskCompletionSource<bool>();
+
+            watcher.LineAdded += async (o, args) => { var line = await PhoneLine.FromIdAsync(args.LineId); phoneLines.Add(line); };
+            watcher.Stopped += (o, args) => lineEnumerationCompletion.TrySetResult(false);
+            watcher.EnumerationCompleted += (o, args) => lineEnumerationCompletion.TrySetResult(true);
+
+            watcher.Start();
+
+            if (!await lineEnumerationCompletion.Task)
+                throw new Exception("Phone Line Enumeration failed");
+
+            watcher.Stop();
+
+            List<PhoneLine> returnedLines = new List<PhoneLine>();
+
+            foreach (PhoneLine phoneLine in phoneLines)
+                if (phoneLine != null && phoneLine.Transport == PhoneLineTransport.Cellular)
+                    returnedLines.Add(phoneLine);
+
+            return returnedLines;
+        }
+
+        public static void ResetWorkArea()
+        {
+            RECT oldWorkArea;
+            oldWorkArea.Left = Screen.PrimaryScreen.Bounds.Left;
+            oldWorkArea.Top = Screen.PrimaryScreen.Bounds.Top;
+            oldWorkArea.Right = Screen.PrimaryScreen.Bounds.Width;
+            oldWorkArea.Bottom = Screen.PrimaryScreen.Bounds.Height;
+
+            SystemParametersInfo(SPI_SETWORKAREA, 0, ref oldWorkArea, 1 | 2);
+        }
+
+        static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
+        {
+            MessageBox.Show("RIP: \n" + e.Exception.Message);
+        }
+
         static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
         {
-            System.Windows.MessageBox.Show("RIP");
+            MessageBox.Show("RIP: \n" + e.ExceptionObject);
         }
 
         private void kbh_OnKeyUnpressed(object sender, VirtualKeyShort e)
@@ -69,11 +182,79 @@ private void kbh_OnKeyPressed(object sender, VirtualKeyShort e)
 
         }
 
-        public static void Configure()
+        public static void ResetScreenCache()
         {
-            //Useless?
+            // use reflection to empty screens cache
+            typeof(Screen).GetField("screens", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).SetValue(null, null);
+        }
 
-            HideExplorerTaskbar();
+        //ToDo clean code.
+        public IntPtr WnfStateUpdates(ulong stateName, uint changeStamp, IntPtr typeId, IntPtr callbackContext, IntPtr bufferPtr, uint bufferSize)
+        {
+            byte[] buffer = new byte[bufferSize];
+            Marshal.Copy(bufferPtr, buffer, 0, buffer.Length);
+
+            if (stateName == WnfQueries.WNF_SHEL_QUIETHOURS_ACTIVE_PROFILE_CHANGED)
+            {
+                var focusAssistStatus = WnfQueries.ToFocusAssistStatus(buffer);
+                stBar.UpdateFocusAssist(focusAssistStatus);
+            }
+            else if (stateName == WnfQueries.WNF_LFS_STATE)
+            {
+                //LOCATION
+                var locationInUse = WnfQueries.ToBool(buffer);
+                stBar.UpdateLocation(locationInUse);
+            }
+            else if (stateName == WnfQueries.WNF_SHEL_NOTIFICATIONS)
+            {
+                //NOTIFICATION
+                var notificationsCount = WnfQueries.ToInt32(buffer);
+                stBar.UpdateNotification(notificationsCount);
+            }
+            else if (stateName == WnfQueries.WNF_TMCN_ISTABLETMODE)
+            {
+                //TABLET MODE
+                var isTabletMode = WnfQueries.ToBool(buffer);
+                IsTabletMode = isTabletMode;
+                ChangeMobileShellBehaviour(isTabletMode);
+            }
+            else if (stateName == WnfQueries.WNF_CELL_SIGNAL_STRENGTH_BARS_CAN0)
+            {
+                var signalStrength = WnfQueries.ToInt32(buffer);
+                stBar.UpdateSignalStrength(signalStrength, 0);
+            }
+            else if (stateName == WnfQueries.WNF_CELL_SIGNAL_STRENGTH_BARS_CAN1)
+            {
+                var signalStrength = WnfQueries.ToInt32(buffer);
+                stBar.UpdateSignalStrength(signalStrength, 0);
+            }
+            return IntPtr.Zero;
+        }
+
+        public static void ChangeMobileShellBehaviour(bool visible)
+        {
+            //return;
+            if (visible)
+            {
+                stBar.SetVisibility(Visibility.Visible);
+                tkBar.SetVisibility(Visibility.Visible);
+                //stBar.UpdateAppBar(); //STACK OVERFLOW EXCEPTION !!!!111!!!11!
+                stBar.SetupAppBar();
+                //tkBar.UpdateAppBar();
+                tkBar.SetupAppBar();
+                HideExplorerTaskbar();
+            }
+            else
+            {
+                stBar.SetVisibility(Visibility.Collapsed);
+                tkBar.SetVisibility(Visibility.Collapsed);
+                //stBar.UpdateAppBar();
+                stBar.UnSetupAppBar();
+                //tkBar.UpdateAppBar();
+                tkBar.UnSetupAppBar();
+                ResetWorkArea();
+                ShowExplorerTaskbar();
+            }
         }
 
         public static void HideExplorerTaskbar()
@@ -82,7 +263,7 @@ public static void HideExplorerTaskbar()
             AppBar.SetWinTaskbarState(AppBar.WinTaskbarState.AutoHide);
 
             //puff, disappear.
-            AppBar.SetWinTaskbarPos((int)NativeMethods.SetWindowPosFlags.SWP_HIDEWINDOW);
+            AppBar.SetWinTaskbarPos((int)SetWindowPosFlags.SWP_HIDEWINDOW);
         }
 
         public static void ShowExplorerTaskbar()
@@ -91,18 +272,7 @@ public static void ShowExplorerTaskbar()
             AppBar.SetWinTaskbarState(AppBar.WinTaskbarState.OnTop);
 
             //Reset.
-            AppBar.SetWinTaskbarPos((int)NativeMethods.SetWindowPosFlags.SWP_SHOWWINDOW);
-        }
-
-        public static void SetWorkArea(Screen screen)
-        {
-            RECT rect;
-            rect.Left = screen.Bounds.Left;
-            rect.Right = screen.Bounds.Right;
-            rect.Top = (int)Math.Floor(screen.Bounds.Top + (24F * DPI));
-            rect.Bottom = (int)Math.Floor(screen.Bounds.Bottom - (42F * DPI));
-
-            SystemParametersInfo(SPI_SETWORKAREA, 0, ref rect, 0);
+            AppBar.SetWinTaskbarPos((int)SetWindowPosFlags.SWP_SHOWWINDOW);
         }
     }
 }

src/Classes/NativeMethods.cs

@@ -18,6 +18,7 @@ public static partial class NativeMethods
         public const int WM_SYSKEYUP = 0x105;
         public const int WM_MOUSEACTIVATE = 0x0021;
         public const int MA_NOACTIVATE = 0x0003;
+        public const int WM_SETTINGCHANGE = 0x001A;
         public const int INPUT_KEYBOARD = 1;
 
         public delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

src/Classes/WPFHelper.cs

@@ -9,8 +9,8 @@ namespace MobileShell.Classes
 {
     public static class WPFHelper
     {
-        private const int MAX_LENGTH = 15;
-        private const int MAX_TIME_MILLISECONDS = 250;
+        private const int MAX_LENGTH = 30;
+        private const int MAX_TIME_MILLISECONDS = 750; //Or 500?
 
         public static bool IsDoubleTap(this TouchEventArgs e, IInputElement inputReference, ref Point? lastTapLocation, Stopwatch doubleTapStopwatch)
         {