.Net Maui Creating And Consuming Platform Specific Services Complete Guide

Complete Examples, Step-by-Step for Beginners: .NET MAUI Creating and Consuming Platform-Specific Services

Overview

In this example, we'll create a simple MAUI application that accesses a platform-specific service to get the battery level of the device. We'll use dependency injection to make it easy to inject and work with the platform-specific service.

Step-by-Step Guide

1. Create a New .NET MAUI Project

   • Open Visual Studio.
   • Select "Create a new project".
   • Choose "Multi-platform" and then "MAUI App (.NET 6)".
   • Name your project (e.g., PlatformSpecificServices).
   • Click "Create".

2. Define an Interface in the Shared Project

   The first step is to create an interface in the shared project that defines the service you want to use. This interface will be implemented on each platform.

   // Shared/IBatteryService.cs
   namespace PlatformSpecificServices
   {
       public interface IBatteryService
       {
           int GetBatteryLevel();
       }
   }
   

3. Implement the Interface for Each Platform

   For each platform (iOS, Android, Windows), you'll need to implement this interface.

   Android

   // Platforms/Android/BatteryService.cs
   using Android.OS;
   using PlatformSpecificServices;
   
   namespace PlatformSpecificServices.Platforms.Android
   {
       public class BatteryService : IBatteryService
       {
           public int GetBatteryLevel()
           {
               var batteryStatus = PowerManager.BatteryStatusOk;
               var batteryLevel = 0;
   
               using (var receiver = new BatteryStatusReceiver())
               {
                   using (var filter = new IntentFilter(Intent.ActionBatteryChanged))
                   {
                       Android.App.Application.Context.RegisterReceiver(receiver, filter);
   
                       batteryStatus = receiver.Status;
                       batteryLevel = (int)(receiver.Level / (float)receiver.Scale * 100);
                       Android.App.Application.Context.UnregisterReceiver(receiver);
                   }
               }
   
               return batteryLevel;
           }
   
           private class BatteryStatusReceiver : BroadcastReceiver
           {
               public int Status { get; private set; }
               public int Level { get; private set; }
               public int Scale { get; private set; }
   
               public override void OnReceive(Context context, Intent intent)
               {
                   Status = intent.GetIntExtra(BatteryManager.ExtraStatus, -1);
                   Level = intent.GetIntExtra(BatteryManager.ExtraLevel, -1);
                   Scale = intent.GetIntExtra(BatteryManager.ExtraScale, -1);
               }
           }
       }
   }
   

   iOS

   // Platforms/iOS/BatteryService.cs
   using UIKit;
   using Foundation;
   using PlatformSpecificServices;
   
   namespace PlatformSpecificServices.Platforms.iOS
   {
       public class BatteryService : IBatteryService
       {
           public int GetBatteryLevel()
           {
               return (int)(UIDevice.CurrentDevice.BatteryLevel * 100);
           }
       }
   }
   

   Windows

   For Windows, you can use the Windows.System.Power namespace to get the battery level.

   // Platforms/Windows/BatteryService.cs
   using Windows.System.Power;
   using PlatformSpecificServices;
   
   namespace PlatformSpecificServices.Platforms.Windows
   {
       public class BatteryService : IBatteryService
       {
           public int GetBatteryLevel()
           {
               var batteryReport = PowerManager.GetPowerSupplyReport();
               if (batteryReport != null && batteryReport.BatteryLifePercent.HasValue)
               {
                   return (int)(batteryReport.BatteryLifePercent.Value * 100);
               }
               return 0;
           }
       }
   }
   

4. Register the Services

   Use the MauiAppBuilder to register the platform-specific implementations of your service.

   // MauiProgram.cs
   using Microsoft.Extensions.DependencyInjection;
   using PlatformSpecificServices;
   using PlatformSpecificServices.Platforms.Android;
   using PlatformSpecificServices.Platforms.iOS;
   using PlatformSpecificServices.Platforms.Windows;
   
   namespace PlatformSpecificServices
   {
       public static class MauiProgram
       {
           public static MauiApp CreateMauiApp()
           {
               var builder = MauiApp.CreateBuilder();
               builder
                   .UseMauiApp<App>()
                   .ConfigureFonts(fonts =>
                   {
                       fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                   });
   
               builder.Services.AddSingleton<IBatteryService>(new BatteryService());
   
               return builder.Build();
           }
       }
   }
   

5. Consume the Service

   Finally, consume the service in your MAUI application. Here's an example of how you can display the battery level in a label.

   // MainPage.xaml.cs
   using Microsoft.Extensions.DependencyInjection;
   using PlatformSpecificServices;
   using System.ComponentModel;
   using System.Runtime.CompilerServices;
   using System.Threading.Tasks;
   
   namespace PlatformSpecificServices
   {
       public partial class MainPage : ContentPage, INotifyPropertyChanged
       {
           private readonly IBatteryService _batteryService;
           private string _batteryLevelText;
   
           public string BatteryLevelText
           {
               get => _batteryLevelText;
               set
               {
                   if (_batteryLevelText != value)
                   {
                       _batteryLevelText = value;
                       OnPropertyChanged();
                   }
               }
           }
   
           public MainPage()
           {
               InitializeComponent();
               BindingContext = this;
   
               _batteryService = MauiApplication.Current.Services.GetService<IBatteryService>();
               UpdateBatteryLevel();
           }
   
           private async Task UpdateBatteryLevel()
           {
               var batteryLevel = _batteryService.GetBatteryLevel();
               BatteryLevelText = $"Battery Level: {batteryLevel}%";
           }
   
           public event PropertyChangedEventHandler PropertyChanged;
           protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
           {
               PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
           }
       }
   }
   

   <!-- MainPage.xaml -->
   <?xml version="1.0" encoding="utf-8" ?>
   <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                x:Class="PlatformSpecificServices.MainPage">
       <StackLayout>
           <Label Text="{Binding BatteryLevelText}"
                  FontSize="Title"
                  HorizontalOptions="Center"
                  VerticalOptions="Center" />
       </StackLayout>
   </ContentPage>
   

6. Build and Run

   • Build and run your application on each platform to see the battery level displayed.

Summary