【UWP】让 UWP 自己托管自己 —— Windows App SDK 篇

#r "nuget:Detours.Win32Metadata"
#r "nuget:Microsoft.Windows.CsWin32"

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Storage.Packaging.Appx;
using Detours = Microsoft.Detours.PInvoke;

/// <summary>
/// Represents a hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
/// </summary>
public sealed partial class HookWindowingModel : IDisposable
{
    /// <summary>
    /// The value that indicates whether the class has been disposed.
    /// </summary>
    private bool disposed;

    /// <summary>
    /// The reference count for the hook.
    /// </summary>
    private static int refCount;

    /// <summary>
    /// The value that represents the current process token.
    /// </summary>
    private const int currentProcessToken = -6;

    /// <remarks>The original <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.</remarks>
    /// <inheritdoc cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/>
    private static unsafe delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> AppPolicyGetWindowingModel;

    /// <summary>
    /// Initializes a new instance of the <see cref="HookWindowingModel"/> class.
    /// </summary>
    public HookWindowingModel()
    {
        refCount++;
        StartHook();
    }

    /// <summary>
    /// Finalizes this instance of the <see cref="HookWindowingModel"/> class.
    /// </summary>
    ~HookWindowingModel()
    {
        Dispose();
    }

    /// <summary>
    /// Gets the value that indicates whether the hook is active.
    /// </summary>
    public static bool IsHooked { get; private set; }

    /// <summary>
    /// Gets or sets the windowing model to use when the hooked <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function is called.
    /// </summary>
    internal static AppPolicyWindowingModel WindowingModel { get; set; } = AppPolicyWindowingModel.AppPolicyWindowingModel_ClassicDesktop;

    /// <summary>
    /// Starts the hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
    /// </summary>
    private static unsafe void StartHook()
    {
        if (!IsHooked)
        {
            using FreeLibrarySafeHandle library = PInvoke.GetModuleHandle("KERNEL32.dll");
            if (!library.IsInvalid && NativeLibrary.TryGetExport(library.DangerousGetHandle(), nameof(PInvoke.AppPolicyGetWindowingModel), out nint appPolicyGetWindowingModel))
            {
                void* appPolicyGetWindowingModelPtr = (void*)appPolicyGetWindowingModel;
                delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

                _ = Detours.DetourRestoreAfterWith();

                _ = Detours.DetourTransactionBegin();
                _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
                _ = Detours.DetourAttach(ref appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
                _ = Detours.DetourTransactionCommit();

                AppPolicyGetWindowingModel = (delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR>)appPolicyGetWindowingModelPtr;
                IsHooked = true;
            }
        }
    }

    /// <summary>
    /// Ends the hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
    /// </summary>
    private static unsafe void EndHook()
    {
        if (--refCount == 0 && IsHooked)
        {
            void* appPolicyGetWindowingModelPtr = AppPolicyGetWindowingModel;
            delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

            _ = Detours.DetourTransactionBegin();
            _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
            _ = Detours.DetourDetach(&appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
            _ = Detours.DetourTransactionCommit();

            AppPolicyGetWindowingModel = null;
            IsHooked = false;
        }
    }

    /// <param name="policy">A pointer to a variable of the <a href="https://docs.microsoft.com/windows/win32/api/appmodel/ne-appmodel-apppolicywindowingmodel">AppPolicyWindowingModel</a> enumerated type.
    /// When the function returns successfully, the variable contains the <see cref="WindowingModel"/> when the identified process is current; otherwise, the windowing model of the identified process.</param>
    /// <remarks>The overridden <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.</remarks>
    /// <inheritdoc cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/>
    [UnmanagedCallersOnly(CallConvs = [typeof(CallConvStdcall)])]
    private static unsafe WIN32_ERROR OverrideAppPolicyGetWindowingModel(HANDLE processToken, AppPolicyWindowingModel* policy)
    {
        if ((int)processToken.Value == currentProcessToken)
        {
            *policy = WindowingModel;
            return WIN32_ERROR.ERROR_SUCCESS;
        }
        return AppPolicyGetWindowingModel(processToken, policy);
    }

    /// <inheritdoc/>
    public void Dispose()
    {
        if (!disposed && IsHooked)
        {
            EndHook();
        }
        GC.SuppressFinalize(this);
        disposed = true;
    }
}

new Thread(() => { ... });

AppWindow window = AppWindow.Create();

DispatcherQueueController controller;
DesktopWindowXamlSource source;

using (HookWindowingModel hook = new())
{
    controller = DispatcherQueueController.CreateOnCurrentThread();
    source = new DesktopWindowXamlSource();
}

source.Initialize(window.Id);
DesktopChildSiteBridge bridge = source.SiteBridge;
bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
bridge.Show();

DispatcherQueue dispatcherQueue = controller.DispatcherQueue;
window.AssociateWithDispatcherQueue(dispatcherQueue);

window.Changed += (sender, args) =>
{
    if (args.DidPresenterChange)
    {
        bridge.ResizePolicy = ContentSizePolicy.None;
        bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
    }
};

dispatcherQueue.RunEventLoop();
await controller.ShutdownQueueAsync();

/// <summary>
/// Create a new <see cref="DesktopWindow"/> instance.
/// </summary>
/// <param name="launched">Do something after <see cref="DesktopWindowXamlSource"/> created.</param>
/// <returns>The new instance of <see cref="DesktopWindow"/>.</returns>
public static Task<DesktopWindow> CreateAsync(Action<DesktopWindowXamlSource> launched)
{
    TaskCompletionSource<DesktopWindow> taskCompletionSource = new();

    new Thread(async () =>
    {
        try
        {
            DispatcherQueueController controller;
            DesktopWindowXamlSource source;
            AppWindow window = AppWindow.Create();

            using (HookWindowingModel hook = new())
            {
                controller = DispatcherQueueController.CreateOnCurrentThread();
                source = new DesktopWindowXamlSource();
            }

            source.Initialize(window.Id);
            DesktopChildSiteBridge bridge = source.SiteBridge;
            bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
            bridge.Show();

            window.Changed += (sender, args) =>
            {
                if (args.DidPresenterChange)
                {
                    bridge.ResizePolicy = ContentSizePolicy.None;
                    bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
                }
            };

            DispatcherQueue dispatcherQueue = controller.DispatcherQueue;
            window.AssociateWithDispatcherQueue(dispatcherQueue);
            TrackWindow(window);

            launched(source);
            DesktopWindow desktopWindow = new()
            {
                AppWindow = window,
                WindowXamlSource = source
            };
            taskCompletionSource.SetResult(desktopWindow);

            dispatcherQueue.RunEventLoop();
            await controller.ShutdownQueueAsync();
        }
        catch (Exception e)
        {
            taskCompletionSource.SetException(e);
        }
    })
    {
        Name = nameof(DesktopWindowXamlSource)
    }.Start();

    return taskCompletionSource.Task;
}

/// <summary>
/// Create a new <see cref="DesktopWindow"/> instance.
/// </summary>
/// <param name="dispatcherQueue">The <see cref="DispatcherQueue"/> to provide thread.</param>
/// <param name="launched">Do something after <see cref="DesktopWindowXamlSource"/> created.</param>
/// <returns>The new instance of <see cref="DesktopWindow"/>.</returns>
public static Task<DesktopWindow> CreateAsync(DispatcherQueue dispatcherQueue, Action<DesktopWindowXamlSource> launched)
{
    TaskCompletionSource<DesktopWindow> taskCompletionSource = new();

    _ = dispatcherQueue.TryEnqueue(() =>
    {
        try
        {
            DesktopWindowXamlSource source;
            AppWindow window = AppWindow.Create();
            window.AssociateWithDispatcherQueue(dispatcherQueue);
            TrackWindow(window);

            using (HookWindowingModel hook = new())
            {
                source = new DesktopWindowXamlSource();
            }

            source.Initialize(window.Id);
            DesktopChildSiteBridge bridge = source.SiteBridge;
            bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
            bridge.Show();

            window.Changed += (sender, args) =>
            {
                if (args.DidPresenterChange)
                {
                    bridge.ResizePolicy = ContentSizePolicy.None;
                    bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
                }
            };

            launched(source);
            DesktopWindow desktopWindow = new()
            {
                AppWindow = window,
                WindowXamlSource = source
            };
            taskCompletionSource.SetResult(desktopWindow);
        }
        catch (Exception e)
        {
            taskCompletionSource.SetException(e);
        }
    });

    return taskCompletionSource.Task;
}

private static void TrackWindow(AppWindow window)
{
    if (ActiveDesktopWindows.ContainsKey(window.DispatcherQueue))
    {
        ActiveDesktopWindows[window.DispatcherQueue] += 1;
    }
    else
    {
        ActiveDesktopWindows[window.DispatcherQueue] = 1;
    }
    window.Destroying -= AppWindow_Destroying;
    window.Destroying += AppWindow_Destroying;
}

private static void AppWindow_Destroying(AppWindow sender, object args)
{
    if (ActiveDesktopWindows.TryGetValue(sender.DispatcherQueue, out ulong num))
    {
        num--;
        if (num == 0)
        {
            ActiveDesktopWindows.Remove(sender.DispatcherQueue);
            sender.DispatcherQueue.EnqueueEventLoopExit();
            return;
        }
        ActiveDesktopWindows[sender.DispatcherQueue] = num;
    }
}

private static Dictionary<DispatcherQueue, ulong> ActiveDesktopWindows { get; } = [];