Qu'est-ce que le "contexte" sur Android?
Dans la programmation Android, en quoi consiste exactement une classe Context et à quoi sert-elle?
J'ai lu à ce sujet sur le site du développeur , mais je suis incapable de le comprendre clairement.
En termes simples:
Comme son nom l'indique, il s'agit du contexte de l'état actuel de l'application/de l'objet. Il permet aux objets nouvellement créés de comprendre ce qui se passe. En général, vous l'appelez pour obtenir des informations sur une autre partie de votre programme (activité et package/application).
Vous pouvez obtenir le contexte en appelant getApplicationContext(), getContext(), getBaseContext() ou this (dans une classe qui s'étend de Context, telle que Application, Activité , Service et IntentService).
Utilisations typiques du contexte:
Création de nouveaux objets: Création de nouvelles vues, adaptateurs, auditeurs:
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 éléments tels que des bases de données
Termes plus simples (exemple 1)
Considérons que Person-X est le PDG d’une entreprise de logiciels en démarrage.
Il y a un architecte principal présent dans l'entreprise, cet architecte principal effectue tout le travail dans l'entreprise, notamment la base de données, l'interface utilisateur, etc.
Maintenant, le PDG engage un nouveau développeur.
C’est l’architecte qui déclare la responsabilité de la personne nouvellement embauchée en fonction des compétences de la nouvelle personne, qu’il travaille ou non dans une base de données ou une interface utilisateur, etc.
Termes plus simples (exemple 2)
C'est comme un accès de l'activité Android à la ressource de l'application.
C'est comme quand vous visitez un hôtel, vous voulez le petit-déjeuner, le déjeuner et le dîner dans les horaires appropriés, n'est-ce pas?
Il y a beaucoup d'autres choses que vous aimez pendant votre séjour. Comment obtenez-vous ces choses?
Vous demandez à la personne du service d'étage d'apporter ces choses pour vous.
Ici, le préposé au service aux chambres est le contexte, étant donné que vous êtes la seule activité et que l'hôtel doit être votre application, enfin, le petit-déjeuner, le déjeuner et le dîner doivent être les ressources.
Les choses qui impliquent un contexte sont:
- Chargement d'une ressource.
- Lancement d'une nouvelle activité.
- Création de vues.
- obtention du service système.
Le contexte est la classe de base pour Activité , Service , Application , etc.
Une autre façon de décrire cela: considérons le contexte comme distant d'un téléviseur et d'une chaîne dans la télévision: ressources, services, utilisation intentionnelle, etc. - - - Ici, la télécommande agit comme un accès permettant d'accéder à tous les différentes ressources en avant-plan.
Ainsi, Remote a accès à des canaux tels que des ressources, des services, des intentions, etc. ...
De même ... Quiconque a accès à distance a naturellement accès à toutes les choses telles que ressources, services, utilisation d'intentions, etc.
Différentes méthodes pour obtenir le contexte
getApplicationContext()getContext()getBaseContext()- ou
this(dans la classe d'activité)
Exemple:
TextView TV=new TextView(this);
this -> fait référence au contexte de l'activité en cours.
Le sujet de contexte dans Android semble dérouter beaucoup. Les gens savent simplement que le contexte est nécessaire assez souvent pour faire des choses de base dans Android. Les gens paniquent parfois parce qu’ils essaient de faire une opération nécessitant le contexte et qu’ils ne savent pas comment "obtenir" le bon contexte. Je vais essayer de démystifier l’idée du contexte dans Android. Un traitement complet de la question dépasse le cadre de cet article, mais je vais essayer de vous 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, examinons le code source:
En quoi consiste exactement le contexte?
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 de contexte 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 indique en outre que Context “… permet l’accès aux ressources et aux classes spécifiques à l’application, ainsi qu’aux appels supplémentaires pour les 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 lien, si vous voulez, pour une activité, un service ou tout autre composant, le liant ainsi au système, permettant ainsi l'accès à l'environnement global de l'application. 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 Les méthodes exposées par la classe Context fournissent des indications supplémentaires sur sa nature.
Voici un échantillonnage aléatoire de ces méthodes:
getAssets()getResources()getPackageManager()getString()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 de l'application.
Le contexte, en d'autres termes, relie le composant qui en fait référence au reste de l'environnement de l'application. Les actifs (dossier think ’/ assets’ de votre projet), par exemple, sont disponibles dans l’application, à condition qu’une activité, un service ou tout autre élément sache accéder à ces ressources. Il en va de même pour getResources() qui permet de faire des choses comme getResources().getColor() qui vous connecte à la ressource colors.xml (ne sachez pas que aapt permet l’accès aux ressources via le code Java, c’est un problème séparé).
Le résultat est que Context est ce qui permet l’accès aux ressources système et ce qui accroche des composants dans la "plus grande application". Voyons les sous-classes de Context, les classes qui fournissent la mise en oeuvre de la méthode abstraite Context La classe la plus évidente est la Activity classe. Activity hérite de ContextThemeWrapper, qui hérite de ContextWrapper, qui hérite de Context elle-même Il est utile de regarder ces classes pour comprendre les choses à un niveau plus profond, mais pour le moment il suffit de savoir que ContextThemeWrapper et ContextWrapper ressemblent beaucoup à ce qu’elles ressemblent. Elles implémentent les éléments abstraits du Context classer elle-même en "encapsulant" un contexte (le contexte réel) et en déléguant ces fonctions à ce contexte. Un exemple est utile - dans la classe ContextWrapper, la méthode abstraite getAssets de la La classe Context est implémentée comme suit:
@Override
public AssetManager getAssets() {
return mBase.getAssets();
}
mBase est simplement un champ défini par le constructeur dans un contexte spécifique. Ainsi, un contexte est encapsulé et la ContextWrapper délègue son implémentation de la méthode getAssets à ce contexte. Revenons à l’examen de la classe Activity qui héritera finalement de Context pour voir comment tout cela fonctionne.
Vous savez probablement ce qu’est une activité, mais pour réviser, c’est une chose que l’utilisateur peut faire. Il se charge 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 comme un "écran". C’est techniquement inexact, mais cela n’a aucune importance pour nos besoins. Alors, comment Activity et Context interagissent-ils et que se passe-t-il exactement dans leur relation d'héritage?
Encore une fois, il est utile d’examiner des exemples spécifiques. Nous savons tous comment lancer des activités. Si vous avez "le contexte" à partir duquel vous démarrez l'activité, 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 qu'est-ce que this? this est votre activité car la classe Activity hérite de Context. Le scoop complet est comme ceci: lorsque vous appelez startActivity, la classe Activity exécute finalement quelque chose comme ceci:
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
Donc, il utilise la execStartActivity de la classe Instrumentation (en fait, elle provient d'une classe interne de Instrumentation appelée ActivityResult).
À ce stade, nous commençons à jeter un coup d’œil sur les composants internes du système.
C'est ici que l'OS gère tout. Alors, comment l'instrumentation démarre-t-elle l'activité exactement? Eh bien, le paramètre this dans la méthode execStartActivity ci-dessus est votre activité, c'est-à-dire le contexte, et la execStartActivity utilise ce contexte.
Voici un aperçu de 30 000 personnes: la classe Instrumentation conserve une liste des activités qu’elle surveille afin de s’acquitter de sa tâche. Cette liste est utilisée pour coordonner toutes les activités et s'assurer que tout se passe bien dans la gestion du flux d'activités.
Je ne me suis pas encore penché sur certaines opérations pour coordonner les problèmes de threads et de processus. En fin de compte, le ActivityResult utilise une opération native - ActivityManagerNative.getDefault().startActivity() qui utilise le Context que vous avez indiqué lorsque vous avez appelé startActivity. Le contexte que vous avez défini est utilisé pour vous aider à "résoudre l’intention" si nécessaire. La résolution de l'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 que Android puisse le faire, il doit pouvoir accéder aux informations fournies par Context. Plus précisément, le système doit accéder à un ContentResolver pour pouvoir "déterminer le type MIME des données de l'intention". Ce petit article sur la façon dont startActivity utilise le contexte était un peu compliqué et je ne le fais pas. Mon objectif principal était simplement d’illustrer la manière dont il est nécessaire d’avoir accès aux ressources d’application pour pouvoir effectuer un grand nombre des opérations essentielles à une application. Context permet d’accéder à ces ressources. Un exemple plus simple pourrait être les vues. Nous savons tous ce que vous créez une vue personnalisée en étendant RelativeLayout ou une autre classe View, vous devez fournir un constructeur qui utilise un Context comme 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, aux ressources et aux autres détails de la configuration de la vue, la configuration de la vue en est un excellent exemple. Chaque contexte a divers paramètres ( champs dans les implémentations de Context) qui sont définis par le système d'exploitation lui-même pour des choses comme la dimension ou la densité de l'écran. Il est facile de comprendre pourquoi ces informations sont importantes pour configurer des vues, etc.
Un dernier mot: Pour une raison quelconque, les personnes qui découvrent Android (et même les personnes qui ne sont pas si nouvelles) semblent complètement oublier les objets- programmation orientée quand il s'agit d'Android. Pour une raison quelconque, les utilisateurs essaient d'associer leur 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. Toutefois, bien que "trouver le bon contexte" puisse 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 ne pas l’avoir. Encore une fois, Java est un langage orienté objet avec une conception d'héritage.
Vous "n'avez" que le contexte dans votre activité, car votre activité elle-même hérite du contexte. Cela n’a aucune magie (à part tout ce que le système d’exploitation fait lui-même pour définir divers paramètres et pour "configurer" correctement votre contexte). Donc, en mettant de côté les problèmes de mémoire/performances (par exemple, conserver des références au contexte lorsque vous n'en avez pas besoin ou le faire d'une manière qui a des conséquences négatives sur la mémoire, etc.), le contexte est un objet comme un autre et peut être transmis. comme n'importe quel POJO (Plain Old Java Object). Parfois, vous devrez peut-être faire des choses intelligentes pour extraire ce contexte, mais toute classe Java normale qui ne s'étend que d’Object lui-même peut être écrite de manière à avoir accès au contexte; simplement exposer une méthode publique qui prend un contexte et l’utiliser ensuite dans cette classe si nécessaire. Cela n’a pas été conçu comme un traitement exhaustif sur le contexte ou Android internes, mais j’espère que cela aidera à démystifier légèrement le contexte.
Un contexte est une poignée du 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 est en cours d'exécution. L'objet d'activité hérite de l'objet Contexte.
Pour plus d'informations, consultez Introduction à Android développement avec Android Studio - Tutorial.
Context est une "interface" avec les informations globales sur un environnement d'application. En pratique, Context est en réalité un classe abstraite, dont l'implémentation est fournie par le système Android.
Il permet d'accéder aux ressources et aux classes spécifiques à l'application, ainsi qu'aux appels supplémentaires pour les opérations au niveau de l'application, telles que les activités de lancement, les intentions de diffusion et de réception, etc.
Dans l'image suivante, vous pouvez voir une hiérarchie de classes, où Context est la classe racine de cette hiérarchie. En particulier, il convient de souligner que Activity est un descendant de Context.
Qu'est-ce que Context exactement?
D'après 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 classes associés à l'environnement, aux services (y compris les services de niveau système), etc. Tout au long de ce livre, et dans votre codage quotidien avec Android, le contexte est fréquemment transmis.
Extrait du livre " Android in Practice ", p. 60.
Plusieurs API Android nécessitent un paramètre Context
Si vous parcourez les différentes API Android, vous remarquerez que nombre d’entre elles prennent un objet Android.content.Context en tant que paramètre. Vous constaterez également qu’une activité ou un service est généralement utilisé en tant que Context. Cela fonctionne parce que ces deux classes s'étendent de Context.
Un Android contexte est un interface (au sens général, pas au sens Java; en Java, Context est en fait une classe abstraite!) qui permet d’accéder à des ressources spécifiques à l’application, ainsi qu’à des informations sur l’environnement de l’application.
Si votre application Android était une application Web, votre contexte serait similaire à ServletContext (je ne fais pas de comparaison exacte ici).
Vos activités et services s'étendent également Context, de sorte qu'ils héritent de toutes ces méthodes pour accéder aux informations d'environnement dans lesquelles l'application est en cours d'exécution.
Exemple simple pour comprendre context dans Android:
Chaque chef a un assistant pour s'occuper de toutes les tâches moins importantes et fastidieuses. Si un dossier ou une tasse de café est nécessaire, un assistant est en fuite. Certains chefs savent à peine ce qui se passe dans le bureau, alors ils interrogent également leurs assistants à ce sujet. Ils travaillent eux-mêmes, mais pour la plupart des choses, ils ont besoin de l'aide de leurs assistants.
Dans ce scénario,
Boss - est l'application Android
Assistant - est le contexte
Files/tasse de café - sont des ressources
Nous appelons généralement contexte lorsque nous devons obtenir des informations sur différentes parties de notre application, telles que Activités, Applications, etc.
Quelques opérations (choses où l’assistant est nécessaire) où le contexte est impliqué:
- Chargement de ressources communes
- Création de vues dynamiques
- Affichage des messages de Toast
- Activités de lancement, etc.
Différentes manières d'obtenir le contexte:
getContext()
getBaseContext()
getApplicationContext()
this
Contextreprésente un descripteur permettant d'obtenir des données d'environnement.- La classe
Contextest déclarée comme abstraite et son implémentation est fournie par le système d'exploitation Android. Contextest comme une télécommande d'une télévision et les chaînes dans la télévision sont des ressources, des services, etc.![enter image description here]()
Que pouvez-vous en faire?
- Chargement de la ressource.
- Lancer une nouvelle activité.
- Création de vues.
- Obtenir un service système.
Façons d'obtenir le contexte:
getApplicationContext()getContext()getBaseContext()![enter image description here]()
![enter image description here]()
Il suffit de le publier pour les débutants;
Alors comprenez d'abord le contexte de 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 entièrement compris et évalué."
"Les parties de quelque chose d'écrit ou de parlé qui précèdent et suivent immédiatement un mot ou un passage et en clarifient le sens."
Maintenant, prenez la même compréhension pour le monde de la programmation:
contexte de l'état actuel de l'application/objet. Il permet aux objets nouvellement créés de comprendre ce qui se passe. En général, vous l'appelez 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 (lorsque vous vous trouvez dans la classe d'activité).
Pour obtenir Context Anywhere dans l'application, utilisez le code suivant:
Créez une nouvelle classe AppContext dans 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 de non activité, appelez cette méthode et vous avez un contexte d'application.
J'espère que cette aide;)
Considérez-le comme la VM qui a rendu le processus d'application de l'application ou du service en mode silencieux. L'environnement en mode silencieux a accès à de nombreuses 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 à des informations sur l'environnement de l'application.
La classe Android.content.Context fournit la connexion au système Android et aux ressources du projet. C'est l'interface avec des informations globales sur l'environnement de l'application.
Le contexte donne également accès à Android Services, par exemple. le service de localisation.
Activités et services étendent la classe Context.
Le contexte est Instances de la classe Android.content.Context fournit 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. C'est l'interface avec des informations globales sur l'environnement de l'application.
La classe de contexte fournit également un accès aux services Android, par exemple, le gestionnaire d'alarmes pour déclencher des événements basés sur l'heure.
Les activités et services étendent la classe de contexte. Par conséquent, ils peuvent être directement utilisés pour accéder au contexte.
Le contexte est une interface pour des informations globales sur un environnement d'application. C'est une classe abstraite dont l'implémentation est fournie par le système Android.
Context permet d'accéder aux ressources et aux classes spécifiques à l'application, ainsi qu'aux appels à 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 le contexte de l'état actuel de l'application/de l'objet. C'est une entité qui représente diverses données d'environnement. Le contexte permet à l'activité actuelle d'interagir avec l'environnement Android extérieur, tels que les fichiers locaux, les bases de données, les chargeurs de classe associés à l'environnement, les services, y compris les services de niveau système, etc.
Un contexte est une poignée du 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. Il s’agit d’un descripteur de l’environnement dans lequel votre application est en cours d’exécution. L’objet d’activité hérite de l’objet Contexte.
Différentes méthodes d'appel par lesquelles vous pouvez obtenir le contexte 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. ou this (lorsque vous vous trouvez dans la classe d'activité).
Le contexte sert essentiellement à accéder aux ressources et à obtenir les détails de l'environnement de l'application (pour le contexte de l'application), de l'activité (pour le contexte de l'activité) ou de tout autre ...
Afin d'éviter les fuites de mémoire, vous devez utiliser le contexte d'application pour chaque composant nécessitant un objet de contexte .... pour plus de clics ici
Le contexte signifie que Android cherche à savoir dans quelle activité je devrais aller ou agir.
1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); il a utilisé dans ceci. 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.Ceci est plus rapide, getContext et getApplicatinContext.
Analogie Assistant Patron
Faisons une petite analogie avant de plonger dans les détails techniques du contexte
Chaque chef a un assistant ou une personne (garçon de course) qui fait pour lui des tâches moins importantes et plus longues. Par exemple, s'ils ont besoin d'un fichier ou d'un café, un assistant sera en service. Le patron ne saura pas ce qui se passe en arrière-plan mais le fichier ou la tâche sera livré
Alors voici
Boss - Android Application
Assistant - Contexte
Fichier ou tasse de café - Ressource
Qu'est-ce que Android site officiel du développeur dit à propos de contexte
Le contexte est votre point d'accès pour les ressources liées à l'application
Voyons certaines de ces ressources ou tâches
Lancer une activité.
Obtenir le chemin absolu du 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 sur le système.
Vérifier si une autorisation particulière vous a été accordée.
Etc.
Ainsi, si une application Android veut démarrer une activité, elle passe directement à Context (point d'accès), et la classe Context lui restitue les ressources ( Intention dans ce cas).
Comme toute autre classe, la classe Context possède également des champs et des méthodes.
Vous pouvez en savoir plus sur Context dans la documentation officielle, cela couvre à peu près tout, les méthodes disponibles, les champs et même comment utiliser les champs avec des méthodes.
Une Context est ce que la plupart d'entre nous appellerions Application. Il est créé par le système Android et ne peut faire que ce qu'une application est capable de faire. Dans Tomcat, un contexte est également ce que j'appellerais une application.
Il y a un contexte qui contient plusieurs activités, chaque activité peut avoir plusieurs vues.
Évidemment, certains diront que cela ne convient pas à cause de ceci ou de cela et ils ont probablement raison, mais le fait de dire qu'un contexte est votre application actuelle vous aidera à comprendre ce que vous mettez dans les paramètres de méthode.
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. C'est l'interface avec des informations globales sur l'environnement de l'application.
La classe de contexte fournit également un accès aux services Android, par exemple, le gestionnaire d'alarmes pour déclencher des événements basés sur l'heure.
Les activités et services étendent la classe de contexte. Par conséquent, ils peuvent être directement utilisés pour accéder au contexte.
Pour simplifier, les androïdes Context est un gâchis que vous n'aimerez pas tant que vous cessez de vous inquiéter.
Android Contexts sont:
Objets de Dieu.
Ce que vous voulez faire circuler dans l’ensemble de votre application lorsque vous commencez à développer pour Android, mais vous éviterez de le faire lorsque vous vous rapprocherez un peu plus de la programmation, des tests et de Android lui-même.
Dépendance peu claire.
Source commune 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, l'affichage des boîtes de dialogue et le gonflement de la présentation. Et vous avez besoin de différentes instances
Contextpour certaines choses distinctes (vous ne pouvez évidemment pas afficher une boîte de dialogue à partir d'un contexte d'application ou de service; les présentations gonflées à partir de contextes d'application et d'activité peuvent être différentes).
Le contexte est l’API spécifique à Android de chaque application-s Sandbox qui fournit des données privées d’application telles que des ressources, une base de données, des répertoires 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/listes de diffusion d'une même application.
Puisque Application, Activity, Service implémente l'interface de contexte, ils peuvent être utilisés lorsqu'un appel à l'API nécessite un paramètre de contexte.
Si vous souhaitez vous connecter contexte à d'autres classes familières d'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
Donc, 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 un fragment, vous souhaitez que la thématisation soit appliquée à vos vues, mais ne vous en souciez pas Service , par exemple.
J'explique la différence dans les contextes ici .
Context signifie composant (ou application) dans différentes périodes. Si je mange tellement de nourriture entre 13 h et 14 h, mon contexte de cette époque 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 une heure donnée. Context des composants de l'application ne cesse de changer en fonction du cycle de vie sous-jacent des composants ou de l'application. Par exemple, dans la onCreate () d’un Activity,
getBaseContext() - donne la context du Activity qui est définie (créée) par le constructeur d'activité. getApplicationContext() - donne la configuration Context (créée) lors de la création de l'application.
Remarque: <application> contient tous les Android Composants.
<application>
<activity> .. </activity>
<service> .. </service>
<receiver> .. </receiver>
<provider> .. </provider>
</application>
Cela signifie que lorsque vous appelez getApplicationContext() de l'intérieur de n'importe quel composant, vous appelez le contexte commun de toute l'application.
Context continue à être modifié par le système en fonction du cycle de vie des composants.