MobileBlazorBindings VS Introducing .NET Multi-platform App UI (MAUI)

It's difficult to imagine. But if the rumour has any merit, perhaps it simply means that there will be a push to consolidate on some blazor tech using stuff like https://github.com/dotnet/MobileBlazorBindings

There's Blazor Mobile Bindings but it's essentially experimental at the moment and isn't exactly active. From playing around with it though, it is pretty neat as you get the Blazor programming model but with native controls.

The benefit at least with the approach instead of embedding Avalonia inside Maui is you could potentially use non xaml frameworks for ui as long as they support Maui as a target. Stuff like Comet or Blazor mobile bindings would be possible aside from xaml. Especially if they're coming from Blazor web or code based ui frameworks like flutter which makes it appealing.

This is one reason I'd really love for them to push through on making alternatives to XAML like Blazor mobile bindings.

I'd say Blazor mobile bindings is also pretty interesting imo, unlike Hybrid it doesn't use Html and uses MAUI controls directly but still keeps the Blazor programming style and still uses razor to tie in C# and components.

Oleksandr has been contributing to the official experiment project, and singlehandedly updated it to support .NET MAUI. He even now has documentation on his fork.

I really hope Blazor Mobile Bindings takes off imo. I still care for native controls and if Mobile bindings does become a valid target, then you'll have an alternative to XAML when writing native components but using Razor syntax (which imo is less verbose). It'll be like how React does it (which is still pretty popular) where you have React web and also React Native which uses the platform's native controls underneath. Both aren't exactly the same but since the framework is similar (React, Blazor) it should be easy to swap between the two.

Yeah I really hope they'll productize Blazor Mobile Bindings (currently experimental), it's essentially using Xaml controls via Razor as the markup format instead and can use C# expressions (so less need for converters).

For example, in Android there's this file: https://github.com/dotnet/MobileBlazorBindings/blob/main/templates/BlazorHybrid-app/NewApp.Android/wwwroot/index.html

It means you can use Blazor's syntax to write MAUI apps, as an alternative to XML-like XAML syntax.

I am migrating XF app into MAUI and writing a simple Navigation framework because Prism doesn't work well and I didn't use anything advanced anyway. So, I am surfing the code of MAUI to intercept all the back buttons, etc. I haven't found a single mention of apis related to predictive back "RegisterOnBackInvokedCallback", "OnBackInvokedDispatcher", "OnBackPressedDispatcher", "AddCallback", "android:enableOnBackInvokedCallback" Also I don't see any issue on github that would say "Support Android Predictive back". Only one kinda related https://github.com/dotnet/maui/issues/8680

Below issue is still reproducing in Maui .net7.0 version also. #10163

Maui is Open Source, MIT License

https://github.com/dotnet/maui

.NET is Open Source

https://dotnet.microsoft.com/en-us/platform/open-source

I do share your skepticism of Microsoft, but it looks like the economics and cash flow dynamics have changed drastically after the advent of the cloud.

Microsoft is more focused on getting developers onto its ecosystem and help them with open source projects with the hope that they will use its Azure cloud services and bring in the money.

My skepticism is a bit relaxed now and I have no qualms using .NET.

I hope I am not wrong.

It's a bit of a hit and miss as of today. CLI, back-end and natively compiled libraries (think dll/so/dylib or even .lib/.a - you can statically link NAOT binaries into other "unmanaged" code) work best, GUI - requires more work.

Avalonia[0] and MAUI[1] have known working templates with it, but YMMV.

[0] https://github.com/lixinyang123/AvaloniaAOT / https://github.com/AvaloniaUI/Avalonia/ / honorable mention https://github.com/VincentH-Net/CSharpForMarkup

[1] https://github.com/dotnet/maui (try out with just true in csproj - it is known to work e.g. on iOS)

While this is the quite endorsed by the community: https://github.com/dotnet/maui/discussions/339

I think the fundamental issue is that desktop Linux is way too fragmented. Not only just GTK2/3 and Qt but you have GNOME, KDE, XFCE, Cinnamon and then you have X11, Xorg, Wayland...

To be honest, all those craps are why desktop Linux never took off. I'm very safe to say MAUI for Linux will eventually renders components off its own using framebuffer and hardware acceleration APIs such as OpenGL or Vulkan just because of the market fragmentations...

If desktop Linux truly wants to get the attention, it will need to unify. Fixing dependency hell using Flatpak is the right direction.

There is an existing old fork of MAUI for Linux that uses GTK: https://github.com/jsuarezruiz/maui-linux

First I came across this Github issue: https://github.com/dotnet/maui/issues/9687 - According to this issue, this is a known bug for MAUI iOS, but it works OK for MAUI Android. As I said, I target Android only and I have the exact same issue. It's apparantly fixed with some of the latest versions for MAUI but the problem still occurs to me even with MAUI version:

I saw this and tried to imitate (ofc my lack of experience wouldn't allow me to do it in the exact way). Already found some documentation that allowed to understand better. Thanks for the insigh.

I implemented the Auth controller following this sample code from Microsoft.