replace Future.value

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

                 if (picked != null && picked != this.selectedDate) this.selectDate(picked);
             });
 
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         private Future _selectTime(BuildContext context)
                 if (picked != null && picked != this.selectedTime) this.selectTime(picked);
             });
 
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         public override Widget build(BuildContext context)

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

                 builder: (BuildContext subContext) => new FullScreenDialogDemo(),
                 fullscreenDialog: true
               ));*/
-              
+               
               D.assert(false, () => "TO DO >>>");
             }
           )

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

                         break;
                 }
 
-                return Future.value(false).to<bool>();
+                return new SynchronousFuture<bool>(false);
             }
 
             return new Dismissible(

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

         {
             FormState form = _formKey.currentState;
             if (form == null || !_formWasEdited || form.validate())
-                return Future.value(true).to<bool>();
+                return new SynchronousFuture<bool>(true);
 
             return material_.showDialog<bool>(
                 context: context,

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

   Future<bool> _onWillPop()  {
     if (!_isOpen) { 
       //SystemNavigator.pop();
-      return Future.value(true).to<bool>();
+      return new SynchronousFuture<bool>(true);
-    return Future.value(true).to<bool>();
+    return new SynchronousFuture<bool>(true);
   }
 
  

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

                     }
                 );
 
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         public override Widget build(BuildContext context)

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

                             if (this._category != null)
                             {
                                 this.setState(() => this._category = null);
-                                return Future.value(false).to<bool>();
+                                return new SynchronousFuture<bool>(false);
-                            return Future.value(true).to<bool>();
+                            return new SynchronousFuture<bool>(true);
                         },
                         child: new Backdrop(
                             backTitle: new Text("Options"),

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

             // }
             //TODO: implement
             setState(() => { _loaded = true; });
-            return Future.value();
+            return new SynchronousFuture(null);
             // D.assert(() {
             //   Timeline.timeSync("Build scheduled", () { }, flow: Flow.end(debugFlowId));
             //   return true;

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

         }
 
         public Future<bool> didPopRoute() {
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
         }
 
         public void didChangeAccessibilityFeatures() {

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

             switch (_platform(context)) {
                 case RuntimePlatform.Android:
                     return
-                        Future.value(); // SystemSound.play(SystemSoundType.click); TODO: replace with unity equivalent
+                        new SynchronousFuture(null); // SystemSound.play(SystemSoundType.click); TODO: replace with unity equivalent
                 case RuntimePlatform.IPhonePlayer:
                 case RuntimePlatform.LinuxEditor:
                 case RuntimePlatform.LinuxPlayer:
                 case RuntimePlatform.WindowsPlayer:
-                    return Future.value();
+                    return new SynchronousFuture(null);
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         public static GestureTapCallback wrapForTap(GestureTapCallback callback, BuildContext context) {
         public static Future forLongPress(BuildContext context) {
             switch (_platform(context)) {
                 case RuntimePlatform.Android:
-                    return Future.value(); // HapticFeedback.vibrate(); TODO
+                    return new SynchronousFuture(null); // HapticFeedback.vibrate(); TODO
                 case RuntimePlatform.IPhonePlayer:
                 case RuntimePlatform.LinuxEditor:
                 case RuntimePlatform.LinuxPlayer:
                 case RuntimePlatform.WindowsPlayer:
-                    return Future.value();
+                    return new SynchronousFuture(null);
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         public static GestureLongPressCallback

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

             _pageController.animateToPage(_currentIndex.Value, duration: material_.kTabScrollDuration,
                 curve: Curves.ease).then((value) => {
                 if (!mounted) {
-                    return Future.value();
+                    return new SynchronousFuture(null);
                 }
 
                 setState(() => {
                     }
                 });
 
-                return Future.value();
+                return new SynchronousFuture(null);
             });
         }
 

com.unity.uiwidgets/Runtime/painting/image_provider.cs

                         completer.complete();
                     }
 
-                    return Future.value();
+                    return new SynchronousFuture(null);
                 }
             );
             return completer.future.to<ImageCacheStatus>();
         public readonly float scale;
 
         public override Future<MemoryImage> obtainKey(ImageConfiguration configuration) {
-            return Future.value(FutureOr.value(this)).to<MemoryImage>();
+            return new SynchronousFuture<MemoryImage>(this);
+            //Future.value(FutureOr.value(this)).to<MemoryImage>();
         }
 
         public override ImageStreamCompleter load(MemoryImage key, DecoderCallback decode) {
         public readonly AssetBundle bundle;
 
         public override Future<AssetBundleImageKey> obtainKey(ImageConfiguration configuration) {
-            return Future.value(FutureOr.value(new AssetBundleImageKey(
+            return new SynchronousFuture<AssetBundleImageKey>(new AssetBundleImageKey(
-            ))).to<AssetBundleImageKey>();
+            ));
+            //     Future.value(FutureOr.value(new AssetBundleImageKey(
+            //     bundle: bundle ? bundle : configuration.bundle,
+            //     name: assetName,
+            //     scale: scale
+            // ))).to<AssetBundleImageKey>();
         }
 
         public bool Equals(ExactAssetImage other) {

com.unity.uiwidgets/Runtime/painting/image_resolution.cs

             AssetBundleImageKey key;
             var cache = AssetBundleCache.instance.get(configuration.bundle);
             if (cache.TryGetValue(assetConfig, out key)) {
-                return Future.value(FutureOr.value(key)).to<AssetBundleImageKey>();
+                return new SynchronousFuture<AssetBundleImageKey>(key);
+                //Future.value(FutureOr.value(key)).to<AssetBundleImageKey>();
             }
 
             AssetBundle chosenBundle = bundle ? bundle : configuration.bundle;
 
-            return Future.value(FutureOr.value(key)).to<AssetBundleImageKey>();
+            return new SynchronousFuture<AssetBundleImageKey>(key);
+            //Future.value(FutureOr.value(key)).to<AssetBundleImageKey>();
         }
 
         internal string _chooseVariant(string main, ImageConfiguration config, List<string> candidates) {

com.unity.uiwidgets/Runtime/painting/shader_warmup.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.async2;
+using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.painting {
             }
 
             canvas.translate(0.0f, drawCallSpacing);
-            return Future.value();
+            return new SynchronousFuture(null); // new SynchronousFuture(null);
         }
     }
 }

com.unity.uiwidgets/Runtime/rendering/viewport_offset.cs

         public virtual Future moveTo(float to, TimeSpan? duration, Curve curve = null, bool clamp = true) {
             if (duration == null || duration.Value == TimeSpan.Zero) {
                 jumpTo(to);
-                return Future.value();
+                return new SynchronousFuture(null);
             } else {
                 return animateTo(to, duration: duration??TimeSpan.Zero , curve: curve ?? Curves.ease);
             }
         }
 
         public override Future animateTo(float to, TimeSpan duration, Curve curve) {
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         public override ScrollDirection userScrollDirection {

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

         }
 
         protected virtual Future handleSystemMessage(Object systemMessage) {
-            return Future.value();
+            return new SynchronousFuture(null);
         }
 
         protected virtual void evict(string asset) {
             MessageHandler handler = _handlers[channel];
             if (handler == null) {
                 ui_.channelBuffers.push(channel, data, callback);
-                return Future.value();
+                return new SynchronousFuture(null);
             }
 
             return handler(data).then(bytes => {

com.unity.uiwidgets/Runtime/services/clipboard.cs

 using System.Runtime.InteropServices;
 using Unity.UIWidgets.async2;
+using Unity.UIWidgets.foundation;
 using UnityEngine;
 
 namespace Unity.UIWidgets.service {
             GUIUtility.systemCopyBuffer = data.text;
 #endif
             
-            return Future.value();
+            return new SynchronousFuture(null);
-            return Future.value(FutureOr.value(data)).to<ClipboardData>();
+            return new SynchronousFuture<ClipboardData>(data);
+            //Future.value(FutureOr.value(data)).to<ClipboardData>();
         }
         
 #if UNITY_WEBGL

com.unity.uiwidgets/Runtime/widgets/app.cs

             D.assert(mounted);
             var navigator = _navigator?.currentState;
             if (navigator == null) {
-                return Future.value(false).to<bool>();
+                return new SynchronousFuture<bool>(false);
             }
 
             return navigator.maybePop<bool>();
             D.assert(mounted);
             var navigator = _navigator?.currentState;
             if (navigator == null) {
-                return Future.value(false).to<bool>();
+                return new SynchronousFuture<bool>(false);
-            return Future.value(true).to<bool>();
+            return new SynchronousFuture<bool>(true);
         }
 
         public void didChangeAccessibilityFeatures() {}

com.unity.uiwidgets/Runtime/widgets/dismissible.cs

                 return widget.confirmDismiss(direction);
             }
 
-            return Future.value(true).to<bool>();
+            return new SynchronousFuture<bool>(true);
         }
 
         void _startResizeAnimation() {

com.unity.uiwidgets/Runtime/widgets/editable_text.cs

         }
 
         public Future<bool> didPopRoute() {
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
         }
 
 

com.unity.uiwidgets/Runtime/widgets/image.cs

         }
 
         public Future<bool> didPopRoute() {
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
         }
     }
 }

com.unity.uiwidgets/Runtime/widgets/localizations.cs

             }
 
             if (pendingList == null) {
-                return Future.value(output).to<Dictionary<Type, object>>();
+                return new SynchronousFuture<Dictionary<Type, object>>(output); 
+                //Future.value(output).to<Dictionary<Type, object>>();
             }
 
             return Future.wait<object>(pendingList.Select(p => p.futureValue))

com.unity.uiwidgets/Runtime/widgets/navigator.cs

         
 
         public virtual Future<RoutePopDisposition> willPop() {
-            return Future.value(isFirst
+            return new SynchronousFuture<RoutePopDisposition>(isFirst
-                : RoutePopDisposition.pop).to<RoutePopDisposition>();
+                : RoutePopDisposition.pop);
+            // Future.value(isFirst
+            // ? RoutePopDisposition.bubble
+            // : RoutePopDisposition.pop).to<RoutePopDisposition>();
         }
 
         public virtual bool willHandlePopInternally {

com.unity.uiwidgets/Runtime/widgets/routes.cs

         public override Future<RoutePopDisposition> willPop() {
             //async
             if (willHandlePopInternally) {
-                return Future.value(RoutePopDisposition.pop).to<RoutePopDisposition>();
+                return new SynchronousFuture<RoutePopDisposition>(RoutePopDisposition.pop);
+                //Future.value(RoutePopDisposition.pop).to<RoutePopDisposition>();
             }
             return base.willPop();
         }
                 var callback = _willPopCallbacks[index];
                 return callback.Invoke().then(v => {
                     if (!(bool) v) {
-                        return Future.value(RoutePopDisposition.doNotPop);
+                        return new SynchronousFuture(RoutePopDisposition.doNotPop);
+                        //Future.value(RoutePopDisposition.doNotPop);
                     }
 
                     return InvokePopCallbacks(index + 1);
             foreach (WillPopCallback callback in _willPopCallbacks) {
                 callback.Invoke().then(v => result = !(bool)v);
                 if (result) {
-                    return  Future.value(RoutePopDisposition.doNotPop).to<RoutePopDisposition>();
+                    return new SynchronousFuture<RoutePopDisposition>(RoutePopDisposition.doNotPop);
+                    //Future.value(RoutePopDisposition.doNotPop).to<RoutePopDisposition>();
                 }
             }
             return base.willPop();

com.unity.uiwidgets/Runtime/widgets/scroll_position.cs

                     break;
             }
             if (target == pixels) {
-                return Future.value();
+                return new SynchronousFuture(null);
-                return Future.value();
+                return new SynchronousFuture(null);
             }
 
             curve = curve ?? Curves.ease;

com.unity.uiwidgets/Runtime/widgets/scroll_position_with_single_context.cs

         ) {
             if (PhysicsUtils.nearEqual(to, pixels, physics.tolerance.distance)) {
                 jumpTo(to);
-                return Future.value();
+                return new SynchronousFuture(null);
             }
 
             DrivenScrollActivity activity = new DrivenScrollActivity(

com.unity.uiwidgets/Runtime/widgets/scrollable.cs

             }
 
             if (futures.isEmpty() || duration == TimeSpan.Zero) {
-                return Future.value();
+                return new SynchronousFuture(null);
             }
 
             if (futures.Count == 1) {

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

         }
 
         public Future<bool> didPopRoute() {
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
         }
 
         void _handleTapDown(TapDownDetails details) {

com.unity.uiwidgets/Runtime/widgets/widget_inspector.cs

                 name: name,
                 callback: 
                 ((IDictionary<string, string> parameters) => {
-                     var result = Future.value(FutureOr.value(new Dictionary<string, object>(){{"result", callback}})).to<IDictionary<string, object>>();
+                    var result = new SynchronousFuture<IDictionary<string, object>>(new Dictionary<string, object>()
+                        {{"result", callback}}); 
+                         //Future.value(FutureOr.value(new Dictionary<string, object>(){{"result", callback}})).to<IDictionary<string, object>>();
                      return result;
                 })
             );
                 ) {
             registerServiceExtension(
               name: name,
-              callback: (IDictionary<string, string> parameters) =>{
-                  var result = Future.value(FutureOr.value((new Dictionary<string, object>{{"result", callback(parameters["objectGroup"])}}))).to<IDictionary<string, object>>();
+              callback: (IDictionary<string, string> parameters) => {
+                  var result = new SynchronousFuture<IDictionary<string, object>>(new Dictionary<string, object>
+                      {{"result", callback(parameters["objectGroup"])}}); 
+                      //Future.value(FutureOr.value((new Dictionary<string, object>{{"result", callback(parameters["objectGroup"])}}))).to<IDictionary<string, object>>();
                   return result;
               }
             );
                 binding.buildOwner.reassemble(binding.renderViewElement);
                 return binding.endOfFrame;
             }
-            return Future.value();
+            return new SynchronousFuture(null);
         }*/
 
         static string _consoleObjectGroup = "console-group";
                 getter: ()  => FlutterError.onError == structuredExceptionHandler,
                 setter: (bool value)=> {
                     FlutterError.onError = value ? structuredExceptionHandler : defaultExceptionHandler;
-                    return Future.value();
+                    return new SynchronousFuture(null);
                 }
             );
 
         }
 
         public Future<bool> didPopRoute() {
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
-            return Future.value(false).to<bool>();
+            return new SynchronousFuture<bool>(false);
         }