Further work on getting uno in

reactiveui · glennawatson · Jun 26, 2019 · Jun 12, 2019 · Jun 12, 2019 · Jun 12, 2019
commit f6148b75aca56dc7d32dea80f100cdb479ef46d6
diff --git a/src/ReactiveUI.Uno/ActivationForViewFetcher.cs b/src/ReactiveUI.Uno/ActivationForViewFetcher.cs
@@ -3,7 +3,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-#if HAS_UNO
 using System;
 using System.Linq;
 using System.Reactive;
@@ -38,12 +37,13 @@ public IObservable<bool> GetActivationForView(IActivatable view)
                 return Observable<bool>.Empty;
             }
 
+#pragma warning disable SA1114 // Parameter list after.
+#if NETSTANDARD || MAC
             var viewLoaded = Observable.FromEvent<RoutedEventHandler, bool>(
-                eventHandler =>
-                {
-                    void Handler(object sender, RoutedEventArgs e) => eventHandler(true);
-                    return Handler;
-                },
+#else
+            var viewLoaded = Observable.FromEvent<TypedEventHandler<DependencyObject, object>, bool>(
+#endif
+                eventHandler => (_, __) => eventHandler(true),
                 x => fe.Loading += x,
                 x => fe.Loading -= x);
 
@@ -64,4 +64,3 @@ public IObservable<bool> GetActivationForView(IActivatable view)
         }
     }
 }
-#endif
diff --git a/src/ReactiveUI.Uno/CoreDispatcherScheduler.cs b/src/ReactiveUI.Uno/CoreDispatcherScheduler.cs
@@ -0,0 +1,251 @@
+// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+using System.Reactive.Disposables;
+using System.Runtime.ExceptionServices;
+using System.Text;
+using System.Threading;
+
+using Windows.UI.Core;
+using Windows.UI.Xaml;
+
+namespace System.Reactive.Concurrency
+{
+    /// <summary>
+    /// Represents an object that schedules units of work on a <see cref="CoreDispatcher"/>.
+    /// </summary>
+    /// <remarks>
+    /// This scheduler type is typically used indirectly through the <see cref="Linq.DispatcherObservable.ObserveOnDispatcher{TSource}(IObservable{TSource})"/> and <see cref="Linq.DispatcherObservable.SubscribeOnDispatcher{TSource}(IObservable{TSource})"/> methods that use the current Dispatcher.
+    /// </remarks>
+    [CLSCompliant(false)]
+    public sealed class CoreDispatcherScheduler : LocalScheduler, ISchedulerPeriodic
+    {
+        /// <summary>
+        /// Constructs a <see cref="CoreDispatcherScheduler"/> that schedules units of work on the given <see cref="CoreDispatcher"/>.
+        /// </summary>
+        /// <param name="dispatcher">Dispatcher to schedule work on.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <c>null</c>.</exception>
+        public CoreDispatcherScheduler(CoreDispatcher dispatcher)
+        {
+            Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
+            Priority = CoreDispatcherPriority.Normal;
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="CoreDispatcherScheduler"/> that schedules units of work on the given <see cref="CoreDispatcher"/> with the given priority.
+        /// </summary>
+        /// <param name="dispatcher">Dispatcher to schedule work on.</param>
+        /// <param name="priority">Priority for scheduled units of work.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <c>null</c>.</exception>
+        public CoreDispatcherScheduler(CoreDispatcher dispatcher, CoreDispatcherPriority priority)
+        {
+            Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
+            Priority = priority;
+        }
+
+        /// <summary>
+        /// Gets the scheduler that schedules work on the <see cref="CoreDispatcher"/> associated with the current Window.
+        /// </summary>
+        public static CoreDispatcherScheduler Current
+        {
+            get
+            {
+                var window = Window.Current;
+                if (window == null)
+                {
+                    throw new InvalidOperationException("There is no current window that has been created.");
+                }
+
+                return new CoreDispatcherScheduler(window.Dispatcher);
+            }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="CoreDispatcher"/> associated with the <see cref="CoreDispatcherScheduler"/>.
+        /// </summary>
+        public CoreDispatcher Dispatcher { get; }
+
+        /// <summary>
+        /// Gets the priority at which work is scheduled.
+        /// </summary>
+        public CoreDispatcherPriority Priority { get; }
+
+        /// <summary>
+        /// Schedules an action to be executed on the dispatcher.
+        /// </summary>
+        /// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
+        /// <param name="state">State passed to the action to be executed.</param>
+        /// <param name="action">Action to be executed.</param>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="action"/> is <c>null</c>.</exception>
+        public override IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
+        {
+            if (action == null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var d = new SingleAssignmentDisposable();
+
+            var res = Dispatcher.RunAsync(Priority, () =>
+            {
+                if (!d.IsDisposed)
+                {
+                    try
+                    {
+                        d.Disposable = action(this, state);
+                    }
+                    catch (Exception ex)
+                    {
+                        //
+                        // Work-around for the behavior of throwing from RunAsync not propagating
+                        // the exception to the Application.UnhandledException event (as of W8RP)
+                        // as our users have come to expect from previous XAML stacks using Rx.
+                        //
+                        // If we wouldn't do this, there'd be an observable behavioral difference
+                        // between scheduling with TimeSpan.Zero or using this overload.
+                        //
+                        // For scheduler implementation guidance rules, see TaskPoolScheduler.cs
+                        // in System.Reactive.PlatformServices\Reactive\Concurrency.
+                        //
+                        var timer = new DispatcherTimer
+                        {
+                            Interval = TimeSpan.Zero
+                        };
+                        timer.Tick += (o, e) =>
+                        {
+                            timer.Stop();
+                            ExceptionDispatchInfo.Capture(ex).Throw();
+                        };
+
+                        timer.Start();
+                    }
+                }
+            });
+
+            return StableCompositeDisposable.Create(
+                d,
+                Disposable.Create(res, _ => _.Cancel())
+            );
+        }
+
+        /// <summary>
+        /// Schedules an action to be executed after <paramref name="dueTime"/> on the dispatcher, using a <see cref="DispatcherTimer"/> object.
+        /// </summary>
+        /// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
+        /// <param name="state">State passed to the action to be executed.</param>
+        /// <param name="action">Action to be executed.</param>
+        /// <param name="dueTime">Relative time after which to execute the action.</param>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="action"/> is <c>null</c>.</exception>
+        public override IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
+        {
+            if (action == null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var dt = Scheduler.Normalize(dueTime);
+            if (dt.Ticks == 0)
+            {
+                return Schedule(state, action);
+            }
+
+            return ScheduleSlow(state, dt, action);
+        }
+
+        private IDisposable ScheduleSlow<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
+        {
+            var d = new MultipleAssignmentDisposable();
+
+            var timer = new DispatcherTimer();
+
+            timer.Tick += (o, e) =>
+            {
+                var t = Interlocked.Exchange(ref timer, null);
+                if (t != null)
+                {
+                    try
+                    {
+                        d.Disposable = action(this, state);
+                    }
+                    finally
+                    {
+                        t.Stop();
+                        action = null;
+                    }
+                }
+            };
+
+            timer.Interval = dueTime;
+            timer.Start();
+
+            d.Disposable = Disposable.Create(() =>
+            {
+                var t = Interlocked.Exchange(ref timer, null);
+                if (t != null)
+                {
+                    t.Stop();
+                    action = (_, __) => Disposable.Empty;
+                }
+            });
+
+            return d;
+        }
+
+        /// <summary>
+        /// Schedules a periodic piece of work on the dispatcher, using a <see cref="DispatcherTimer"/> object.
+        /// </summary>
+        /// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
+        /// <param name="state">Initial state passed to the action upon the first iteration.</param>
+        /// <param name="period">Period for running the work periodically.</param>
+        /// <param name="action">Action to be executed, potentially updating the state.</param>
+        /// <returns>The disposable object used to cancel the scheduled recurring action (best effort).</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="action"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than <see cref="TimeSpan.Zero"/>.</exception>
+        public IDisposable SchedulePeriodic<TState>(TState state, TimeSpan period, Func<TState, TState> action)
+        {
+            //
+            // According to MSDN documentation, the default is TimeSpan.Zero, so that's definitely valid.
+            // Empirical observation - negative values seem to be normalized to TimeSpan.Zero, but let's not go there.
+            //
+            if (period < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(period));
+            }
+
+            if (action == null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var timer = new DispatcherTimer();
+
+            var state1 = state;
+
+            timer.Tick += (o, e) =>
+            {
+                state1 = action(state1);
+            };
+
+            timer.Interval = period;
+            timer.Start();
+
+            return Disposable.Create(() =>
+            {
+                var t = Interlocked.Exchange(ref timer, null);
+                if (t != null)
+                {
+                    t.Stop();
+                    action = _ => _;
+                }
+            });
+        }
+    }
+}
diff --git a/...orms/netstandard/PlatformRegistrations.cs → src/ReactiveUI.Uno/PlatformRegistrations.cs b/...orms/netstandard/PlatformRegistrations.cs → src/ReactiveUI.Uno/PlatformRegistrations.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Reactive.Concurrency;
+using System.Reactive.PlatformServices;
 
 namespace ReactiveUI
 {
@@ -22,8 +23,20 @@ public void Register(Action<Func<object>, Type> registerFunction)
             registerFunction(() => new DependencyObjectObservableForProperty(), typeof(ICreatesObservableForProperty));
             registerFunction(() => new BooleanToVisibilityTypeConverter(), typeof(IBindingTypeConverter));
             registerFunction(() => new AutoDataTemplateBindingHook(), typeof(IPropertyBindingHook));
-            RxApp.TaskpoolScheduler = WasmScheduler.Default;
-            RxApp.MainThreadScheduler = WasmScheduler.Default;
+
+#if NETSTANDARD
+            if (WasmPlatformEnlightenmentProvider.IsWasm)
+            {
+                RxApp.TaskpoolScheduler = WasmScheduler.Default;
+                RxApp.MainThreadScheduler = WasmScheduler.Default;
+            }
+            else
+#endif
+            {
+                RxApp.TaskpoolScheduler = TaskPoolScheduler.Default;
+                RxApp.MainThreadScheduler = new WaitForDispatcherScheduler(() => CoreDispatcherScheduler.Current);
+            }
+
             registerFunction(() => new WinRTAppDataDriver(), typeof(ISuspensionDriver));
         }
     }

diff --git a/src/ReactiveUI.Uno/ReactiveUI.Uno.csproj b/src/ReactiveUI.Uno/ReactiveUI.Uno.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="MSBuild.Sdk.Extras">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;MonoAndroid81</TargetFrameworks>
+    <TargetFrameworks>netstandard20;MonoAndroid81;MonoAndroid90;Xamarin.iOS10;Xamarin.Mac20</TargetFrameworks>
     <PackageId>ReactiveUI.Uno</PackageId>
     <Description>Uno Platform specific extensions for ReactiveUI</Description>
     <DefineConstants>HAS_UNO</DefineConstants>
-    <NoWarn>$(NoWarn);SA1648;CA1816;CA1001;CS0108;CS0114</NoWarn>
+    <NoWarn>$(NoWarn);SA1648;CA1816;CA1001;CS0108;CS0114;CS3021;CS1574;CA1303</NoWarn>
   </PropertyGroup>  
 
   <ItemGroup>
@@ -18,22 +18,21 @@
     <!-- Include all the files under RxUI, due to the way Uno works we need to duplicate -->
     <Compile Include="..\ReactiveUI\**\*.cs" LinkBase="ReactiveUI" />
 
-    <!-- Remove all the directories from compile, we will readd some of them based on the platform. -->
-    <Compile Remove=".\Platforms\**\*.cs" />
-    <Compile Remove=".\system.reactive\**\*.cs" />
-    <Compile Remove=".\Platforms\**\*.cs" />
-    <Compile Remove="..\ReactiveUI\Platforms\**\*.cs" />
+    <Compile Remove="..\ReactiveUI\Platforms\**\*.*" />
     <Compile Remove="..\ReactiveUI\**\bin\**\*.*" />
     <Compile Remove="..\ReactiveUI\**\obj\**\*.*" />
 
-    <Compile Include="..\ReactiveUI\Platforms\windows-common\**\*.cs" LinkBase="ReactiveUI\Platforms\windows-common" />
+    <Compile Remove=".\Platforms\**\*.*" />
+
     <Compile Include="..\ReactiveUI\Platforms\uap\TransitioningContentControl.Empty.cs" LinkBase="ReactiveUI\Platforms\uap" />
     <Compile Include="..\ReactiveUI\Platforms\uap\DependencyObjectObservableForProperty.cs" LinkBase="ReactiveUI\Platforms\uap" />
+    <Compile Include="..\ReactiveUI\Platforms\windows-common\**\*.cs" LinkBase="ReactiveUI\Platforms\windows-common" />
+
   	<None Include="..\ReactiveUI\Platforms\uap\ReactiveUI.rd.xml" PackagePath="lib\uap\ReactiveUI\Properties\ReactiveUI.rd.xml" Pack="true" />
   </ItemGroup>
 
   <ItemGroup Condition=" $(TargetFramework.StartsWith('netstandard')) ">
-    <PackageReference Include="Reactive.Wasm" Version="1.0.1-preview.3" />
+    <PackageReference Include="Reactive.Wasm" Version="1.0.1-preview.8" />
     <Compile Include=".\Platforms\netstandard\**\*.cs" />
   </ItemGroup>
 

diff --git a/src/ReactiveUI/Platforms/uap/TransitioningContentControl.Empty.cs b/src/ReactiveUI/Platforms/uap/TransitioningContentControl.Empty.cs
@@ -12,7 +12,11 @@ namespace ReactiveUI
     /// A control with a single transition.
     /// </summary>
     [SuppressMessage("Design", "CA1010:Collections should implement generic interface", Justification = "Deliberate usage")]
-    public class TransitioningContentControl : ContentControl
+    public
+#if HAS_UNO
+        partial
+#endif
+        class TransitioningContentControl : ContentControl
     {
     }
 }
diff --git a/src/ReactiveUI/Platforms/windows-common/ReactivePage.cs b/src/ReactiveUI/Platforms/windows-common/ReactivePage.cs
@@ -78,9 +78,13 @@ namespace ReactiveUI
     /// The type of the view model backing the view.
     /// </typeparam>
     [SuppressMessage("Design", "CA1010:Collections should implement generic interface", Justification = "Deliberate usage")]
-    public abstract class ReactivePage<TViewModel> :
-        Page, IViewFor<TViewModel>
-        where TViewModel : class
+    public abstract
+#if HAS_UNO
+        partial
+#endif
+        class ReactivePage<TViewModel> :
+            Page, IViewFor<TViewModel>
+            where TViewModel : class
     {
         /// <summary>
         /// The view model dependency property.