Dans la programmation Android, qu'est-ce qu'une Contextclasse et à quoi sert-elle exactement ?

J'ai lu à ce sujet sur le site du développeur , mais je n'arrive pas à le comprendre clairement.

En termes simples:

Comme son nom l'indique, c'est le contexte de l'état actuel de l'application / objet. Il permet aux objets nouvellement créés de comprendre ce qui s'est passé. Vous l'appelez généralement pour obtenir des informations sur une autre partie de votre programme (activité et package / application).

Vous pouvez obtenir le contexte en invoquant getApplicationContext(), getContext(), getBaseContext()ou this(quand dans une classe qui va de Context, comme l'application, l' activité, les classes de service et IntentService).

Utilisations typiques du contexte:

• Création de nouveaux objets : Création de nouvelles vues, adaptateurs, écouteurs:

  TextView tv = new TextView(getContext());
  ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);

• Accès aux ressources communes standard : services tels que LAYOUT_INFLATER_SERVICE, SharedPreferences:

  context.getSystemService(LAYOUT_INFLATER_SERVICE)
  getApplicationContext().getSharedPreferences(*name*, *mode*);

• Accès implicite aux composants : concernant les fournisseurs de contenu, les diffusions, l'intention

  getApplicationContext().getContentResolver().query(uri, ...);

Définition du contexte

• Le contexte représente les données d'environnement
• Il donne accès à des choses telles que les bases de données

Termes plus simples (exemple 1)

• Considérez Person-X est le PDG d'une start-up de logiciels.

• Il y a un architecte principal présent dans l'entreprise, cet architecte principal fait tout le travail dans l'entreprise qui implique notamment la base de données, l'interface utilisateur, etc.

• Maintenant, le PDG embauche un nouveau développeur.

• C'est l'architecte qui indique la responsabilité de la personne nouvellement embauchée en fonction des compétences de la nouvelle personne que s'il travaillera sur la base de données ou l'interface utilisateur, etc.

Termes plus simples (exemple 2)

• C'est comme l'accès d'une activité Android à la ressource de l'application.

• C'est comme lorsque vous visitez un hôtel, vous voulez le petit déjeuner, le déjeuner et le dîner aux horaires appropriés, non?

• Il y a beaucoup d'autres choses que vous aimez pendant la durée du séjour. Comment obtenez-vous ces choses?

• Vous demandez à la personne du service en chambre de vous apporter ces choses.

• Ici, le service de chambre est le contexte, étant donné que vous êtes l'activité unique et que l'hôtel est votre application, enfin le petit-déjeuner, le déjeuner et le dîner doivent être les ressources.

Les choses qui impliquent le contexte sont:

1. Chargement d'une ressource.
2. Lancement d'une nouvelle activité.
3. Création de vues.
4. obtenir le service du système.

Le contexte est la classe de base pour l' activité , le service , l' application , etc.

Une autre façon de décrire cela: Considérez le contexte comme éloigné d'un téléviseur et les chaînes de la télévision sont les ressources, les services, l'utilisation d'intentions, etc. - - - Ici, la télécommande agit comme un accès pour accéder à toutes les différentes ressources au premier plan.

• Ainsi, Remote a accès à des canaux tels que les ressources, les services, l'utilisation d'intentions, etc.

• De même ... Quiconque a accès à distance a naturellement accès à toutes les choses telles que les ressources, les services, l'utilisation d'intentions, etc.

Différentes méthodes par lesquelles vous pouvez obtenir le contexte

• getApplicationContext()
• getContext()
• getBaseContext()
• ou this(dans la classe d'activité)

Exemple:

TextView tv = new TextView(this);

Le mot-clé thisfait référence au contexte de l'activité en cours.

La source

Le sujet du contexte dans Android semble dérouter beaucoup. Les gens savent juste que le contexte est assez souvent nécessaire pour faire des choses de base dans Android. Les gens paniquent parfois parce qu'ils essaient d'effectuer une opération qui nécessite le contexte et ils ne savent pas «obtenir» le bon contexte. Je vais essayer de démystifier l'idée de Context dans Android. Un traitement complet de la question dépasse le cadre de cet article, mais je vais essayer de donner un aperçu général afin que vous ayez une idée de ce qu'est le contexte et de la façon de l'utiliser. Pour comprendre ce qu'est le contexte, jetons un œil au code source:

https://github.com/android/platform_frameworks_base/blob/master/core/java/android/content/Context.java

Quel est exactement le contexte?

Eh bien, la documentation elle-même fournit une explication assez simple: la classe Context est une «interface avec des informations globales sur un environnement d'application».

La classe Context elle-même est déclarée comme classe abstraite, dont l'implémentation est fournie par le système d'exploitation Android. La documentation prévoit en outre que le contexte «… permet l'accès aux ressources et classes spécifiques à l'application, ainsi que les appels à la hausse pour des opérations au niveau de l'application telles que le lancement d'activités, la diffusion et la réception d'intentions, etc.».

Vous pouvez très bien comprendre maintenant pourquoi le nom est Context. C'est parce que c'est juste ça. Le contexte fournit le lien ou le hook, si vous le souhaitez, pour une activité, un service ou tout autre composant, le reliant ainsi au système, permettant l'accès à l'environnement d'application global. En d'autres termes: le contexte fournit la réponse à la question des composants de "où diable suis-je par rapport à l'application en général et comment puis-je accéder / communiquer avec le reste de l'application?" Si tout cela semble un peu déroutant, un rapide coup d'œil aux méthodes exposées par la classe Context fournit quelques indices supplémentaires sur sa vraie nature.

Voici un échantillonnage aléatoire de ces méthodes:

1. getAssets()
2. getResources()
3. getPackageManager()
4. getString()
5. getSharedPrefsFile()

Qu'est-ce que toutes ces méthodes ont en commun? Ils permettent tous à quiconque a accès au contexte de pouvoir accéder aux ressources à l'échelle de l'application.

Le contexte, en d'autres termes, accroche le composant qui y fait référence au reste de l'environnement d'application. Les actifs (pensez au dossier '/ assets' dans votre projet), par exemple, sont disponibles dans l'application, à condition qu'une activité, un service ou autre sache comment accéder à ces ressources. Il en va de même pour getResources()ce qui permet de faire des choses comme celle getResources().getColor()qui vous accrochera dans lecolors.xml ressource (même si aapt permet d'accéder aux ressources via le code java, c'est un problème distinct).

Le résultat est ce Contextqui permet d'accéder aux ressources système et ce qui accroche les composants dans la "plus grande application". Regardons les sous-classes de Context, les classes qui fournissent l'implémentation de la Contextclasse abstraite . La classe la plus évidente est la Activityclasse. ActivityHérite from ContextThemeWrapper, qui hérite de ContextWrapper, qui hérite de Contextlui-même. Ces classes sont utiles à regarder pour comprendre les choses à un niveau plus profond, mais pour l'instant il suffit de savoir cela ContextThemeWrapperet laContextWrapper sont à peu près ce à quoi elles ressemblent. Elles implémentent les éléments abstraits de la Contextclasse elle-même en «enveloppant» un contexte (le contexte réel) et en déléguant ces fonctions à ce contexte. Un exemple est utile - dans leContextWrapper, la méthode abstraite getAssetsde la Contextclasse est implémentée comme suit:

@Override
    public AssetManager getAssets() {
        return mBase.getAssets();
    }

mBaseest simplement un champ défini par le constructeur dans un contexte spécifique. Un contexte est donc encapsulé et le ContextWrapperdélégué délègue son implémentation de la méthode getAssets à ce contexte. Revenons à l'examen de la Activityclasse qui hérite finalement de Contextpour voir comment tout cela fonctionne.

Vous savez probablement ce qu'est une activité, mais pour revoir - c'est fondamentalement «une seule chose que l'utilisateur peut faire. Il prend soin de fournir une fenêtre dans laquelle placer l'interface utilisateur avec laquelle l'utilisateur interagit '. Les développeurs familiers avec d'autres API et même les non-développeurs pourraient le considérer de manière vernaculaire comme un «écran». C'est techniquement inexact, mais cela n'a pas d'importance pour nous. Alors , comment faire Activityet ContextInteragir et ce qui se passe dans leur relation d'héritage exactement?

Encore une fois, il est utile d'examiner des exemples spécifiques. Nous savons tous comment lancer des activités. Pourvu que vous ayez «le contexte» à partir duquel vous démarrez l'activité, vous appelez simplement startActivity(intent), où l'intention décrit le contexte à partir duquel vous démarrez une activité et l'activité que vous souhaitez démarrer. Ceci est le familier startActivity(this, SomeOtherActivity.class).

Et c'est quoi this? thisest votre activité car la Activityclasse hérite de Context. Le scoop complet est comme ceci: Lorsque vous appelez startActivity, la Activityclasse exécute finalement quelque chose comme ceci:

Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode);

Il utilise donc le execStartActivityde la Instrumentationclasse (en fait d'une classe interne Instrumentationappelée ActivityResult).

À ce stade, nous commençons à avoir un aperçu des composants internes du système.

C'est là que OS gère tout. Alors, comment l'instrumentation démarre-t-elle exactement l'activité? Eh bien, le paramètre thisdans la execStartActivityméthode ci-dessus est votre activité, c'est-à-dire le contexte, et execStartActivityutilise ce contexte.

Voici un aperçu de 30 000: la classe d'instrumentation garde une trace d'une liste des activités qu'elle surveille afin de faire son travail. Cette liste est utilisée pour coordonner toutes les activités et s'assurer que tout se déroule bien dans la gestion du flux d'activités.

Il y a certaines opérations que je n'ai pas complètement examinées qui déterminent les problèmes de thread et de processus. En fin de compte, le ActivityResultutilise une opération native - ActivityManagerNative.getDefault().startActivity()qui utilise le Contextque vous avez transmis lorsque vous avez appelé startActivity. Le contexte que vous avez transmis est utilisé pour aider à la «résolution d'intention» si nécessaire. La résolution d'intention est le processus par lequel le système peut déterminer la cible de l'intention si elle n'est pas fournie. (Consultez le guide ici pour plus de détails).

Et pour ce faire, Android doit avoir accès aux informations fournies par Context. Plus précisément, le système doit accéder à un ContentResolverafin qu'il puisse «déterminer le type MIME des données de l'intention». Tout ce peu sur la façon dont le startActivitycontexte est utilisé était un peu compliqué et je ne comprends pas moi-même les éléments internes. Mon principal argument était juste pour illustrer la façon dont les ressources à l'échelle de l'application doivent être accessibles afin d'effectuer de nombreuses opérations qui sont essentielles pour une application. Contextest ce qui permet d'accéder à ces ressources. Un exemple plus simple pourrait être Vues. Nous savons tous ce que vous créez un vue personnalisée en étendant RelativeLayoutou une autre Viewclasse, vous devez fournir un constructeur qui prend unContextcomme argument. Lorsque vous instanciez votre vue personnalisée, vous passez dans le contexte. Pourquoi? Parce que la vue doit pouvoir accéder aux thèmes, ressources et autres détails de configuration de la vue. La configuration de la vue est en fait un excellent exemple. Chaque contexte a différents paramètres (champs dans Contextles implémentations de) qui sont définis par le système d'exploitation lui-même pour des choses comme la dimension ou la densité de l'affichage. Il est facile de comprendre pourquoi ces informations sont importantes pour la configuration des vues, etc.

Un dernier mot: pour une raison quelconque, les nouveaux utilisateurs d'Android (et même les moins novices) semblent complètement oublier la programmation orientée objet en ce qui concerne Android. Pour une raison quelconque, les gens essaient de plier leur développement Android à des paradigmes préconçus ou à des comportements appris.

Android a son propre paradigme et un certain modèle qui est en fait assez cohérent si vous abandonnez vos notions préconçues et lisez simplement la documentation et le guide de développement. Mon vrai point, cependant, alors que «trouver le bon contexte» peut parfois être délicat, les gens paniquent de manière injustifiée parce qu'ils se retrouvent dans une situation où ils ont besoin du contexte et pensent qu'ils ne l'ont pas. Encore une fois, Java est un langage orienté objet avec une conception d'héritage.

Vous «avez» seulement le contexte à l'intérieur de votre activité parce que votre activité elle-même hérite du contexte. Il n'y a pas de magie (sauf pour tout ce que le système d'exploitation fait par lui-même pour définir divers paramètres et «configurer» correctement votre contexte). Donc, en mettant de côté les problèmes de mémoire / performances (par exemple en conservant des références au contexte lorsque vous n'en avez pas besoin ou en le faisant d'une manière qui a des conséquences négatives sur la mémoire, etc.), le contexte est un objet comme les autres et il peut être contourné comme tout POJO (Plain Old Java Object). Parfois, vous devrez peut-être faire des choses intelligentes pour récupérer ce contexte, mais toute classe Java régulière qui s'étend de rien d'autre que Object lui-même peut être écrite d'une manière qui a accès au contexte; exposez simplement une méthode publique qui prend un contexte, puis utilisez-la dans cette classe selon vos besoins.

Un contexte est une poignée pour le système; il fournit des services tels que la résolution de ressources, l'accès aux bases de données et aux préférences, etc. Une application Android a des activités. Le contexte est comme un descripteur de l'environnement dans lequel votre application s'exécute actuellement. L'objet d'activité hérite de l'objet contextuel.

Pour plus d'informations, consultez Introduction au développement Android avec Android Studio - Tutoriel .

Contextest une "interface" avec les informations globales sur un environnement d'application. En pratique, il Contexts'agit en fait d'une classe abstraite , dont l'implémentation est fournie par le système Android.

Il permet d'accéder à des ressources et des classes spécifiques à l'application, ainsi qu'à des appels ascendants pour des opérations au niveau de l'application, telles que le lancement d'activités, la diffusion et la réception d'intentions, etc.

Dans l'image suivante, vous pouvez voir une hiérarchie de classes, où se Contexttrouve la classe racine de cette hiérarchie. En particulier, il convient de souligner qu'il Activitys'agit d'un descendant de Context.

C'est quoi Contextexactement?

Selon la documentation de référence Android, il s'agit d'une entité qui représente diverses données d'environnement. Il permet d'accéder aux fichiers locaux, aux bases de données, aux chargeurs de classe associés à l'environnement, aux services (y compris les services au niveau du système), etc. Tout au long de ce livre, et dans votre codage au jour le jour avec Android, vous verrez le contexte passer fréquemment.

Extrait du livre " Android en pratique ", p. 60.

Plusieurs API Android nécessitent un Contextparamètre as

Si vous regardez les différentes API Android, vous remarquerez que beaucoup d'entre elles prennent un android.content.Contextobjet comme paramètre. Vous verrez également qu'une activité ou un service est généralement utilisé comme un Context. Cela fonctionne parce que ces deux classes s'étendent de Context.

Exemple simple à comprendre contextdans Android:

Chaque patron a un assistant pour s'occuper de toutes les tâches moins importantes et plus longues. Si un dossier ou une tasse de café est nécessaire, un assistant est en fuite. Certains patrons savent à peine ce qui se passe au bureau, alors ils demandent aussi à leurs assistants à ce sujet. Ils font certains travaux eux-mêmes mais pour la plupart des autres choses, ils ont besoin de l'aide de leurs assistants.

Dans ce scénario,

Boss - est l'application Android

Assistant - est le contexte

Dossiers / Tasse de café - sont des ressources

Nous appelons généralement le contexte lorsque nous avons besoin d'obtenir des informations sur différentes parties de notre application comme les activités, les applications, etc.

Certaines opérations (choses où l'assistant est nécessaire) où le contexte est impliqué:

• Chargement des ressources communes
• Création de vues dynamiques
• Affichage des messages Toast
• Activités de lancement, etc.

Différentes façons d'obtenir du contexte:

getContext()

getBaseContext()

getApplicationContext()

this

Un contexte Android est une interface (dans le sens général, pas dans le sens Java; en Java, Contextest en fait une classe abstraite!) Qui permet d'accéder aux ressources et classes spécifiques à l'application et aux informations sur l'environnement d'application.

Si votre application Android était une application Web, votre contexte serait quelque chose de similaire ServletContext(je ne fais pas de comparaison exacte ici).

Vos activités et services s'étendent également Context, ils héritent donc de toutes ces méthodes pour accéder aux informations d'environnement dans lesquelles l'application s'exécute.

• Context représente une poignée pour obtenir des données d'environnement.
• Context La classe elle-même est déclarée abstraite, dont l'implémentation est fournie par le système d'exploitation Android.
• Context est comme la télécommande d'une télévision et les chaînes de télévision sont des ressources, des services, etc.

Que pouvez-vous en faire?

• Chargement de la ressource.
• Lancement d'une nouvelle activité.
• Création de vues.
• Obtention du service système.

Façons d'obtenir le contexte:

• getApplicationContext()
• getContext()
• getBaseContext()

Le mettre juste là pour les débutants;

Alors d'abord comprendre le contexte Word:

En anglais-lib. ça veut dire:

"Les circonstances qui constituent le cadre d'un événement, d'une déclaration ou d'une idée, et en fonction desquelles il peut être pleinement compris et évalué."

"Les parties de quelque chose écrit ou parlé qui précèdent et suivent immédiatement un mot ou un passage et clarifient sa signification."

Prenez maintenant la même compréhension du monde de la programmation:

contexte de l'état actuel de l'application / de l'objet. Il permet aux objets nouvellement créés de comprendre ce qui s'est passé. Vous l'appelez généralement pour obtenir des informations sur une autre partie de votre programme (activité, package / application)

Vous pouvez obtenir le contexte en appelant getApplicationContext(), getContext(), getBaseContext()ou this(dans la classe d'activité).

Pour obtenir Context Anywhere dans l'application, utilisez le code suivant:

Créez une nouvelle classe AppContextdans votre application Android

public class AppContext extends Application {

    private static Context context;

    public void onCreate(){
        super.onCreate();
        AppContext.context = getApplicationContext();
    }

    public static Context getAppContext() {
        return AppContext.context;
    }
}

Maintenant, chaque fois que vous voulez un contexte d'application dans une classe sans activité, appelez cette méthode et vous avez le contexte d'application.

J'espère que cette aide;)

Considérez-le comme la machine virtuelle qui a cloisonné le processus dans lequel l'application ou le service s'exécute. L'environnement cloisonné a accès à un tas d'informations système sous-jacentes et à certaines ressources autorisées. Vous avez besoin de ce contexte pour accéder à ces services.

Le contexte est une référence à l'objet actuel comme ceci. Le contexte permet également d'accéder aux informations sur l'environnement d'application.

La classe android.content.Contextfournit la connexion au système Android et les ressources du projet. Il s'agit de l'interface vers des informations globales sur l'environnement d'application.

Le contexte permet également d'accéder aux services Android, par exemple au service de localisation.

Les activités et services prolongent la Contextclasse.

Le contexte est Les instances de la classe android.content.Context fournissent la connexion au système Android qui exécute l'application. Par exemple, vous pouvez vérifier la taille de l'affichage actuel de l'appareil via le contexte.

Il donne également accès aux ressources du projet. Il s'agit de l'interface vers des informations globales sur l'environnement d'application.

La classe Context fournit également un accès aux services Android, par exemple, le gestionnaire d'alarmes pour déclencher des événements temporels.

Les activités et services étendent la classe Context. Par conséquent, ils peuvent être directement utilisés pour accéder au contexte.

Le contexte est une interface vers des informations globales sur un environnement d'application. C'est une classe abstraite dont l'implémentation est fournie par le Androidsystème.

Context permet d'accéder aux ressources et classes spécifiques à l'application, ainsi qu'aux appels pour des opérations au niveau de l'application telles que launching activities, broadcasting and receiving intents, etc.

Voici un exemple

 public class MyActivity extends Activity {

      public void Testing() {

      Context actContext = this; /*returns the Activity Context since   Activity extends Context.*/

      Context appContext = getApplicationContext();    /*returns the context of the single, global Application object of the current process. */

      Button BtnShowAct1 = (Button) findViewById(R.id.btnGoToAct1);
      Context BtnContext = BtnShowAct1.getContext();   /*returns the context of the View. */

Pour plus de détails, vous pouvez visiter http://developer.android.com/reference/android/content/Context.html

Le contexte est essentiellement pour l'accès aux ressources et l'obtention des détails de l'environnement de l'application (pour le contexte de l'application) ou de l'activité (pour le contexte de l'activité) ou de tout autre ...

Afin d'éviter une fuite de mémoire, vous devez utiliser le contexte d'application pour tous les composants qui ont besoin d'un objet de contexte .... pour plus cliquez ici

Le contexte est le contexte de l'état actuel de l'application / de l'objet, c'est-à-dire une entité qui représente diverses données d'environnement. Le contexte aide l'activité actuelle à interagir avec l'environnement Android externe comme les fichiers locaux, les bases de données, les chargeurs de classe associés à l'environnement, les services, y compris les services au niveau du système, etc.

Un contexte est une poignée pour le système. Il fournit des services tels que la résolution de ressources, l'accès aux bases de données et aux préférences, etc. Une application Android a des activités. C'est comme un descripteur de l'environnement dans lequel votre application s'exécute actuellement. L'objet Activity hérite de l'objet Context.

Différentes méthodes d'appel par lesquelles vous pouvez obtenir le contexte 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. ou ceci (dans la classe d'activité).

Le contexte signifie qu'Android apprend dans quelle activité je dois aller ou agir.

1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); il a utilisé dans ce domaine. Context context = ActivityName.this;

2 -startActivity(new Intent(context,LoginActivity.class));

dans ce contexte signifie à partir de quelle activité vous voulez aller à une autre activité. context ou ActivityName. c'est plus rapide que cela, getContext et getApplicatinContext.

A Contextest ce que la plupart d'entre nous appelleraient Application . Il est fabriqué par le système Android et ne peut faire que ce qu'une application est capable de faire. Dans Tomcat, un contexte est aussi ce que j'appellerais une application.

Il y a un contexte qui contient de nombreuses activités, chaque activité peut avoir plusieurs vues.

Évidemment, certains diront que cela ne correspond pas à cause de ceci ou cela et ils ont probablement raison, mais dire qu'un contexte est votre application actuelle vous aidera à comprendre ce que vous mettez dans les paramètres de méthode.

Boss Assistant Analogy

Ayons une petite analogie avant de plonger profondément dans la technicité du contexte

Chaque boss a un assistant ou quelqu'un (garçon de courses) qui fait des choses moins importantes et plus longues pour lui. Par exemple, s'ils ont besoin d'un fichier ou d'un café, un assistant sera en cours d'exécution. Le patron ne saura pas ce qui se passe en arrière-plan mais le fichier ou la tâche sera livré

So Here
Boss -
Assistant d' application Android -
Fichier contextuel ou tasse de café - Ressource

Ce que le site officiel des développeurs Android dit sur le contexte

Le contexte est votre point d'accès aux ressources liées aux applications

Voyons quelques-unes de ces ressources ou tâches

• Lancer une activité.

• Obtenir un chemin absolu vers le répertoire de cache spécifique à l'application sur le système de fichiers.

• Déterminer si l'autorisation donnée est autorisée pour un processus particulier et un ID utilisateur s'exécutant dans le système.

• Vérifier si vous avez obtenu une autorisation particulière.

Etc.
Donc, si une application Android veut démarrer une activité, elle va directement à Context(Point d'accès), et la Contextclasse lui rend les ressources (Intention dans ce cas).

Comme toute autre classe, la Contextclasse possède des champs et des méthodes.
Vous pouvez en savoir plus sur la Contextdocumentation officielle, elle couvre à peu près tout, les méthodes disponibles, les champs et même comment utiliser les champs avec les méthodes.

Les instances de la classe android.content.Context fournissent la connexion au système Android qui exécute l'application. Par exemple, vous pouvez vérifier la taille de l'affichage actuel de l'appareil via le contexte.

Il donne également accès aux ressources du projet. Il s'agit de l'interface vers des informations globales sur l'environnement d'application.

La classe Context fournit également un accès aux services Android, par exemple, le gestionnaire d'alarmes pour déclencher des événements temporels.

Les activités et services étendent la classe Context. Par conséquent, ils peuvent être directement utilisés pour accéder au contexte.

Si vous souhaitez connecter Context à d'autres classes familières dans Android, gardez à l'esprit cette structure:

Contexte <ContextWrapper <Application

Context <ContextWrapper <ContextThemeWrapper <Activité

Context <ContextWrapper <ContextThemeWrapper <Activity <ListActivity

Contexte <ContextWrapper <Service

Contexte <ContextWrapper <Service <IntentService

Ainsi, toutes ces classes sont des contextes à leur manière. Vous pouvez convertir Service et ListActivity en contexte si vous le souhaitez. Mais si vous regardez de plus près, certaines classes héritent également du thème. Dans l'activité ou le fragment, vous souhaitez que le thème soit appliqué à vos vues, mais ne vous souciez pas de la classe de service , par exemple.

J'explique ici la différence de contextes .

Pour faire simple, les androïdes Context est un gâchis que vous n'aimerez pas tant que vous ne vous inquiétez plus.

Les Android Contextsont:

• Objets divins.

• Chose que vous souhaitez transmettre à toutes vos applications lorsque vous commencez à développer pour Android, mais évitez de le faire lorsque vous vous rapprochez un peu de la programmation, des tests et d'Android lui-même.

  • Dépendance peu claire.

  • Source courante de fuites de mémoire.

  • PITA pour les tests.

• Contexte réel utilisé par le système Android pour répartir les autorisations, les ressources, les préférences, les services, les diffusions, les styles, afficher les boîtes de dialogue et gonfler la disposition. Et vous avez besoin d' Contextinstances différentes pour certaines choses distinctes (évidemment, vous ne pouvez pas afficher une boîte de dialogue à partir d'un contexte d'application ou de service; les dispositions gonflées à partir des contextes d'application et d'activité peuvent différer).

Le Context est l'API spécifique à Android pour chaque Sandbox d'application qui fournit des données privées d'application d'accès comme des ressources, une base de données, des répertoires de fichiers privés, des préférences, des paramètres ...

La plupart des données privées sont les mêmes pour toutes les activités / services / auditeurs de diffusion d'une application.

Puisque Application, Activity, Service implémentent l'interface Context, ils peuvent être utilisés lorsqu'un appel API a besoin d'un paramètre Context

Contextsignifie composant (ou application) sur diverses périodes. Si je mange tellement de nourriture entre 13 h et 14 h, mon contexte de cette période est utilisé pour accéder à toutes les méthodes (ou ressources) que j'utilise pendant cette période. Le contenu est un composant (application) pour un moment particulier. Les Contextcomposants de l'application changent constamment en fonction du cycle de vie sous-jacent des composants ou de l'application. Par exemple, à l'intérieur du onCreate () d'un Activity,

getBaseContext()- donne le contextdu Activityqui est fixé (créé) par le constructeur de l'activité. getApplicationContext()- donne la Contextconfiguration (créée) lors de la création de l'application.

Remarque: <application>contient tous les composants Android.

<application>
    <activity> .. </activity> 

    <service>  .. </service>

    <receiver> .. </receiver>

    <provider> .. </provider>
</application> 

Cela signifie que lorsque vous appelez getApplicationContext()de l'intérieur d'un composant, vous appelez le contexte commun de l'ensemble de l'application.

Context continue d'être modifié par le système en fonction du cycle de vie des composants.

Considérez le contexte comme une boîte avec différentes ressources: chaîne, couleurs et polices. Si vous avez besoin d'une ressource, vous vous tournez vers cette case. Lorsque vous faites pivoter l'écran, cette case change car l'orientation change en paysage.

 Contextsignifie courant. Contextutiliser pour faire l'opération pour l'écran actuel. ex.
  1. getApplicationContext ()
  2. getContext ()

Toast.makeText(getApplicationContext(), "hello", Toast.LENGTH_SHORT).show();

Bonnes explications! Pour compléter tout ce qui précède, j'ai trouvé celui-ci de MindOrks très utile, qui montre même quelques cas d'utilisation de base pour vous aider:

Comprendre le contexte dans l'application Android

En Java, nous disons que ce mot - clé fait référence à l'état de l'objet actuel de l'application.
De même, dans une alternative que nous avons Contextdans le développement Android.

Cela peut être défini de manière explicite ou implicite,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Cet attribut déclare à quelle activité cette disposition est associée par défaut .