Universal Fix for Touch Keyboard on Tablets

[Wandtket]

As of Windows App SDK 1.2 the Touch keyboard does not pop up automatically when a user taps a text entry field on Desktop when no keyboard is present, combining multiple other threads together I have put together a class that re-enables this functionality.

All you need to do is add this Dependency object to your app, go into your app.xaml and set the allowtouchkeyboard property to true.

    public class TouchKeyboard : DependencyObject
    {
        public static readonly DependencyProperty AllowProperty =
           DependencyProperty.RegisterAttached("Allow", typeof(bool), typeof(TouchKeyboard), new PropertyMetadata("", OnChanged));

        public static bool GetAllow(DependencyObject obj)
        {
            return (bool)obj.GetValue(AllowProperty);
        }

        public static void SetAllow(DependencyObject obj, bool value)
        {
            obj.SetValue(AllowProperty, value);
        }

        private static void OnChanged(DependencyObject d, DependencyPropertyChangedEventArgs args)
        {
            bool? Value = args.NewValue as bool?;

            if (Value == true)
            {
                switch (d)
                {
                    case Control control:
                        control.GotFocus += Control_GotFocus;
                        break;
                }
            }
            else
            {
                switch (d)
                {
                    case Control control:
                        control.GotFocus -= Control_GotFocus;
                        break;
                }
            }
        }

        private static async void Control_GotFocus(object sender, RoutedEventArgs e)
        {            
            if (UI.IsTouchEnabled() && UI.PhysicalKeyboardAttached == false)
            {              
                var uiHostNoLaunch = new UIHostNoLaunch();
                var tipInvocation = (ITipInvocation)uiHostNoLaunch;

                var inputPane = (IFrameworkInputPane)new FrameworkInputPane();
                inputPane.Location(out var rect);

                if (rect.Height == 0 && rect.Width == 0)
                {
                    tipInvocation.Toggle(GetDesktopWindow());
                    Marshal.ReleaseComObject(uiHostNoLaunch);
                }
            }
        }



        [ComImport, Guid("4ce576fa-83dc-4F88-951c-9d0782b4e376")]
        class UIHostNoLaunch
        {
        }

        [ComImport, Guid("37c994e7-432b-4834-a2f7-dce1f13b834b")]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        interface ITipInvocation
        {
            void Toggle(IntPtr hwnd);
        }

        [DllImport("user32.dll", SetLastError = false)]
        static extern IntPtr GetDesktopWindow();



        [ComImport, Guid("D5120AA3-46BA-44C5-822D-CA8092C1FC72")]
        public class FrameworkInputPane
        {
        }

        [ComImport, System.Security.SuppressUnmanagedCodeSecurity,
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
        Guid("5752238B-24F0-495A-82F1-2FD593056796")]
        public interface IFrameworkInputPane
        {
            [PreserveSig]
            int Advise(
                [MarshalAs(UnmanagedType.IUnknown)] object pWindow,
                [MarshalAs(UnmanagedType.IUnknown)] object pHandler,
                out int pdwCookie
                );

            [PreserveSig]
            int AdviseWithHWND(
                IntPtr hwnd,
                [MarshalAs(UnmanagedType.IUnknown)] object pHandler,
                out int pdwCookie
                );

            [PreserveSig]
            int Unadvise(
                int pdwCookie
                );

            [PreserveSig]
            int Location(
                out Rectangle prcInputPaneScreenLocation
                );
        }


    }

Your App.xaml should look like this to apply it to all textboxes, password boxes, etc

xmlns:extensions="using:YourNameSpace.Extensions"

<Application.Resources>
        <ResourceDictionary>
            <Style TargetType="TextBox" BasedOn="{StaticResource DefaultTextBoxStyle}">
                <Setter Property="extensions:TouchKeyboard.Allow" Value="True"/>
            </Style>

            <Style TargetType="PasswordBox" BasedOn="{StaticResource DefaultPasswordBoxStyle}">
                <Setter Property="extensions:TouchKeyboard.Allow" Value="True"/>
            </Style>

            <Style TargetType="NumberBox">
                <Setter Property="extensions:TouchKeyboard.Allow" Value="True"/>
            </Style>

            <Style TargetType="AutoSuggestBox" BasedOn="{StaticResource DefaultAutoSuggestBoxStyle}">
                <Setter Property="extensions:TouchKeyboard.Allow" Value="True"/>
            </Style>

            <Style TargetType="RichEditBox" BasedOn="{StaticResource DefaultRichEditBoxStyle}">
                <Setter Property="extensions:TouchKeyboard.Allow" Value="True"/>
            </Style>
        </ResourceDictionary>
</Application.Resources>

Also add a class to host static UI object to reference back to

public class UI
{
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern int GetSystemMetrics(int nIndex);

        public static bool IsTouchEnabled()
        {
            const int MAXTOUCHES_INDEX = 95;
            int maxTouches = GetSystemMetrics(MAXTOUCHES_INDEX);

            return maxTouches > 0;
        }

        public static bool PhysicalKeyboardAttached = false;
}

[Wandtket]

If you want to detect something like a surface keyboard being attached / disconnected to prevent the TouchKeyboard from opening (Or detecting anything really) Here's a class that appears to work well for our needs until Microsoft fixes it.

    public static class Devices
    {

        public static string CurrentDeviceId = "";


        /// <summary>
        /// Event Handler for detecting devices
        /// </summary>
        public static event StatusUpdatedEventHandler StatusUpdated;
        public delegate void StatusUpdatedEventHandler(DeviceType Type, bool IsConnected);


        /// <summary>
        /// Device Watcher to detect a user plugging in USB / Connected Wireless Devices
        /// </summary>
        public static DeviceWatcher watcher = DeviceInformation.CreateWatcher(DeviceClass.All);


        public static void Monitor()
        {
            watcher.Updated += Watcher_Updated;
            watcher.Start();
        }


        public static async Task<bool> IsPhysicalKeyboardAttachedToTablet()
        {
            List<SupportedDevice> supportedDevices = ListSupportedDevices();

            foreach (SupportedDevice supportedDevice in supportedDevices)
            {
                if (supportedDevice.DeviceType == DeviceType.Keyboard)
                {
                    var collection = await DeviceInformation.FindAllAsync();
                    foreach (var device in collection)
                    {
                        if (device.Id == supportedDevice.DeviceId)
                        {
                            var Keys = device.Properties.Keys.ToList();
                            var Values = device.Properties.Values.ToList();

                            for (int i = 0; i < Keys.Count; i++)
                            {
                                if (Keys[i] != null)
                                {
                                    if (Keys[i].ToString() == "System.Devices.InterfaceEnabled")
                                    {
                                        bool Attached = Convert.ToBoolean(Values[i].ToString());
                                        UI.PhysicalKeyboardAttached = Attached;
                                        return Attached;
                                    }
                                }
                            }
                        }
                    }
                }                  
            }
            
            return false;
        }



        /// <summary>
        /// When a Human Interface Device (HID) is connected this event will fire, use the "System.Devices.InterfaceEnabled" Key to determine connection.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private static async void Watcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args)
        {
            watcher.Stop();

            CurrentDeviceId = args.Id;

            var Device = await DeviceInformation.CreateFromIdAsync(args.Id);

            List<SupportedDevice> supportedDevices = ListSupportedDevices();

            foreach (SupportedDevice supporteddevice in supportedDevices)
            {
                if (Device.Id == supporteddevice.DeviceId)
                {
                    var Keys = Device.Properties.Keys.ToList();
                    var Values = Device.Properties.Values.ToList();

                    for (int i = 0; i < Keys.Count; i++)
                    {
                        if (Keys[i] != null)
                        {
                            if (Keys[i].ToString() == "System.Devices.InterfaceEnabled")
                            {
                                bool Connected = Convert.ToBoolean(Values[i].ToString());                               
                                StatusUpdated.Invoke(supporteddevice.DeviceType, Connected);
                                break;
                            }
                        }
                    }
                }
            }       

            await Task.Delay(100);
            watcher.Start();        
        }







        /// <summary>
        /// Add device properties here you wish to detect. Use the CurrentDeviceId string to get information about devices (Device Manager isn't reliable to compare strings)
        /// </summary>
        /// <returns></returns>
        public static List<SupportedDevice> ListSupportedDevices()
        {
            List<SupportedDevice> supportedDevices = new List<SupportedDevice>
            {
                //Asus ExpertBook B3 (Detachable) Touch Keyboard
                new SupportedDevice { DeviceType = DeviceType.Keyboard, DeviceId = @"\\?\USB#VID_0B05&PID_0603#DK_8231_001#{a5dcbf10-6530-11d2-901f-00c04fb951ed}" },

                //Surface Touch Keyboard
                new SupportedDevice { DeviceType = DeviceType.Keyboard, DeviceId = @"Your Surface Keyboard Id goes here, (They should be the same from device to device if the model is the same, there may be a way to look it up as well." },
            };

            return supportedDevices;            
        }
    }


    /// <summary>
    /// Add device types here to determine what to do with StatusUpdated event handler (Can be generic or specific)
    /// </summary>
    public enum DeviceType
    {
        Keyboard,
        Mouse,
        FlashDrive,
    }

    /// <summary>
    /// Class to save devices that you want to detect when a user plugs in a USB or connects a wireless device.
    /// </summary>
    public class SupportedDevice
    {
        public DeviceType DeviceType { get; set; }

        public string DeviceId { get; set; }
    }

To use it put this in your App.xaml.cs and remember to get the DeviceId from the device and put it in SupportedDevices.

 if (UI.IsTouchEnabled() == true)
{
        Devices.Monitor();
        Devices.StatusUpdated += Devices_StatusUpdated;

         if (await Devices.IsPhysicalKeyboardAttachedToTablet() == true)
         {
               UI.PhysicalKeyboardAttached = true;
         }
 }

[adamfierek]

First, thank you so much for sharing your solution!

This solves one more problem, still existing in 1.4 - touch keyboard does not appear when textbox gets programmatic focus.

Two things are not clear for me: calling IsTouchEnabled() every time Control got focus and existance of separate UI class. Without these, it seems to work good, but I made an Behavior based on your solution instead of attached property.