Go through the Flutter Engine, and create a class and methods for everything in the dart::ui library.

Using the Model, create inheritance for all Flutter SDK classes created, using the extends or implements methods.

I've been developing C#/Winforms for over 10 years now and recently i decided to switch to a more viable alternative so that i could code for mobile/desktop. Xamarin was a good option but sadly it lacks the UI buzz that Flutter has. Luckily, I found this project and i am so willing to invest time and effort into making this work along with you but I have some questions

1. What part of Flutter does this project port? As far as I understand, You translated the Flutter SDK, which was built on top of Flutter Engine which in turn uses opengl, so that it uses SkiaSharp instead and runs on top of mono instead of dart.
2. If the previous is true, You're building upon two pretty feature rich projects kinda uniting Xamarin's rich apis with Flutter's UI capabilities, doesn't this mean that this project is actually as complete as Flutter and Xamarin are?
3. Now this one is important 😂... Have you been able run Flutter animations?
4. How much of the Flutter SDK could successfully be transpiled?

I am so excited to hear your thoughts about this.

Using SkiaSharp, create a full screen Canvas in a page that can be inherited. Pass the Canvas reference to the Bindings project.

Parse out the code inside methods, and give to the DartModel. This will include everything from variable assignments, if/else statements, switches, returns, operator assignments, other function calls.

I'm seeing a couple places where automated transpiling may be impossible (or at least require a full program analysis). For instance: flutter/lib/src/foundation/annotations.dart includes attributes, which in Dart are just regular classes. Without looking around the code for references to those attributes, there's no way to tell that those classes should be rewritten as C# attributes.

So either we can spend time on the transpiler implementing that full program analysis or we can just have a map file that says, "when you see this file, use this hand-transpiled C# file from over here instead."

Something like this:

{
  "handTranspiledFiles": [
    { "dartFile": "flutter/lib/src/foundation/annotations.dart", "handTranspiledFile": "handTranspiled/lib/src/foundation/annotations.cs" },
    ...
  ]
}

The Binding library will likely need events to and from the Shell. This is seen as shown in the current Shell of Flutter.

Examples:

https://github.com/flutter/engine/tree/master/shell/platform/android/io/flutter/app

https://github.com/flutter/engine/tree/master/shell/platform/android/io/flutter/view

Hi Adam. It's nice to see your effort. I'm a newbie Xamarin developer, and have come across your website and there. And I have read about some flutter stuff. And I found something here. I found some C# to Dart transpiler tools.
Maybe if it could help this work. Good luck and keep up the good work Adam 👍 :)

In FlutterBinding/UI/Compositing.cs

Wire up all the native calls to the relevant Engine code.

https://github.com/flutter/engine/tree/master/lib/ui/compositing

Work with anyone on Shell part on getting the canvas from there.

So obviously this isn't the highest priority for version 1 given that the transpiler isn't complete, but I thought I'd bring it up in case planning for this feature might affect design decisions going forward.

Basically, state-full hot reload would be implemented using a client/server architecture whereby a server on the development machine watches for file changes and sends updates to the running flutter engine, which then dynamically recompiles views on the fly, preserving state.

This is similar to how livexaml and HotReload work. The tricky bit is dynamically recompiling views, given that they are now C# code and not xaml files. Perhaps in debug mode the whole app runs in interpreted mode and gets live reloaded? Can we use the mono interpreter?

For example, see the AbstractNode class in the flutter sources.

How can it cross-compile these and retain type safety (or as much as possible with C#?). I thought maybe it could rewrite the class to use a covariant generic interface.

So for AbstractNode, for example, it would generate something like this interface (not sure if this would work):

    public interface INode {}
    public interface INode<out T> : INode
    {
        INode owner { get; } // had to loosen the type here, not sure if we can do better?
        INode<INode<T>> parent { get; }
        int depth { get; set; }
        bool attached { get; }

        void attach(INode owner);
        void redepthChildren();
        void detach();
    }

    public class AbstractNode<T> : INode<T> {
        ...etc... 
        protected void dropChild<TChild>(INode<TChild> child) { ...etc.. }
    }

Create all mixin's as appropriate, including the method body implementations. Since Mixin's aren't available in C#, you will need to devise a method on how to implement them.

In the Android Shell project, create an Activity that can be inherited, that will create a full screen Skia Canvas. Pass the Canvas reference to the bindings project.

Just tried this yesterday. Got this error while running analyzer.dart:
C:\Users\JBell\Downloads\xamarin.flutter-master\xamarin.flutter-master\flutter\lib\src\packages\flutter_tools\lib\src\base\logger.dart Unhandled exception: NoSuchMethodError: The getter 'childEntities' was called on null. Receiver: null Tried calling: childEntities #0 Object.noSuchMethod (dart:core/runtime/libobject_patch.dart:50:5) #1 Implementation.processMethodInvocation (file:///C:/Users

Also got a few "ouch" messages along the way:

C:\Users\JBell\Downloads\xamarin.flutter-master\xamarin.flutter-master\flutter\lib\src\packages\flutter\lib\src\rendering\platform_view.dart
ouch
ouch

C:\Users\JBell\Downloads\xamarin.flutter-master\xamarin.flutter-master\flutter\lib\src\packages\flutter\lib\src\widgets\platform_view.dart
ouch
ouch