Présentation de l'administration des appareils

Abandon de l'outil d'administration des appareils. À partir d'Android 9 (niveau d'API 28), certaines règles d'administration seront marquées comme obsolètes lorsqu'elles sont appelées par un administrateur d'appareil. Nous vous recommandons de vous préparer dès maintenant à ce changement. Pour en savoir plus et consulter les options de migration, consultez Abandon de l'administrateur d'appareils.

Android prend en charge les applications d'entreprise via API Android Device Administration. L'API Device Administration fournit des informations sur les appareils au niveau du système. Ces API vous permettent de créer des applications axées sur la sécurité qui sont utiles dans les environnements d'entreprise, où les professionnels de l'IT ont besoin d'un contrôle étendu sur les appareils des employés. Par exemple, l'application de messagerie Android intégrée a exploité ces API pour améliorer Prise en charge d'Exchange. Via l'application de messagerie, les administrateurs Exchange peuvent appliquer des règles de mot de passe, y compris des mots de passe alphanumériques ou des codes numériques, sur tous les appareils. Les administrateurs peuvent également effacer à distance (c'est-à-dire rétablir les paramètres d'usine) les téléphones perdus ou volés. Synchronisation des utilisateurs Exchange leurs e-mails et leurs données d'agenda.

Ce document s'adresse aux développeurs qui souhaitent développer des solutions d'entreprise pour les appareils Android. Il aborde les différentes fonctionnalités fournies par l'API Device Administration afin de renforcer la sécurité des les appareils des employés qui fonctionnent sous Android.

Remarque : Pour savoir comment créer un Work Policy Controller pour les déploiements Android for Work, consultez Créer un Device Policy Controller.

Mode propriétaire de l'appareil headless

Android 14 (niveau d'API 34) introduit le mode Utilisateur système headless (les appareils dans lequel UserManager.isHeadlessSystemUserMode renvoie true). En mode "Headless System User", l'utilisateur système est utilisateur en arrière-plan et compte sur des utilisateurs de premier plan supplémentaires pour l'utilisateur final d'interaction. Android 14 introduit également un mode affilié au propriétaire de l'appareil sans tête, qui ajoute un propriétaire de profil à tous les utilisateurs affiliés, à l'exception de l'utilisateur système sur lequel le propriétaire de l'appareil est défini.

Dans les appareils configurés avec un utilisateur système headless (où l'utilisateur système s'exécute en arrière-plan), uniquement les règles relatives aux appareils qui ont un champ d'application global. (règles applicables à tous les utilisateurs) sont appliquées à l'utilisateur de premier plan. ou utilisateurs. Voir addUserRestriction pour en savoir plus.

<ph type="x-smartling-placeholder">

</ph> Remarque:Sous Android 14 (niveau d'API 34), une application DPC peut être définie en tant que propriétaire d'un appareil configuré en tant que Appareil en mode utilisateur système headless uniquement s'il est compatible avec le mode affilié. Voir HEADLESS_DEVICE_OWNER_MODE_AFFILIATED pour en savoir plus.

Les fabricants d'appareils Android peuvent consulter les consignes publiées sur source.android.com.

Présentation de l'API Device Administration

Voici des exemples de types d'applications qui peuvent utiliser l'API Device Administration:

• Clients de messagerie.
• Applications de sécurité qui effectuent un effacement à distance
• Services et applications de gestion d'appareils.

Fonctionnement

Vous utilisez l'API Device Administration pour écrire des applications d'administration d'appareils que les utilisateurs installent sur leurs appareils. L'application d'administration de l'appareil applique les règles souhaitées. Voici le principe de fonctionnement :

• Un administrateur système écrit une application d'administration d'appareil qui applique des règles de sécurité d'appareil à distance/locale. Ces règles peuvent être codées en dur dans l'application, ou l'application peut récupérer dynamiquement des règles à partir d'un serveur tiers.
• L'application est installée sur les appareils des utilisateurs appareils. Android ne disposent actuellement d'aucune solution de provisionnement automatisé. Voici quelques-unes des méthodes qu'un administrateur système peut utiliser pour distribuer l'application aux utilisateurs :
  • Google Play.
  • Activation de l'installation depuis un autre magasin.
  • Distribuer l'application par d'autres moyens, tels que des e-mails ou des sites Web
• Le système invite l'utilisateur à activer l'application d'administration de l'appareil. Comment Le moment où cela se produit dépend de la façon dont l'application est implémentée.
• Une fois que les utilisateurs activent l'application d'administration de l'appareil, ils sont soumis aux ses règles. Le respect de ces règles présente généralement des avantages, tels que l'accès à des données et systèmes sensibles.

Si les utilisateurs n'activent pas l'application d'administration de l'appareil, elle reste sur l'appareil, mais dans un état inactif. Les utilisateurs ne seront pas soumis à ses règles et ne bénéficieront en revanche d'aucun des avantages de l'application. Par exemple, ils ne pourront peut-être pas synchroniser de données.

Si un utilisateur ne respecte pas les règles (par exemple, si un utilisateur définit un qui enfreint ces consignes), il appartient à l'application de décider comment gérer cela. Toutefois, cela empêche généralement l'utilisateur en mesure de synchroniser des données.

Si un appareil tente de se connecter à un serveur qui exige des règles non prise en charge dans l'API Device Administration, la connexion n'est pas ne sont pas autorisés. L'API Device Administration n'autorise actuellement pas le provisionnement partiel. En d'autres termes, si un appareil (un ancien appareil, par exemple) n'est pas compatible avec toutes les règles mentionnées, il n'existe aucun moyen périphérique pour se connecter.

Si un appareil contient plusieurs applications d'administration activées, la règle la plus stricte est est appliquée. Il n'existe aucun moyen de cibler une application d'administration spécifique.

Pour désinstaller une application d'administration de l'appareil, les utilisateurs doivent : commencez par annuler l'enregistrement de l'application en tant qu'administrateur.

Règles

Dans une entreprise, les appareils des employés doivent souvent respectent un ensemble de règles strictes régissant l'utilisation de l'appareil. L'API Device Administration est compatible avec les règles listées dans le tableau 1. Notez que l'API Device Administration n'est actuellement compatible qu'avec les mots de passe d'écran verrouiller:

Tableau 1. Règles compatibles avec l'API Device Administration.

Règle	Description
Mot de passe activé	Nécessite que les appareils demandent un code ou un mot de passe.
Longueur minimale du mot de passe	Définissez le nombre de caractères requis pour le mot de passe. Par exemple, vous pouvez exiger que les codes ou les mots de passe comportent au moins six caractères.
Mot de passe alphanumérique requis	Les mots de passe doivent comporter une combinaison de lettres et de chiffres. Ils peuvent inclure des caractères symboliques.
Mot de passe complexe requis	Les mots de passe doivent contenir au moins une lettre, un chiffre et un symbole spécial. Introduit dans Android 3.0.
Nombre minimal de lettres requis dans le mot de passe	Le nombre minimum de les lettres requises dans le mot de passe pour tous les administrateurs ou pour un administrateur en particulier. Introduit dans Android 3.0.
Nombre minimal de lettres minuscules requises dans le mot de passe	Le nombre minimal de minuscules les lettres requises dans le mot de passe pour tous les administrateurs ou pour un administrateur en particulier. Introduit dans Android 3.0.
Nombre minimal de caractères autres que des lettres requis dans le mot de passe	Le nombre minimum de caractères autres que des lettres requis dans le mot de passe pour tous les administrateurs ou pour un administrateur particulier. Introduit dans Android 3.0.
Nombre minimal de chiffres requis dans le mot de passe	Nombre minimal de chiffres requis dans le mot de passe pour tous les administrateurs ou un administrateur en particulier. Introduit dans Android 3.0.
Nombre minimal de symboles requis dans le mot de passe	Nombre minimal de symboles requis dans le mot de passe pour tous les administrateurs ou pour un administrateur en particulier. Introduit dans Android 3.0.
Nombre minimal de lettres majuscules requises dans le mot de passe	Nombre minimal de lettres majuscules requis dans le mot de passe pour tous les administrateurs ou pour un administrateur en particulier. Introduit dans Android 3.0.
Délai avant expiration du mot de passe	Délai d'expiration du mot de passe, exprimé en millisecondes à partir du moment où l'administrateur de l'appareil a défini le délai d'expiration. Introduit dans Android 3.0.
Restriction de l'historique des mots de passe	Cette règle empêche les utilisateurs de réutiliser les n derniers mots de passe uniques. Cette règle est généralement utilisée avec setPasswordExpirationTimeout(), qui oblige les utilisateurs à mettre à jour leurs mots de passe une fois un certain temps écoulé. Introduit dans Android 3.0.
Nombre maximal de tentatives de saisie de mot de passe infructueuses	Indique le nombre de fois où un utilisateur peut saisir un mot de passe incorrect avant que l'appareil ne efface ses données. L'API Device Administration permet également aux administrateurs de rétablir la configuration d'usine de l'appareil à distance. Cela sécurise les données en cas de perte ou de vol de l'appareil.
Durée maximale d'inactivité sans verrouillage	Définit le délai écoulé depuis la dernière fois que l'utilisateur a touché l'écran ou appuyé sur un bouton avant que l'appareil ne verrouille l'écran. Lorsque cela se produit, les utilisateurs doivent ressaisir leur code PIN ou leurs mots de passe avant de pouvoir utiliser leurs appareils et accéder aux données. La valeur peut être comprise entre 1 et 60 minutes.
Exiger le chiffrement du stockage	Indique que la zone de stockage doit être chiffrée, si l'appareil le permet. Introduit dans Android 3.0.
Désactiver l'appareil photo	Indique que la caméra doit être désactivée. Notez que cette désactivation n'a pas besoin d'être définitive. La caméra peut être activée/désactivée de façon dynamique. en fonction du contexte, de l'heure, etc. Introduit dans Android 4.0.

Autres fonctions

En plus de prendre en charge les règles listées dans le tableau ci-dessus, l'API Device Administration vous permet d'effectuer les opérations suivantes :

• Invitez l'utilisateur à définir un nouveau mot de passe.
• Verrouillez immédiatement l'appareil.
• Effacer les données de l'appareil (c'est-à-dire rétablir sa configuration d'usine)

Application exemple

Les exemples utilisés sur cette page sont basés sur l'exemple d'API Device Administration, qui est inclus dans les exemples de SDK (disponibles via le SDK Manager Android) et se trouve sur votre système sous le nom <sdk_root>/ApiDemos/app/src/main/java/com/example/android/apis/app/DeviceAdminSample.java.

L'application exemple propose une démonstration des fonctionnalités d'administration des appareils. Il présente aux utilisateurs une interface utilisateur qui leur permet d'activer l'application d'administration de l'appareil. Une fois l'application activée, les utilisateurs peuvent utiliser les boutons de l'interface utilisateur pour effectuer les opérations suivantes :

• Définissez la qualité du mot de passe.
• Spécifiez les exigences relatives au mot de passe de l'utilisateur, telles que la longueur minimale, le nombre minimal de les caractères numériques qu'elle doit contenir, etc.
• Définissez le mot de passe. Si le mot de passe n'est pas conforme aux règles spécifiées, le système renvoie une erreur.
• Définir le nombre de tentatives infructueuses de saisie du mot de passe avant l'effacement des données de l'appareil (c'est-à-dire lorsque sa configuration d'usine a été rétablie).
• Définissez le délai d'expiration du mot de passe.
• Définissez la longueur de l'historique des mots de passe (length fait référence au nombre d'anciens mots de passe stockés dans l'historique). Cela empêche les utilisateurs de réutiliser l'un des n derniers mots de passe qu'ils ont utilisés.
• Indiquez que la zone de stockage doit être chiffrée, si l'appareil le permet.
• Définir la durée maximale d'inactivité avant l'appareil ces serrures.
• Verrouillez immédiatement l'appareil.
• Effacez les données de l'appareil (c'est-à-dire rétablissez la configuration d'usine).
• Désactivez la caméra.

Figure 1 : Capture d'écran de l'application exemple

Développer une application d'administration d'appareils

Les administrateurs système peuvent utiliser l'API Device Administration pour écrire une application. qui applique l’application des stratégies de sécurité des appareils distants/locaux. Cette section résume les étapes à suivre pour créer une application d'administration d'appareils.

Créer le fichier manifeste

Pour utiliser l'API Device Administration, le fichier manifeste doit inclure les éléments suivants:

• Sous-classe de DeviceAdminReceiver qui inclut les éléments suivants :
  • L'autorisation BIND_DEVICE_ADMIN
  • La possibilité de répondre à l'ACTION_DEVICE_ADMIN_ENABLED un intent, exprimé dans le fichier manifeste sous la forme d'un filtre d'intent.
• Déclaration des règles de sécurité utilisées dans les métadonnées.

Voici un extrait de l'exemple de fichier manifeste d'administration des appareils:

<activity android:name=".app.DeviceAdminSample"
            android:label="@string/activity_sample_device_admin">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.SAMPLE_CODE" />
    </intent-filter>
</activity>
<receiver android:name=".app.DeviceAdminSample$DeviceAdminSampleReceiver"
        android:label="@string/sample_device_admin"
        android:description="@string/sample_device_admin_description"
        android:permission="android.permission.BIND_DEVICE_ADMIN">
    <meta-data android:name="android.app.device_admin"
            android:resource="@xml/device_admin_sample" />
    <intent-filter>
        <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
    </intent-filter>
</receiver>

Gardez à l'esprit les points suivants :

• Les attributs suivants font référence aux ressources de chaîne qui, pour l'exemple d'application, se trouvent ApiDemos/res/values/strings.xml Pour en savoir plus sur les ressources, consultez la section Ressources d'application.
  • android:label="@string/activity_sample_device_admin" fait référence au libellé lisible par l'utilisateur de l'activité.
  • android:label="@string/sample_device_admin" fait référence au libellé lisible par l'utilisateur pour l'autorisation.
  • android:description="@string/sample_device_admin_description" fait référence à la description lisible par l’utilisateur de l’autorisation. Une description est généralement plus longue et plus informative qu'un libellé.
• android:permission="android.permission.BIND_DEVICE_ADMIN" est une autorisation qu'une sous-classe DeviceAdminReceiver doit pour s'assurer que seul le système peut interagir avec le récepteur (aucune application ne peut obtenir cette autorisation). Ce empêche les autres applications d'utiliser l'application d'administration de votre appareil de façon abusive.
• android.app.action.DEVICE_ADMIN_ENABLED est l'instance principale action qu'une sous-classe DeviceAdminReceiver doit gérer pour être autorisé à gérer un appareil. Ce paramètre est défini sur le destinataire lorsque l'utilisateur active l'application d'administration de l'appareil. Votre code gère généralement cela dans onEnabled(). Pour être pris en charge, le récepteur doit également ont besoin de l'autorisation BIND_DEVICE_ADMIN pour que les autres applications ne peut pas en abuser.
• Lorsqu'un utilisateur active l'application d'administration de l'appareil, le destinataire est autorisé à effectuer des actions en réponse à la diffusion d'événements système spécifiques. Lorsqu'un événement approprié se produit, l'appli peut imposer une règle. Par exemple, si l'utilisateur tente de définir un nouveau mot de passe qui ne répond pas aux exigences du règlement, l'application peut l'inviter à choisir un autre mot de passe qui répond aux exigences.
• Évitez de modifier le nom du récepteur après avoir publié votre application. Si le nom figurant dans le champ modifications du fichier manifeste, l'administration de l'appareil est désactivée lorsque les utilisateurs mettent à jour l'application. Pour en savoir plus, consultez <receiver>
• android:resource="@xml/device_admin_sample" déclare les stratégies de sécurité utilisées dans les métadonnées. Les métadonnées fournissent des informations supplémentaires spécifiques à l'administrateur de l'appareil, telles qu'elles sont analysées par la classe DeviceAdminInfo. Voici le contenu de device_admin_sample.xml :

<device-admin xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-policies>
    <limit-password />
    <watch-login />
    <reset-password />
    <force-lock />
    <wipe-data />
    <expire-password />
    <encrypted-storage />
    <disable-camera />
  </uses-policies>
</device-admin>

Lors de la conception de votre application d'administration d'appareils, vous n'avez pas besoin toutes les règles, seulement celles qui s'appliquent à votre application.

Pour en savoir plus sur le fichier manifeste, consultez le guide du développeur Android.

Implémenter le code

L'API Device Administration comprend les classes suivantes:

DeviceAdminReceiver

Classe de base pour l'implémentation d'un composant d'administration des appareils. Cette classe permet d'interpréter facilement les actions d'intent brutes envoyées par le système. Votre application d'administration des appareils doit inclure une sous-classe DeviceAdminReceiver.

DevicePolicyManager

Classe permettant de gérer les règles appliquées à un appareil. La plupart des clients de cette classe doivent avoir publié un DeviceAdminReceiver que l'utilisateur a actuellement activé. DevicePolicyManager gère les stratégies d'une ou de plusieurs instances DeviceAdminReceiver.

DeviceAdminInfo

Cette classe est utilisée pour spécifier les métadonnées. d'un composant d'administrateur de l'appareil.

Ces classes constituent la base d'une application d'administration d'appareils entièrement fonctionnelle. Le reste de cette section explique comment utiliser les API DeviceAdminReceiver et DevicePolicyManager pour écrire une application d'administration d'appareils.

Sous-classer DeviceAdminReceiver

Pour créer une application d'administration d'appareil, vous devez sous-classer DeviceAdminReceiver. La classe DeviceAdminReceiver consiste en une série de rappels qui sont déclenchés lorsque des événements particuliers se produisent.

Dans sa sous-classe DeviceAdminReceiver, l'application exemple affiche simplement une notification Toast en réponse à des événements particuliers. Exemple :

KotlinJava

class DeviceAdminSample : DeviceAdminReceiver() {

    private fun showToast(context: Context, msg: String) {
        context.getString(R.string.admin_receiver_status, msg).let { status ->
            Toast.makeText(context, status, Toast.LENGTH_SHORT).show()
        }
    }

    override fun onEnabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_enabled))

    override fun onDisableRequested(context: Context, intent: Intent): CharSequence =
            context.getString(R.string.admin_receiver_status_disable_warning)

    override fun onDisabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_disabled))

    override fun onPasswordChanged(context: Context, intent: Intent, userHandle: UserHandle) =
            showToast(context, context.getString(R.string.admin_receiver_status_pw_changed))
...
}

public class DeviceAdminSample extends DeviceAdminReceiver {

    void showToast(Context context, String msg) {
        String status = context.getString(R.string.admin_receiver_status, msg);
        Toast.makeText(context, status, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onEnabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_enabled));
    }

    @Override
    public CharSequence onDisableRequested(Context context, Intent intent) {
        return context.getString(R.string.admin_receiver_status_disable_warning);
    }

    @Override
    public void onDisabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_disabled));
    }

    @Override
    public void onPasswordChanged(Context context, Intent intent, UserHandle userHandle) {
        showToast(context, context.getString(R.string.admin_receiver_status_pw_changed));
    }
...
}

Activer l'application

L'un des principaux événements qu'une application d'administration de l'appareil doit gérer est l'utilisateur activer l'application. L'utilisateur doit activer explicitement l'application pour les stratégies à appliquer. Si l'utilisateur choisit de ne pas activer l'application il sera toujours présent sur l'appareil, mais ses règles ne seront pas appliquées et l'utilisateur n'y aura pas accès de bénéficier de tous les avantages de l'application.

Le processus d'activation de l'application commence lorsque l'utilisateur effectue action qui déclenche le ACTION_ADD_DEVICE_ADMIN l'intention. Dans l'application exemple, cela se produit lorsque l'utilisateur clique sur la case à cocher Activer l'administrateur.

Lorsque l'utilisateur clique sur la case à cocher Activer l'administrateur, l'écran change pour inviter l'utilisateur à activer l'application d'administration de l'appareil, comme illustré à la figure 2.

Figure 2. Application exemple: activation de l'application

Vous trouverez ci-dessous le code exécuté lorsque l'utilisateur clique sur la case Activer l'administrateur. Cela a pour effet de déclencher le rappel onPreferenceChange(). Ce rappel est appelé lorsque la valeur de cet élément Preference a été modifiée par l'utilisateur et qu'elle est sur le point d'être définie et/ou conservée. Si l'utilisateur active l'application, l'écran change pour l'inviter à activer l'application d'administration de l'appareil, comme illustré à la figure 2. Sinon, l'application d'administration de l'appareil est désactivée.

KotlinJava

override fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {
    if (super.onPreferenceChange(preference, newValue)) return true
    val value = newValue as Boolean
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                val intent = Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN).apply {
                    putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample)
                    putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                            activity.getString(R.string.add_admin_extra_app_text))
                }
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN)
                // return false - don't update checkbox until we're really active
                return false
            } else {
                dpm.removeActiveAdmin(deviceAdminSample)
                enableDeviceCapabilitiesArea(false)
                adminActive = false
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value)
    }
    return true
}

@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
    if (super.onPreferenceChange(preference, newValue)) {
        return true;
    }
    boolean value = (Boolean) newValue;
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
                intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample);
                intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                        activity.getString(R.string.add_admin_extra_app_text));
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN);
                // return false - don't update checkbox until we're really active
                return false;
            } else {
                dpm.removeActiveAdmin(deviceAdminSample);
                enableDeviceCapabilitiesArea(false);
                adminActive = false;
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value);
    }
    return true;
}

La ligne intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, mDeviceAdminSample) indique que mDeviceAdminSample (qui est un composant DeviceAdminReceiver) est la règle cible. Cette ligne appelle l'interface utilisateur illustrée à la figure 2, qui guide les utilisateurs à travers ajouter l'administrateur de l'appareil au système (ou lui permettre de le refuser).

Lorsque l'application doit effectuer une opération qui dépend de la l'application d'administration de l'appareil en cours d'activation, cela confirme que l'application est actif. Pour ce faire, il utilise la méthode DevicePolicyManager isAdminActive(). Notez que la méthode isAdminActive() de DevicePolicyManager utilise un composant DeviceAdminReceiver comme argument :

KotlinJava

private lateinit var dpm: DevicePolicyManager
...
private fun isActiveAdmin(): Boolean = dpm.isAdminActive(deviceAdminSample)

DevicePolicyManager dpm;
...
private boolean isActiveAdmin() {
    return dpm.isAdminActive(deviceAdminSample);
}

Gestion des règles

DevicePolicyManager est une classe publique permettant de gérer les règles. sur un appareil. DevicePolicyManager gère des règles pour une personne ou plusieurs instances DeviceAdminReceiver.

Vous obtenez un handle vers DevicePolicyManager comme suit:

KotlinJava

dpm = getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager

DevicePolicyManager dpm =
    (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);

Cette section explique comment utiliser DevicePolicyManager pour effectuer tâches administratives:

• Définir des règles de mots de passe
• Définir le verrouillage de l'appareil
• Effacer les données

Définir des règles relatives aux mots de passe

DevicePolicyManager inclut des API permettant de définir et d'appliquer règles relatives aux mots de passe de l'appareil. Dans l'API Device Administration, le mot de passe ne s'applique qu'au verrouillage de l'écran. Cette section décrit les tâches courantes liées aux mots de passe.

Définir un mot de passe pour l'appareil

Ce code affiche une interface utilisateur invitant l'utilisateur à définir un mot de passe :

KotlinJava

Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD).also { intent ->
    startActivity(intent)
}

Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
startActivity(intent);

Définir la qualité du mot de passe

La qualité du mot de passe peut être l'une des constantes DevicePolicyManager suivantes:

PASSWORD_QUALITY_ALPHABETIC

L'utilisateur doit saisir un mot de passe contenant au moins des caractères alphabétiques (ou d'autres symboles).

PASSWORD_QUALITY_ALPHANUMERIC

L'utilisateur doit saisir un mot de passe contenant au moins à la fois des caractères numériques et alphabétiques (ou autres symboles).

PASSWORD_QUALITY_NUMERIC

L'utilisateur doit saisir un mot de passe contenant au moins des caractères numériques.

PASSWORD_QUALITY_COMPLEX

L'utilisateur doit avoir saisi un mot de passe contenant au moins une lettre, un chiffre et un symbole spécial.

PASSWORD_QUALITY_SOMETHING

Les requiert une sorte de de mot de passe, mais peu importe.

PASSWORD_QUALITY_UNSPECIFIED

Le règlement n'impose aucune exigence concernant le mot de passe.

Par exemple, voici comment vous définiriez la règle de mot de passe pour exiger un mot de passe alphanumérique:

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC);

Définir les exigences relatives au contenu des mots de passe

À partir d'Android 3.0, la classe DevicePolicyManager inclut des méthodes qui vous permettent d'affiner le contenu du mot de passe. Pour Par exemple, vous pouvez définir une stratégie qui stipule que les mots de passe doivent contenir au moins n lettres majuscules. Voici les méthodes permettant d'affiner contenus:

• setPasswordMinimumLetters()
• setPasswordMinimumLowerCase()
• setPasswordMinimumUpperCase()
• setPasswordMinimumNonLetter()
• setPasswordMinimumNumeric()
• setPasswordMinimumSymbols()

Par exemple, cet extrait indique que le mot de passe doit comporter au moins deux lettres majuscules:

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwMinUppercase = 2
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwMinUppercase = 2;
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase);

Définir la longueur minimale du mot de passe

Vous pouvez spécifier qu'un mot de passe doit avoir au moins la longueur minimale spécifiée. Exemple :

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwLength: Int = ...
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwLength;
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength);

Définir le nombre maximal de tentatives infructueuses de saisie du mot de passe

Vous pouvez définir le nombre maximal de tentatives de saisie de mot de passe autorisées avant que l'appareil ne soit effacé (c'est-à-dire rétabli aux paramètres d'usine). Exemple :

KotlinJava

val dPM:DevicePolicyManager
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val maxFailedPw: Int = ...
...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int maxFailedPw;
 ...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw);

Définir le délai d'expiration du mot de passe

À partir d'Android 3.0, vous pouvez utiliser le setPasswordExpirationTimeout() permettant de définir la date d'expiration d'un mot de passe, exprimée en millisecondes à partir du moment où l'administrateur de l'appareil définit le délai d'expiration. Exemple :

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwExpiration: Long = ...
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
long pwExpiration;
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration);

Restreindre les mots de passe en fonction de l'historique

À partir de la version 3.0 d'Android, vous pouvez utiliser le setPasswordHistoryLength() pour limiter le nombre d'utilisateurs la possibilité de réutiliser d'anciens mots de passe. Cette méthode reçoit un paramètre length, qui spécifie le nombre d'anciens mots de passe stockés. Lorsque cette règle est active, les utilisateurs ne peuvent pas saisir un nouveau mot de passe qui correspond aux n derniers mots de passe. Cela empêche les utilisateurs d'utiliser le même mot de passe à plusieurs reprises. Cette règle est généralement utilisée en conjonction avec setPasswordExpirationTimeout(), ce qui oblige les utilisateurs de mettre à jour leurs mots de passe après un certain temps.

Par exemple, cet extrait interdit aux utilisateurs de réutiliser l'un de leurs cinq derniers mots de passe :

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwHistoryLength = 5
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwHistoryLength = 5;
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength);

Définir le verrouillage de l'appareil

Vous pouvez définir la période maximale d'inactivité de l'utilisateur qui peut se produire avant le les verrouillages de l'appareil. Exemple :

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val timeMs: Long = 1000L * timeout.text.toString().toLong()
...
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
long timeMs = 1000L*Long.parseLong(timeout.getText().toString());
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs);

Vous pouvez également programmer le verrouillage immédiat de l'appareil:

KotlinJava

private lateinit var dpm: DevicePolicyManager
dpm.lockNow()

DevicePolicyManager dpm;
dpm.lockNow();

Effacer les données

Vous pouvez utiliser la méthode DevicePolicyManagerwipeData() pour rétablir la configuration d'usine de l'appareil. C'est utile en cas de perte ou de vol de l'appareil. La décision d'effacer l'appareil est souvent prise lorsque certaines conditions sont remplies. Par exemple, vous pouvez utiliser setMaximumFailedPasswordsForWipe() pour indiquer qu'un appareil doit être effacé après un nombre spécifique de tentatives de saisie de mot de passe infructueuses.

Pour effacer les données, procédez comme suit:

KotlinJava

private lateinit var dpm: DevicePolicyManager
dpm.wipeData(0)

DevicePolicyManager dpm;
dpm.wipeData(0);

La méthode wipeData() utilise comme paramètre un masque de bits d'options supplémentaires. Actuellement, la valeur doit être 0.

Désactiver l'appareil photo

À partir d'Android 4.0, vous pouvez désactiver la caméra. Notez qu'il n'est pas nécessaire que cette désactivation soit définitive. La caméra peut être activée/désactivée de manière dynamique en fonction du contexte, de l'heure, etc.

Vous pouvez contrôler si la caméra est désactivée à l'aide de la méthode setCameraDisabled(). Par exemple, cet extrait définit l'activation ou la désactivation de la caméra en fonction d'un paramètre de case à cocher :

KotlinJava

private lateinit var disableCameraCheckbox: CheckBoxPreference
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked)

private CheckBoxPreference disableCameraCheckbox;
DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked());

Chiffrement du stockage

À partir d'Android 3.0, vous pouvez utiliser le setStorageEncryption() permettant de définir une règle exigeant le chiffrement de l'espace de stockage, le cas échéant.

Exemple :

KotlinJava

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setStorageEncryption(deviceAdminSample, true)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setStorageEncryption(deviceAdminSample, true);

Consultez l'exemple d'API Device Administration pour découvrir comment activer le chiffrement du stockage.

Autres exemples de code

Android AppRestrictionEnforcer. et DeviceOwner qui illustrent plus en détail l'utilisation des API abordées sur cette page.