Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Gestion de l'alimentation des applications

Dans Android 9 et les versions ultérieures, la plate-forme peut surveiller les applications pour détecter un comportement qui affecte négativement la durée de vie de la batterie des appareils. La plateforme utilise et évalue les règles de configuration pour fournir un flux UX qui donne aux utilisateurs la possibilité de restreindre les applications qui enfreignent les règles.

Dans Android 8.0 et les versions antérieures, il y avait des restrictions via des fonctionnalités telles que Doze, la mise en veille de l'application, les limites d'arrière-plan et les limites d'emplacement en arrière-plan. Cependant, certaines applications ont continué à présenter de mauvais comportements, dont certains sont décrits dans Android Vitals . Android 9 a introduit une infrastructure de système d'exploitation qui peut détecter et restreindre les applications en fonction de règles de configuration pouvant être mises à jour au fil du temps.

Restrictions d'arrière-plan

Les utilisateurs peuvent restreindre les applications, ou le système peut suggérer que les applications qu'il détecte ont un impact négatif sur la santé de l'appareil.

Applications restreintes:

  • Peut encore être lancé par l'utilisateur.
  • Impossible d'exécuter des tâches / alarmes ou d'utiliser le réseau en arrière-plan.
  • Impossible d'exécuter les services de premier plan.
  • Peut être changé en une application sans restriction par l'utilisateur.

Les développeurs d'appareils peuvent ajouter des restrictions supplémentaires aux applications pour:

  • Empêchez l'application de redémarrer automatiquement.
  • Interdire aux services d'être liés (très risqué).

Les applications restreintes en arrière-plan ne devraient pas consommer de ressources de l'appareil, telles que la mémoire, le processeur et la batterie. Les applications restreintes en arrière-plan ne devraient pas avoir d'incidence sur la santé de l'appareil lorsque l'utilisateur n'utilise pas activement ces applications. Cependant, on s'attend à ce que les mêmes applications soient pleinement fonctionnelles lorsque l'utilisateur lance les applications.

Utilisation d'implémentations personnalisées

Les développeurs d'appareils peuvent continuer à utiliser leurs méthodes personnalisées pour appliquer des restrictions sur les applications.

Intégration des restrictions d'application

Les sections suivantes expliquent comment définir et intégrer les restrictions d'application sur votre appareil. Si vous utilisez des méthodes de restriction d'applications à partir d'Android 8.x ou version antérieure, consultez attentivement les sections suivantes pour connaître les modifications apportées à Android 9 et versions ultérieures.

Définition de l'indicateur AppOpsManager

Lorsqu'une application est restreinte, définissez l'indicateur approprié dans AppOpsManager . Un exemple d'extrait de code de packages/apps/Settings/src/com/android/settings/fuelgauge/BatteryUtils.java :

   public void setForceAppStandby(int uid, String packageName,
            int mode) {
        final boolean isPreOApp = isPreOApp(packageName);
        if (isPreOApp) {
       // Control whether app could run in the background if it is pre O app
            mAppOpsManager.setMode(AppOpsManager.OP_RUN_IN_BACKGROUND, uid, packageName, mode);
        }
       // Control whether app could run jobs in the background
        mAppOpsManager.setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, uid, packageName, mode);
    }

S'assurer que isBackgroundRestricted renvoie true

Lorsqu'une application est restreinte, assurez-vous que ActivityManager.isBackgroundRestricted() renvoie true .

Enregistrer la raison de la restriction

Lorsqu'une application est restreinte, enregistrez les raisons de la restriction. Un exemple d'extrait de code de journalisation à partir de packages/apps/Settings/src/com/android/settings/fuelgauge/batterytip/actions/RestrictAppAction.java :

mBatteryUtils.setForceAppStandby(mBatteryUtils.getPackageUid(packageName), packageName,AppOpsManager.MODE_IGNORED);
if (CollectionUtils.isEmpty(appInfo.anomalyTypes)) {
  // Only log context if there is no anomaly type
  mMetricsFeatureProvider.action(mContext,
    MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP, packageName,
    Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT,metricsKey));
            } else {
  // Log ALL the anomaly types
  for (int type : appInfo.anomalyTypes) {
    mMetricsFeatureProvider.action(mContext,
      MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP, packageName,
      Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT, metricsKey),
      Pair.create(MetricsProto.MetricsEvent.FIELD_ANOMALY_TYPE, type));
  }

Remplacez type par la valeur d' AnomalyType .

Les développeurs de périphériques peuvent utiliser les constantes définies dans src/com/android/settings/fuelgauge/batterytip/StatsManagerConfig.java :

public @interface AnomalyType {
        // This represents an error condition in the anomaly detection.
        int NULL = -1;
         // The anomaly type does not match any other defined type.
        int UNKNOWN_REASON = 0;
         // The application held a partial (screen off) wake lock for a period of time that
         // exceeded the threshold with the screen off when not charging.
        int EXCESSIVE_WAKELOCK_ALL_SCREEN_OFF = 1;
         // The application exceeded the maximum number of wakeups while in the background
         // when not charging.
        int EXCESSIVE_WAKEUPS_IN_BACKGROUND = 2;
         // The application did unoptimized Bluetooth scans too frequently when not charging.
        int EXCESSIVE_UNOPTIMIZED_BLE_SCAN = 3;
         // The application ran in the background for a period of time that exceeded the
         // threshold.
        int EXCESSIVE_BACKGROUND_SERVICE = 4;
         // The application exceeded the maximum number of wifi scans when not charging.
        int EXCESSIVE_WIFI_SCAN = 5;
         // The application exceed the maximum number of flash writes
        int EXCESSIVE_FLASH_WRITES = 6;
         // The application used more than the maximum memory, while not spending any time
         // in the foreground.
        int EXCESSIVE_MEMORY_IN_BACKGROUND = 7;
         // The application exceeded the maximum percentage of frames with a render rate of
         // greater than 700ms.
        int EXCESSIVE_DAVEY_RATE = 8;
         // The application exceeded the maximum percentage of frames with a render rate
         // greater than 16ms.
        int EXCESSIVE_JANKY_FRAMES = 9;
         // The application exceeded the maximum cold start time - the app has not been
         // launched since last system start, died or was killed.
        int SLOW_COLD_START_TIME = 10;
         // The application exceeded the maximum hot start time - the app and activity are
         // already in memory.
        int SLOW_HOT_START_TIME = 11;
         // The application exceeded the maximum warm start time - the app was already in
         // memory but the activity wasn't created yet or was removed from memory.
        int SLOW_WARM_START_TIME = 12;
         // The application exceeded the maximum number of syncs while in the background.
        int EXCESSIVE_BACKGROUND_SYNCS = 13;
         // The application exceeded the maximum number of gps scans while in the background.
        int EXCESSIVE_GPS_SCANS_IN_BACKGROUND = 14;
         // The application scheduled more than the maximum number of jobs while not charging.
        int EXCESSIVE_JOB_SCHEDULING = 15;
         // The application exceeded the maximum amount of mobile network traffic while in
         // the background.
        int EXCESSIVE_MOBILE_NETWORK_IN_BACKGROUND = 16;
         // The application held the WiFi lock for more than the maximum amount of time while
         // not charging.
        int EXCESSIVE_WIFI_LOCK_TIME = 17;
         // The application scheduled a job that ran longer than the maximum amount of time.
        int JOB_TIMED_OUT = 18;
         // The application did an unoptimized Bluetooth scan that exceeded the maximum
         // time while in the background.
        int LONG_UNOPTIMIZED_BLE_SCAN = 19;
         // The application exceeded the maximum ANR rate while in the background.
        int BACKGROUND_ANR = 20;
         // The application exceeded the maximum crash rate while in the background.
        int BACKGROUND_CRASH_RATE = 21;
         // The application exceeded the maximum ANR-looping rate.
        int EXCESSIVE_ANR_LOOPING = 22;
         // The application exceeded the maximum ANR rate.
        int EXCESSIVE_ANRS = 23;
         // The application exceeded the maximum crash rate.
        int EXCESSIVE_CRASH_RATE = 24;
         // The application exceeded the maximum crash-looping rate.
        int EXCESSIVE_CRASH_LOOPING = 25;
         // The application crashed because no more file descriptors were available.
        int NUMBER_OF_OPEN_FILES = 26;
    }

Lorsque l'utilisateur ou le système supprime les restrictions d'une application, vous devez enregistrer les raisons de la suppression des restrictions. Un exemple d'extrait de code de journalisation à partir de packages/apps/Settings/src/com/android/settings/fuelgauge/batterytip/actions/UnrestrictAppAction.java :

public void handlePositiveAction(int metricsKey) {
        final AppInfo appInfo = mUnRestrictAppTip.getUnrestrictAppInfo();
        // Clear force app standby, then app can run in the background
        mBatteryUtils.setForceAppStandby(appInfo.uid, appInfo.packageName,
                AppOpsManager.MODE_ALLOWED);
        mMetricsFeatureProvider.action(mContext,
                MetricsProto.MetricsEvent.ACTION_TIP_UNRESTRICT_APP, appInfo.packageName,
                Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT, metricsKey));
    }

Test des restrictions d'application

Pour tester le comportement des restrictions d'application dans Android 9 et versions ultérieures, utilisez l'une des commandes suivantes:

  • Mettre une application en restriction:
    appops set package-name RUN_ANY_IN_BACKGROUND ignore
  • Retirez une application de la restriction et restaurez le comportement par défaut:
    appops set package-name RUN_ANY_IN_BACKGROUND allow
  • Rendre une application en arrière-plan inactive immédiatement:
    am make-uid-idle [--user user-id | all | current] package-name
  • Ajouter un package à tempwhitelist pour une courte durée:
    cmd deviceidle tempwhitelist [-u user] [-d duration] [package package-name]
  • Ajouter / supprimer un package de la liste blanche des utilisateurs:
    cmd deviceidle whitelist [+/-]package-name
  • Vérifier l'état interne du jobscheduler de jobscheduler et du gestionnaire d'alarmes:
    dumpsys jobscheduler
    dumpsys alarm

Veille de l'application

La mise en veille des applications prolonge la durée de vie de la batterie en différant l'activité réseau en arrière-plan et les tâches des applications que l'utilisateur n'utilise pas activement.

Cycle de vie de veille de l'application

La plate-forme détecte les applications inactives et les met en veille jusqu'à ce que l'utilisateur commence à s'engager activement avec l'application.

Pendant la phase de détection , la plate-forme détecte qu'une application est inactive lorsque l'appareil ne se charge pas et que l'utilisateur n'a pas lancé l'application directement ou indirectement pendant une durée spécifique de l'horloge ainsi qu'une durée spécifique de temps d'écran. . (Les lancements indirects se produisent lorsqu'une application de premier plan accède à un service dans une deuxième application.)

Pendant la mise en veille de l'application , la plate-forme empêche les applications d'accéder au réseau plus d'une fois par jour, reportant ainsi les synchronisations d'applications et d'autres tâches.

La plateforme quitte l'application du mode veille lorsque:

  • L'application devient active.
  • L'appareil est branché et en charge.

Les applications actives ne sont pas affectées par la mise en veille des applications. Une application est active lorsqu'elle a:

  • Un processus actuellement au premier plan (soit en tant qu'activité ou service de premier plan, soit utilisé par une autre activité ou un service de premier plan), tel qu'un écouteur de notification, des services d'accessibilité, un fond d'écran en direct, etc.
  • Une notification affichée par l'utilisateur, comme dans l'écran de verrouillage ou dans la barre de notification
  • Été explicitement lancé par l'utilisateur

Une application est inactive si aucune des activités ci-dessus n'a eu lieu pendant un certain temps.

Test de la mise en veille de l'application

Vous pouvez tester manuellement la mise en veille de l'application à l'aide des commandes adb suivantes:

adb shell dumpsys battery unplug
adb shell am set-idle package-name true
adb shell am set-idle package-name false
adb shell am get-idle package-name