Merge pull request #130 from Unity-Technologies/siyaoH/1.17/clean

Siyao h/1.17/clean

Samples/UIWidgetsSamples_2019_4/Assets/CountDemo.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.cupertino;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using Text = Unity.UIWidgets.widgets.Text;

Samples/UIWidgetsSamples_2019_4/Assets/Editor/EditorWindowSample/GalleryMain.cs

 using System.Collections.Generic;
 using UIWidgetsGallery.gallery;
 using Unity.UIWidgets.Editor;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.widgets;
 using UnityEditor;
 using UnityEngine;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/BottomAppBarSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/DividerAndButton.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/HoverSample.cs

-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialAppBarSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialButtonSample.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialInkWellSample.cs

-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialNavigationBarSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialSliderSample.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialTabBarSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/MaterialThemeSample.cs

 using uiwidgets;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/NavigatorPopSample.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.async;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/NetWorkImageSample.cs

 using System.Collections;
 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/ReorderableListSample.cs

 using System.Collections.Generic;
 using System.Linq;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/MaterialSample/TableSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/Script/CountTest.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;

Samples/UIWidgetsSamples_2019_4/Assets/Script/ImageTest.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;

Samples/UIWidgetsSamples_2019_4/Assets/Script/TextFieldTest.cs

-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.widgets;
 using ui_ = Unity.UIWidgets.widgets.ui_;
 using Unity.UIWidgets.cupertino;

Samples/UIWidgetsSamples_2019_4/Assets/Script/TextTest.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 //using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/GalleryMain.cs

 using System.Collections.Generic;
 using UIWidgetsGallery.gallery;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.widgets;
 
 namespace UIWidgetsGallery

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/cupertino/cupertino_refresh_demo.cs

 using System;
 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.cupertino;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/cupertino/cupertino_segmented_control_demo.cs

 using System;
 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.cupertino;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/bottom_navigation_demo.cs

 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/cards_demo.cs

                                 // of the Material and display ink effects above it. Using a
                                 // standard Image will obscure the ink splash.
                                 child: Ink.image(
-                                    image: new FileImage(this.destination.assetPackage + "/" +
-                                                         this.destination.assetName),
+                                    image: new FileImage(System.IO.Path.Combine(destination.assetPackage,
+                                                         destination.assetName)),
                                     fit: BoxFit.cover,
                                     child: new Container()
                                 )

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/date_and_time_picker_demo.cs

 using System.Linq;
 using uiwidgets;
 using UIWidgetsGallery.gallery;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/leave_behind_demo.cs

 using System.Linq;
 using uiwidgets;
 using UIWidgetsGallery.gallery;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/overscroll_demo.cs

 using System;
 using System.Collections.Generic;
 using UIWidgetsGallery.gallery;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/material/text_form_field_demo.cs

 using uiwidgets;
 using UIWidgets.Runtime.material;
 using UIWidgetsGallery.gallery;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.material;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/shrine/expanding_bottom_sheet.cs

 using System.Xml.Serialization;
 using UIWidgetsGallery.demo.shrine.model;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/shrine/model/scoped_model.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/gallery/app.cs

 using System.Collections.Generic;
 using uiwidgets;
 using UIWidgetsGallery.demo.shrine.model;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/gallery/demo.cs

 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/gallery/home.cs

 using System.Linq;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.material;

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/gallery/updater.cs

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/CustomPaintSample.cs

-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/DragDropSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/ExpansionPanelSample.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/HttpRequestSample.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.rendering;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/ImageFormatSample.cs

 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/LongPressSample.cs

 using uiwidgets;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.widgets;
 using UnityEngine;
 using Color = Unity.UIWidgets.ui.Color;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/NavigationSample.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.material;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/PageViewSample.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using ui_ = Unity.UIWidgets.widgets.ui_;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/ScrollbarSample.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/UIWidgetsSamplePanel.cs

 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.widgets;
 
 namespace UIWidgetsSample {

com.unity.uiwidgets/Editor/UIWidgetsEditorPanel.cs

 using System.Collections;
 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
-using Font = Unity.UIWidgets.engine2.Font;
+using Font = Unity.UIWidgets.engine.Font;
 using Rect = UnityEngine.Rect;
 
 namespace Unity.UIWidgets.Editor {

com.unity.uiwidgets/Editor/UIWidgetsPanelEditor.cs

 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.foundation;
 using UnityEditor;
 using UnityEditor.UI;

com.unity.uiwidgets/Runtime/Plugins/Android/InputConnectionAdaptor.java.meta

   isPreloaded: 0
   isOverridable: 1
   isExplicitlyReferenced: 0
+  validateReferences: 1
   platformData:
   - first:
       Android: Android

com.unity.uiwidgets/Runtime/Plugins/Android/TextInputPlugin.java.meta

   isPreloaded: 0
   isOverridable: 1
   isExplicitlyReferenced: 0
+  validateReferences: 1
   platformData:
   - first:
       Android: Android

com.unity.uiwidgets/Runtime/Plugins/Android/TextInputView.java.meta

   isPreloaded: 0
   isOverridable: 1
   isExplicitlyReferenced: 0
+  validateReferences: 1
   platformData:
   - first:
       Android: Android

com.unity.uiwidgets/Runtime/animation/animation_controller.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.physics;
 using Unity.UIWidgets.ui;
-using Ticker = Unity.UIWidgets.scheduler2.Ticker;
-using TickerFuture = Unity.UIWidgets.scheduler2.TickerFuture;
-using TickerProvider = Unity.UIWidgets.scheduler2.TickerProvider;
+using Ticker = Unity.UIWidgets.scheduler.Ticker;
+using TickerFuture = Unity.UIWidgets.scheduler.TickerFuture;
+using TickerProvider = Unity.UIWidgets.scheduler.TickerProvider;
 
 namespace Unity.UIWidgets.animation {
     enum _AnimationDirection {

com.unity.uiwidgets/Runtime/animation/tween_sequence.cs

 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using System;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;

com.unity.uiwidgets/Runtime/async/timer.cs

-/*
-using System.Collections.Generic;
-using Unity.UIWidgets.foundation;
+using System.Runtime.InteropServices;
+using AOT;
+using Unity.UIWidgets.ui;
-#if UNITY_EDITOR
-using UnityEditor;
-
-#endif
-        public abstract void cancel();
-
-        public void Dispose() {
-            cancel();
-        }
-
-        public static float timeSinceStartup {
-            get {
-#if UNITY_EDITOR
-                return (float) EditorApplication.timeSinceStartup;
-#else
-                return Time.realtimeSinceStartup;
-#endif
+        public static Timer create(TimeSpan duration, ZoneCallback callback) {
+            if (Zone.current == Zone.root) {
+                return Zone.current.createTimer(duration, callback);
-        }
-        public static TimeSpan timespanSinceStartup {
-            get { return TimeSpan.FromSeconds(timeSinceStartup); }
+            return Zone.current
+                .createTimer(duration, Zone.current.bindCallbackGuarded(callback));
-        static readonly object _syncObj = new object();
+       
-        static LinkedList<Action> _callbacks = new LinkedList<Action>();
-
-        public static void runInMainFromFinalizer(Action callback) {
-            lock (_syncObj) {
-                _callbacks.AddLast(callback);
-            }
+        public static Timer create(TimeSpan duration, Action callback) {
+            return create(duration, () => {
+                callback.Invoke();
+                return null;
+            });
-        internal static void update() {
-            LinkedList<Action> callbacks;
-
-            lock (_syncObj) {
-                if (_callbacks.isEmpty()) {
-                    return;
-                }
-
-                callbacks = _callbacks;
-                _callbacks = new LinkedList<Action>();
+        public static Timer periodic(TimeSpan duration, ZoneUnaryCallback callback) {
+            if (Zone.current == Zone.root) {
+                return Zone.current.createPeriodicTimer(duration, callback);
-            foreach (var callback in callbacks) {
-                try {
-                    callback();
-                }
-                catch (Exception ex) {
-                    D.logError("Error to execute runInMain callback: ", ex);
-                }
-            }
+            var boundCallback = Zone.current.bindUnaryCallbackGuarded(callback);
+            return Zone.current.createPeriodicTimer(duration, boundCallback);
-    }
-    public class TimerProvider {
-        readonly PriorityQueue<TimerImpl> _queue;
-
-        public TimerProvider() {
-            _queue = new PriorityQueue<TimerImpl>();
+        public static void run(ZoneCallback callback) {
+            create(TimeSpan.Zero, callback);
-        public Timer runInMain(Action callback) {
-            var timer = new TimerImpl(callback);
+        public abstract void cancel();
-            lock (_queue) {
-                _queue.enqueue(timer);
-            }
-
-            return timer;
+        public void Dispose() {
+            cancel();
-        public Timer run(TimeSpan duration, Action callback) {
-            var timer = new TimerImpl(duration, callback);
+        public abstract long tick { get; }
+
+        public abstract bool isActive { get; }
-            lock (_queue) {
-                _queue.enqueue(timer);
-            }
+        internal static Timer _createTimer(TimeSpan duration, ZoneCallback callback) {
+            return _Timer._createTimer(_ => callback(), (int) duration.TotalMilliseconds, false);
+        }
-            return timer;
+        internal static Timer _createPeriodicTimer(
+            TimeSpan duration, ZoneUnaryCallback callback) {
+            return _Timer._createTimer(callback, (int) duration.TotalMilliseconds, true);
+    }
-        public Timer periodic(TimeSpan duration, Action callback) {
-            var timer = new TimerImpl(duration, callback, periodic: true);
+    class _Timer : Timer {
+        long _tick = 0;
-            lock (_queue) {
-                _queue.enqueue(timer);
-            }
+        ZoneUnaryCallback _callback;
+        long _wakeupTime;
+        readonly int _milliSeconds;
+        readonly bool _repeating;
-            return timer;
+        _Timer(ZoneUnaryCallback callback, long wakeupTime, int milliSeconds, bool repeating) {
+            _callback = callback;
+            _wakeupTime = wakeupTime;
+            _milliSeconds = milliSeconds;
+            _repeating = repeating;
-
-        static readonly List<TimerImpl> _timers = new List<TimerImpl>();
-        static readonly List<TimerImpl> _appendList = new List<TimerImpl>();
-        public void update(Action flushMicroTasks = null) {
-            var now = Timer.timeSinceStartup;
-
-            _timers.Clear();
-            _appendList.Clear();
-            lock (_queue) {
-                while (_queue.count > 0 && _queue.peek().deadline <= now) {
-                    var timer = _queue.dequeue();
-                    _timers.Add(timer);
-                }
+        public static TimeSpan timespanSinceStartup {
+            get { return TimeSpan.FromMilliseconds(UIMonoState_timerMillisecondClock()); }
+        }
+
+        internal static _Timer _createTimer(ZoneUnaryCallback callback, int milliSeconds, bool repeating) {
+            if (milliSeconds < 0) {
+                milliSeconds = 0;
-            if (_timers.Count != 0) {
-                foreach (var timer in _timers) {
-                    if (flushMicroTasks != null) {
-                        flushMicroTasks();
-                    }
+            long now = UIMonoState_timerMillisecondClock();
+            long wakeupTime = (milliSeconds == 0) ? now : (now + 1 + milliSeconds);
-                    timer.invoke();
-                    if (timer.periodic && !timer.done) {
-                        _appendList.Add(timer);
-                    }
-                }
-            }
+            _Timer timer = new _Timer(callback, wakeupTime, milliSeconds, repeating);
+            timer._enqueue();
-            if (_appendList.Count != 0) {
-                lock (_queue) {
-                    foreach (var timer in _appendList) {
-                        _queue.enqueue(timer);
-                    }
-                }
-            }
+            return timer;
-        class TimerImpl : Timer, IComparable<TimerImpl> {
-            float _deadline;
-            readonly Action _callback;
-            bool _done;
+        public override void cancel() {
+            _callback = null;
+        }
-            public readonly bool periodic;
-            readonly TimeSpan _interval;
+        public override bool isActive => _callback != null;
-            public TimerImpl(TimeSpan duration, Action callback, bool periodic = false) {
-                _deadline = timeSinceStartup + (float) duration.TotalSeconds;
-                _callback = callback;
-                _done = false;
+        public override long tick => _tick;
-                this.periodic = periodic;
-                if (periodic) {
-                    _interval = duration;
-                }
+        void _advanceWakeupTime() {
+            if (_milliSeconds > 0) {
+                _wakeupTime += _milliSeconds;
-
-            public TimerImpl(Action callback) {
-                _deadline = 0;
-                _callback = callback;
-                _done = false;
+            else {
+                _wakeupTime = UIMonoState_timerMillisecondClock();
+        }
-            public float deadline {
-                get { return _deadline; }
-            }
+        const long MILLI_TO_NANO = 1000000L;
+        
+        void _enqueue() {
+            Isolate.ensureExists();
+            
+            GCHandle callbackHandle = GCHandle.Alloc(this);
+            UIMonoState_postTaskForTime(_postTaskForTime, (IntPtr) callbackHandle, _wakeupTime * MILLI_TO_NANO);
+        }
-            public override void cancel() {
-                _done = true;
-            }
+        [MonoPInvokeCallback(typeof(UIMonoState_postTaskForTimeCallback))]
+        static void _postTaskForTime(IntPtr callbackHandle) {
+            GCHandle timerHandle = (GCHandle) callbackHandle;
+            var timer = (_Timer) timerHandle.Target;
+            timerHandle.Free();
-            public bool done {
-                get { return _done; }
-            }
-
-            public void invoke() {
-                if (_done) {
-                    return;
-                }
+            try {
+                if (timer._callback != null) {
+                    var callback = timer._callback;
+                    if (!timer._repeating) {
+                        timer._callback = null;
+                    }
+                    else if (timer._milliSeconds > 0) {
+                        var ms = timer._milliSeconds;
+                        long overdue = UIMonoState_timerMillisecondClock() - timer._wakeupTime;
+                        if (overdue > ms) {
+                            long missedTicks = overdue / ms;
+                            timer._wakeupTime += missedTicks * ms;
+                            timer._tick += missedTicks;
+                        }
+                    }
-                var now = timeSinceStartup;
-                if (!periodic) {
-                    _done = true;
-                }
+                    timer._tick += 1;
-                try {
-                    _callback();
-                }
-                catch (Exception ex) {
-                    D.logError("Error to execute timer callback: ", ex);
-                }
+                    callback(timer);
-                if (periodic) {
-                    _deadline = now + (float) _interval.TotalSeconds;
+                    if (timer._repeating && (timer._callback != null)) {
+                        timer._advanceWakeupTime();
+                        timer._enqueue();
+                    }
-
-            public int CompareTo(TimerImpl other) {
-                return deadline.CompareTo(other.deadline);
+            catch (Exception ex) {
+                Debug.LogException(ex);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern long UIMonoState_timerMillisecondClock();
+
+        delegate void UIMonoState_postTaskForTimeCallback(IntPtr callbackHandle);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIMonoState_postTaskForTime(UIMonoState_postTaskForTimeCallback callback,
+            IntPtr callbackHandle, long targetTimeNanos);
-}*/
+}

com.unity.uiwidgets/Runtime/cupertino/button.cs

 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;
-using TickerFuture = Unity.UIWidgets.scheduler2.TickerFuture;
+using TickerFuture = Unity.UIWidgets.scheduler.TickerFuture;
 
 namespace Unity.UIWidgets.cupertino {
     public class CupertinoButtonUtils {

com.unity.uiwidgets/Runtime/cupertino/context_menu.cs

 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using System;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;

com.unity.uiwidgets/Runtime/cupertino/context_menu_action.cs

 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;

com.unity.uiwidgets/Runtime/cupertino/date_picker.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/cupertino/localization.cs

 using System;
 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

com.unity.uiwidgets/Runtime/cupertino/refresh.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/cupertino/route.cs

 using System;
 using System.Collections.Generic;
 using uiwidgets;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;

com.unity.uiwidgets/Runtime/cupertino/scrollbar.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;

com.unity.uiwidgets/Runtime/cupertino/slider.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/cupertino/switch.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/engine/DisplayMetrics.cs

-using System;
 using System.Runtime.InteropServices;
 using Unity.UIWidgets.ui;
 using UnityEngine;
         public float padding_right;
     }
 
-    public static class DisplayMetricsProvider {
-        public static Func<DisplayMetrics> provider = () => new PlayerDisplayMetrics();
-    }
-
-    public interface DisplayMetrics {
-        void OnEnable();
-        void OnGUI();
-        void Update();
-        void onViewMetricsChanged();
-
-        float devicePixelRatio { get; }
-
-        viewMetrics viewMetrics { get; }
-
-        WindowPadding viewPadding { get; }
-
-        WindowPadding viewInsets { get; }
-    }
-
-    public class PlayerDisplayMetrics : DisplayMetrics {
-        float _devicePixelRatio = 0;
-        viewMetrics? _viewMetrics = null;
-
-        public void OnEnable() {
-        }
-
-        public void OnGUI() {
-        }
-
-        public void Update() {
-            
-        }
-
-        public void onViewMetricsChanged() {
-            //view metrics marks dirty
-            _viewMetrics = null;
-        }
+    public class DisplayMetrics {
+        float _devicePixelRatioByDefault;
-        public float devicePixelRatio {
+        public float DevicePixelRatioByDefault {
-                if (_devicePixelRatio > 0) {
-                    return _devicePixelRatio;
+                if (_devicePixelRatioByDefault > 0) {
+                    return _devicePixelRatioByDefault;
-                _devicePixelRatio = AndroidDevicePixelRatio();
-#endif
-
-#if UNITY_WEBGL
-                this._devicePixelRatio = UIWidgetsWebGLDevicePixelRatio();
+                _devicePixelRatioByDefault = AndroidDevicePixelRatio();
-                //this._devicePixelRatio = IOSDeviceScaleFactor();
+                _devicePixelRatioByDefault = IOSDeviceScaleFactor();
-                if (_devicePixelRatio <= 0) {
-                    _devicePixelRatio = 1;
+                if (_devicePixelRatioByDefault <= 0) {
+                    _devicePixelRatioByDefault = 1;
-                return _devicePixelRatio;
+                return _devicePixelRatioByDefault;
-
+        
         public WindowPadding viewPadding {
             get {
                 return new WindowPadding(viewMetrics.padding_left,
             }
         }
 
+        private viewMetrics? _viewMetrics;
+
         public viewMetrics viewMetrics {
             get {
                 if (_viewMetrics != null) {
-#if UNITY_ANDROID
-
+#if UNITY_ANDROID && !UNITY_EDITOR
                 using (
                     AndroidJavaClass viewController =
                         new AndroidJavaClass("com.unity.uiwidgets.plugin.UIWidgetsViewController")
                         padding_bottom = padding_bottom
                     };
                 }
-#elif UNITY_WEBGL
-                this._viewMetrics = new viewMetrics {
-                    insets_bottom = 0,
-                    insets_left = 0,
-                    insets_right = 0,
-                    insets_top = 0,
-                    padding_left = 0,
-                    padding_top = 0,
-                    padding_right = 0,
-                    padding_bottom = 0
-                };
-#elif UNITY_IOS
-                //viewMetrics metrics = IOSGetViewportPadding();
-                //this._viewMetrics = metrics;
+#elif !UNITY_EDITOR && UNITY_IOS
+                viewMetrics metrics = IOSGetViewportPadding();
+                this._viewMetrics = metrics;
 #else
                 _viewMetrics = new viewMetrics {
                     insets_bottom = 0,
                 return _viewMetrics.Value;
             }
         }
+        
+        public void onViewMetricsChanged() {
+            //view metrics marks dirty
+            _viewMetrics = null;
+        }
 
 #if UNITY_ANDROID
         static float AndroidDevicePixelRatio() {
         }
 #endif
 
-#if UNITY_WEBGL
-        [DllImport("__Internal")]
-        static extern float UIWidgetsWebGLDevicePixelRatio();
-#endif
-
-        //[DllImport("__Internal")]
-        //static extern float IOSDeviceScaleFactor();
+        [DllImport("__Internal")]
+        static extern float IOSDeviceScaleFactor();
-		//[DllImport("__Internal")]
-		//static extern viewMetrics IOSGetViewportPadding();
+        [DllImport("__Internal")]
+        static extern viewMetrics IOSGetViewportPadding();
+
     }
 }

com.unity.uiwidgets/Runtime/engine/UIWidgetsMessageManager.cs

 using System.Collections.Generic;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.external.simplejson;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.service;

com.unity.uiwidgets/Runtime/engine/UIWidgetsPanel.cs

-/*using System.Collections.Generic;
-using Unity.UIWidgets.async;
-using Unity.UIWidgets.editor;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.UIWidgets.engine;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.external.simplejson;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using UnityEngine.UI;
 using RawImage = UnityEngine.UI.RawImage;
-using Rect = UnityEngine.Rect;
-using Texture = UnityEngine.Texture;
-    public class UIWidgetWindowAdapter : WindowAdapter {
-        readonly UIWidgetsPanel _uiWidgetsPanel;
-        bool _needsPaint;
+    public enum UIWidgetsWindowType {
+        InvalidPanel = 0,
+        GameObjectPanel = 1,
+        EditorWindowPanel = 2
+    }
+    [Serializable]
+    public struct Font {
+        public string asset;
+        public int weight;
+    }
-        protected override void updateSafeArea() {
-            _padding = _uiWidgetsPanel.viewPadding;
-            _viewInsets = _uiWidgetsPanel.viewInsets;
-        }
+    [Serializable]
+    public struct TextFont {
+        public string family;
+        [SerializeField] public Font[] fonts;
+    }
-        protected override bool hasFocus() {
-            return EventSystem.current != null &&
-                   EventSystem.current.currentSelectedGameObject == _uiWidgetsPanel.gameObject;
-        }
+    public interface IUIWidgetsWindow {
+        Offset windowPosToScreenPos(Offset offset);
-        public override void scheduleFrame(bool regenerateLayerTree = true) {
-            base.scheduleFrame(regenerateLayerTree);
-            _needsPaint = true;
-        }
+        void startCoroutine(IEnumerator routing);
-        public UIWidgetWindowAdapter(UIWidgetsPanel uiWidgetsPanel) {
-            _uiWidgetsPanel = uiWidgetsPanel;
-        }
+        bool isActive();
+
+        void mainEntry();
+        void onNewFrameScheduled();
-        public override void OnGUI(Event evt) {
-            if (displayMetricsChanged()) {
-                _needsPaint = true;
+        UIWidgetsWindowType getWindowType();
+    }
+    public class Configurations {
+        
+        private Dictionary<string, TextFont> _textFonts = new Dictionary<string, TextFont>();
+
+        public void Clear() {
+            _textFonts.Clear();
+        }
+        public void AddFont(string family, TextFont font) {
+           _textFonts[key: family] = font;
+        }
+        public object fontsToObject() {
+            Dictionary<string, TextFont> settings = _textFonts;
+            if (settings == null || settings.Count == 0) {
+                return null;
-            if (evt.type == EventType.Repaint) {
-                if (!_needsPaint) {
-                    return;
+            var result = new object[settings.Count];
+            var i = 0;
+            foreach (var setting in settings) {
+                var font = new Dictionary<string, object>();
+                font.Add("family", value: setting.Key);
+                var dic = new Dictionary<string, object>[setting.Value.fonts.Length];
+                for (var j = 0; j < setting.Value.fonts.Length; j++) {
+                    dic[j] = new Dictionary<string, object>();
+                    if (setting.Value.fonts[j].asset.Length > 0) {
+                        dic[j].Add("asset", value: setting.Value.fonts[j].asset);
+                    }
+
+                    if (setting.Value.fonts[j].weight > 0) {
+                        dic[j].Add("weight", value: setting.Value.fonts[j].weight);
+                    }
-                _needsPaint = false;
+                font.Add("fonts", value: dic);
+                result[i] = font;
+                i++;
-            base.OnGUI(evt);
+            return result;
+    }
-        protected override Surface createSurface() {
-            return new WindowSurfaceImpl(_uiWidgetsPanel.applyRenderTexture);
-        }
+    public partial class UIWidgetsPanel : RawImage, IUIWidgetsWindow {
+        static List<UIWidgetsPanel> panels = new List<UIWidgetsPanel>();
-        public override GUIContent titleContent {
-            get { return new GUIContent(_uiWidgetsPanel.gameObject.name); }
-        }
+        static public Isolate anyIsolate {
+            get {
+                if (panels.Count == 0) {
+                    return null;
+                }
-        protected override float queryDevicePixelRatio() {
-            return _uiWidgetsPanel.devicePixelRatio;
-        }
-        
-        protected override int queryAntiAliasing() {
-            return _uiWidgetsPanel.antiAliasing;
+                return panels[0]._wrapper.isolate;
+            }
-        protected override Vector2 queryWindowSize() {
-            var rect = _uiWidgetsPanel.rectTransform.rect;
-            // Here we use ReferenceEquals instead of "==" due to
-            // https://blogs.unity3d.com/2014/05/16/custom-operator-should-we-keep-it/
-            // In short, "==" is overloaded for UnityEngine.Object and will bring performance issues
-            if (!ReferenceEquals(_uiWidgetsPanel.canvas, null)) {
-                var size = new Vector2(rect.width, rect.height) *
-                           _uiWidgetsPanel.canvas.scaleFactor / _uiWidgetsPanel.devicePixelRatio;
-                size.x = Mathf.Round(size.x);
-                size.y = Mathf.Round(size.y);
-                return size;
-            }
+        static void registerPanel(UIWidgetsPanel panel) {
+            panels.Add(panel);
+        }
-            return new Vector2(0, 0);
+        static void unregisterPanel(UIWidgetsPanel panel) {
+            panels.Remove(panel);
-        public Offset windowPosToScreenPos(Offset windowPos) {
-            Camera camera = null;
-            var canvas = _uiWidgetsPanel.canvas;
-            if (canvas.renderMode != RenderMode.ScreenSpaceCamera) {
-                camera = canvas.GetComponent<GraphicRaycaster>().eventCamera;
-            }
+        float _devicePixelRatioOverride;
-            var pos = new Vector2(windowPos.dx, windowPos.dy);
-            pos = pos * queryDevicePixelRatio() / _uiWidgetsPanel.canvas.scaleFactor;
-            var rectTransform = _uiWidgetsPanel.rectTransform;
-            var rect = rectTransform.rect;
-            pos.x += rect.min.x;
-            pos.y = rect.max.y - pos.y;
-            var worldPos = rectTransform.TransformPoint(new Vector2(pos.x, pos.y));
-            var screenPos = RectTransformUtility.WorldToScreenPoint(camera, worldPos);
-            return new Offset(screenPos.x, Screen.height - screenPos.y);
-        }
-    }
+        public bool hardwareAntiAliasing;
-    [RequireComponent(typeof(RectTransform))]
-    public class UIWidgetsPanel : RawImage, IPointerDownHandler, IPointerUpHandler, IDragHandler,
-        IPointerEnterHandler, IPointerExitHandler, WindowHost {
-        static Event _repaintEvent;
+        public TextFont[] fonts;
-        [Tooltip("set to zero if you want to use the default device pixel ratio of the target platforms; otherwise the " +
-                 "device pixel ratio will be forced to the given value on all devices.")]
-        [SerializeField] protected float devicePixelRatioOverride;
-        
-        [Tooltip("set to true will enable the hardware anti-alias feature, which will improve the appearance of the UI greatly but " +
-                 "making it much slower. Enable it only when seriously required.")]
-        [SerializeField] protected bool hardwareAntiAliasing = false;
-        WindowAdapter _windowAdapter;
-        Texture _texture;
-        Vector2 _lastMouseMove;
+        Configurations _configurations;
-        readonly HashSet<int> _enteredPointers = new HashSet<int>();
-
-        bool _viewMetricsCallbackRegistered;
+        UIWidgetsPanelWrapper _wrapper;
-        bool _mouseEntered {
-            get { return !_enteredPointers.isEmpty(); }
+        int _currentWidth {
+            get { return Mathf.RoundToInt(rectTransform.rect.width * canvas.scaleFactor); }
-        DisplayMetrics _displayMetrics;
-
-        const int mouseButtonNum = 3;
-
-        void _handleViewMetricsChanged(string method, List<JSONNode> args) {
-            _windowAdapter?.onViewMetricsChanged();
-            _displayMetrics?.onViewMetricsChanged();
+        int _currentHeight {
+            get { return Mathf.RoundToInt(rectTransform.rect.height * canvas.scaleFactor); }
-        protected virtual void InitWindowAdapter() {
-            D.assert(_windowAdapter == null);
-            _windowAdapter = new UIWidgetWindowAdapter(this);
+        float _currentDevicePixelRatio {
+            get {
+#if !UNITY_EDITOR
+                return _wrapper.displayMetrics.DevicePixelRatioByDefault;
+#endif
+                var currentDpi = Screen.dpi;
+                if (currentDpi == 0) {
+                    currentDpi = canvas.GetComponent<CanvasScaler>().fallbackScreenDPI;
+                }
-            _windowAdapter.OnEnable();
+                return currentDpi / 96;
+            }
-        protected override void OnEnable() {
-            base.OnEnable();
-
-            //Disable the default touch -> mouse event conversion on mobile devices
-            Input.simulateMouseWithTouches = false;
-
-            _displayMetrics = DisplayMetricsProvider.provider();
-            _displayMetrics.OnEnable();
+        bool _viewMetricsCallbackRegistered;
-            _enteredPointers.Clear();
+        void _handleViewMetricsChanged(string method, List<JSONNode> args) {
+            using (Isolate.getScope(anyIsolate)) {
+                _wrapper.displayMetrics.onViewMetricsChanged();
+                Window.instance.updateSafeArea();
+                Window.instance.onMetricsChanged?.Invoke();
+            }
+        }
+        
+        protected virtual void Update() {
+            UIWidgetsMessageManager.ensureUIWidgetsMessageManagerIfNeeded();
-            if (_repaintEvent == null) {
-                _repaintEvent = new Event {type = EventType.Repaint};
+            if (!_viewMetricsCallbackRegistered) {
+                _viewMetricsCallbackRegistered = true;
+                UIWidgetsMessageManager.instance?.AddChannelMessageDelegate("ViewportMetricsChanged",
+                    _handleViewMetricsChanged);
-            InitWindowAdapter();
+            Input_Update();
+        }
-            Widget root;
-            using (_windowAdapter.getScope()) {
-                root = createWidget();
-            }
+#if !UNITY_EDITOR && UNITY_ANDROID
+        bool AndroidInitialized = true;
-            _windowAdapter.attachRootWidget(root);
-            _lastMouseMove = Input.mousePosition;
+        IEnumerator DoInitAndroid() {
+            yield return new WaitForEndOfFrame();
+            AndroidPlatformUtil.Init();
+            yield return new WaitForEndOfFrame();
+            enabled = true;
-
-        public float devicePixelRatio {
-            get {
-                return devicePixelRatioOverride > 0
-                    ? devicePixelRatioOverride
-                    : _displayMetrics.devicePixelRatio;
+        bool IsAndroidInitialized() {
+            if (AndroidInitialized) {
+                enabled = false;
+                AndroidInitialized = false;
+                startCoroutine(DoInitAndroid());
+                return false;
+            return true;
-        
-        public int antiAliasing {
-            get { return hardwareAntiAliasing ? Window.defaultAntiAliasing : 0; }
-        }
+#endif
-        public WindowPadding viewPadding {
-            get { return _displayMetrics.viewPadding; }
-        }
-
-        public WindowPadding viewInsets {
-            get { return _displayMetrics.viewInsets; }
+        protected void OnEnable() {
+#if !UNITY_EDITOR && UNITY_ANDROID
+            if (!IsAndroidInitialized()) {return ;}
+#endif
+#if !UNITY_EDITOR && UNITY_IOS
+            //the hook API cannot be automatically called on IOS, so we need try hook it here
+            Hooks.tryHook();
+#endif
+            base.OnEnable();
+            
+            D.assert(_wrapper == null);
+            _configurations = new Configurations();
+            _wrapper = new UIWidgetsPanelWrapper();
+            onEnable();
+            if (fonts != null && fonts.Length > 0) {
+                foreach (var font in fonts) {
+                    AddFont(family: font.family, font: font);
+                }
+            }
+            _wrapper.Initiate(this, width: _currentWidth, height: _currentHeight, dpr: _currentDevicePixelRatio,
+                _configurations: _configurations);
+            _configurations.Clear();
+            texture = _wrapper.renderTexture;
+            Input_OnEnable();
+            registerPanel(this);
-            D.assert(_windowAdapter != null);
-            _windowAdapter.OnDisable();
-            _windowAdapter = null;
+            unregisterPanel(this);
+            D.assert(_wrapper != null);
+            _wrapper?.Destroy();
+            _wrapper = null;
+            texture = null;
+            Input_OnDisable();
-        protected virtual Widget createWidget() {
-            return null;
+        protected virtual void OnGUI() {
+            Input_OnGUI();
-        public void recreateWidget() {
-            Widget root;
-            using (_windowAdapter.getScope()) {
-                root = createWidget();
+        protected override void OnRectTransformDimensionsChange() {
+            if (_wrapper != null && _wrapper.didDisplayMetricsChanged(width: _currentWidth, height: _currentHeight,
+                dpr: _currentDevicePixelRatio)) {
+                _wrapper.OnDisplayMetricsChanged(width: _currentWidth, height: _currentHeight,
+                    dpr: _currentDevicePixelRatio);
+                texture = _wrapper.renderTexture;
-
-            _windowAdapter.attachRootWidget(root);
-        internal void applyRenderTexture(Rect screenRect, Texture texture, Material mat) {
-            this.texture = texture;
-            material = mat;
+        public UIWidgetsWindowType getWindowType() {
+            return UIWidgetsWindowType.GameObjectPanel;
-        protected virtual void Update() {
-            _displayMetrics.Update();
-            UIWidgetsMessageManager.ensureUIWidgetsMessageManagerIfNeeded();
+        public bool isActive() {
+            return IsActive();
+        }
-#if UNITY_ANDROID
-            if (Input.GetKeyDown(KeyCode.Escape)) {
-                this._windowAdapter.withBinding(() => { WidgetsBinding.instance.handlePopRoute(); });
-            }
-#endif
+        public void startCoroutine(IEnumerator routing) {
+            StartCoroutine(routine: routing);
+        }
-            if (!_viewMetricsCallbackRegistered) {
-                _viewMetricsCallbackRegistered = true;
-                UIWidgetsMessageManager.instance?.AddChannelMessageDelegate("ViewportMatricsChanged",
-                    _handleViewMetricsChanged);
-            }
+        public void onNewFrameScheduled() {
+        }
-            if (_mouseEntered) {
-                if (_lastMouseMove.x != Input.mousePosition.x || _lastMouseMove.y != Input.mousePosition.y) {
-                    handleMouseMovement();
-                }
+        public Offset windowPosToScreenPos(Offset offset) {
+            Camera camera = null;
+            if (canvas.renderMode != RenderMode.ScreenSpaceCamera) {
+                camera = canvas.GetComponent<GraphicRaycaster>().eventCamera;
-            _lastMouseMove = Input.mousePosition;
-
-            if (_mouseEntered) {
-                handleMouseScroll();
-            }
+            var pos = new Vector2(x: offset.dx, y: offset.dy);
+            pos = pos * _currentDevicePixelRatio / canvas.scaleFactor;
+            var rect = rectTransform.rect;
+            pos.x += rect.min.x;
+            pos.y = rect.max.y - pos.y;
+            var worldPos = rectTransform.TransformPoint(new Vector2(x: pos.x, y: pos.y));
+            var screenPos = RectTransformUtility.WorldToScreenPoint(cam: camera, worldPoint: worldPos);
+            return new Offset(dx: screenPos.x, Screen.height - screenPos.y);
+        }
-            D.assert(_windowAdapter != null);
-            _windowAdapter.Update();
-            _windowAdapter.OnGUI(_repaintEvent);
+        public void mainEntry() {
+            main();
-        void OnGUI() {
-            _displayMetrics.OnGUI();
-            if (Event.current.type == EventType.KeyDown || Event.current.type == EventType.KeyUp) {
-                _windowAdapter.OnGUI(Event.current);
-            }
+        protected virtual void onEnable() {
+        }
+        
+        protected void AddFont(string family, TextFont font) {
+            _configurations.AddFont(family,font);
-        void handleMouseMovement() {
-            var pos = getPointPosition(Input.mousePosition);
-            if (pos == null) {
+        protected void AddFont(string family, List<string> assets, List<int> weights) {
+            if (assets.Count != weights.Count) {
+                Debug.LogError($"The size of {family}‘s assets should be equal to the weights'.");
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.hover,
-                kind: PointerDeviceKind.mouse,
-                device: getMouseButtonDown(),
-                physicalX: pos.Value.x,
-                physicalY: pos.Value.y
-            ));
-        }
-        void handleMouseScroll() {
-            if (Input.mouseScrollDelta.y != 0 || Input.mouseScrollDelta.x != 0) {
-                var scaleFactor = canvas.scaleFactor;
-                var pos = getPointPosition(Input.mousePosition);
-                if (pos == null) {
-                    return;
-                }
-                _windowAdapter.onScroll(Input.mouseScrollDelta.x * scaleFactor,
-                    Input.mouseScrollDelta.y * scaleFactor,
-                    pos.Value.x,
-                    pos.Value.y,
-                    InputUtils.getScrollButtonKey());
+            var textFont = new TextFont {family = family};
+            var fonts = new Font[assets.Count];
+            for (var j = 0; j < assets.Count; j++) {
+                var font = new Font {asset = assets[index: j], weight = weights[index: j]};
+                fonts[j] = font;
+
+            textFont.fonts = fonts;
+            AddFont(family: family, font: textFont);
+        }
+        
+        protected virtual void main() {
+    }
-        int getMouseButtonDown() {
-            //default mouse button key = left mouse button
-            var defaultKey = 0;
-            for (int key = 0; key < mouseButtonNum; key++) {
-                if (Input.GetMouseButton(key)) {
-                    defaultKey = key;
-                    break;
-                }
-            }
+    enum UIWidgetsInputMode 
+    {
+        Mouse,
+        Touch
+    }
+
+    public partial class UIWidgetsPanel : IPointerDownHandler, IPointerUpHandler,
+        IPointerEnterHandler, IPointerExitHandler, IDragHandler {
+        bool _isEntered;
+        Vector2 _lastMousePosition;
-            return InputUtils.getMouseButtonKey(defaultKey);
-        }
+        UIWidgetsInputMode _inputMode;
-        public void OnPointerDown(PointerEventData eventData) {
-            var position = getPointPosition(eventData);
-            if (position == null) {
-                return;
-            }
-            EventSystem.current.SetSelectedGameObject(gameObject, eventData);
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.down,
-                kind: InputUtils.getPointerDeviceKind(eventData),
-                device: InputUtils.getPointerDeviceKey(eventData),
-                physicalX: position.Value.x,
-                physicalY: position.Value.y
-            ));
+        void _convertPointerData(PointerEventData evt, out Vector2? position, out int pointerId) {
+            position = _inputMode == UIWidgetsInputMode.Mouse
+                ? _getPointerPosition(Input.mousePosition)
+                : _getPointerPosition(evt);
+            pointerId = _inputMode == UIWidgetsInputMode.Mouse ? evt.pointerId : (-1 - evt.pointerId);
-        public void OnPointerUp(PointerEventData eventData) {
-            var position = getPointPosition(eventData);
-            if (position == null) {
-                return;
+        Vector2? _getPointerPosition(Vector2 position) {
+            var worldCamera = canvas.worldCamera;
+            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
+                rect: rectTransform, screenPoint: position, cam: worldCamera, out var localPoint)) {
+                var scaleFactor = canvas.scaleFactor;
+                localPoint.x = (localPoint.x - rectTransform.rect.min.x) * scaleFactor;
+                localPoint.y = (rectTransform.rect.max.y - localPoint.y) * scaleFactor;
+                return localPoint;
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.up,
-                kind: InputUtils.getPointerDeviceKind(eventData),
-                device: InputUtils.getPointerDeviceKey(eventData),
-                physicalX: position.Value.x,
-                physicalY: position.Value.y
-            ));
+
+            return null;
-        Camera getActiveCamera() {
+        Vector2? _getPointerPosition(PointerEventData eventData) {
-            return eventCamera;
-        }
-        Vector2? getPointPosition(PointerEventData eventData) {
-            Camera camera = getActiveCamera();
-                camera, out localPoint);
+                eventCamera, out localPoint);
             var scaleFactor = canvas.scaleFactor;
             localPoint.x = (localPoint.x - rectTransform.rect.min.x) * scaleFactor;
             localPoint.y = (rectTransform.rect.max.y - localPoint.y) * scaleFactor;
-        Vector2? getPointPosition(Vector2 position) {
-            Vector2 localPoint;
-            Camera eventCamera = getActiveCamera();
+        void Input_OnEnable() {
+            _inputMode = Input.mousePresent ? UIWidgetsInputMode.Mouse : UIWidgetsInputMode.Touch;
+        }
-            RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, position,
-                eventCamera, out localPoint);
-            var scaleFactor = canvas.scaleFactor;
-            localPoint.x = (localPoint.x - rectTransform.rect.min.x) * scaleFactor;
-            localPoint.y = (rectTransform.rect.max.y - localPoint.y) * scaleFactor;
-            return localPoint;
+        void Input_OnDisable() {
+        }
+
+        void Input_Update() {
+            //we only process hover events for desktop applications
+            if (_inputMode == UIWidgetsInputMode.Mouse) {
+                if (_isEntered) {
+                    if (!Input.GetMouseButton(0) && !Input.GetMouseButton(1) && !Input.GetMouseButton(2)) {
+                        if (_lastMousePosition.x != Input.mousePosition.x ||
+                            _lastMousePosition.y != Input.mousePosition.y) {
+                            _lastMousePosition = Input.mousePosition;
+                            _onMouseMove();
+                        }
+                    }
+                    else {
+                        _lastMousePosition = Input.mousePosition;
+                    }
+
+                    if (Input.mouseScrollDelta.magnitude != 0) {
+                        _onScroll();
+                    }
+                }
+            }
+        }
+
+        void Input_OnGUI() {
+            var e = Event.current;
+            if (e.isKey) {
+                _wrapper.OnKeyDown(e: e);
+            }
+        }
+
+        void _onMouseMove() {
+            if (_inputMode != UIWidgetsInputMode.Mouse) {
+                return;
+            }
+            var pos = _getPointerPosition(Input.mousePosition);
+            _wrapper.OnMouseMove(pos);
-        public void OnDrag(PointerEventData eventData) {
-            var position = getPointPosition(eventData);
-            if (position == null) {
+        void _onScroll() {
+            if (_inputMode != UIWidgetsInputMode.Mouse) {
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.move,
-                kind: InputUtils.getPointerDeviceKind(eventData),
-                device: InputUtils.getPointerDeviceKey(eventData),
-                physicalX: position.Value.x,
-                physicalY: position.Value.y
-            ));
+            var pos = _getPointerPosition(Input.mousePosition);
+            _wrapper.OnMouseScroll(Input.mouseScrollDelta, pos);
-            var position = getPointPosition(eventData);
-            if (position == null) {
+            if (_inputMode != UIWidgetsInputMode.Mouse) {
-            var pointerKey = InputUtils.getPointerDeviceKey(eventData);
-            _enteredPointers.Add(pointerKey);
-
-            _lastMouseMove = eventData.position;
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.hover,
-                kind: InputUtils.getPointerDeviceKind(eventData),
-                device: pointerKey,
-                physicalX: position.Value.x,
-                physicalY: position.Value.y
-            ));
+            D.assert(eventData.pointerId < 0);
+            _isEntered = true;
+            _lastMousePosition = Input.mousePosition;
-            var position = getPointPosition(eventData);
-            if (position == null) {
+            if (_inputMode != UIWidgetsInputMode.Mouse) {
-            var pointerKey = InputUtils.getPointerDeviceKey(eventData);
-            _enteredPointers.Remove(pointerKey);
-            _windowAdapter.postPointerEvent(new PointerData(
-                timeStamp: Timer.timespanSinceStartup,
-                change: PointerChange.hover,
-                kind: InputUtils.getPointerDeviceKind(eventData),
-                device: pointerKey,
-                physicalX: position.Value.x,
-                physicalY: position.Value.y
-            ));
+            D.assert(eventData.pointerId < 0);
+            _isEntered = false;
+            _wrapper.OnPointerLeave();
+        }
+
+        public void OnPointerDown(PointerEventData eventData) {
+            _convertPointerData(eventData, out var pos, out var pointerId);
+            _wrapper.OnPointerDown(pos, pointerId);
+        }
+
+        public void OnPointerUp(PointerEventData eventData) {
+            _convertPointerData(eventData, out var pos, out var pointerId);
+            _wrapper.OnPointerUp(pos, pointerId);
-        public Window window {
-            get { return _windowAdapter; }
+        public void OnDrag(PointerEventData eventData) {
+            _convertPointerData(eventData, out var pos, out var pointerId);
+            _wrapper.OnDrag(pos, pointerId);
-}*/
+}

com.unity.uiwidgets/Runtime/engine/UIWidgetsPanel.cs.meta

 fileFormatVersion: 2
-guid: 5f8434687aa245d9ae7f766b6109166b
-timeCreated: 1545642183
+guid: 305c123a2a944eba8f2b397a962323ff
+timeCreated: 1597215247

com.unity.uiwidgets/Runtime/foundation/basic_types.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.InternalBridge;
 using UnityEngine;
 using Object = UnityEngine.Object;

com.unity.uiwidgets/Runtime/foundation/binding.cs

 using System.Collections;
 using System.Collections.Generic;
 using developer;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.foundation {

com.unity.uiwidgets/Runtime/foundation/debug.cs

 using System;
 using System.Diagnostics;
 using System.Linq;
-using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.engine;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
 using UnityEngine;

com.unity.uiwidgets/Runtime/foundation/isolates.cs

 using System.ComponentModel;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.foundation {

com.unity.uiwidgets/Runtime/foundation/synchronous_future.cs

 using System;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 
 namespace Unity.UIWidgets.foundation {
     public class SynchronousFuture : Future {

com.unity.uiwidgets/Runtime/gestures/binding.cs

 using System;
 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using UnityEngine;
 

com.unity.uiwidgets/Runtime/gestures/force_press.cs

 using System.Collections.Generic;
 using System.Linq;
 using Unity.UIWidgets.foundation;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.gestures {

com.unity.uiwidgets/Runtime/gestures/mouse_tracking.cs

 using System.Collections.Generic;
 using System.Linq;
 using Unity.UIWidgets.foundation;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.gestures {

com.unity.uiwidgets/Runtime/gestures/multidrag.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 

com.unity.uiwidgets/Runtime/gestures/multitap.cs

 using System;
 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 

com.unity.uiwidgets/Runtime/gestures/recognizer.cs

 using System;
 using System.Collections.Generic;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/about.cs

 using System.Collections.Generic;
 using developer;
 using uiwidgets;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;

com.unity.uiwidgets/Runtime/material/bottom_navigation_bar.cs

 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.service;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

com.unity.uiwidgets/Runtime/material/bottom_sheet.cs

 using uiwidgets;
 using Unity.UIWidget.material;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/checkbox.cs

 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/dialog.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;

com.unity.uiwidgets/Runtime/material/dropdown.cs

 using System.Linq;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.external;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;

com.unity.uiwidgets/Runtime/material/feedback.cs

-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.widgets;

com.unity.uiwidgets/Runtime/material/material.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;

com.unity.uiwidgets/Runtime/material/material_localizations.cs

 using System;
 using System.Collections.Generic;
 using System.Text;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;

com.unity.uiwidgets/Runtime/material/pickers/date_picker_dialog.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;

com.unity.uiwidgets/Runtime/material/popup_menu.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;

com.unity.uiwidgets/Runtime/material/radio.cs

 using uiwidgets;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 

com.unity.uiwidgets/Runtime/material/range_slider.cs

 using System.Collections.Generic;
 using System.Linq;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/refresh_indicator.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;

com.unity.uiwidgets/Runtime/material/scaffold.cs

 using uiwidgets;
 using Unity.UIWidget.material;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/scrollbar.cs

 using System;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.cupertino;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;

com.unity.uiwidgets/Runtime/material/search.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.service;
 using Unity.UIWidgets.ui;

com.unity.uiwidgets/Runtime/material/selectable_text.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.cupertino;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;

com.unity.uiwidgets/Runtime/material/slider.cs

 using uiwidgets;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.async;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

com.unity.uiwidgets/Runtime/material/snack_bar.cs

 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;

com.unity.uiwidgets/Runtime/material/tab_controller.cs

 using System;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
-using Unity.UIWidgets.scheduler2;
+using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.widgets;
 using UnityEngine;
 

com.unity.uiwidgets/Runtime/material/tabs.cs

 using System.Collections.Generic;
 using uiwidgets;
 using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async2;
+using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;