@nativescript/windows 0.1.0-alpha.61 → 0.1.0-alpha.63

package/framework/dotnet-bridge/Bridge.TaskHelper.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Threading.Tasks;
 
@@ -10,10 +12,6 @@ public static partial class Bridge
 {
     private static readonly ConcurrentDictionary<Type, Func<object, Task>?> s_awaitableCache = new();
 
-    // Invoked when the binary instance call "__dotnet_await__(resolveId, rejectId)" arrives.
-    // Converts any awaitable handle (Task<T>, ValueTask<T>, IAsyncOperation<T>, …) into an
-    // async continuation that calls back into V8 via s_jsInvoker when it completes —
-    // without blocking the main thread.
     internal static void ScheduleTaskContinuation(int handleId, int resolveId, int rejectId)
     {
         if (!s_handles.TryGetValue(handleId, out var obj) || obj is null)
@@ -22,7 +20,7 @@ public static partial class Bridge
         var task = GetTaskForAwaitable(obj)
             ?? throw new InvalidOperationException(
                 $"Object of type {obj.GetType().FullName} is not awaitable. " +
-                $"Expected Task<T>, ValueTask<T>, or any type implementing GetAwaiter().");
+                $"Expected Task<T>, ValueTask<T>, IAsyncOperation<T>, or any type implementing GetAwaiter().");
 
         task.ContinueWith(completed =>
         {
@@ -50,10 +48,6 @@ public static partial class Bridge
         }, TaskScheduler.Default);
     }
 
-    // Converts any awaitable to a Task<object?> using the GetAwaiter() pattern via
-    // reflection. Handles Task<T>, ValueTask<T>, WinRT IAsyncOperation<T>, and any
-    // custom awaitable without requiring compile-time type knowledge. Results are
-    // cached per awaitable type so reflection only runs on the first encounter.
     private static Task? GetTaskForAwaitable(object obj)
     {
         if (obj is Task t) return t;
@@ -63,12 +57,12 @@ public static partial class Bridge
         if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>))
             return ValueTaskAsTaskCache.AsTask(type, obj);
 
+        var winrtTask = WinRtAsyncCache.TryGetTask(type, obj);
+        if (winrtTask != null) return winrtTask;
+
         return s_awaitableCache.GetOrAdd(type, BuildAwaitableFactory)?.Invoke(obj);
     }
 
-    // Builds a factory that wraps an arbitrary awaitable type in a
-    // TaskCompletionSource<object?>.  Works for any type with GetAwaiter() returning
-    // an object that has IsCompleted, GetResult(), and OnCompleted/UnsafeOnCompleted.
     private static Func<object, Task>? BuildAwaitableFactory(Type type)
     {
         var getAwaiter = type.GetMethod("GetAwaiter",
@@ -101,7 +95,7 @@ public static partial class Bridge
                     {
                         tcs.SetResult(getResult?.Invoke(awaiter, null));
                     }
-                    catch (System.Reflection.TargetInvocationException ex)
+                    catch (TargetInvocationException ex)
                     {
                         tcs.SetException(ex.InnerException ?? ex);
                     }
@@ -119,3 +113,95 @@ public static partial class Bridge
         };
     }
 }
+
+internal static class WinRtAsyncCache
+{
+    private static readonly ConcurrentDictionary<Type, Func<object, Task>?> s_cache = new();
+
+    public static Task? TryGetTask(Type type, object obj)
+        => s_cache.GetOrAdd(type, BuildFactory)?.Invoke(obj);
+
+    private static Func<object, Task>? BuildFactory(Type type)
+    {
+        foreach (var iface in type.GetInterfaces())
+        {
+            var ifn = iface.FullName ?? "";
+            if (!ifn.StartsWith("Windows.Foundation.IAsync", StringComparison.Ordinal)) continue;
+
+            var completedProp = iface.GetProperty("Completed");
+            if (completedProp?.GetSetMethod() is not { } setter) continue;
+
+            var delegateType   = completedProp.PropertyType;
+            var delegateInvoke = delegateType.GetMethod("Invoke");
+            if (delegateInvoke == null) continue;
+
+            var dp = delegateInvoke.GetParameters()
+                .Select(p => Expression.Parameter(p.ParameterType))
+                .ToArray();
+
+            if (iface.IsGenericType)
+            {
+                var resultType = iface.GetGenericArguments()[0];
+                var getResults = iface.GetMethod("GetResults");
+                if (getResults == null) continue;
+
+                var tcsType  = typeof(TaskCompletionSource<>).MakeGenericType(resultType);
+                var taskProp = tcsType.GetProperty("Task")!;
+                var completeM = typeof(WinRtAsyncCache)
+                    .GetMethod(nameof(CompleteResult), BindingFlags.NonPublic | BindingFlags.Static)!
+                    .MakeGenericMethod(resultType);
+
+                return obj =>
+                {
+                    var tcs = Activator.CreateInstance(tcsType, TaskCreationOptions.RunContinuationsAsynchronously)!;
+                    var body = Expression.Call(completeM,
+                        Expression.Constant(tcs),
+                        Expression.Convert(dp[0], typeof(object)),
+                        Expression.Convert(dp[1], typeof(int)),
+                        Expression.Constant(getResults));
+                    setter.Invoke(obj, [Expression.Lambda(delegateType, body, dp).Compile()]);
+                    return (Task)taskProp.GetValue(tcs)!;
+                };
+            }
+            else
+            {
+                var completeM = typeof(WinRtAsyncCache)
+                    .GetMethod(nameof(CompleteAction), BindingFlags.NonPublic | BindingFlags.Static)!;
+
+                return obj =>
+                {
+                    var tcs = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
+                    var body = Expression.Call(completeM,
+                        Expression.Constant(tcs),
+                        Expression.Convert(dp[1], typeof(int)));
+                    setter.Invoke(obj, [Expression.Lambda(delegateType, body, dp).Compile()]);
+                    return tcs.Task;
+                };
+            }
+        }
+        return null;
+    }
+
+    private static void CompleteResult<T>(object tcs, object sender, int status, MethodInfo getResults)
+    {
+        var typed = (TaskCompletionSource<T>)tcs;
+        try
+        {
+            if (status == 1)
+                typed.TrySetResult((T)getResults.Invoke(sender, null)!);
+            else if (status == 2)
+                typed.TrySetCanceled();
+            else
+                typed.TrySetException(new Exception($"WinRT async operation failed (status {status})"));
+        }
+        catch (TargetInvocationException ex) { typed.TrySetException(ex.InnerException ?? ex); }
+        catch (Exception ex) { typed.TrySetException(ex); }
+    }
+
+    private static void CompleteAction(TaskCompletionSource<object?> tcs, int status)
+    {
+        if (status == 1) tcs.TrySetResult(null);
+        else if (status == 2) tcs.TrySetCanceled();
+        else tcs.TrySetException(new Exception($"WinRT async action failed (status {status})"));
+    }
+}

package/framework/dotnet-bridge/Bridge.cs

@@ -4,6 +4,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Runtime.InteropServices;
 using System.Runtime.Loader;
 using System.Text.Json;
@@ -159,6 +161,118 @@ public static partial class Bridge
         }
     }
 
+    public static object? RunOnUIThread(int callbackId)
+    {
+        var action = new Action(() =>
+        {
+            unsafe
+            {
+                if (s_jsInvoker == null) return;
+                byte* respPtr = null;
+                int respLen = 0;
+                s_jsInvoker(callbackId, null, 0, &respPtr, &respLen);
+                if (respPtr != null && respLen > 0) Marshal.FreeHGlobal((IntPtr)respPtr);
+            }
+        });
+
+        try
+        {
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var coreAppType = asm.GetType("Windows.ApplicationModel.Core.CoreApplication");
+                if (coreAppType == null) continue;
+                var mainViewProp = coreAppType.GetProperty("MainView", BindingFlags.Public | BindingFlags.Static);
+                var mainView = mainViewProp?.GetValue(null);
+                if (mainView == null) continue;
+                var dispatcherProp = mainView.GetType().GetProperty("Dispatcher", BindingFlags.Public | BindingFlags.Instance);
+                var dispatcher = dispatcherProp?.GetValue(mainView);
+                if (dispatcher == null) continue;
+
+                var hasAccessProp = dispatcher.GetType().GetProperty("HasThreadAccess", BindingFlags.Public | BindingFlags.Instance);
+                if (hasAccessProp?.GetValue(dispatcher) is true)
+                {
+                    action();
+                    return null;
+                }
+
+                foreach (var m in dispatcher.GetType().GetMethods().Where(m => m.Name == "RunAsync"))
+                {
+                    var parameters = m.GetParameters();
+                    if (parameters.Length != 2) continue;
+                    var enumType = parameters[0].ParameterType;
+                    object priority = enumType.IsEnum ? Enum.ToObject(enumType, 0) : Activator.CreateInstance(enumType)!;
+                    var handlerType = parameters[1].ParameterType;
+                    var mre = new ManualResetEventSlim(false);
+                    var wrapped = new Action(() => { try { action(); } finally { mre.Set(); } });
+                    try
+                    {
+                        var d = Delegate.CreateDelegate(handlerType, wrapped.Target, wrapped.Method);
+                        m.Invoke(dispatcher, new object[] { priority, d });
+                        mre.Wait();
+                        return null;
+                    }
+                    catch { }
+                }
+                break;
+            }
+        }
+        catch { }
+
+        try
+        {
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var dqType = asm.GetType("Microsoft.UI.Dispatching.DispatcherQueue");
+                if (dqType == null) continue;
+                var getForCurrent = dqType.GetMethod("GetForCurrentThread", BindingFlags.Public | BindingFlags.Static);
+                var dq = getForCurrent?.Invoke(null, null);
+                if (dq == null) continue;
+
+                if (dq.GetType().GetProperty("HasThreadAccess")?.GetValue(dq) is true)
+                {
+                    action();
+                    return null;
+                }
+                break;
+            }
+        }
+        catch { }
+
+        try
+        {
+            var wpfDispatcherType = AppDomain.CurrentDomain.GetAssemblies()
+                .Select(a => a.GetType("System.Windows.Threading.Dispatcher"))
+                .FirstOrDefault(t => t != null);
+            if (wpfDispatcherType != null)
+            {
+                var currentDispatcherProp = wpfDispatcherType.GetProperty("CurrentDispatcher", BindingFlags.Public | BindingFlags.Static);
+                var dispatcher = currentDispatcherProp?.GetValue(null);
+                if (dispatcher != null)
+                {
+                    var checkAccess = dispatcher.GetType().GetMethod("CheckAccess");
+                    if (checkAccess?.Invoke(dispatcher, null) is true)
+                    {
+                        action();
+                        return null;
+                    }
+                    var beginInvoke = dispatcher.GetType().GetMethod("BeginInvoke", new[] { typeof(Action) })
+                        ?? dispatcher.GetType().GetMethods().FirstOrDefault(m => m.Name == "BeginInvoke" && m.GetParameters().Length == 1);
+                    if (beginInvoke != null)
+                    {
+                        var mre = new ManualResetEventSlim(false);
+                        beginInvoke.Invoke(dispatcher, new object[] { new Action(() => { try { action(); } finally { mre.Set(); } }) });
+                        mre.Wait();
+                        return null;
+                    }
+                }
+            }
+        }
+        catch { }
+
+        action();
+        return null;
+    }
+
     private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
     {
         try

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/windows",
-  "version": "0.1.0-alpha.61",
+  "version": "0.1.0-alpha.63",
   "description": "NativeScript for using Windows v8",
   "repository": {
         "type": "git",