Mobile Platform Support

using Avalonia;
using Avalonia.iOS;
using Foundation;
using UIKit;

[Register("AppDelegate")]
public class AppDelegate : AvaloniaAppDelegate<App>
{
    protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
    {
        return builder
            .UseiOS()
            .UseSkia();
    }
}

using Avalonia;

protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
{
    return builder
        .With(new iOSPlatformOptions
        {
            RenderingMode = new[]
            {
                iOSRenderingMode.Metal,   // Preferred: Metal rendering
                iOSRenderingMode.OpenGl   // Fallback: OpenGL ES (EAGL)
            }
        })
        .UseiOS()
        .UseSkia();
}

using Avalonia.iOS;
using UIKit;

public class ViewController : UIViewController
{
    private AvaloniaView _avaloniaView;

    public override void ViewDidLoad()
    {
        base.ViewDidLoad();
        
        // Create Avalonia view
        _avaloniaView = new AvaloniaView
        {
            Content = new MyAvaloniaControl()
        };
        
        View.AddSubview(_avaloniaView);
    }
    
    public override void ViewDidLayoutSubviews()
    {
        base.ViewDidLayoutSubviews();
        _avaloniaView.Frame = View.Bounds;
    }
}

using Avalonia.Controls;
using Avalonia.Platform;

public class MainView : UserControl
{
    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
    {
        base.OnAttachedToVisualTree(e);
        
        var insetsManager = TopLevel.GetTopLevel(this)
            ?.InsetsManager;
            
        if (insetsManager != null)
        {
            // React to safe area changes (notch, etc.)
            insetsManager.SafeAreaChanged += OnSafeAreaChanged;
        }
    }
    
    private void OnSafeAreaChanged(object? sender, SafeAreaChangedArgs e)
    {
        // Adjust UI for safe areas
        Padding = new Thickness(
            e.SafeAreaPadding.Left,
            e.SafeAreaPadding.Top,
            e.SafeAreaPadding.Right,
            e.SafeAreaPadding.Bottom
        );
    }
}

using Android.App;
using Android.Content.PM;
using Avalonia;
using Avalonia.Android;

[Activity(
    Label = "MyApp",
    Theme = "@style/MyTheme.NoActionBar",
    Icon = "@drawable/icon",
    MainLauncher = true,
    ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize)]
public class MainActivity : AvaloniaMainActivity<App>
{
    protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
    {
        return builder
            .UseAndroid()
            .UseSkia();
    }
}

using Avalonia;

protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
{
    return builder
        .With(new AndroidPlatformOptions
        {
            RenderingMode = new[]
            {
                AndroidRenderingMode.Vulkan,    // Best: Vulkan
                AndroidRenderingMode.Egl,       // Good: OpenGL ES
                AndroidRenderingMode.Software   // Fallback: CPU
            }
        })
        .UseAndroid()
        .UseSkia();
}

using Avalonia.Android.Platform;
using Avalonia.Platform;

public class MainView : UserControl
{
    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
    {
        base.OnAttachedToVisualTree(e);
        
        var systemNav = TopLevel.GetTopLevel(this)
            ?.SystemNavigationManager;
            
        if (systemNav != null)
        {
            // Handle back button
            systemNav.BackRequested += OnBackRequested;
        }
    }
    
    private void OnBackRequested(object? sender, BackRequestedEventArgs e)
    {
        if (CanGoBack())
        {
            GoBack();
            e.Handled = true;  // Prevent default back behavior
        }
    }
}

using Avalonia.Controls;
using Avalonia.Platform;

public class MainView : UserControl
{
    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
    {
        base.OnAttachedToVisualTree(e);
        
        var insetsManager = TopLevel.GetTopLevel(this)
            ?.InsetsManager;
            
        if (insetsManager != null)
        {
            // System UI insets changed
            insetsManager.SystemBarInsets += OnSystemBarInsetsChanged;
        }
    }
    
    private void OnSystemBarInsetsChanged(object? sender, SystemBarInsetsChangedArgs e)
    {
        // Adjust for system bars
        Padding = new Thickness(
            e.Insets.Left,
            e.Insets.Top,
            e.Insets.Right,
            e.Insets.Bottom
        );
    }
}

using Avalonia.Controls.ApplicationLifetimes;

public override void OnFrameworkInitializationCompleted()
{
    if (ApplicationLifetime is IActivatableLifetime activatable)
    {
        // Handle app activation/deactivation
        activatable.Activated += OnActivated;
        activatable.Deactivated += OnDeactivated;
    }

    base.OnFrameworkInitializationCompleted();
}

private void OnActivated(object? sender, ActivatedEventArgs e)
{
    // App came to foreground
}

private void OnDeactivated(object? sender, ActivatedEventArgs e)
{
    // App went to background - save state
}

using Avalonia.Input;

public class TouchableControl : Control
{
    protected override void OnPointerPressed(PointerPressedEventArgs e)
    {
        base.OnPointerPressed(e);
        
        var props = e.GetCurrentPoint(this).Properties;
        
        if (props.IsLeftButtonPressed)
        {
            // Handle touch/tap
            var position = e.GetPosition(this);
            Console.WriteLine($"Touch at {position}");
        }
    }
    
    protected override void OnPointerMoved(PointerEventArgs e)
    {
        base.OnPointerMoved(e);
        
        // Handle drag/pan
        var position = e.GetPosition(this);
    }
}

using Avalonia.Input;
using Avalonia.Platform;

public class LoginView : UserControl
{
    private void ShowKeyboard()
    {
        var inputPane = TopLevel.GetTopLevel(this)
            ?.InputPane;
            
        if (inputPane != null)
        {
            // Show keyboard
            inputPane.Show();
            
            // Listen for keyboard visibility changes
            inputPane.StateChanged += (s, e) =>
            {
                if (e.NewState == InputPaneState.Closed)
                {
                    // Keyboard was hidden
                }
            };
        }
    }
}

using Avalonia.Platform.Storage;

public async Task PickImageAsync()
{
    var topLevel = TopLevel.GetTopLevel(this);
    var files = await topLevel.StorageProvider.OpenFilePickerAsync(
        new FilePickerOpenOptions
        {
            Title = "Select an image",
            AllowMultiple = false,
            FileTypeFilter = new[]
            {
                FilePickerFileTypes.ImageAll
            }
        });
    
    if (files.Count > 0)
    {
        await using var stream = await files[0].OpenReadAsync();
        // Load image from stream
    }
}

using Avalonia.Platform;

public class ResponsiveView : UserControl
{
    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
    {
        base.OnAttachedToVisualTree(e);
        
        var screens = TopLevel.GetTopLevel(this)?.Screens;
        if (screens?.ScreenFromVisual(this) is Screen screen)
        {
            UpdateLayoutForOrientation(screen.CurrentOrientation);
            
            // Listen for orientation changes
            screens.Changed += (s, args) =>
            {
                if (screens.ScreenFromVisual(this) is Screen currentScreen)
                {
                    UpdateLayoutForOrientation(currentScreen.CurrentOrientation);
                }
            };
        }
    }
    
    private void UpdateLayoutForOrientation(ScreenOrientation orientation)
    {
        if (orientation == ScreenOrientation.Portrait ||
            orientation == ScreenOrientation.PortraitFlipped)
        {
            // Portrait layout
        }
        else
        {
            // Landscape layout
        }
    }
}

// Mobile devices have limited memory
public override void OnFrameworkInitializationCompleted()
{
    if (ApplicationLifetime is IActivatableLifetime activatable)
    {
        activatable.Deactivated += (s, e) =>
        {
            // Clear caches when app goes to background
            GC.Collect();
            GC.WaitForPendingFinalizers();
        };
    }
}