How MAUI Apps Work and Render on iOS and Android

 

MAUI Architecture Overview

.NET MAUI (Multi-platform App UI) is a cross-platform framework for creating native mobile and desktop apps with C# and XAML. Here's how it works:

1. Single Project Structure

• MAUI uses a single project that targets multiple platforms (iOS, Android, Windows, macOS)

• Platform-specific code is handled through conditional compilation or dependency injection

2. Rendering Process

On Each Platform:

1. Your shared C#/XAML code is compiled

2. MAUI's platform-specific handlers map UI controls to native views

3. The .NET runtime (Mono for Android, .NET for iOS) executes the shared code

4. MAUI's rendering engine creates native UI elements for each platform

iOS Specifics

• Uses Apple's UIKit under the hood

• MAUI controls are translated to native UIKit views (e.g., Button becomes UIButton)

• Runs on top of .NET 6+ runtime for iOS

Android Specifics

• Uses Android's view system

• MAUI controls become Android views (e.g., Button becomes AppCompatButton)

• Runs on Mono runtime (part of .NET for Android)

Differences from Xamarin.Forms

1. Project Structure:

   • Xamarin: Separate projects for each platform + shared project

   • MAUI: Single project with multi-targeting

2. Performance:

   • MAUI has optimized handlers and reduced overhead

   • Faster startup times and better memory management

3. Controls:

   • MAUI introduces new controls and updates existing ones

   • More consistent behavior across platforms

4. Hot Reload:

   • MAUI has improved hot reload capabilities

   • Better support for both XAML and C# changes

5. Platform Support:

   • MAUI adds official macOS and Windows desktop support

   • Xamarin.Forms primarily focused on mobile (iOS/Android)

6. Tooling:

   • MAUI is integrated with Visual Studio 2022+

   • Uses the latest .NET SDK (6.0+) rather than legacy Mono

7. Architecture:

   • MAUI uses handlers instead of renderers (more lightweight)

   • Simplified property mapping system

8. Dependency Injection:

   • MAUI has built-in DI support

   • More modern application startup pattern

MAUI represents the evolution of Xamarin.Forms, with better performance, more platform support, and a more modern development experience while maintaining the ability to create truly native UIs on each platform.

1. Compilation Pipeline

Shared Code Compilation

• Your C#/XAML code gets compiled to Intermediate Language (IL)

• MAUI-specific MSBuild targets process:

  • XAML files → compiled to C# (generated partial classes)

  • Resources (images, fonts) → processed for each platform

  • App structure → converted to platform-specific bootstrap code

Platform-Specific Compilation

For Android:

1. IL → converted to Dalvik bytecode via mono-android AOT compilation

2. Resources packaged in Android-appropriate formats (drawables, etc.)

3. Final APK bundle created with:

   • Managed assemblies

   • Mono runtime

   • Platform libraries

For iOS:

1. IL → fully AOT compiled to native ARM code

2. Linked with Xamarin.iOS runtime

3. Resources packaged in Asset Catalogs

4. Final IPA bundle contains native executable

2. Application Startup Process

Common MAUI Bootstrapping

1. MauiProgram.cs initializes the DI container

2. App.xaml.cs creates the initial application shell

3. Platform-specific entry points are called

Android Specific Startup:

1. MainActivity (derived from MauiAppCompatActivity) launches

2. JNI bridge initializes Mono runtime

3. MAUI's Android host creates the application context

4. XAML handler system initializes

iOS Specific Startup:

1. Main entry point in Program.cs executes

2. UIApplicationMain called with MAUI's app delegate

3. Native iOS window system initializes

4. MAUI's iOS host starts the .NET runtime

3. UI Rendering Pipeline

Control Mapping Architecture

MAUI uses a handler-based architecture with these key components:

1. Cross-Platform Control (e.g., Button)

   • Defines properties, events, and behavior

   • No platform-specific code

2. Handler (e.g., ButtonHandler)

   • Interface mapping cross-platform control to native views

   • Contains property mappers that translate properties

3. Platform View (e.g., UIButton on iOS, AppCompatButton on Android)

   • Actual native control instance

Rendering Process Flow

1. Control Instantiation:

   • XAML parsed or C# code creates MAUI control

   • IViewHandler factory creates platform-specific handler

2. Native View Creation:

   csharp

   // Simplified handler implementation
   protected override UIView CreatePlatformView()
   {
       return new UIButton(UIButtonType.System);
   }

3. Property Mapping:

   • MAUI property system triggers updates

   • Handler's property mapper translates values:

     csharp

     mapper.ModifyMapping<Button, IButtonHandler>(nameof(Button.Text), 
         (h, v) => h.PlatformView.SetTitle(v.Text, UIControlState.Normal));

4. Layout System:

   • MAUI's layout engine calculates positions

   • Converts to platform-specific layout calls:

     • iOS: Uses Frame and AutoResizingMask

     • Android: Uses ViewGroup measurement system

4. Platform Integration Layer

Android Specifics

• Input Handling:

  • Touch events → converted to MAUI gestures

  • Hardware buttons → routed through KeyListener

• Lifecycle:

  • Activity lifecycle events → mapped to MauiApplication callbacks

  • OnCreate, OnPause etc. trigger MAUI events

• Resource System:

  • @mipmap, @drawable → MAUI's single resource system

  • Density-specific assets automatically selected

iOS Specifics

• Touch Handling:

  • UITouch events → MAUI gesture recognizers

  • UIResponder chain integrated with MAUI controls

• Lifecycle:

  • AppDelegate events → MAUI lifecycle events

  • SceneDelegate support for multi-window apps

• Resource System:

  • Assets.xcassets → MAUI unified images

  • @1x, @2x, @3x automatically handled

5. Performance Optimizations

1. Handler Architecture:

   • Lighter than Xamarin's renderer system

   • Property mapper reduces unnecessary updates

2. Dependency Injection:

   • Services initialized once at startup

   • Platform implementations injected at runtime

3. Compiled Bindings:

   • XAML compiled to IL for faster binding

   • x:DataType enables AOT binding compilation

4. Image Handling:

   • Smart caching and resizing

   • Platform-specific loading optimizations

6. Debugging and Diagnostics

1. Tracing System:

   • Microsoft.Maui.Controls source traces

   • Platform-specific debug logs

2. Diagnostic Tools:

   • .NET Memory Profiler integration

   • Platform-specific profilers (Android Studio, Xcode)

3. Hot Reload:

   • Roslyn-based code updates

   • XAML parsing engine for UI updates

This entire pipeline enables MAUI to deliver native performance while maintaining a single codebase, with the framework handling all platform-specific adaptations through its sophisticated handler system and compilation model.