Autorisations

Parcourir l'exemple

Cet article décrit comment utiliser la classe .NET MAUI (.NET Multi-Platform App UI) Permissions. Cette classe vous permet de vérifier et de demander des autorisations au moment de l’exécution. Le type Permissions est disponible dans l’espace de noms Microsoft.Maui.ApplicationModel.

Autorisations disponibles

.NET MAUI tente d’extraire autant d’autorisations que possible. Toutefois, l’ensemble d’autorisations est différent pour chaque système d’exploitation. Même si l’API autorise l’accès à une autorisation commune, des différences liées à cette autorisation peuvent exister entre les systèmes d’exploitation. Le tableau suivant décrit les autorisations disponibles :

Dans le tableau suivant, ✔️ indique que l’autorisation est prise en charge et ❌ indique que l’autorisation n’est pas prise en charge ou n’est pas requise :

Autorisation	Android	iOS	Windows	tvOS
Batterie	✔️	❌	❌	❌
Bluetooth	✔️	❌	❌	❌
CalendarRead	✔️	✔️	❌	❌
CalendarWrite	✔️	✔️	❌	❌
Appareil photo	✔️	✔️	❌	❌
ContactsRead	✔️	✔️	❌	❌
ContactsWrite	✔️	✔️	❌	❌
Lampe torche	✔️	❌	❌	❌
LocationWhenInUse	✔️	✔️	❌	✔️
LocationAlways	✔️	✔️	❌	❌
Média	❌	✔️	❌	❌
Microphone	✔️	✔️	❌	❌
NearbyWifiDevices	✔️	❌	❌	❌
NetworkState	✔️	❌	❌	❌
Téléphone	✔️	✔️	❌	❌
Photos	❌	✔️	❌	✔️
PhotosAddOnly	❌	✔️	❌	✔️
PostNotifications	✔️	❌	❌	❌
Rappels	❌	✔️	❌	❌
Capteurs	✔️	✔️	❌	❌
Sms	✔️	✔️	❌	❌
Speech	✔️	✔️	❌	❌
StorageRead	✔️	❌	❌	❌
StorageWrite	✔️	❌	❌	❌
Vibreur	✔️	❌	❌	❌

Important

Les autorisations StorageRead et StorageWrite retournent Granted toujours sur l’API Android 33+. Cela est dû au fait que les autorisations et Android READ_EXTERNAL_STORAGE WRITE_EXTERNAL_STORAGE sous-jacentes ne sont plus disponibles à partir de l’API 33.

Si une autorisation est signalée par ❌, elle retourne toujours Granted lorsqu’elle est activée ou demandée.

Vérification des autorisations

Pour vérifier l’état actuel d’une autorisation, utilisez la méthode Permissions.CheckStatusAsync, ainsi que l’autorisation spécifique pour laquelle obtenir l’état. L’exemple suivant vérifie l’état de l’autorisation LocationWhenInUse :

PermissionStatus status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();

Une PermissionException est levée si l’autorisation requise n’est pas déclarée.

Il est préférable de vérifier l’état de l’autorisation avant de la demander. Chaque système d’exploitation retourne un état par défaut différent si l’utilisateur n’a jamais été invité. iOS retourne Unknown, tandis que d’autres systèmes d’exploitation retournent Denied. Si l’état est Granted, il est inutile d’effectuer d’autres appels. Sur iOS, si l’état est Denied, vous devez inviter l’utilisateur à modifier l’autorisation dans les paramètres. Sur Android, vous pouvez appeler ShouldShowRationale pour détecter si l’utilisateur a déjà refusé l’autorisation dans le passé.

État de l’autorisation

Si vous utilisez CheckStatusAsync ou RequestAsync, vous pouvez utiliser le PermissionStatus retourné pour déterminer les étapes suivantes :

• Unknown
  L’autorisation est dans un état inconnu ou, sur iOS, l’utilisateur n’a jamais été invité.

• Denied
  L’utilisateur a refusé la demande d’autorisation.

• Disabled
  La fonctionnalité est désactivée sur l’appareil.

• Granted
  L’utilisateur a accordé l’autorisation ou l’autorisation est automatiquement accordée.

• Restricted
  Dans un état restreint.

• Limited
  Dans un état limité. Seul iOS retourne cet état.

Demande d’autorisations

Pour demander une autorisation aux utilisateurs, utilisez la méthode RequestAsync, ainsi que l’autorisation spécifique à demander. Si l’utilisateur a précédemment accordé une autorisation et ne l’a pas révoquée, cette méthode retourne Granted sans présenter de boîte de dialogue à l’utilisateur. Les autorisations ne doivent pas être demandées à partir de votre classe MauiProgram ou App, et ne doivent être demandées qu’une fois la première page de l’application affichée.

L’exemple suivant demande l’autorisation LocationWhenInUse :

PermissionStatus status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();

Une PermissionException est levée si l’autorisation requise n’est pas déclarée.

Important

Sur certaines plateformes, une demande d’autorisation ne peut être activée qu’une seule fois. Le développeur doit gérer d’autres invites pour vérifier si une autorisation est dans l’état Denied, puis pour demander à l’utilisateur de l’activer manuellement.

Expliquer pourquoi l’autorisation est nécessaire

Nous vous recommandons d’expliquer à votre utilisateur pourquoi votre application a besoin d’une autorisation spécifique. Sur iOS, vous devez spécifier une chaîne qui est présentée à l’utilisateur. Android n’offre pas cette option et définit également l’état d’autorisation par défaut sur Disabled. Cela limite la possibilité de savoir si l’utilisateur a refusé l’autorisation ou si c’est la première fois que l’autorisation est demandée. Vous pouvez utiliser la méthode ShouldShowRationale pour déterminer si une interface utilisateur informative doit être affichée. Si la méthode retourne true, cela signifie que l’utilisateur a refusé ou désactivé l’autorisation par le passé. D’autres plateformes retournent toujours false lors de l’appel de cette méthode.

Exemple

Le code suivant présente le modèle d’utilisation général permettant de déterminer si une autorisation a été accordée, puis de la demander si ce n’est pas le cas.

public async Task<PermissionStatus> CheckAndRequestLocationPermission()
{
    PermissionStatus status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();

    if (status == PermissionStatus.Granted)
        return status;

    if (status == PermissionStatus.Denied && DeviceInfo.Platform == DevicePlatform.iOS)
    {
        // Prompt the user to turn on in settings
        // On iOS once a permission has been denied it may not be requested again from the application
        return status;
    }

    if (Permissions.ShouldShowRationale<Permissions.LocationWhenInUse>())
    {
        // Prompt the user with additional information as to why the permission is needed
    }

    status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();

    return status;
}

Extension des autorisations

L’API Permissions a été créée pour être flexible et extensible pour les applications nécessitant davantage de validation ou d’autorisations qui ne sont pas incluses dans .NET MAUI. Créez une classe qui hérite de Permissions.BasePermission et implémentez les méthodes abstraites requises. L’exemple de code suivant illustre les membres abstraits de base, mais sans implémentation :

public class MyPermission : Permissions.BasePermission
{
    // This method checks if current status of the permission.
    public override Task<PermissionStatus> CheckStatusAsync()
    {
        throw new System.NotImplementedException();
    }

    // This method is optional and a PermissionException is often thrown if a permission is not declared.
    public override void EnsureDeclared()
    {
        throw new System.NotImplementedException();
    }

    // Requests the user to accept or deny a permission.
    public override Task<PermissionStatus> RequestAsync()
    {
        throw new System.NotImplementedException();
    }

    // Indicates that the requestor should prompt the user as to why the app requires the permission, because the
    // user has previously denied this permission.
    public override bool ShouldShowRationale()
    {
        throw new NotImplementedException();
    }
}

Lors de l’implémentation d’une autorisation sur une plateforme spécifique, la classe Permissions.BasePlatformPermission peut être héritée. Cette classe fournit des méthodes d’assistance de plateforme supplémentaires pour vérifier automatiquement les déclarations d’autorisation. Vous pouvez ainsi créer des autorisations personnalisées qui effectuent des regroupements, par exemple en demandant un accès en lecture et en écriture au stockage sur Android. L’exemple de code suivant illustre une demande d’accès au stockage en lecture et en écriture :

public class ReadWriteStoragePerms : Permissions.BasePlatformPermission
{
    public override (string androidPermission, bool isRuntime)[] RequiredPermissions =>
        new List<(string androidPermission, bool isRuntime)>
        {
        (global::Android.Manifest.Permission.ReadExternalStorage, true),
        (global::Android.Manifest.Permission.WriteExternalStorage, true)
        }.ToArray();
}

Vérifiez ensuite l’autorisation de la même façon que tout autre type d’autorisation fourni par .NET MAUI :

PermissionStatus status = await Permissions.RequestAsync<ReadWriteStoragePerms>();

Si vous souhaitez appeler cette API à partir de votre code multiplateforme, vous pouvez créer une interface et inscrire l’autorisation personnalisée en tant que dépendance dans le conteneur de services de l’application. L’exemple suivant montre l’interface IReadWritePermission :

public interface IReadWritePermission
{        
    Task<PermissionStatus> CheckStatusAsync();
    Task<PermissionStatus> RequestAsync();
}

Implémentez ensuite l’interface dans votre autorisation personnalisée :

public class ReadWriteStoragePermission : Permissions.BasePlatformPermission, IReadWritePermission
{
    public override (string androidPermission, bool isRuntime)[] RequiredPermissions => new List<(string androidPermission, bool isRuntime)>
    {
        (Android.Manifest.Permission.ReadExternalStorage, true),
        (Android.Manifest.Permission.WriteExternalStorage, true)
    }.ToArray();
}

Dans la classe MauiProgram, vous devez ensuite inscrire l’interface et son type concret, ainsi que le type qui consommera l’autorisation personnalisée, dans le conteneur de services de l’application :

builder.Services.AddTransient<MyViewModel>();
builder.Services.AddSingleton<IReadWritePermission, ReadWriteStoragePermission>();

Vous pouvez ensuite résoudre l’implémentation de l’autorisation personnalisée et l’appeler à partir de l’un de vos types, par exemple un viewmodel :

public class MyViewModel
{
    IReadWritePermission _readWritePermission;

    public MyViewModel(IReadWritePermission readWritePermission)
    {
        _readWritePermission = readWritePermission;
    }

    public async Task CheckPermissionAsync()
    {
        var status = await _readWritePermission.CheckStatusAsync();
        if (status != PermissionStatus.Granted)
        {
            status = await _readWritePermission.RequestAsync();
        }
    }
}

Différences selon les plateformes

Cette section décrit les différences propres à la plateforme concernant l’API d’autorisations.

Android

Les attributs correspondants doivent être définis dans le fichier manifeste Android des autorisations. L’état de l’autorisation est défini par défaut sur Denied.

iOS/Mac Catalyst

Les autorisations doivent avoir une chaîne correspondante dans le fichier Info.plist. Une fois qu’une autorisation a été demandée et refusée, la deuxième demande d’autorisation ne fait plus apparaître de fenêtre contextuelle. Vous devez inviter votre utilisateur à ajuster manuellement le paramètre dans l’écran Paramètres des applications dans iOS. L’état de l’autorisation est défini par défaut sur Unknown.

Windows

Aucune différence entre les plateformes.