Activity Classe

Définition

Espace de noms:: Android.App

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Une activité est une chose unique et ciblée que l’utilisateur peut faire.

[Android.Runtime.Register("android/app/Activity", DoNotGenerateAcw=true)]
public class Activity : Android.Views.ContextThemeWrapper, Android.Content.IComponentCallbacks2, Android.Views.KeyEvent.ICallback, Android.Views.LayoutInflater.IFactory2, Android.Views.View.IOnCreateContextMenuListener, Android.Views.Window.ICallback, IDisposable

[<Android.Runtime.Register("android/app/Activity", DoNotGenerateAcw=true)>]
type Activity = class
    inherit ContextThemeWrapper
    interface IComponentCallbacks
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IComponentCallbacks2
    interface KeyEvent.ICallback
    interface LayoutInflater.IFactory
    interface LayoutInflater.IFactory2
    interface View.IOnCreateContextMenuListener
    interface Window.ICallback

Héritage: Object

JavaObject

Object

Context

ContextWrapper

ContextThemeWrapper
Activity

Dérivé: Android.Accounts.AccountAuthenticatorActivity

Android.App.ActivityGroup

Android.App.AliasActivity

Android.App.ExpandableListActivity

Android.App.ListActivity

Plus…

Attributs: RegisterAttribute

Implémente: IComponentCallbacks IComponentCallbacks2 IJavaObject KeyEvent.ICallback LayoutInflater.IFactory LayoutInflater.IFactory2 View.IOnCreateContextMenuListener Window.ICallback IJavaPeerable IDisposable

Remarques

Une activité est une chose unique et ciblée que l’utilisateur peut faire. Presque toutes les activités interagissent avec l’utilisateur, de sorte que la classe Activity s’occupe de créer une fenêtre pour vous dans laquelle vous pouvez placer votre interface utilisateur avec setContentView(View). Bien que les activités soient souvent présentées à l’utilisateur en tant que fenêtres plein écran, elles peuvent également être utilisées de différentes manières : en tant que fenêtres flottantes (via un thème avec R.attr.windowIsFloating set), mode Multi-Fenêtre ou incorporé dans d’autres fenêtres. Il existe deux méthodes que presque toutes les sous-classes d’activité implémentent : onCreate(Bundle) est l’emplacement où vous initialisez votre activité. Plus important encore, ici, vous allez généralement appeler setContentView(int) avec une ressource de disposition définissant votre interface utilisateur et en utilisant findViewById(int) pour récupérer les widgets dans cette interface utilisateur que vous devez interagir par programmation. onPause() est l’endroit où vous traitez avec l’utilisateur qui interrompt l’interaction active avec l’activité. Toutes les modifications apportées par l’utilisateur doivent à ce stade être validées (généralement dans ContentProvider contenant les données). Dans cet état, l’activité est toujours visible à l’écran. Pour être utilisée avec Context.startActivity(), toutes les classes d’activité doivent avoir une déclaration d’activité> correspondante <dans la AndroidManifest.xmlde leur package.

Rubriques abordées ici : Fragments activity Lifecycle Configuration Changes Starting Activities and Getting Results Saving Persistent State Permissions Process Developer Guides The Activity class is an important part of an application’s global lifecycle, and the way activities are started and assemble is a fundamental part of the platform’s application model. Pour obtenir une perspective détaillée de la structure d’une application Android et de la façon dont les activités se comportent, lisez les guides de développement De base et Tâches de l’application et Back Stack.

Vous trouverez également une discussion détaillée sur la création d’activités dans le guide du développeur d’activités.

La sous-classe FragmentActivity peut utiliser la classe Fragment pour mieux modulariser son code, créer des interfaces utilisateur plus sophistiquées pour des écrans plus grands et mettre à l’échelle leur application entre petits et grands écrans.

Pour plus d’informations sur l’utilisation de fragments, consultez le guide du développeur Fragments.

Les activités du système sont gérées en tant que piles d’activités. Lorsqu’une nouvelle activité est démarrée, elle est généralement placée en haut de la pile actuelle et devient l’activité en cours d’exécution : l’activité précédente reste toujours en dessous de celle-ci dans la pile et ne revient pas au premier plan tant que la nouvelle activité ne se termine pas. Il peut y avoir une ou plusieurs piles d’activités visibles à l’écran.

Une activité a essentiellement quatre états :

Le diagramme suivant montre les chemins d’état importants d’une activité. Les rectangles carrés représentent des méthodes de rappel que vous pouvez implémenter pour effectuer des opérations lorsque l’activité se déplace entre les états. Les ovales colorés sont des états majeurs où l’activité peut se trouver.

Il existe trois boucles clés que vous souhaiterez peut-être surveiller au sein de votre activité : toute la durée de vie d’une activité se produit entre le premier appel à onCreate(Bundle) jusqu’à un seul appel final à onDestroy(). Une activité effectue toutes les configurations de l’état « global » dans onCreate() et libère toutes les ressources restantes dans onDestroy(). Par exemple, si un thread s’exécute en arrière-plan pour télécharger des données à partir du réseau, il peut créer ce thread dans onCreate(), puis arrêter le thread dans onDestroy(). La durée de vie visible d’une activité se produit entre un appel à onStart() jusqu’à un appel correspondant à onStop(). Pendant ce temps, l’utilisateur peut voir l’activité à l’écran, bien qu’elle ne soit pas au premier plan et interagit avec l’utilisateur. Entre ces deux méthodes, vous pouvez gérer les ressources nécessaires pour afficher l’activité à l’utilisateur. Par exemple, vous pouvez inscrire un BroadcastReceiver dans onStart() pour surveiller les modifications qui affectent votre interface utilisateur et annuler son inscription dans onStop() lorsque l’utilisateur ne voit plus ce que vous affichez. Les méthodes onStart() et onStop() peuvent être appelées plusieurs fois, car l’activité devient visible et masquée à l’utilisateur. La durée de vie de premier plan d’une activité se produit entre un appel à onResume() jusqu’à un appel correspondant à onPause(). Pendant ce temps, l’activité est visible, active et interagit avec l’utilisateur. Une activité peut fréquemment aller entre les états repris et suspendus ( par exemple, lorsque l’appareil passe en veille, lorsqu’un résultat d’activité est remis, lorsqu’une nouvelle intention est livrée), de sorte que le code de ces méthodes doit être assez léger. Le cycle de vie entier d’une activité est défini par les méthodes d’activité suivantes. Toutes ces connexions sont des crochets que vous pouvez remplacer pour effectuer le travail approprié lorsque l’activité change d’état. Toutes les activités implémentent onCreate(Bundle) pour effectuer leur configuration initiale ; beaucoup implémentent également onPause() pour valider les modifications apportées aux données et se préparer à suspendre l’interaction avec l’utilisateur, et onStop() pour gérer ne plus être visible à l’écran. Vous devez toujours appeler votre superclasse lors de l’implémentation de ces méthodes.

En général, le mouvement par le biais du cycle de vie d’une activité ressemble à ceci :

Toujours suivi de onStart(). Aucun onStart() onRestart() Appelé après l’arrêt de votre activité avant son redémarrage. Toujours suivi de onStart() No onStart() onStart() Appelé lorsque l’activité devient visible par l’utilisateur. Suivi de onResume() si l’activité vient au premier plan, ou onStop() si elle devient masquée. Aucun onResume() ou onStop() onResume() Appelé lorsque l’activité commence à interagir avec l’utilisateur. À ce stade, votre activité se trouve en haut de sa pile d’activités, avec l’entrée de l’utilisateur qui y accède. Toujours suivi de onPause(). Aucune onPause() onPause() Appelée lorsque l’activité perd l’état de premier plan, n’est plus focusable ou avant la transition vers l’état arrêté/masqué ou détruit. L’activité est toujours visible par l’utilisateur. Il est donc recommandé de la conserver visuellement active et de continuer à mettre à jour l’interface utilisateur. Les implémentations de cette méthode doivent être très rapides, car l’activité suivante ne sera pas reprise tant que cette méthode ne sera pas retournée. Suivi de onResume() si l’activité revient à l’avant, ou onStop() si elle devient invisible à l’utilisateur. Pré-Build.VERSION_CODES. HONEYCOMB onResume() ou onStop() onStop() Appelé lorsque l’activité n’est plus visible par l’utilisateur. Cela peut se produire soit parce qu’une nouvelle activité est démarrée par-dessus, qu’une activité existante soit mise en place devant celle-ci, soit qu’elle soit détruite. Cela est généralement utilisé pour arrêter les animations et actualiser l’interface utilisateur, etc. Suivi de onRestart() si cette activité revient pour interagir avec l’utilisateur, ou onDestroy() si cette activité disparaît. Oui onRestart() ou onDestroy() onDestroy() L’appel final que vous recevez avant la destruction de votre activité. Cela peut se produire soit parce que l’activité se termine (une personne appelée Activity.finish sur celle-ci), soit parce que le système détruit temporairement cette instance de l’activité pour économiser de l’espace. Vous pouvez faire la distinction entre ces deux scénarios avec la méthode Activity.isFinishing. Oui rien notez la colonne « Killable » dans le tableau ci-dessus : pour ces méthodes marquées comme étant tuables, une fois que cette méthode retourne le processus d’hébergement de l’activité peut être tué par le système à tout moment sans qu’une autre ligne de son code soit exécutée. En raison de cela, vous devez utiliser la méthode onPause() pour écrire toutes les données persistantes (telles que les modifications utilisateur) dans le stockage. En outre, la méthode onSaveInstanceState(Bundle) est appelée avant de placer l’activité dans un tel état d’arrière-plan, ce qui vous permet d’enregistrer tout état d’instance dynamique dans votre activité dans le bundle donné, à recevoir ultérieurement dans onCreate(Bundle) si l’activité doit être recréée. Consultez la section Cycle de vie des processus pour plus d’informations sur la façon dont le cycle de vie d’un processus est lié aux activités qu’il héberge. Notez qu’il est important d’enregistrer des données persistantes dans onPause() au lieu de onSaveInstanceState(Bundle), car ces derniers ne font pas partie des rappels de cycle de vie, et ne seront donc pas appelés dans toutes les situations décrites dans sa documentation.

N’oubliez pas que ces sémantiques changent légèrement entre les applications ciblant des plateformes commençant par Build.VERSION_CODES. HONEYCOMB et celles ciblant des plateformes antérieures. À compter de Honeycomb, une application n’est pas dans l’état tuable tant que son onStop() n’a pas retourné. Cela a un impact sur le moment où onSaveInstanceState(Bundle) peut être appelé (il peut être appelé en toute sécurité après onPause()) et permet à une application d’attendre en toute sécurité jusqu’à ce que onStop() enregistre l’état persistant.

Pour les applications ciblant des plateformes commençant par Build.VERSION_CODES. P onSaveInstanceState(Bundle) est toujours appelé après onStop(), afin qu’une application puisse effectuer en toute sécurité des transactions fragmentées dans onStop() et être en mesure d’enregistrer l’état persistant ultérieurement.

Pour les méthodes qui ne sont pas marquées comme étant tuables, le processus de l’activité ne sera pas tué par le système à partir du moment où la méthode est appelée et continue après son retour. Par conséquent, une activité est dans l’état killable, par exemple, entre onStop() et le début d’onResume(). N’oubliez pas que, sous une pression extrême de la mémoire, le système peut tuer le processus d’application à tout moment.

Si la configuration de l’appareil (telle que définie par la classe Resources.Configuration) change, tout ce qui affiche une interface utilisateur doit être mis à jour pour correspondre à cette configuration. Étant donné que l’activité est le mécanisme principal d’interaction avec l’utilisateur, il inclut une prise en charge spéciale de la gestion des modifications de configuration.

Sauf indication contraire, une modification de configuration (par exemple, une modification de l’orientation de l’écran, de la langue, des périphériques d’entrée, etc.) entraîne la destruction de votre activité actuelle, en passant par le processus de cycle de vie d’activité normal de onPause(), onStop() et onDestroy() selon les besoins. Si l’activité avait été au premier plan ou visible par l’utilisateur, une fois onDestroy() appelée dans cette instance, une nouvelle instance de l’activité sera créée, avec ce qui a enregistréInstanceState que l’instance précédente avait générée à partir de onSaveInstanceState(Bundle).

Pour ce faire, n’importe quelle ressource d’application, y compris les fichiers de disposition, peut changer en fonction de n’importe quelle valeur de configuration. Ainsi, le seul moyen sûr de gérer une modification de configuration consiste à récupérer à nouveau toutes les ressources, y compris les dispositions, les dessins et les chaînes. Étant donné que les activités doivent déjà savoir comment enregistrer leur état et se recréer à partir de cet état, il s’agit d’un moyen pratique de redémarrer une activité elle-même avec une nouvelle configuration.

Dans certains cas spéciaux, vous pouvez ignorer le redémarrage de votre activité en fonction d’un ou de plusieurs types de modifications de configuration. Cette opération est effectuée avec l’attribut android :configChanges dans son manifeste. Pour tous les types de modifications de configuration que vous dites qu’il vous faut gérer, vous recevrez un appel à la méthode onConfigurationChanged(Configuration) de votre activité actuelle au lieu d’être redémarré. Si une modification de configuration implique que vous ne gérez pas, toutefois, l’activité est toujours redémarrée et onConfigurationChanged(Configuration) n’est pas appelée.

La méthode startActivity(Intent) est utilisée pour démarrer une nouvelle activité, qui sera placée en haut de la pile d’activités. Il prend un argument unique, une intention, qui décrit l’activité à exécuter.

Parfois, vous souhaitez obtenir un résultat à partir d’une activité quand elle se termine. Par exemple, vous pouvez démarrer une activité qui permet à l’utilisateur de sélectionner une personne dans une liste de contacts ; lorsqu’elle se termine, elle retourne la personne sélectionnée. Pour ce faire, vous appelez la version android.app.Activity.startActivityForResult(Intent,int) avec un deuxième paramètre entier identifiant l’appel. Le résultat revient à travers votre méthode onActivityResult(int, int, Intent).

Lorsqu’une activité se termine, elle peut appeler setResult(int) pour renvoyer des données à son parent. Il doit toujours fournir un code de résultat, qui peut être les résultats standard RESULT_CANCELED, RESULT_OK ou toutes les valeurs personnalisées commençant à RESULT_FIRST_USER. En outre, il peut éventuellement retourner une intention contenant toutes les données supplémentaires souhaitées. Toutes ces informations s’affichent sur Activity.onActivityResult() du parent, ainsi que l’identificateur entier qu’il a fourni à l’origine.

Si une activité enfant échoue pour une raison quelconque (par exemple, un blocage), l’activité parente reçoit un résultat avec le code RESULT_CANCELED.

Il existe généralement deux types d’état persistant avec lequel une activité traite : les données de type document partagé (généralement stockées dans une base de données SQLite à l’aide d’un fournisseur de contenu) et l’état interne comme les préférences utilisateur.

Pour les données du fournisseur de contenu, nous vous suggérons d’utiliser un modèle utilisateur « modifier en place ». Autrement dit, toutes les modifications effectuées par un utilisateur sont effectuées immédiatement sans nécessiter d’étape de confirmation supplémentaire. La prise en charge de ce modèle est généralement une question simple de deux règles suivantes :

Lors de la création d’un document, l’entrée ou le fichier de base de données de stockage pour celui-ci est créé immédiatement. Par exemple, si l’utilisateur choisit d’écrire un nouvel e-mail, une nouvelle entrée pour cet e-mail est créée dès qu’elle commence à entrer des données, de sorte que si elle accède à une autre activité après ce point, cet e-mail apparaît désormais dans la liste des brouillons.

Lorsqu’une méthode onPause() d’une activité est appelée, elle doit s’engager auprès du fournisseur de contenu de stockage ou fichier toute modification apportée par l’utilisateur. Cela garantit que ces modifications seront vues par toute autre activité sur le point d’être exécutée. Vous souhaiterez probablement valider vos données de manière encore plus agressive au cours du cycle de vie de votre activité : par exemple avant de commencer une nouvelle activité, avant de terminer votre propre activité, lorsque l’utilisateur bascule entre les champs d’entrée, etc.

Ce modèle est conçu pour empêcher la perte de données lorsqu’un utilisateur navigue entre les activités et permet au système de tuer en toute sécurité une activité (car les ressources système sont nécessaires ailleurs) à tout moment après son arrêt (ou suspendu sur les versions de plateforme avant Build.VERSION_CODES. HONEYCOMB). Notez que l’utilisateur appuyant sur BACK de votre activité ne signifie pas « annuler », ce qui signifie que l’activité conserve son contenu actuel enregistré. L’annulation des modifications dans une activité doit être fournie par le biais d’un autre mécanisme, tel qu’une option explicite « rétablir » ou « annuler ».

Pour plus d’informations sur les fournisseurs de contenu, consultez le package de contenu. Il s’agit d’un aspect clé de la façon dont différentes activités appellent et propagent des données entre elles.

La classe Activity fournit également une API permettant de gérer l’état persistant interne associé à une activité. Cela peut être utilisé, par exemple, pour mémoriser l’affichage initial préféré de l’utilisateur dans un calendrier (affichage jour ou semaine) ou la page d’accueil par défaut de l’utilisateur dans un navigateur web.

L’état persistant de l’activité est géré avec la méthode getPreferences(int), ce qui vous permet de récupérer et de modifier un ensemble de paires nom/valeur associées à l’activité. Pour utiliser des préférences partagées entre plusieurs composants d’application (activités, récepteurs, services, fournisseurs), vous pouvez utiliser la méthode Context.getSharedPreferences() sous-jacente pour récupérer un objet de préférences stocké sous un nom spécifique. (Notez qu’il n’est pas possible de partager des données de paramètres entre les packages d’application. Pour cela, vous aurez besoin d’un fournisseur de contenu.)

Voici un extrait d’une activité de calendrier qui stocke le mode d’affichage préféré de l’utilisateur dans ses paramètres persistants :

La possibilité de démarrer une activité particulière peut être appliquée lorsqu’elle est déclarée dans la balise d’activité> de <son manifeste. Ainsi, d’autres applications devront déclarer un élément d’autorisation> d’utilisation correspondant <dans leur propre manifeste pour pouvoir démarrer cette activité. Lorsque vous démarrez une activité, vous pouvez définir Intent.FLAG_GRANT_READ_URI_PERMISSION et/ou Intent.FLAG_GRANT_WRITE_URI_PERMISSION sur l’intention. Cela accordera à l’activité l’accès aux URI spécifiques dans l’intention. L’accès restera jusqu’à ce que l’activité soit terminée (elle restera dans le processus d’hébergement en cours de mort et d’autres destructions temporaires). À partir de Build.VERSION_CODES. GINGERBREAD, si l’activité a déjà été créée et qu’une nouvelle intention est remise à onNewIntent(Intent), toutes les autorisations d’URI nouvellement accordées seront ajoutées aux autorisations existantes qu’elle contient. Consultez le document Sécurité et Autorisations pour plus d’informations sur les autorisations et la sécurité en général. Cycle de vie du processus Le système Android tente de conserver un processus d’application aussi longtemps que possible, mais il devra éventuellement supprimer les anciens processus lorsque la mémoire est faible. Comme décrit dans le cycle de vie de l’activité, la décision sur le processus à supprimer est intimement liée à l’état de l’interaction de l’utilisateur avec celui-ci. En règle générale, il existe quatre états où un processus peut être basé sur les activités en cours d’exécution, listées ici dans l’ordre d’importance. Le système tuera des processus moins importants (les derniers) avant qu’il n’a recours à tuer des processus plus importants (les premiers). L’activité de premier plan (l’activité en haut de l’écran avec laquelle l’utilisateur interagit actuellement) est considérée comme la plus importante. Son processus ne sera tué qu’en dernier recours, s’il utilise plus de mémoire que disponible sur l’appareil. En règle générale, l’appareil a atteint un état de pagination de la mémoire. Il est donc nécessaire de maintenir la réactivité de l’interface utilisateur. Une activité visible (une activité visible par l’utilisateur, mais pas au premier plan, telle qu’une personne assise derrière une boîte de dialogue de premier plan ou en regard d’autres activités en mode multi-fenêtre) est considérée comme extrêmement importante et ne sera pas tuée, sauf s’il est nécessaire de maintenir l’activité de premier plan en cours d’exécution. Une activité en arrière-plan (une activité qui n’est pas visible par l’utilisateur et qui a été arrêtée) n’est plus critique, de sorte que le système peut tuer en toute sécurité son processus pour récupérer de la mémoire pour d’autres processus au premier plan ou visibles. Si son processus doit être tué, lorsque l’utilisateur revient à l’activité (ce qui le rend visible à nouveau sur l’écran), sa méthode onCreate(Bundle) est appelée avec l’objet savedInstanceState qu’il avait précédemment fourni dans onSaveInstanceState(Bundle) afin qu’il puisse redémarrer lui-même dans le même état que l’utilisateur l’a laissé pour la dernière fois. Un processus vide n’héberge aucune activité ou d’autres composants d’application (tels que les classes Service ou BroadcastReceiver). Ceux-ci sont tués très rapidement par le système, car la mémoire devient faible. Pour cette raison, toute opération en arrière-plan que vous effectuez en dehors d’une activité doit être exécutée dans le contexte d’une activité BroadcastReceiver ou service pour vous assurer que le système sait qu’il doit conserver votre processus. Parfois, une activité peut avoir besoin d’effectuer une opération de longue durée qui existe indépendamment du cycle de vie de l’activité lui-même. Par exemple, il peut s’agir d’une application de caméra qui vous permet de charger une image sur un site web. Le chargement peut prendre beaucoup de temps et l’application doit permettre à l’utilisateur de quitter l’application pendant son exécution. Pour ce faire, votre activité doit démarrer un service dans lequel le chargement a lieu. Cela permet au système de hiérarchiser correctement votre processus (compte tenu qu’il est plus important que d’autres applications non visibles) pendant la durée du chargement, indépendamment de la suspension, de l’arrêt ou de la fin de l’activité d’origine.

Référence Android pour android.app.Activity.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.

Constructeurs

Nom	Description
Activity()	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
Activity(IntPtr, JniHandleOwnership)	Initialise une représentation managée d’un objet Java Native Interface existant.

Champs

Nom	Description
AccessibilityService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.view.accessibility.AccessibilityManager` message permettant d’envoyer des commentaires utilisateur aux événements d’interface utilisateur via les écouteurs d’événements inscrits. (Hérité de Context)
AccountService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.accounts.AccountManager` intention de réception à la fois de votre choix. (Hérité de Context)
ActivityService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.app.ActivityManager` élément permettant d’interagir avec l’état du système global. (Hérité de Context)
AdvancedProtectionService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.security.advancedprotection.AdvancedProtectionManager` (Hérité de Context)
AlarmService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.app.AlarmManager` intention de réception à la fois de votre choix. (Hérité de Context)
AppFunctionService	Utilisez-la `#getSystemService(String)` pour récupérer une `AppFunctionManager` fonction d’application en cours d’exécution. (Hérité de Context)
AppOpsService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.app.AppOpsManager` pour le suivi des opérations d’application sur l’appareil. (Hérité de Context)
AppSearchService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.app.appsearch.AppSearchManager` indexage et l’interrogation des données d’application gérées par le système. (Hérité de Context)
AppwidgetService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.appwidget.AppWidgetManager` élément permettant d’accéder à AppWidgets. (Hérité de Context)
AudioService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.media.AudioManager` fonctionnalité permettant de gérer la gestion du volume, des modes sonnerie et du routage audio. (Hérité de Context)
BatteryService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.os.BatteryManager` pour gérer l’état de la batterie. (Hérité de Context)
BindAllowActivityStarts	Obsolète. Indicateur pour `#bindService`: si la liaison à partir d’une application visible, le service lié est autorisé à démarrer une activité en arrière-plan. (Hérité de Context)
BindExternalServiceLong	Fonctionne de la même façon que `#BIND_EXTERNAL_SERVICE`, mais il est défini comme une `long` valeur compatible avec `BindServiceFlags`. (Hérité de Context)
BindNotPerceptible	Obsolète. Indicateur pour `#bindService`: si la liaison à partir d’une application visible ou perceptible par l’utilisateur réduit l’importance du service cible au-dessous du niveau perceptible. (Hérité de Context)
BindPackageIsolatedProcess	Obsolète. Indicateur pour `#bindIsolatedService`: lier le service à un processus isolé partagé, mais uniquement avec d’autres services isolés du même package qui déclarent le même nom de processus. (Hérité de Context)
BindSharedIsolatedProcess	Obsolète. Indicateur pour `#bindIsolatedService`: lier le service à un processus isolé partagé. (Hérité de Context)
BiometricService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.hardware.biometrics.BiometricManager` option permettant de gérer l’authentification biométrique et par code confidentiel/modèle/mot de passe. (Hérité de Context)
BlobStoreService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.app.blob.BlobStoreManager` élément permettant de contribuer et d’accéder aux objets blob de données à partir du magasin d’objets blob géré par le système. (Hérité de Context)
BluetoothService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.bluetooth.BluetoothManager` pour utiliser Bluetooth. (Hérité de Context)
BugreportService	Service pour capturer un rapport de bogues. (Hérité de Context)
CameraService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.hardware.camera2.CameraManager` pour interagir avec les appareils photo. (Hérité de Context)
CaptioningService	`#getSystemService(String)` Permet de récupérer un `android.view.accessibility.CaptioningManager` pour obtenir des propriétés de sous-titrage et d’écouter les modifications apportées aux préférences de sous-titrage. (Hérité de Context)
CarrierConfigService	Utilisez cette `#getSystemService(String)` option pour récupérer des `android.telephony.CarrierConfigManager` valeurs de configuration de l’opérateur de lecture. (Hérité de Context)
ChooserService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.service.chooser.ChooserManager`. (Hérité de Context)
ClipboardService	`#getSystemService(String)` Permet de récupérer un `android.content.ClipboardManager` élément permettant d’accéder au contenu du Presse-papiers global et de le modifier. (Hérité de Context)
CompanionDeviceService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.companion.CompanionDeviceManager` pour gérer les appareils complémentaires (Hérité de Context)
ConnectivityDiagnosticsService	Utilisez cette `#getSystemService(String)` option pour récupérer des `android.net.ConnectivityDiagnosticsManager` diagnostics de connectivité réseau, ainsi que pour recevoir des informations de connectivité réseau à partir du système. (Hérité de Context)
ConnectivityService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.net.ConnectivityManager` pour gérer la gestion des connexions réseau. (Hérité de Context)
ConsumerIrService	`#getSystemService(String)` Permet de récupérer un `android.hardware.ConsumerIrManager` signal infrarouge à partir de l’appareil pour transmettre des signaux infrarouges. (Hérité de Context)
ContactKeysService	Utilisez-la `#getSystemService(String)` pour récupérer une `E2eeContactKeysManager` clé de contact pour gérer les clés de contact. (Hérité de Context)
CredentialService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.credentials.CredentialManager` utilisateur pour authentifier un utilisateur auprès de votre application. (Hérité de Context)
CrossProfileAppsService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.content.pm.CrossProfileApps` opération de profil croisé. (Hérité de Context)
DeviceIdDefault	ID d’appareil par défaut, qui est l’ID de l’appareil principal (non virtuel). (Hérité de Context)
DeviceIdInvalid	ID d’appareil non valide. (Hérité de Context)
DeviceLockService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.devicelock.DeviceLockManager`. (Hérité de Context)
DevicePolicyService	Utilisez-la `#getSystemService(String)` pour récupérer un outil permettant d’utiliser `android.app.admin.DevicePolicyManager` la gestion globale des stratégies d’appareil. (Hérité de Context)
DisplayHashService	`#getSystemService(String)` Permet d’accéder `android.view.displayhash.DisplayHashManager` à des hachages d’affichage. (Hérité de Context)
DisplayService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.hardware.display.DisplayManager` élément permettant d’interagir avec les appareils d’affichage. (Hérité de Context)
DomainVerificationService	`#getSystemService(String)` Permet d’accéder `android.content.pm.verify.domain.DomainVerificationManager` à la récupération de l’approbation et de l’état utilisateur pour les domaines web déclarés. (Hérité de Context)
DownloadService	`#getSystemService(String)` Permet de récupérer un `android.app.DownloadManager` téléchargement HTTP pour demander des téléchargements HTTP. (Hérité de Context)
DropboxService	Utilisez cette `#getSystemService(String)` option pour récupérer une `android.os.DropBoxManager` instance pour enregistrer les journaux de diagnostic. (Hérité de Context)
EuiccService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.telephony.euicc.EuiccManager` pour gérer l’eUICC de l’appareil (SIM incorporé). (Hérité de Context)
FileIntegrityService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.security.FileIntegrityManager`. (Hérité de Context)
FingerprintService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.hardware.fingerprint.FingerprintManager` contrôle de gestion des empreintes digitales. (Hérité de Context)
FullscreenModeRequestEnter	Obsolète. Type de requête requestFullscreenMode(int,OutcomeReceiver), pour demander l’entrée en mode plein écran à partir du mode multi-fenêtre.
FullscreenModeRequestExit	Obsolète. Type de requête requestFullscreenMode(int,OutcomeReceiver), pour demander la sortie du mode plein écran demandé et la restauration vers le mode multi-fenêtre précédent.
GameService	Utiliser avec `#getSystemService(String)` pour récupérer un `GameManager`. (Hérité de Context)
GrammaticalInflectionService	Utiliser avec `#getSystemService(String)` pour récupérer un `GrammaticalInflectionManager`. (Hérité de Context)
HardwarePropertiesService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.os.HardwarePropertiesManager` élément permettant d’accéder au service de propriétés matérielles. (Hérité de Context)
HealthconnectService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.health.connect.HealthConnectManager`. (Hérité de Context)
InputMethodService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.view.inputmethod.InputMethodManager` pour accéder aux méthodes d’entrée. (Hérité de Context)
InputService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.hardware.input.InputManager` pour interagir avec les appareils d’entrée. (Hérité de Context)
IpsecService	`#getSystemService(String)` Permet de récupérer un `android.net.IpSecManager` sockets ou des réseaux chiffrés avec IPSec. (Hérité de Context)
JobSchedulerService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.app.job.JobScheduler` instance pour gérer des tâches en arrière-plan occasionnelles. (Hérité de Context)
KeyguardService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.app.KeyguardManager` contrôle de keyguard. (Hérité de Context)
KeystoreService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.security.keystore.KeyStoreManager` élément permettant d’accéder aux fonctions Android Keystore. (Hérité de Context)
LauncherAppsService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.content.pm.LauncherApps` requête et la surveillance des applications pouvant être lancées sur différents profils d’un utilisateur. (Hérité de Context)
LayoutInflaterService	Permet de `#getSystemService(String)` récupérer une `android.view.LayoutInflater` ressource de disposition pour l’inflation dans ce contexte. (Hérité de Context)
LocaleService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.app.LocaleManager`. (Hérité de Context)
LocationService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.location.LocationManager` contrôle des mises à jour d’emplacement. (Hérité de Context)
MediaCommunicationService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.media.MediaCommunicationManager` pour la gestion `android.media.MediaSession2`. (Hérité de Context)
MediaMetricsService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.media.metrics.MediaMetricsManager` option permettant d’interagir avec les métriques multimédias sur l’appareil. (Hérité de Context)
MediaProjectionService	Utilisez cette `#getSystemService(String)` option pour récupérer une `android.media.projection.MediaProjectionManager` instance pour gérer les sessions de projection multimédia. (Hérité de Context)
MediaQualityService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.media.quality.MediaQualityManager` image et des paramètres d’API audio standard. (Hérité de Context)
MediaRouterService	Utilisez-la `#getSystemService` pour récupérer un `android.media.MediaRouter` contrôle et la gestion du routage des supports. (Hérité de Context)
MediaSessionService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.media.session.MediaSessionManager` élément permettant de gérer les sessions multimédias. (Hérité de Context)
MidiService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.media.midi.MidiManager` élément permettant d’accéder au service MIDI. (Hérité de Context)
NetworkStatsService	`#getSystemService(String)` Permet de récupérer un `android.app.usage.NetworkStatsManager` pour interroger les statistiques d’utilisation du réseau. (Hérité de Context)
NfcService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.nfc.NfcManager` pour utiliser NFC. (Hérité de Context)
NotificationService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.app.NotificationManager` élément permettant d’informer l’utilisateur des événements en arrière-plan. (Hérité de Context)
NsdService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.net.nsd.NsdManager` pour gérer la gestion de la découverte de service réseau (Hérité de Context)
OverlayService	`#getSystemService(String)` Permet de récupérer un `android.content.om.OverlayManager` package de superposition pour la gestion des packages de superposition. (Hérité de Context)
OverrideTransitionClose	Obsolète. Type de requête de overrideActivityTransition(int, int, int) ou overrideActivityTransition(int, int, int, int), pour remplacer la transition fermante.
OverrideTransitionOpen	Obsolète. Type de requête de overrideActivityTransition(int, int, int) ou overrideActivityTransition(int, int, int, int), pour remplacer la transition d’ouverture.
PeopleService	Utilisez-la `#getSystemService(String)` pour accéder à une `PeopleManager` interaction avec vos conversations publiées. (Hérité de Context)
PerformanceHintService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.os.PerformanceHintManager` élément permettant d’accéder au service d’indicateur de performances. (Hérité de Context)
PersistentDataBlockService	Utilisez-la `#getSystemService(String)` pour récupérer une instance permettant d’interagir `android.service.persistentdata.PersistentDataBlockManager` avec un appareil de stockage qui se trouve entre les réinitialisations d’usine. (Hérité de Context)
PowerService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.os.PowerManager` contrôle de la gestion de l’alimentation, notamment les « verrous de veille », ce qui vous permet de conserver l’appareil pendant que vous exécutez de longues tâches. (Hérité de Context)
PrintService	`android.print.PrintManager` pour l’impression et la gestion des imprimantes et des tâches d’impression. (Hérité de Context)
ProfilingService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.os.ProfilingManager`. (Hérité de Context)
ReceiverExported	Obsolète. Indicateur pour `#registerReceiver`: le récepteur peut recevoir des diffusions d’autres applications. (Hérité de Context)
ReceiverNotExported	Obsolète. Indicateur pour `#registerReceiver`: le récepteur ne peut pas recevoir de diffusions d’autres applications. (Hérité de Context)
ReceiverVisibleToInstantApps	Obsolète. Indicateur pour `#registerReceiver`: le récepteur peut recevoir des diffusions à partir d’applications instantanées. (Hérité de Context)
RestrictionsService	Utilisez cette `#getSystemService(String)` option pour récupérer des `android.content.RestrictionsManager` restrictions d’application et demander des autorisations pour les opérations restreintes. (Hérité de Context)
RoleService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.app.role.RoleManager` pour gérer les rôles. (Hérité de Context)
SatelliteService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.telephony.satellite.SatelliteManager` fonctionnalité satellite. (Hérité de Context)
SearchService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.app.SearchManager` pour gérer les recherches. (Hérité de Context)
SecurityStateService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.os.SecurityStateManager` élément permettant d’accéder au service Security State Manager. (Hérité de Context)
SensorService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.hardware.SensorManager` pour accéder aux capteurs. (Hérité de Context)
ShortcutService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.content.pm.ShortcutManager` pour accéder au service de raccourci du lanceur. (Hérité de Context)
StatusBarService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.app.StatusBarManager` élément permettant d’interagir avec la barre d’état et les paramètres rapides. (Hérité de Context)
StorageService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.os.storage.StorageManager` pour accéder aux fonctions de stockage système. (Hérité de Context)
StorageStatsService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.app.usage.StorageStatsManager` option permettant d’accéder aux statistiques de stockage système. (Hérité de Context)
SystemHealthService	Utilisez-la `#getSystemService(String)` pour récupérer des `android.os.health.SystemHealthManager` métriques d’intégrité du système (batterie, alimentation, mémoire, etc.). (Hérité de Context)
TelecomService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.telecom.TelecomManager` fonctionnalité liée aux télécommunications de l’appareil. (Hérité de Context)
TelephonyImsService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.telephony.ims.ImsManager`. (Hérité de Context)
TelephonyPhoneNumberService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.telephony.PhoneNumberManager` numéro de téléphone d’analyse. (Hérité de Context)
TelephonyService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.telephony.TelephonyManager` fonctionnalité de gestion des fonctionnalités de téléphonie de l’appareil. (Hérité de Context)
TelephonySubscriptionService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.telephony.SubscriptionManager` pour gérer les abonnements de téléphonie de l’appareil. (Hérité de Context)
TetheringService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.net.TetheringManager` pour gérer les fonctions de connexion. (Hérité de Context)
TextClassificationService	Utiliser avec `#getSystemService(String)` pour récupérer un `TextClassificationManager` pour les services de classification de texte. (Hérité de Context)
TextServicesManagerService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.view.textservice.TextServicesManager` pour accéder aux services de texte. (Hérité de Context)
TvAdService	Utilisez-la `#getSystemService(String)` pour récupérer une option permettant d’interagir `android.media.tv.ad.TvAdManager` avec les services de publicité côté client tv sur l’appareil. (Hérité de Context)
TvInputService	Utilisez-la `#getSystemService(String)` pour récupérer une option permettant d’interagir `android.media.tv.TvInputManager` avec les entrées tv sur l’appareil. (Hérité de Context)
TvInteractiveAppService	Utilisez-la `#getSystemService(String)` pour récupérer une option permettant d’interagir `android.media.tv.interactive.TvInteractiveAppManager` avec des applications interactives tv sur l’appareil. (Hérité de Context)
UiModeService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.app.UiModeManager` pour contrôler les modes d’interface utilisateur. (Hérité de Context)
UsageStatsService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.app.usage.UsageStatsManager` pour interroger les statistiques d’utilisation des appareils. (Hérité de Context)
UsbService	Utilisez-la pour `#getSystemService(String)` récupérer un `android.hardware.usb.UsbManager` accès aux périphériques USB (en tant qu’hôte USB) et pour contrôler le comportement de cet appareil en tant qu’appareil USB. (Hérité de Context)
UserService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.os.UserManager` pour gérer les utilisateurs sur les appareils qui prennent en charge plusieurs utilisateurs. (Hérité de Context)
VibratorManagerService	Utilisez avec `#getSystemService(String)` pour récupérer un `android.os.VibratorManager` pour accéder aux vibreurs d’appareil, interagir avec des individus individuels et jouer des effets synchronisés sur plusieurs vibrateurs. (Hérité de Context)
VibratorService	Utilisez-la `#getSystemService(String)` pour récupérer un `android.os.Vibrator` élément permettant d’interagir avec le matériel de vibration. (Hérité de Context)
VirtualDeviceService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.companion.virtual.VirtualDeviceManager` pour la gestion des appareils virtuels. (Hérité de Context)
VpnManagementService	Permet de `#getSystemService(String)` récupérer un `android.net.VpnManager` profil pour gérer les profils pour le VPN intégré de la plateforme. (Hérité de Context)
WallpaperService	Utiliser avec `#getSystemService(String)` pour récupérer une com. (Hérité de Context)
WifiAwareService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.net.wifi.aware.WifiAwareManager` gestion de la gestion des Wi-Fi conscients. (Hérité de Context)
WifiP2pService	Utilisez-la `#getSystemService(String)` pour récupérer une `android.net.wifi.p2p.WifiP2pManager` gestion de la gestion des connexions d’égal à égal Wi-Fi. (Hérité de Context)
WifiRttRangingService	Utilisez-le `#getSystemService(String)` pour récupérer un `android.net.wifi.rtt.WifiRttManager` appareil pour la gamme d’appareils avec wifi. (Hérité de Context)
WifiService	Utiliser avec `#getSystemService(String)` pour récupérer un `android.net.wifi.WifiManager` pour gérer la gestion de l’accès Wi-Fi. (Hérité de Context)
WindowService	Utilisez cette `#getSystemService(String)` option pour récupérer un `android.view.WindowManager` élément permettant d’accéder au gestionnaire de fenêtres du système. (Hérité de Context)

Propriétés

Nom	Description
ActionBar	Récupérez une référence à la barre d’actions de cette activité.
Application	Retourne l’application propriétaire de cette activité.
ApplicationContext	Retourne le contexte de l’objet Application unique global du processus actuel. (Hérité de ContextWrapper)
ApplicationInfo	Retournez les informations complètes de l’application pour le package de ce contexte. (Hérité de ContextWrapper)
Assets	Retournez une instance AssetManager pour le package de votre application. (Hérité de ContextWrapper)
AttributionSource	Obtient la source d’attribution associée à ce contexte. (Hérité de Context)
AttributionTag	L’attribution peut être utilisée dans des applications complexes pour séparer logiquement les parties de l’application. (Hérité de Context)
BaseContext	(Hérité de ContextWrapper)
CacheDir	Retourne le chemin absolu du répertoire de cache spécifique à l’application sur le système de fichiers. (Hérité de ContextWrapper)
Caller	Retourne l’instance ComponentCaller de l’application qui a démarré cette activité.
CallingActivity	Retourne le nom de l’activité qui a appelé cette activité.
CallingPackage	Retourne le nom du package qui a appelé cette activité.
ChangingConfigurations	Si cette activité est détruite, car elle ne peut pas gérer un paramètre de configuration modifié (et par conséquent sa méthode onConfigurationChanged(Configuration) n’est pas appelée), vous pouvez utiliser cette méthode pour découvrir l’ensemble des modifications qui se sont produites pendant le processus de destruction.
Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
ClassLoader	Retournez un chargeur de classes que vous pouvez utiliser pour récupérer des classes dans ce package. (Hérité de ContextWrapper)
CodeCacheDir	Retourne le chemin absolu du répertoire de cache spécifique à l’application sur le système de fichiers conçu pour stocker du code mis en cache. (Hérité de ContextWrapper)
ComponentName	Retourne le nom complet du composant de cette activité.
ContentResolver	Retourne une instance ContentResolver pour le package de votre application. (Hérité de ContextWrapper)
ContentScene	Récupérez la scène représentant le contenu actuel de cette fenêtre.
ContentTransitionManager	Récupérez le TransitionManager responsable des transitions par défaut dans cette fenêtre.
CurrentCaller	Retourne l’instance ComponentCaller de l’application qui a relancé cette activité avec une nouvelle intention via onNewIntent(Intent) ou onActivityResult(int, int, Intent).
CurrentFocus	Appelle Window.getCurrentFocus() dans la fenêtre de cette activité pour retourner la vue actuellement axée.
DataDir	Retourne le chemin absolu du répertoire sur le système de fichiers où tous les fichiers privés appartenant à cette application sont stockés. Les applications ne doivent pas utiliser ce chemin directement ; ils doivent utiliser plutôt getFilesDir(), getCacheDir() , getDir() , getDir(String,int) ou d’autres API de stockage sur cette classe. Le chemin retourné peut changer au fil du temps si l’application appelante est déplacée vers un appareil de stockage adopté. Seuls les chemins relatifs doivent donc être conservés. Aucune autorisation supplémentaire n’est requise pour que l’application appelante lit ou écrit des fichiers sous le chemin d’accès retourné. Retourne un fichier (Hérité de ContextWrapper)
DeviceId	Obtient l’ID d’appareil avec lequel ce contexte est associé. (Hérité de Context)
Display	Obtenez l’affichage avec lequel ce contexte est associé. (Hérité de Context)
ExternalCacheDir	Retourne le chemin absolu du répertoire sur le système de fichiers externe principal (qui se trouve quelque part sur ExternalStorageDirectory l’emplacement où l’application peut placer des fichiers de cache qu’elle possède. (Hérité de ContextWrapper)
FilesDir	Retourne le chemin absolu du répertoire sur le système de fichiers où OpenFileOutput(String, FileCreationMode) les fichiers créés sont stockés. (Hérité de ContextWrapper)
FocusedStateSet	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
FragmentManager	Cette méthode a été déconseillée au niveau de l’API 28.
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
HasWindowFocus	Retourne true si la fenêtre principale de cette activité a actuellement le focus sur la fenêtre.
Immersive	Bit indiquant que cette activité est « immersive » et ne doit pas être interrompue par les notifications si possible.
InitialCaller	Retourne l’instance ComponentCaller de l’application qui a initialement lancé cette activité.
InstanceCount	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
Intent	Retourne l’intention qui a démarré cette activité.
IsActivityTransitionRunning	Retourne si des transitions d’activité sont en cours d’exécution sur cette activité.
IsChangingConfigurations	Vérifiez si cette activité est en cours de destruction afin d’être recréée avec une nouvelle configuration.
IsChild	Cette méthode a été déconseillée au niveau de l’API 35.
IsDestroyed	Retourne la valeur true si l’appel final onDestroy() a été effectué sur l’activité. Par conséquent, cette instance est maintenant morte.
IsDeviceProtectedStorage	Indique si les API de stockage de ce contexte sont sauvegardées par le stockage protégé par l’appareil. (Hérité de ContextWrapper)
IsFinishing	Vérifiez si cette activité est en cours de finition, soit parce que vous avez appelé finish() sur celle-ci ou si quelqu’un d’autre l’a demandé.
IsInMultiWindowMode	Retourne true si l’activité est actuellement en mode multi-fenêtre.
IsInPictureInPictureMode	Retourne true si l’activité est actuellement en mode image-in-picture.
IsLaunchedFromBubble	Indique si cette activité est lancée à partir d’une bulle.
IsLocalVoiceInteractionSupported	Interroge si le service d’interaction vocale actuellement activé prend en charge le renvoi d’un interagissant vocal à utiliser par l’activité.
IsRestricted	Indique si ce contexte est restreint. (Hérité de Context)
IsTaskRoot	Retournez si cette activité est la racine d’une tâche.
IsUiContext	Retourne `true` si le contexte est un contexte d’interface utilisateur qui peut accéder aux composants de l’interface utilisateur tels que `WindowManager`, `android.view.LayoutInflater LayoutInflater` ou `android.app.WallpaperManager WallpaperManager`. (Hérité de Context)
IsVoiceInteraction	Vérifiez si cette activité s’exécute dans le cadre d’une interaction vocale avec l’utilisateur.
IsVoiceInteractionRoot	Comme isVoiceInteraction(), mais retourne uniquement true si c’est également la racine d’une interaction vocale.
JniIdentityHashCode	Obtient le code de hachage d’identité affecté à cet homologue Java par le runtime d’interopérabilité. (Hérité de Object)
JniManagedPeerState	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
JniPeerMembers	Fournit une infrastructure de liaison JNI pour Android.App.Activity.
LastNonConfigurationInstance	Récupérez les données d’instance non de configuration qui ont été retournées précédemment par onRetainNonConfigurationInstance().
LaunchedFromPackage	Retourne le nom du package de l’application qui a initialement lancé cette activité.
LaunchedFromUid	Retourne l’uid de l’application qui a lancé cette activité initialement.
LayoutInflater	Commodité pour appeler Window.getLayoutInflater().
LoaderManager	Cette méthode a été déconseillée au niveau de l’API 28.
LocalClassName	Retourne le nom de classe de cette activité avec le préfixe de package supprimé.
MainExecutor	Retournez une tâche en file d’attente `Executor` sur le thread principal associé à ce contexte. (Hérité de Context)
MainLooper	Retournez le Looper pour le thread principal du processus actuel. (Hérité de ContextWrapper)
MaxNumPictureInPictureActions	Retourne le nombre d’actions qui seront affichées dans l’interface utilisateur image-in-picture lorsque l’utilisateur interagit avec l’activité actuellement en mode image-in-picture.
MediaController	Obtient le contrôleur qui doit recevoir des événements de clé multimédia et de volume pendant que cette activité est au premier plan.
MenuInflater	Retourne un MenuInflater avec ce contexte.
NoBackupFilesDir	Retourne le chemin absolu du répertoire sur le système de fichiers similaire à FilesDir. (Hérité de ContextWrapper)
ObbDir	Retournez le répertoire de stockage externe principal où se trouvent les fichiers OBB de cette application (le cas échéant). (Hérité de ContextWrapper)
OnBackInvokedDispatcher	Retourne l’instance OnBackInvokedDispatcher associée à la fenêtre à laquelle cette activité est attachée.
OpPackageName	Retournez le nom du package qui doit être utilisé pour `android.app.AppOpsManager` les appels à partir de ce contexte, afin que la vérification uid du gestionnaire d’opérations d’application fonctionne avec le nom. (Hérité de Context)
PackageCodePath	Retournez le chemin d’accès complet au package Android principal de ce contexte. (Hérité de ContextWrapper)
PackageManager	Retournez l’instance PackageManager pour rechercher des informations globales sur le package. (Hérité de ContextWrapper)
PackageName	Retourne le nom du package de cette application. (Hérité de ContextWrapper)
PackageResourcePath	Retournez le chemin d’accès complet au package Android principal de ce contexte. (Hérité de ContextWrapper)
Params	Retourne l’ensemble de paramètres avec lesquels ce contexte a été créé, s’il a été créé via `#createContext(ContextParams)`. (Hérité de Context)
Parent	Cette méthode a été déconseillée au niveau de l’API 35.
ParentActivityIntent	Obtenez une intention qui lancera une activité cible explicite spécifiée par le parent logique de cette activité.
PeerReference	Obtient la référence d’objet JNI pour cet homologue Java. (Hérité de Object)
Referrer	Retournez des informations sur les personnes qui ont lancé cette activité.
RequestedOrientation	Retourne l’orientation demandée actuelle de l’activité, qui est l’orientation demandée dans le manifeste de l’application ou la dernière orientation donnée à setRequestedOrientation(int).
Resources	Retourne une instance Resources pour le package de votre application. (Hérité de ContextWrapper)
SearchEvent	Pendant les rappels onSearchRequested(), cette fonction retourne l’événement SearchEvent qui a déclenché le rappel, s’il existe.
SplashScreen	Obtenez l’interface que l’activité utilise pour communiquer avec l’écran de démarrage.
TaskId	Retourne l’identificateur de la tâche dans laquelle cette activité se trouve.
Theme	Retourne l’objet Theme associé à ce contexte. (Hérité de ContextWrapper)
ThresholdClass	Fournit une infrastructure de liaison JNI pour Android.App.Activity.
ThresholdType	Fournit une infrastructure de liaison JNI pour Android.App.Activity.
Title	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
TitleColor	Obsolète. Modifiez la couleur du titre associé à cette activité.
TitleFormatted	Modifiez le titre associé à cette activité.
VoiceInteractor	Récupérez le VoiceInteractor actif que l’utilisateur traverse pour interagir avec cette activité.
VolumeControlStream	Obtient le flux audio suggéré dont le volume doit être modifié par les contrôles de volume matériel.
Wallpaper	(Hérité de ContextWrapper)
WallpaperDesiredMinimumHeight	(Hérité de ContextWrapper)
WallpaperDesiredMinimumWidth	(Hérité de ContextWrapper)
Window	Récupérez la fenêtre active de l’activité.
WindowManager	Récupérez le gestionnaire de fenêtres pour afficher les fenêtres personnalisées.

Méthodes

Nom	Description
AddContentView(View, ViewGroup+LayoutParams)	Ajoutez une vue de contenu supplémentaire à l’activité.
ApplyOverrideConfiguration(Configuration)	Appelez pour définir une « configuration de remplacement » sur ce contexte : il s’agit d’une configuration qui répond à une ou plusieurs valeurs de la configuration standard appliquée au contexte. (Hérité de ContextThemeWrapper)
AttachBaseContext(Context)	Définissez le contexte de base de ce ContextWrapper. (Hérité de ContextWrapper)
BindIsolatedService(Intent, Context+BindServiceFlags, String, IExecutor, IServiceConnection)	Consultez bindIsolatedService(Intent,int,String,Executor,ServiceConnection) Call BindServiceFlags.of(long) pour obtenir un objet BindServiceFlags. (Hérité de Context)
BindIsolatedService(Intent, Int32, String, IExecutor, IServiceConnection)	La variante de `#bindService` ce problème, dans le cas spécifique des services isolés, permet à l’appelant de générer plusieurs instances d’un service à partir d’une seule déclaration de composant. (Hérité de Context)
BindService(Intent, Bind, IExecutor, IServiceConnection)	Identique à celui de `#bindService(Intent, ServiceConnection, int) bindService(Intent, ServiceConnection, int)` l’exécuteur pour contrôler les rappels ServiceConnection. (Hérité de Context)
BindService(Intent, Context+BindServiceFlags, IExecutor, IServiceConnection)	Consultez bindService(Intent,int,Executor,ServiceConnection) Call BindServiceFlags.of(long) pour obtenir un objet BindServiceFlags. (Hérité de Context)
BindService(Intent, IServiceConnection, Bind)	Connectez-vous à un service d’application, en le créant si nécessaire. (Hérité de ContextWrapper)
BindService(Intent, IServiceConnection, Context+BindServiceFlags)	Consultez bindService(Intent,ServiceConnection,int) Call BindServiceFlags.of(long) pour obtenir un objet BindServiceFlags. (Hérité de Context)
BindServiceAsUser(Intent, IServiceConnection, Context+BindServiceFlags, UserHandle)	Consultez bindServiceAsUser(Intent,ServiceConnection,int,UserHandle) Call BindServiceFlags.of(long) pour obtenir un objet BindServiceFlags. (Hérité de Context)
BindServiceAsUser(Intent, IServiceConnection, Int32, UserHandle)	Lie à un service de la `user` même manière que `#bindService`. (Hérité de Context)
CheckCallingOrSelfPermission(String)	Déterminez si le processus d’appel d’un IPC ou si vous avez reçu une autorisation particulière. (Hérité de ContextWrapper)
CheckCallingOrSelfUriPermission(Uri, ActivityFlags)	Déterminez si le processus appelant d’un IPC ou si vous avez reçu l’autorisation d’accéder à un URI spécifique. (Hérité de ContextWrapper)
CheckCallingOrSelfUriPermissions(IList<Uri>, Int32)	Déterminez si le processus d’appel d’un em<IPC >ou vous</em> a été autorisé à accéder à une liste d’URI. (Hérité de Context)
CheckCallingPermission(String)	Déterminez si le processus appelant d’un IPC que vous gérez a reçu une autorisation particulière. (Hérité de ContextWrapper)
CheckCallingUriPermission(Uri, ActivityFlags)	Déterminez si le processus appelant et l’ID utilisateur ont été autorisés à accéder à un URI spécifique. (Hérité de ContextWrapper)
CheckCallingUriPermissions(IList<Uri>, Int32)	Déterminez si le processus appelant et l’uid ont été autorisés à accéder à une liste d’URI. (Hérité de Context)
CheckContentUriPermissionFull(Uri, Int32, Int32, ActivityFlags)	Déterminez si un processus particulier et un uid ont été autorisés à accéder à un URI de contenu spécifique. (Hérité de Context)
CheckPermission(String, Int32, Int32)	Déterminez si l’autorisation donnée est autorisée pour un processus particulier et un ID utilisateur en cours d’exécution dans le système. (Hérité de ContextWrapper)
CheckSelfPermission(String)	Déterminez si vous avez reçu une autorisation particulière. (Hérité de ContextWrapper)
CheckUriPermission(Uri, Int32, Int32, ActivityFlags)	Déterminez si un processus particulier et un ID utilisateur ont été autorisés à accéder à un URI spécifique. (Hérité de ContextWrapper)
CheckUriPermission(Uri, String, String, Int32, Int32, ActivityFlags)	Vérifiez à la fois un URI et une autorisation normale. (Hérité de ContextWrapper)
CheckUriPermissions(IList<Uri>, Int32, Int32, Int32)	Déterminez si un processus particulier et un uid ont été autorisés à accéder à une liste d’URI. (Hérité de Context)
ClearOverrideActivityTransition(OverrideTransition)	Efface les animations qui sont définies à partir de overrideActivityTransition(int, int, int).
ClearWallpaper()	Obsolète. (Hérité de ContextWrapper)
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
CloseContextMenu()	Ferme par programmation le menu contextuel le plus récemment ouvert, si vous l’affichez.
CloseOptionsMenu()	Progammatiquement ferme le menu options.
Construct(JniObjectReference, JniObjectReferenceOptions)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
CreateAttributionContext(String)	Retourne un nouvel objet Context pour le contexte actuel, mais l’attribut à une autre balise. (Hérité de Context)
CreateConfigurationContext(Configuration)	Retourne un nouvel objet Context pour le contexte actuel, mais dont les ressources sont ajustées pour correspondre à la configuration donnée. (Hérité de ContextWrapper)
CreateContext(ContextParams)	Crée un contexte avec des propriétés et des comportements spécifiques. (Hérité de Context)
CreateContextForSplit(String)	Retourne un nouvel objet Context pour le nom de fractionnement donné. Le nouveau contexte a un objet ClassLoader et Resources qui peut accéder à la fractionnement et à toutes ses dépendances code/ressources. Chaque appel à cette méthode retourne une nouvelle instance d’un objet Context ; Les objets de contexte ne sont pas partagés, mais l’état courant (ClassLoader, d’autres ressources pour le même fractionnement) peut donc être assez léger. (Hérité de ContextWrapper)
CreateDeviceContext(Int32)	Retourne un nouvel `Context` objet à partir du contexte actuel, mais avec l’association d’appareil donnée par le `deviceId`. (Hérité de Context)
CreateDeviceProtectedStorageContext()	Retourne un nouvel objet Context pour le contexte actuel, mais dont les API de stockage sont sauvegardées par le stockage protégé par l’appareil. Sur les appareils avec démarrage direct, les données stockées dans cet emplacement sont chiffrées avec une clé liée à l’appareil physique, et elles sont accessibles immédiatement après le démarrage de l’appareil, avant et après que l’utilisateur s’est authentifié avec ses informations d’identification (par exemple, un modèle de verrouillage ou un code confidentiel). Étant donné que les données protégées par l’appareil sont disponibles sans authentification utilisateur, vous devez limiter soigneusement les données que vous stockez à l’aide de ce contexte. Par exemple, le stockage de jetons d’authentification sensibles ou de mots de passe dans la zone protégée par l’appareil est fortement déconseillé. Si l’appareil sous-jacent n’a pas la possibilité de stocker les données protégées par l’appareil et les informations d’identification protégées à l’aide de différentes clés, les deux zones de stockage seront disponibles en même temps. Ils restent sous la forme de deux emplacements de stockage distincts sur le disque, et seules les fenêtres de disponibilité changent. Chaque appel à cette méthode retourne une nouvelle instance d’un objet Context ; Les objets de contexte ne sont pas partagés, mais l’état courant (ClassLoader, d’autres ressources pour la même configuration) peut donc être assez léger. Retourne le contexte (Hérité de ContextWrapper)
CreateDisplayContext(Display)	Retourne un nouvel objet Context pour le contexte actuel, mais dont les ressources sont ajustées pour correspondre aux métriques de l’affichage donné. (Hérité de ContextWrapper)
CreatePackageContext(String, PackageContextFlags)	Retourne un nouvel objet Context pour le nom d’application donné. (Hérité de ContextWrapper)
CreatePendingResult(Int32, Intent, PendingIntentFlags)	Créez un objet PendingIntent que vous pouvez transmettre à d’autres personnes pour qu’ils puissent les utiliser pour renvoyer des données de résultat à votre rappel onActivityResult(int, int, Intent).
CreateWindowContext(Display, Int32, Bundle)	Crée une `Context` fenêtre non-fenêtre`android.app.Activity activity` sur l’élément donné `Display`. (Hérité de Context)
CreateWindowContext(Int32, Bundle)	Crée un contexte pour une fenêtre non-activité. (Hérité de Context)
DatabaseList()	Retourne un tableau de chaînes nommant les bases de données privées associées au package d’application de ce contexte. (Hérité de ContextWrapper)
DeleteDatabase(String)	Supprimez une sqLiteDatabase privée existante associée au package d’application de ce contexte. (Hérité de ContextWrapper)
DeleteFile(String)	Supprimez le fichier privé donné associé au package d’application de ce contexte. (Hérité de ContextWrapper)
DeleteSharedPreferences(String)	Supprimez un fichier de préférences partagées existant. (Hérité de ContextWrapper)
DismissDialog(Int32)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
DismissKeyboardShortcutsHelper()	Ignorer l’écran Raccourcis clavier.
DispatchGenericMotionEvent(MotionEvent)	Appelé pour traiter les événements de mouvement génériques.
DispatchKeyEvent(KeyEvent)	Appelé pour traiter les événements clés.
DispatchKeyShortcutEvent(KeyEvent)	Appelé pour traiter un événement de raccourci de touche.
DispatchPopulateAccessibilityEvent(AccessibilityEvent)	Appelé pour traiter la population d’AccessibilityEvents.
DispatchTouchEvent(MotionEvent)	Appelé pour traiter les événements d’écran tactile.
DispatchTrackballEvent(MotionEvent)	Appelé pour traiter les événements trackball.
Dispose()	Libère les ressources détenues par cet homologue Java. (Hérité de Object)
Dispose(Boolean)	Libère les ressources détenues par cet homologue Java. (Hérité de Object)
DisposeUnlessReferenced()	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
Dump(String, FileDescriptor, PrintWriter, String[])	Imprimez l’état de l’activité dans le flux donné.
EnforceCallingOrSelfPermission(String, String)	Si ni vous ni le processus appelant d’un IPC que vous gérez a reçu une autorisation particulière, lèvez un SecurityException. (Hérité de ContextWrapper)
EnforceCallingOrSelfUriPermission(Uri, ActivityFlags, String)	Si le processus appelant d’un IPC ou si vous n’avez pas reçu l’autorisation d’accéder à un URI spécifique, lèvez SecurityException. (Hérité de ContextWrapper)
EnforceCallingPermission(String, String)	Si le processus appelant d’un IPC que vous gérez n’a pas reçu d’autorisation particulière, lèvez un SecurityException. (Hérité de ContextWrapper)
EnforceCallingUriPermission(Uri, ActivityFlags, String)	Si le processus appelant et l’ID utilisateur n’ont pas été autorisés à accéder à un URI spécifique, lèvez SecurityException. (Hérité de ContextWrapper)
EnforcePermission(String, Int32, Int32, String)	Si l’autorisation donnée n’est pas autorisée pour un processus particulier et un ID utilisateur en cours d’exécution dans le système, lèvez un SecurityException. (Hérité de ContextWrapper)
EnforceUriPermission(Uri, Int32, Int32, ActivityFlags, String)	Si un processus particulier et un ID utilisateur n’ont pas été autorisés à accéder à un URI spécifique, lèvez SecurityException. (Hérité de ContextWrapper)
EnforceUriPermission(Uri, String, String, Int32, Int32, ActivityFlags, String)	Appliquez à la fois un URI et une autorisation normale. (Hérité de ContextWrapper)
EnterPictureInPictureMode()	Place l’activité en mode image dans l’image si possible dans l’état système actuel.
EnterPictureInPictureMode(PictureInPictureParams)	Place l’activité en mode image dans l’image si possible dans l’état système actuel.
Equals(Object)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
FileList()	Retourne un tableau de chaînes nommant les fichiers privés associés au package d’application de ce contexte. (Hérité de ContextWrapper)
FindViewById(Int32)	Recherche une vue identifiée par l’attribut XML android :id qui a été traité dans onCreate(Bundle).
FindViewById<T>(Int32)	Recherche une vue identifiée par l’attribut ID de la ressource de disposition XML.
Finish()	Appelez-le lorsque votre activité est terminée et doit être fermée.
FinishActivity(Int32)	Forcez la fin d’une autre activité que vous aviez démarrée précédemment avec startActivityForResult(Intent, int).
FinishActivityFromChild(Activity, Int32)	Cette méthode a été déconseillée au niveau de l’API 30.
FinishAffinity()	Terminez cette activité ainsi que toutes les activités immédiatement en dessous de celle-ci dans la tâche actuelle qui ont la même affinité.
FinishAfterTransition()	Inverse la transition d’entrée de scène d’activité et déclenche l’activité appelante pour inverser sa transition de sortie.
FinishAndRemoveTask()	Appelez cela lorsque votre activité est terminée et doit être fermée et la tâche doit être complètement supprimée dans le cadre de la fin de l’activité racine de la tâche.
FinishFromChild(Activity)	Cette méthode a été déconseillée au niveau de l’API 30.
GetColor(Int32)	Retourne une couleur associée à un ID de ressource particulier et avec style pour le thème actuel. (Hérité de Context)
GetColorStateList(Int32)	Retourne une liste d’états de couleur associée à un ID de ressource particulier et mise en forme pour le thème actuel. (Hérité de Context)
GetDatabasePath(String)	Retourne le chemin absolu sur le système de fichiers où une base de données créée avec openOrCreateDatabase(String, int, CursorFactory) est stockée. Le chemin retourné peut changer au fil du temps si l’application appelante est déplacée vers un appareil de stockage adopté. Seuls les chemins relatifs doivent donc être conservés. (Hérité de ContextWrapper)
GetDir(String, FileCreationMode)	Récupérez, créez, si nécessaire, un nouveau répertoire dans lequel l’application peut placer ses propres fichiers de données personnalisés. (Hérité de ContextWrapper)
GetDrawable(Int32)	Retourne un objet dessinable associé à un ID de ressource particulier et mis en forme pour le thème actuel. (Hérité de Context)
GetExternalCacheDirs()	Retourne des chemins absolus vers des répertoires spécifiques à l’application sur tous les appareils de stockage externes où l’application peut placer des fichiers de cache qu’elle possède. (Hérité de ContextWrapper)
GetExternalFilesDir(String)	Retourne le chemin absolu du répertoire sur le système de fichiers externe principal (qui se trouve quelque part sur ExternalStorageDirectory) où l’application peut placer des fichiers persistants qu’elle possède. (Hérité de ContextWrapper)
GetExternalFilesDirs(String)	Retourne des chemins absolus vers des répertoires spécifiques à l’application sur tous les appareils de stockage externes où l’application peut placer des fichiers persistants qu’elle possède. (Hérité de ContextWrapper)
GetExternalMediaDirs()	Obsolète. Retourne des chemins absolus vers des répertoires spécifiques à l’application sur tous les appareils de stockage externes où l’application peut placer des fichiers multimédias. (Hérité de ContextWrapper)
GetFileStreamPath(String)	Retourne le chemin absolu sur le système de fichiers dans lequel un fichier créé est OpenFileOutput(String, FileCreationMode) stocké. (Hérité de ContextWrapper)
GetHashCode()	Retourne une valeur de code de hachage pour l’objet. (Hérité de Object)
GetObbDirs()	Retourne des chemins absolus vers des répertoires spécifiques à l’application sur tous les appareils de stockage externes où se trouvent les fichiers OBB de l’application (le cas échéant). (Hérité de ContextWrapper)
GetPreferences(FileCreationMode)	Récupérez un objet SharedPreferences pour accéder aux préférences privées à cette activité.
GetSharedPreferences(String, FileCreationMode)	Récupérez et maintenez le contenu du fichier de préférences « name », en retournant une instance SharedPreferences par le biais de laquelle vous pouvez récupérer et modifier ses valeurs. (Hérité de ContextWrapper)
GetString(Int32, Object[])	Retourne une chaîne localisée à partir de la table de chaînes par défaut du package de l’application. (Hérité de Context)
GetString(Int32)	Retourne une chaîne localisée à partir de la table de chaînes par défaut du package de l’application. (Hérité de Context)
GetSystemService(Class)	Retournez le handle dans un service de niveau système par classe. (Hérité de Context)
GetSystemService(String)	Retournez le handle à un service de niveau système par nom. (Hérité de ContextWrapper)
GetSystemServiceName(Class)	Obtient le nom du service au niveau du système représenté par la classe spécifiée. (Hérité de ContextWrapper)
GetText(Int32)	Retournez une charSequence localisée et styleée à partir de la table de chaînes par défaut du package de l’application. (Hérité de Context)
GetTextFormatted(Int32)	Retournez une charSequence localisée et styleée à partir de la table de chaînes par défaut du package de l’application. (Hérité de Context)
GrantUriPermission(String, Uri, ActivityFlags)	Accordez l’autorisation d’accéder à un URI spécifique à un autre package, que ce package ait l’autorisation générale d’accéder au fournisseur de contenu de l’URI. (Hérité de ContextWrapper)
InvalidateOptionsMenu()	Déclarez que le menu options a changé. Il doit donc être recréé.
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
ManagedQuery(Uri, String[], String, String[], String)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
MoveDatabaseFrom(Context, String)	Déplacez un fichier de base de données existant du contexte de stockage source donné vers ce contexte. Il est généralement utilisé pour migrer des données entre les emplacements de stockage après une mise à niveau, comme la migration vers le stockage protégé par l’appareil. La base de données doit être fermée avant d’être déplacée. (Hérité de ContextWrapper)
MoveSharedPreferencesFrom(Context, String)	Déplacez un fichier de préférences partagées existant du contexte de stockage source donné vers ce contexte. Il est généralement utilisé pour migrer des données entre les emplacements de stockage après une mise à niveau, par exemple le déplacement vers le stockage protégé par l’appareil. (Hérité de ContextWrapper)
MoveTaskToBack(Boolean)	Déplacez la tâche contenant cette activité vers l’arrière de la pile d’activités.
NavigateUpTo(Intent)	Accédez de cette activité à l’activité spécifiée par upIntent, en terminant cette activité dans le processus.
NavigateUpToFromChild(Activity, Intent)	Cette méthode a été déconseillée au niveau de l’API 30.
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
ObtainStyledAttributes(IAttributeSet, Int32[], Int32, Int32)	Récupérez les informations d’attribut de style dans le thème de ce contexte. (Hérité de Context)
ObtainStyledAttributes(IAttributeSet, Int32[])	Récupérez les informations d’attribut de style dans le thème de ce contexte. (Hérité de Context)
ObtainStyledAttributes(Int32, Int32[])	Récupérez les informations d’attribut de style dans le thème de ce contexte. (Hérité de Context)
ObtainStyledAttributes(Int32[])	Récupérez les informations d’attribut de style dans le thème de ce contexte. (Hérité de Context)
OnActionModeFinished(ActionMode)	Avertit l’activité qu’un mode d’action a terminé.
OnActionModeStarted(ActionMode)	Avertit l’activité qu’un mode d’action a été démarré.
OnActivityReenter(Int32, Intent)	Appelée lorsqu’une activité que vous avez lancée avec une transition d’activité expose cette activité par le biais d’une transition d’activité de retour, ce qui vous donne le resultCode et toutes les données supplémentaires à partir de celle-ci.
OnActivityResult(Int32, Result, Intent, ComponentCaller)	Identique à onActivityResult(int,int,Intent), mais avec un paramètre supplémentaire pour l’instance ComponentCaller associée à l’application qui a envoyé le résultat.
OnActivityResult(Int32, Result, Intent)	Appelé lorsqu’une activité que vous avez lancée s’arrête, ce qui vous donne le requestCode avec lequel vous l’avez démarré, le resultCode qu’il a retourné et toutes les données supplémentaires de celui-ci.
OnApplyThemeResource(Resources+Theme, Int32, Boolean)	Appelé par `#setTheme` et `#getTheme` pour appliquer une ressource de thème à l’objet Theme actuel. (Hérité de ContextThemeWrapper)
OnAttachedToWindow()	Appelé lorsque la fenêtre principale associée à l’activité a été attachée au gestionnaire de fenêtres.
OnAttachFragment(Fragment)	Cette méthode a été déconseillée au niveau de l’API 28.
OnBackPressed()	Cette méthode a été déconseillée au niveau de l’API 33.
OnChildTitleChanged(Activity, ICharSequence)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
OnChildTitleChanged(Activity, String)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
OnConfigurationChanged(Configuration)	Appelé par le système lorsque la configuration de l’appareil change pendant l’exécution de votre activité.
OnContentChanged()	Ce hook est appelé chaque fois que l’affichage de contenu de l’écran change (en raison d’un appel à Window.setContentView ou Window.addContentView).
OnContextItemSelected(IMenuItem)	Ce hook est appelé chaque fois qu’un élément d’un menu contextuel est sélectionné.
OnContextMenuClosed(IMenu)	Ce hook est appelé chaque fois que le menu contextuel est fermé (soit par l’utilisateur annulant le menu avec le bouton précédent/menu, soit lorsqu’un élément est sélectionné).
OnCreate(Bundle, PersistableBundle)	Identique à onCreate(android.os.Bundle) mais a appelé pour ces activités créées avec l’attribut R.attr.persistableMode défini sur persistAcrossReboots.
OnCreate(Bundle)	Appelé lorsque l’activité démarre.
OnCreateContextMenu(IContextMenu, View, IContextMenuContextMenuInfo)	Appelé lorsqu’un menu contextuel de l’affichage est sur le point d’être affiché.
OnCreateDescription()	Générez une nouvelle description pour cette activité.
OnCreateDescriptionFormatted()	Générez une nouvelle description pour cette activité.
OnCreateDialog(Int32, Bundle)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
OnCreateDialog(Int32)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
OnCreateNavigateUpTaskStack(TaskStackBuilder)	Définissez la pile de tâches synthétique qui sera générée pendant la navigation vers le haut à partir d’une autre tâche.
OnCreateOptionsMenu(IMenu)	Initialisez le contenu du menu options standard de l’activité.
OnCreatePanelMenu(Int32, IMenu)	Implémentation par défaut de Window.Callback.onCreatePanelMenu(int, Menu) pour les activités.
OnCreatePanelView(Int32)	Implémentation par défaut de Window.Callback.onCreatePanelView(int) pour les activités.
OnCreateThumbnail(Bitmap, Canvas)	Cette méthode a été déconseillée au niveau de l’API 28.
OnCreateView(String, Context, IAttributeSet)	Implémentation standard de LayoutInflater.Factory.onCreateView(String, Context, AttributeSet) utilisée lors de l’inflation avec LayoutInflater retournée par Context.getSystemService(Class).
OnCreateView(View, String, Context, IAttributeSet)	Implémentation standard d’android.view.LayoutInflater.Factory2.onCreateView(View,String,Context,AttributeSet) utilisée lors de l’inflation avec LayoutInflater retournée par Context.getSystemService(Class).
OnDestroy()	Effectuez un nettoyage final avant la destruction d’une activité.
OnDetachedFromWindow()	Appelé lorsque la fenêtre principale associée à l’activité a été détachée du gestionnaire de fenêtres.
OnEnterAnimationComplete()	Les activités ne peuvent pas dessiner pendant la période dans laquelle leurs fenêtres s’animent.
OnGenericMotionEvent(MotionEvent)	Appelé lorsqu’un événement de mouvement générique n’a pas été géré par l’une des vues à l’intérieur de l’activité.
OnGetDirectActions(CancellationSignal, IConsumer)	Retourne la liste des actions directes prises en charge par l’application.
OnKeyDown(Keycode, KeyEvent)	Appelé lorsqu’une touche a été enfoncée et non gérée par l’une des vues à l’intérieur de l’activité.
OnKeyLongPress(Keycode, KeyEvent)	Implémentation par défaut de KeyEvent.Callback.onKeyLongPress() : retourne toujours false (ne gère pas l’événement).
OnKeyMultiple(Keycode, Int32, KeyEvent)	Implémentation par défaut de KeyEvent.Callback.onKeyMultiple() : retourne toujours false (ne gère pas l’événement).
OnKeyShortcut(Keycode, KeyEvent)	Appelé lorsqu’un événement de raccourci de touche n’est pas géré par l’une des vues de l’activité.
OnKeyUp(Keycode, KeyEvent)	Appelé lorsqu’une clé a été libérée et non gérée par l’une des vues à l’intérieur de l’activité.
OnLocalVoiceInteractionStarted()	Rappel indiquant que startLocalVoiceInteraction(Bundle) a entraîné le démarrage d’une session d’interaction vocale.
OnLocalVoiceInteractionStopped()	Rappel pour indiquer que l’interaction vocale locale s’est arrêtée, car elle a été demandée par le biais d’un appel pour arrêterLocalVoiceInteraction() ou parce qu’elle a été annulée par l’utilisateur.
OnLowMemory()	Cela est appelé lorsque le système global est en cours d’exécution faible en mémoire et que les processus en cours d’exécution doivent réduire leur utilisation de la mémoire.
OnMenuItemSelected(Int32, IMenuItem)	Implémentation par défaut de Window.Callback.onMenuItemSelected(int, MenuItem) pour les activités.
OnMenuOpened(Int32, IMenu)	Appelé lorsque le menu d’un panneau est ouvert par l’utilisateur.
OnMultiWindowModeChanged(Boolean, Configuration)	Appelé par le système lorsque l’activité passe du mode plein écran en mode multi-fenêtre et visa-versa.
OnMultiWindowModeChanged(Boolean)	Cette méthode a été déconseillée au niveau de l’API 26.
OnNavigateUp()	Cette méthode est appelée chaque fois que l’utilisateur choisit de naviguer vers le haut dans la hiérarchie d’activité de votre application à partir de la barre d’action.
OnNavigateUpFromChild(Activity)	Cette méthode a été déconseillée au niveau de l’API 30.
OnNewIntent(Intent, ComponentCaller)	Identique à onNewIntent(Intent), mais avec un paramètre supplémentaire pour l’instance ComponentCaller associée à l’application qui a envoyé l’intention.
OnNewIntent(Intent)	Cela est appelé pour les activités qui définissent launchMode sur « singleTop » dans leur package, ou si un client a utilisé l’indicateur Intent.FLAG_ACTIVITY_SINGLE_TOP lors de l’appel de startActivity(Intent).
OnOptionsItemSelected(IMenuItem)	Ce hook est appelé chaque fois qu’un élément de votre menu Options est sélectionné.
OnOptionsMenuClosed(IMenu)	Ce hook est appelé chaque fois que le menu options est fermé (soit par l’utilisateur annulant le menu avec le bouton précédent/menu, soit lorsqu’un élément est sélectionné).
OnPanelClosed(Int32, IMenu)	Implémentation par défaut d’android.view.Window.Callback.onPanelClosed(int,Menu) pour les activités.
OnPause()	Appelé dans le cadre du cycle de vie de l’activité lorsque l’utilisateur n’interagit plus activement avec l’activité, mais qu’il est toujours visible à l’écran.
OnPerformDirectAction(String, Bundle, CancellationSignal, IConsumer)	Cette opération est appelée pour effectuer une action précédemment définie par l’application.
OnPictureInPictureModeChanged(Boolean, Configuration)	Appelé par le système lorsque l’activité passe en mode image en mode image-in-picture.
OnPictureInPictureModeChanged(Boolean)	Cette méthode a été déconseillée au niveau de l’API 26.
OnPictureInPictureRequested()	Cette méthode est appelée par le système dans différents cas où l’image en mode image doit être entrée si prise en charge.
OnPictureInPictureUiStateChanged(PictureInPictureUiState)	Appelé par le système lorsque l’activité se trouve dans PiP et a des modifications d’état.
OnPostCreate(Bundle, PersistableBundle)	Il s’agit de la même chose que onPostCreate(Bundle), mais elle est appelée pour les activités créées avec l’attribut R.attr.persistableMode défini sur persistAcrossReboots.
OnPostCreate(Bundle)	Appelé lorsque le démarrage de l’activité est terminé (après onStart() et onRestoreInstanceState(Bundle) ont été appelés).
OnPostResume()	Appelé lorsque la reprise de l’activité est terminée (après l’appel de onResume().
OnPrepareDialog(Int32, Dialog, Bundle)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
OnPrepareDialog(Int32, Dialog)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
OnPrepareNavigateUpTaskStack(TaskStackBuilder)	Préparez la pile de tâches synthétique qui sera générée pendant la navigation vers le haut à partir d’une autre tâche.
OnPrepareOptionsMenu(IMenu)	Préparez le menu options standard de l’écran à afficher.
OnPreparePanel(Int32, View, IMenu)	Implémentation par défaut de Window.Callback.onPreparePanel(int, View, Menu) pour les activités.
OnProvideAssistContent(AssistContent)	Cela est appelé lorsque l’utilisateur demande une assistance pour fournir des références au contenu lié à l’activité actuelle.
OnProvideAssistData(Bundle)	Cela est appelé lorsque l’utilisateur demande une assistance, pour générer une intention complète Intent.ACTION_ASSIST avec tout le contexte de l’application actuelle.
OnProvideKeyboardShortcuts(IList<KeyboardShortcutGroup>, IMenu, Int32)	Appelé lorsque les raccourcis clavier sont demandés pour la fenêtre active.
OnProvideReferrer()	Remplacez la génération du référent souhaité pour le contenu actuellement affiché par l’application.
OnRequestPermissionsResult(Int32, String[], Permission[], Int32)	Rappel pour le résultat de la demande d’autorisations.
OnRequestPermissionsResult(Int32, String[], Permission[])	Rappel pour le résultat de la demande d’autorisations.
OnRestart()	Appelé après onStop() lorsque l’activité actuelle est réinscrite à l’utilisateur (l’utilisateur y a accédé).
OnRestoreInstanceState(Bundle, PersistableBundle)	Il s’agit de la même chose que onRestoreInstanceState(Bundle), mais elle est appelée pour les activités créées avec l’attribut R.attr.persistableMode défini sur persistAcrossReboots.
OnRestoreInstanceState(Bundle)	Cette méthode est appelée après onStart() lorsque l’activité est réinitialisée à partir d’un état précédemment enregistré, comme indiqué ici dans savedInstanceState.
OnResume()	Appelé après onRestoreInstanceState(Bundle), onRestart() ou onPause().
OnRetainNonConfigurationInstance()	Appelé par le système, dans le cadre de la destruction d’une activité en raison d’une modification de configuration, lorsqu’il est connu qu’une nouvelle instance sera immédiatement créée pour la nouvelle configuration.
OnSaveInstanceState(Bundle, PersistableBundle)	Il s’agit de la même chose que onSaveInstanceState(Bundle), mais elle est appelée pour les activités créées avec l’attribut R.attr.persistableMode défini sur persistAcrossReboots.
OnSaveInstanceState(Bundle)	Appelé pour récupérer l’état par instance d’une activité avant d’être tué afin que l’état puisse être restauré dans onCreate(Bundle) ou onRestoreInstanceState(Bundle) (le bundle rempli par cette méthode sera transmis aux deux).
OnSearchRequested()	Appelé lorsque l’utilisateur signale le désir de démarrer une recherche.
OnSearchRequested(SearchEvent)	Ce hook est appelé lorsque l’utilisateur signale le désir de démarrer une recherche.
OnStart()	Appelé après onCreate(Bundle) ou après onRestart() lorsque l’activité a été arrêtée, mais est à nouveau affichée à l’utilisateur.
OnStateNotSaved()	Cette méthode a été déconseillée au niveau de l’API 29.
OnStop()	Appelé lorsque vous n’êtes plus visible par l’utilisateur.
OnTitleChanged(ICharSequence, Color)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
OnTitleChanged(String, Color)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
OnTopResumedActivityChanged(Boolean)	Appelé lorsque l’activité obtient ou perd la position de reprise supérieure dans le système.
OnTouchEvent(MotionEvent)	Appelé lorsqu’un événement d’écran tactile n’a pas été géré par l’une des vues à l’intérieur de l’activité.
OnTrackballEvent(MotionEvent)	Appelé lorsque le trackball a été déplacé et non géré par l’une des vues à l’intérieur de l’activité.
OnTrimMemory(TrimMemory)	Appelé lorsque le système d’exploitation a déterminé qu’il est judicieux qu’un processus supprime la mémoire inutile de son processus.
OnUserInteraction()	Appelé chaque fois qu’une touche, une touche tactile ou un événement trackball est distribué à l’activité.
OnUserLeaveHint()	Appelé dans le cadre du cycle de vie de l’activité lorsqu’une activité est sur le point d’entrer en arrière-plan en raison du choix de l’utilisateur.
OnVisibleBehindCanceled()	Cette méthode a été déconseillée au niveau de l’API 26.
OnWindowAttributesChanged(WindowManagerLayoutParams)	Cela est appelé chaque fois que les attributs de fenêtre actuels changent.
OnWindowFocusChanged(Boolean)	Appelé lorsque la fenêtre actuelle de l’activité gagne ou perd le focus.
OnWindowStartingActionMode(ActionMode+ICallback, ActionModeType)	Appelé lorsqu’un mode d’action est démarré pour cette fenêtre.
OnWindowStartingActionMode(ActionMode+ICallback)	Donnez à l’activité la possibilité de contrôler l’interface utilisateur d’un mode d’action demandé par le système.
OpenContextMenu(View)	Ouvre par programmation le menu contextuel d’une vue particulière.
OpenFileInput(String)	Ouvrez un fichier privé associé au package d’application de ce contexte pour la lecture. (Hérité de ContextWrapper)
OpenFileOutput(String, FileCreationMode)	Ouvrez un fichier privé associé au package d’application de ce contexte pour l’écriture. (Hérité de ContextWrapper)
OpenOptionsMenu()	Ouvre par programmation le menu options.
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory, IDatabaseErrorHandler)	Ouvrez une nouvelle sqLiteDatabase privée associée au package d’application de ce contexte. (Hérité de ContextWrapper)
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory)	Ouvrez une nouvelle sqLiteDatabase privée associée au package d’application de ce contexte. (Hérité de ContextWrapper)
OverrideActivityTransition(OverrideTransition, Int32, Int32, Int32)	Personnalise l’animation et la couleur d’arrière-plan pour les transitions d’activité.
OverrideActivityTransition(OverrideTransition, Int32, Int32)	Personnalise l’animation pour les transitions d’activité.
OverridePendingTransition(Int32, Int32, Int32)	Cette méthode a été déconseillée au niveau de l’API 34.
OverridePendingTransition(Int32, Int32)	Cette méthode a été déconseillée au niveau de l’API 34.
PeekWallpaper()	Obsolète. (Hérité de ContextWrapper)
PostponeEnterTransition()	Reporter la transition d’activité d’entrée lorsque l’activité a été démarrée avec android.app.ActivityOptions.makeSceneTransitionAnimation(Activity,android.util.Pair[]).
Recreate()	Provoquez la recréation de cette activité avec une nouvelle instance.
RegisterActivityLifecycleCallbacks(Application+IActivityLifecycleCallbacks)	Inscrivez une instance Application.ActivityLifecycleCallbacks qui reçoit des rappels de cycle de vie uniquement pour cette activité.
RegisterComponentCallbacks(IComponentCallbacks)	Ajoutez une nouveauté `ComponentCallbacks` à l’application de base du contexte, qui sera appelée en même temps que les méthodes ComponentCallbacks des activités et d’autres composants. (Hérité de Context)
RegisterDeviceIdChangeListener(IExecutor, IIntConsumer)	Ajoute un nouvel écouteur d’ID d’appareil modifié à celui `Context`qui sera appelé lorsque l’association de l’appareil est modifiée par le système. (Hérité de Context)
RegisterForContextMenu(View)	Inscrit un menu contextuel à afficher pour l’affichage donné (plusieurs affichages peuvent afficher le menu contextuel).
RegisterReceiver(BroadcastReceiver, IntentFilter, ActivityFlags)	Obsolète. Inscrivez-vous pour recevoir des diffusions d’intentions, le récepteur étant éventuellement exposé aux applications instantanées. Pour plus d’informations, consultez registerReceiver(BroadcastReceiver,IntentFilter). Par défaut, les applications instantanées ne peuvent pas interagir avec des récepteurs dans d’autres applications, ce qui vous permet d’exposer un récepteur avec lequel Les applications instantanées peuvent interagir. Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. À partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE , le système peut placer des diffusions inscrites dans le contexte dans une file d’attente pendant que l’application est à l’état mis en cache. Lorsque l’application quitte l’état mis en cache, tel que le retour au premier plan, le système remet toutes les diffusions en file d’attente. Plusieurs instances de certaines diffusions peuvent être fusionnées dans une seule diffusion. À partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH , les récepteurs inscrits avec cette méthode respectent correctement l’intent.setPackage(String) spécifié pour une intention en cours de diffusion. Avant cela, il serait ignoré et remis à tous les récepteurs inscrits correspondants. Soyez prudent si vous utilisez cette option pour la sécurité. Récepteur de paramètres BroadcastReceiver : cette valeur peut être null. (Hérité de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, ReceiverFlags)	Inscrivez-vous pour recevoir des diffusions d’intentions, le récepteur étant éventuellement exposé aux applications instantanées. Pour plus d’informations, consultez registerReceiver(BroadcastReceiver,IntentFilter). Par défaut, les applications instantanées ne peuvent pas interagir avec des récepteurs dans d’autres applications, ce qui vous permet d’exposer un récepteur avec lequel Les applications instantanées peuvent interagir. Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. À partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE , le système peut placer des diffusions inscrites dans le contexte dans une file d’attente pendant que l’application est à l’état mis en cache. Lorsque l’application quitte l’état mis en cache, tel que le retour au premier plan, le système remet toutes les diffusions en file d’attente. Plusieurs instances de certaines diffusions peuvent être fusionnées dans une seule diffusion. À partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH , les récepteurs inscrits avec cette méthode respectent correctement l’intent.setPackage(String) spécifié pour une intention en cours de diffusion. Avant cela, il serait ignoré et remis à tous les récepteurs inscrits correspondants. Soyez prudent si vous utilisez cette option pour la sécurité. Récepteur de paramètres BroadcastReceiver : BroadcastReceiver pour gérer la diffusion. Cette valeur peut être null. (Hérité de Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ActivityFlags)	Obsolète. Inscrivez-vous pour recevoir des diffusions d’intentions, à exécuter dans le contexte du planificateur . Pour plus d’informations, consultez registerReceiver(BroadcastReceiver,IntentFilter,int) et registerReceiver(BroadcastReceiver,IntentFilter,String,Handler). Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. À partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE , le système peut placer des diffusions inscrites dans le contexte dans une file d’attente pendant que l’application est à l’état mis en cache. Lorsque l’application quitte l’état mis en cache, tel que le retour au premier plan, le système remet toutes les diffusions en file d’attente. Plusieurs instances de certaines diffusions peuvent être fusionnées dans une seule diffusion. À partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH , les récepteurs inscrits avec cette méthode respectent correctement l’intent.setPackage(String) spécifié pour une intention en cours de diffusion. Avant cela, il serait ignoré et remis à tous les récepteurs inscrits correspondants. Soyez prudent si vous utilisez cette option pour la sécurité. Récepteur de paramètres BroadcastReceiver : cette valeur peut être null. (Hérité de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ReceiverFlags)	Inscrivez-vous pour recevoir des diffusions d’intentions, à exécuter dans le contexte du planificateur . Pour plus d’informations, consultez registerReceiver(BroadcastReceiver,IntentFilter,int) et registerReceiver(BroadcastReceiver,IntentFilter,String,Handler). Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. À partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE , le système peut placer des diffusions inscrites dans le contexte dans une file d’attente pendant que l’application est à l’état mis en cache. Lorsque l’application quitte l’état mis en cache, tel que le retour au premier plan, le système remet toutes les diffusions en file d’attente. Plusieurs instances de certaines diffusions peuvent être fusionnées dans une seule diffusion. À partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH , les récepteurs inscrits avec cette méthode respectent correctement l’intent.setPackage(String) spécifié pour une intention en cours de diffusion. Avant cela, il serait ignoré et remis à tous les récepteurs inscrits correspondants. Soyez prudent si vous utilisez cette option pour la sécurité. Récepteur de paramètres BroadcastReceiver : BroadcastReceiver pour gérer la diffusion. (Hérité de Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler)	Inscrivez-vous pour recevoir des diffusions d’intentions, à exécuter dans le contexte du <planificateur>/<var>. (Hérité de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter)	Inscrivez un BroadcastReceiver à exécuter dans le thread d’activité principal. (Hérité de ContextWrapper)
RegisterScreenCaptureCallback(IExecutor, Activity+IScreenCaptureCallback)	Inscrit un rappel de capture d’écran pour cette activité.
ReleaseInstance()	Demandez à l’instance d’application locale de cette activité de libérer sa mémoire.
RemoveDialog(Int32)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
RemoveStickyBroadcast(Intent)	Obsolète. (Hérité de ContextWrapper)
RemoveStickyBroadcastAsUser(Intent, UserHandle)	Obsolète. (Hérité de ContextWrapper)
ReportFullyDrawn()	Signalez au système que votre application est désormais entièrement dessinée, à des fins de diagnostic et d’optimisation.
RequestDragAndDropPermissions(DragEvent)	Créez un objet DragAndDropPermissions lié à cette activité et contrôlez les autorisations d’accès pour les URI de contenu associés à DragEvent.
RequestFullscreenMode(FullscreenModeRequest, IOutcomeReceiver)	Demande de placer l’activité en plein écran.
RequestOpenInBrowserEducation()	Demandes d’affichage du \u201cOuvrir dans le navigateur\u201d éducation.
RequestPermissions(String[], Int32, Int32)	Demande des autorisations à accorder à cette application.
RequestPermissions(String[], Int32)	Demande des autorisations à accorder à cette application.
RequestShowKeyboardShortcuts()	Demandez à l’écran Raccourcis clavier de s’afficher.
RequestVisibleBehind(Boolean)	Cette méthode a été déconseillée au niveau de l’API 26.
RequestWindowFeature(WindowFeatures)	Activer les fonctionnalités de fenêtre étendues.
RequireViewById(Int32)	Recherche une vue identifiée par l’attribut XML android :id qui a été traité dans onCreate(Bundle) ou lève une exception IllegalArgumentException si l’ID n’est pas valide ou qu’il n’existe aucune vue correspondante dans la hiérarchie.
RequireViewById<T>(Int32)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
RevokeSelfPermissionOnKill(String)	Déclenche la révocation asynchrone d’une autorisation d’exécution. (Hérité de Context)
RevokeSelfPermissionsOnKill(ICollection<String>)	Déclenche la révocation d’une ou plusieurs autorisations pour le package appelant. (Hérité de Context)
RevokeUriPermission(String, Uri, ActivityFlags)	Supprimez les autorisations d’accès à un URI de fournisseur de contenu particulier qui ont été précédemment ajoutés avec grantUriPermission(String, Uri, int) pour un package cible spécifique. L’URI donné correspond à tous les URI précédemment accordés qui sont identiques ou un sous-chemin d’accès de l’URI donné. Autrement dit, la révocation de « content://foo/target » révoque « content://foo/target » et « content://foo/target/sub », mais pas « content://foo ». Elle ne supprime pas les octrois de préfixes qui existent à un niveau supérieur. Contrairement à revokeUriPermission(Uri,int), cette méthode révoque uniquement les autorisations qui ont été explicitement accordées via grantUriPermission(String, Uri, int) et uniquement pour le package spécifié. Toutes les subventions correspondantes qui se sont produites par le biais d’autres mécanismes (Presse-papiers, lancement d’activité, démarrage du service, etc.) ne seront pas supprimées. (Hérité de ContextWrapper)
RevokeUriPermission(Uri, ActivityFlags)	Supprimez toutes les autorisations d’accès à un URI de fournisseur de contenu particulier qui ont été précédemment ajoutés avec M :Android.Content.Context.GrantUriPermission(System.String,Android.Net.Uri,Android.Net.Uri). (Hérité de ContextWrapper)
RunOnUiThread(Action)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
RunOnUiThread(IRunnable)	Exécute l’action spécifiée sur le thread d’interface utilisateur.
SendBroadcast(Intent, String, Bundle)	Diffusez l’intention donnée à tous les BroadcastReceivers intéressés, ce qui permet d’appliquer une autorisation facultative requise. (Hérité de Context)
SendBroadcast(Intent, String)	Diffusez l’intention donnée à tous les BroadcastReceivers intéressés, ce qui permet d’appliquer une autorisation facultative requise. (Hérité de ContextWrapper)
SendBroadcast(Intent)	Diffusez l’intention donnée à tous les broadcastReceivers intéressés. (Hérité de ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle, String)	La version de ce qui vous permet de SendBroadcast(Intent, String) spécifier l’utilisateur auquel la diffusion sera envoyée. (Hérité de ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle)	La version de ce qui vous permet de SendBroadcast(Intent) spécifier l’utilisateur auquel la diffusion sera envoyée. (Hérité de ContextWrapper)
SendBroadcastWithMultiplePermissions(Intent, String[])	Diffusez l’intention donnée à tous les BroadcastReceivers intéressés, ce qui permet d’appliquer un tableau d’autorisations requises. (Hérité de Context)
SendOrderedBroadcast(Intent, Int32, String, String, BroadcastReceiver, Handler, String, Bundle, Bundle)	Diffuse une intention de récepteurs intéressés dans l’ordre. (Hérité de ContextWrapper)
SendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, Result, String, Bundle)	La version de ce qui vous permet de SendBroadcast(Intent) recevoir des données de retour à partir de la diffusion. (Hérité de ContextWrapper)
SendOrderedBroadcast(Intent, String, Bundle, BroadcastReceiver, Handler, Result, String, Bundle)	La version de ce qui vous permet de `#sendBroadcast(Intent)` recevoir des données de retour à partir de la diffusion. (Hérité de Context)
SendOrderedBroadcast(Intent, String, Bundle)	Diffusez l’intention donnée à tous les destinataires intéressés de BroadcastReceivers, en les fournissant un à la fois pour permettre aux récepteurs plus préférés de consommer la diffusion avant qu’elle ne soit remise à des récepteurs moins préférés. (Hérité de Context)
SendOrderedBroadcast(Intent, String, String, BroadcastReceiver, Handler, Result, String, Bundle)	La version de ce qui vous permet de `#sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)` spécifier l’opération d’application pour appliquer des restrictions sur les récepteurs auxquels la diffusion sera envoyée. (Hérité de Context)
SendOrderedBroadcast(Intent, String)	Diffusez l’intention donnée à tous les destinataires intéressés de BroadcastReceivers, en les fournissant un à la fois pour permettre aux récepteurs plus préférés de consommer la diffusion avant qu’elle ne soit remise à des récepteurs moins préférés. Cet appel est asynchrone ; elle retourne immédiatement, et vous continuerez à s’exécuter pendant l’exécution des récepteurs. Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. (Hérité de ContextWrapper)
SendOrderedBroadcastAsUser(Intent, UserHandle, String, BroadcastReceiver, Handler, Result, String, Bundle)	Version de sendOrderedBroadcast(Intent,String,BroadcastReceiver,Handler,int,String,Bundle) qui vous permet de spécifier l’utilisateur auquel la diffusion sera envoyée. Cela n’est pas disponible pour les applications qui ne sont pas préinstallées sur l’image système. Pour plus d’informations sur les diffusions d’intention, consultez BroadcastReceiver. Nécessite android. Manifest.permission.INTERACT_ACROSS_USERS (Hérité de ContextWrapper)
SendStickyBroadcast(Intent, Bundle)	Effectuez un `#sendBroadcast(Intent)` « sticky », ce qui signifie que l’intention que vous envoyez reste autour une fois la diffusion terminée, afin que d’autres puissent rapidement récupérer ces données par le biais de la valeur de retour de `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Hérité de Context)
SendStickyBroadcast(Intent)	Obsolète. Effectuez un `#sendBroadcast(Intent)` « sticky », ce qui signifie que l’intention que vous envoyez reste autour une fois la diffusion terminée, afin que d’autres puissent rapidement récupérer ces données par le biais de la valeur de retour de `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Hérité de ContextWrapper)
SendStickyBroadcastAsUser(Intent, UserHandle)	Obsolète. (Hérité de ContextWrapper)
SendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, Result, String, Bundle)	Obsolète. (Hérité de ContextWrapper)
SendStickyOrderedBroadcastAsUser(Intent, UserHandle, BroadcastReceiver, Handler, Result, String, Bundle)	Obsolète. (Hérité de ContextWrapper)
SetActionBar(Toolbar)	Définissez une barre d’outils pour qu’elle agisse comme actionBar pour cette fenêtre d’activité.
SetAllowCrossUidActivitySwitchFromBelow(Boolean)	Spécifie si les activités ci-dessous dans la tâche peuvent également démarrer d’autres activités ou terminer la tâche.
SetContentView(Int32)	Définissez le contenu de l’activité à partir d’une ressource de disposition.
SetContentView(View, ViewGroup+LayoutParams)	Définissez le contenu de l’activité sur une vue explicite.
SetContentView(View)	Définissez le contenu de l’activité sur une vue explicite.
SetDefaultKeyMode(DefaultKey)	Sélectionnez la gestion des clés par défaut pour cette activité.
SetEnterSharedElementCallback(SharedElementCallback)	Lorsque android.app.ActivityOptions.makeSceneTransitionAnimation(Activity,android.view.View,String) a été utilisé pour démarrer une activité, le rappel est appelé pour gérer les éléments partagés sur l’activité lancée.
SetExitSharedElementCallback(SharedElementCallback)	Lorsque android.app.ActivityOptions.makeSceneTransitionAnimation(Activity,android.view.View,String) a été utilisé pour démarrer une activité, le rappel est appelé pour gérer les éléments partagés sur l’activité de lancement.
SetFeatureDrawable(WindowFeatures, Drawable)	Commodité pour appeler android.view.Window.setFeatureDrawable(int,Drawable).
SetFeatureDrawableAlpha(WindowFeatures, Int32)	Commodité pour appeler Window.setFeatureDrawableAlpha(int, int).
SetFeatureDrawableResource(WindowFeatures, Int32)	Commodité pour appeler Window.setFeatureDrawableResource(int, int).
SetFeatureDrawableUri(WindowFeatures, Uri)	Commodité pour appeler Window.setFeatureDrawableUri(int, Uri).
SetFinishOnTouchOutside(Boolean)	Définit si cette activité est terminée lorsqu’elle est tactile en dehors des limites de sa fenêtre.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
SetInheritShowWhenLocked(Boolean)	Spécifie si cette activité doit être affichée en haut de l’écran de verrouillage chaque fois que l’écran de verrouillage est activé et que cette activité a une autre activité derrière elle avec l’ensemble d’attributs showWhenLock.
SetIntent(Intent, ComponentCaller)	Modifie l’intention retournée par getIntent(), et ComponentCaller retournée par getCaller().
SetLocusContext(LocusId, Bundle)	Définit le LocusId pour cette activité.
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
SetPersistent(Boolean)	Ce membre est déconseillé.
SetPictureInPictureParams(PictureInPictureParams)	Met à jour les propriétés de l’activité picture-in-picture ou définit son utilisation ultérieurement lorsque enterPictureInPictureMode() est appelé.
SetProgress(Int32)	Cette méthode a été déconseillée au niveau de l’API 24.
SetProgressBarIndeterminate(Boolean)	Cette méthode a été déconseillée au niveau de l’API 24.
SetProgressBarIndeterminateVisibility(Boolean)	Cette méthode a été déconseillée au niveau de l’API 24.
SetProgressBarVisibility(Boolean)	Cette méthode a été déconseillée au niveau de l’API 24.
SetRecentsScreenshotEnabled(Boolean)	Si la valeur est false, cela indique au système qu’il ne doit jamais prendre une capture d’écran de l’activité à utiliser comme représentation dans l’écran récent.
SetResult(Result, Intent)	Appelez-le pour définir le résultat que votre activité retournera à son appelant.
SetResult(Result)	Appelez-le pour définir le résultat que votre activité retournera à son appelant.
SetSecondaryProgress(Int32)	Cette méthode a été déconseillée au niveau de l’API 24.
SetShouldDockBigOverlays(Boolean)	Spécifie une préférence pour ancrer des superpositions volumineuses comme l’image développée sur la télévision (voir PictureInPictureParams.Builder.setExpandedAspectRatio).
SetShowWhenLocked(Boolean)	Spécifie si une activité doit être affichée en haut de l’écran de verrouillage chaque fois que l’écran de verrouillage est activé et que l’activité est reprise.
SetTaskDescription(ActivityManager+TaskDescription)	Définit des informations décrivant la tâche avec cette activité pour la présentation à l’intérieur de l’interface utilisateur du système Recents.
SetTheme(Int32)	Définissez le thème de base pour ce contexte. (Hérité de ContextWrapper)
SetTheme(Resources+Theme)	Définissez le thème actuel pour configurer le thème actuel. (Hérité de ContextThemeWrapper)
SetTitle(Int32)	Modifiez le titre associé à cette activité.
SetTranslucent(Boolean)	Convertissez une activité, en particulier avec l’attribut R.attr.windowIsTranslucent ou R.attr.windowIsFloating, en une activité opaque en plein écran, ou convertissez-la de retour opaque en translucide.
SetTurnScreenOn(Boolean)	Spécifie si l’écran doit être activé lors de la reprise de l’activité.
SetVisible(Boolean)	Contrôlez si la fenêtre principale de cette activité est visible.
SetVrModeEnabled(Boolean, ComponentName)	Activez ou désactivez le mode réalité virtuelle (VR) pour cette activité.
SetWallpaper(Bitmap)	Obsolète. (Hérité de ContextWrapper)
SetWallpaper(Stream)	Obsolète. (Hérité de ContextWrapper)
ShouldDockBigOverlays()	Retourne si les superpositions volumineuses doivent être ancrées en regard de l’activité comme défini par setShouldDockBigOverlays(boolean).
ShouldShowRequestPermissionRationale(String, Int32)	Obtient si vous devez afficher l’interface utilisateur avec raison avant de demander une autorisation.
ShouldShowRequestPermissionRationale(String)	Obtient si vous devez afficher l’interface utilisateur avec raison avant de demander une autorisation.
ShouldUpRecreateTask(Intent)	Retourne true si l’application doit recréer la tâche lors de la navigation « vers le haut » de cette activité à l’aide de targetIntent.
ShowAssist(Bundle)	Demandez à l’assistant actuel d’afficher à l’utilisateur.
ShowDialog(Int32, Bundle)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
ShowDialog(Int32)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
ShowLockTaskEscapeMessage()	Affiche l’utilisateur le message défini par le système pour indiquer à l’utilisateur comment quitter le mode de tâche de verrouillage.
StartActionMode(ActionMode+ICallback, ActionModeType)	Démarrez un mode d’action du type donné.
StartActionMode(ActionMode+ICallback)	Démarrez un mode d’action du type par défaut ActionMode.TYPE_PRIMARY.
StartActivities(Intent[], Bundle)	Lancez plusieurs nouvelles activités. (Hérité de ContextWrapper)
StartActivities(Intent[])	Identique à StartActivities(Intent[], Bundle) sans options spécifiées. (Hérité de ContextWrapper)
StartActivity(Intent, Bundle)	Lancez une nouvelle activité. (Hérité de ContextWrapper)
StartActivity(Intent)	Identique à StartActivity(Intent, Bundle) sans options spécifiées. (Hérité de ContextWrapper)
StartActivity(Type)	Identique à startActivity(Intent,Bundle) sans options spécifiées. (Hérité de Context)
StartActivityForResult(Intent, Int32, Bundle)	Lancez une activité pour laquelle vous souhaitez obtenir un résultat une fois terminé.
StartActivityForResult(Intent, Int32)	Identique à l’appel de startActivityForResult(Intent,int,Bundle) sans options.
StartActivityForResult(Type, Int32)	Démarre une activité du type managé spécifié et demande un résultat.
StartActivityFromChild(Activity, Intent, Int32, Bundle)	Cette méthode a été déconseillée au niveau de l’API 30.
StartActivityFromChild(Activity, Intent, Int32)	Cette méthode a été déconseillée au niveau de l’API 30.
StartActivityFromFragment(Fragment, Intent, Int32, Bundle)	Cette méthode a été déconseillée au niveau de l’API 28.
StartActivityFromFragment(Fragment, Intent, Int32)	Cette méthode a été déconseillée au niveau de l’API 28.
StartActivityIfNeeded(Intent, Int32, Bundle)	Variante spéciale pour lancer une activité uniquement si une nouvelle instance d’activité est nécessaire pour gérer l’intention donnée.
StartActivityIfNeeded(Intent, Int32)	Identique à l’appel de startActivityIfNeeded(Intent,int,Bundle) sans options.
StartForegroundService(Intent)	Similaire à startService(Intent), mais avec une promesse implicite que le service appelle startForeground(int, android.app.Notification) une fois qu’il commence à s’exécuter. Le service reçoit une durée comparable à l’intervalle ANR pour ce faire, sinon le système bloque automatiquement le processus, auquel cas une exception interne ForegroundServiceDidNotStartInTimeException est journalisée sur les appareils exécutant la version du SDK Build.VERSION_CODES. S ou version ultérieure. Sur les versions antérieures d’Android, une exception interne RemoteServiceException est consignée à la place, avec un message correspondant. Contrairement au startService(Intent) ordinaire, cette méthode peut être utilisée à tout moment, que l’application hébergeant le service soit au premier plan. Remarque : À compter de la version du SDK Build.VERSION_CODES. S , applications ciblant la version du SDK Build.VERSION_CODES. S ou version ultérieure ne sont pas autorisés à démarrer les services de premier plan à partir de l’arrière-plan. Pour plus d’informations, voir Changements de comportement : Applications ciblant Android 12. (Hérité de ContextWrapper)
StartInstrumentation(ComponentName, String, Bundle)	Commencez à exécuter une Instrumentation classe. (Hérité de ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Comme StartActivity(Intent, Bundle), mais prendre un IntentSender pour commencer. (Hérité de ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32)	Identique à startIntentSender(IntentSender,IntentSender,Intent,Int,int,Bundle) sans options spécifiées. (Hérité de ContextWrapper)
StartIntentSenderForResult(IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Comme startActivityForResult(Intent,int), mais vous permet d’utiliser un IntentSender pour décrire l’activité à démarrer.
StartIntentSenderForResult(IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32)	Identique à l’appel de startIntentSenderForResult(IntentSender,int,Intent,int,int,int,Bundle) sans options.
StartIntentSenderFromChild(Activity, IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Cette méthode a été déconseillée au niveau de l’API 30.
StartIntentSenderFromChild(Activity, IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32)	Cette méthode a été déconseillée au niveau de l’API 30.
StartLocalVoiceInteraction(Bundle)	Démarre une session d’interaction vocale locale.
StartLockTask()	Demande de placer cette activité dans un mode où l’utilisateur est verrouillé sur un ensemble restreint d’applications.
StartManagingCursor(ICursor)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
StartNextMatchingActivity(Intent, Bundle)	Version spéciale du démarrage d’une activité, à utiliser lorsque vous remplacez d’autres composants d’activité.
StartNextMatchingActivity(Intent)	Identique à l’appel de startNextMatchingActivity(Intent,Bundle) sans options.
StartPostponedEnterTransition()	Commencez les transitions reportées après le reportEnterTransition().
StartSearch(String, Boolean, Bundle, Boolean)	Ce hook est appelé pour lancer l’interface utilisateur de recherche.
StartService(Intent)	Demandez qu’un service d’application donné soit démarré. (Hérité de ContextWrapper)
StopLocalVoiceInteraction()	Demande d’arrêt de l’interaction vocale actuelle qui a été démarrée précédemment à l’aide de startLocalVoiceInteraction(Bundle).
StopLockTask()	Arrêtez la tâche actuelle d’être verrouillée.
StopManagingCursor(ICursor)	Obsolète. Cette méthode a été déconseillée au niveau de l’API 15.
StopService(Intent)	Demandez qu’un service d’application donné soit arrêté. (Hérité de ContextWrapper)
TakeKeyEvents(Boolean)	Demandez que les événements clés viennent à cette activité.
ToArray<T>()	Crée un tableau managé à partir de ce wrapper de tableau Java. (Hérité de Object)
ToString()	Retourne une représentation sous forme de chaîne de l’objet. (Hérité de Object)
TriggerSearch(String, Bundle)	Similaire à startSearch(String, boolean, Bundle, boolean), mais déclenche réellement la requête de recherche après l’appel de la boîte de dialogue de recherche.
UnbindService(IServiceConnection)	Déconnectez-vous d’un service d’application. (Hérité de ContextWrapper)
UnregisterActivityLifecycleCallbacks(Application+IActivityLifecycleCallbacks)	Annulez l’inscription d’une application.ActivityLifecycleCallbacks précédemment inscrite auprès de registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks).
UnregisterComponentCallbacks(IComponentCallbacks)	Supprimez un `ComponentCallbacks` objet précédemment inscrit auprès `#registerComponentCallbacks(ComponentCallbacks)`de . (Hérité de Context)
UnregisterDeviceIdChangeListener(IIntConsumer)	Supprime un écouteur modifié d’ID d’appareil du contexte. (Hérité de Context)
UnregisterForContextMenu(View)	Empêche l’affichage d’un menu contextuel.
UnregisterFromRuntime()	Annule l’inscription de cet homologue Java à partir du runtime d’interopérabilité. (Hérité de Object)
UnregisterReceiver(BroadcastReceiver)	Annulez l’inscription d’un BroadcastReceiver précédemment inscrit. (Hérité de ContextWrapper)
UnregisterScreenCaptureCallback(Activity+IScreenCaptureCallback)	Annule l’inscription d’un rappel de capture d’écran pour cette surface.
UpdateServiceGroup(IServiceConnection, Int32, Int32)	Pour un service précédemment lié à `#bindService` ou à une méthode associée, modifiez la façon dont le système gère le processus de ce service par rapport à d’autres processus. (Hérité de Context)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

Nom	Description
IJavaPeerable.Disposed()	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.Finalized()	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Une activité est une chose unique et ciblée que l’utilisateur peut faire. (Hérité de JavaObject)
IJavaPeerable.UnregisterFromRuntime()	Une activité est une chose unique et ciblée que l’utilisateur peut faire.

Méthodes d’extension

Nom	Description
GetJniTypeName(IJavaPeerable)	Obtient le nom JNI du type de l’instance `self`.
JavaAs<TResult>(IJavaPeerable)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.
JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Une activité est une chose unique et ciblée que l’utilisateur peut faire.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.

S’applique à