.NET MAUI Documentation

Integrating with the iOS Platform

This guide explores how to leverage native iOS features and APIs within your .NET MAUI applications. .NET MAUI provides a robust framework for building cross-platform applications, and understanding platform-specific integration is key to unlocking the full potential of each target device.

Accessing Native iOS APIs

The .NET MAUI platform API allows you to access native iOS APIs. You can do this by creating an extension method on the Microsoft.Maui.Controls.Element class. This method will be specific to the iOS platform.

Example: Invoking a Native iOS Alert

Let's create a simple example to show a native iOS alert dialog:

namespace MauiApp.Platforms.iOS
{
    using Microsoft.Maui.Controls;
    using UIKit; // Required for iOS native types

    public static class iOSPlatformExtensions
    {
        public static void ShowNativeAlert(this Element element, string message, string title = "Alert")
        {
            Device.BeginInvokeOnMainThread(() =>
            {
                var alertController = UIAlertController.Create(title, message, UIAlertControllerStyle.Alert);
                alertController.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
                UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(alertController, true, null);
            });
        }
    }
}
                

To use this extension method in your shared MAUI code:

// In your ViewModel or Code-behind
async void ShowAlertButton_Clicked(object sender, EventArgs e)
{
    var message = "This is a native iOS alert!";
    // Assuming 'this' refers to a ContentPage or other Element
    this.ShowNativeAlert(message, "Native iOS Example");
}
                

Platform-Specific UI Customization

For advanced UI customization that is specific to iOS, you can create custom renderers or handlers. These allow you to directly manipulate the native iOS controls that .NET MAUI uses under the hood.

Custom Handlers (Recommended for MAUI)

While custom renderers were the primary mechanism in Xamarin.Forms, .NET MAUI encourages the use of handlers for platform-specific customization. Handlers provide a more decoupled and maintainable way to extend controls.

You can define a custom handler in your iOS project. For instance, to customize a Button's appearance on iOS:

// In your iOS project (e.g., Handlers/MyCustomButtonHandler.cs)
using Microsoft.Maui.Handlers;
using Microsoft.Maui.Platform;
using UIKit;
using YourAppName.Controls; // Your custom button definition

namespace YourAppName.Platforms.iOS.Handlers
{
    public class MyCustomButtonHandler : ButtonHandler
    {
        protected override AppKit.NSView CreateNativeControl()
        {
            var nativeButton = base.CreateNativeControl();
            // Customize nativeButton here (e.g., set specific iOS properties)
            if (nativeButton is UIButton uiButton)
            {
                uiButton.Layer.CornerRadius = 10;
                uiButton.Layer.BorderColor = UIColor.SystemBlue.CGColor;
                uiButton.Layer.BorderWidth = 2;
            }
            return nativeButton;
        }
    }
}

// In your MauiProgram.cs or App.xaml.cs to register the handler:
// In MauiProgram.cs:
// builder.ConfigureMauiHandlers(handlers =>
// {
//     handlers.AddHandler(typeof(MyCustomButton), typeof(MyCustomButtonHandler));
// });
                

Key iOS Specifics to Consider:

• Permissions: Requesting permissions for features like camera, location, or contacts using native iOS APIs.
• Lifecycle Events: Handling specific iOS application lifecycle events (e.g., entering background, receiving push notifications).
• Gestures: Implementing complex custom gestures using UIGestureRecognizer.
• Device Capabilities: Accessing hardware features like accelerometer, gyroscope, or Face ID.
• App Store Guidelines: Ensuring your integration adheres to Apple's App Store review guidelines.

Performance Considerations

When accessing native APIs or performing heavy computations, always be mindful of performance. Offload long-running tasks to background threads and ensure UI updates are performed on the main thread.

Resources