Définition de Contexte:

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

Termes plus simples::

• Considérer la Personne X est le PDG d'une start-up de la société de logiciels.

• il y a un plomb architecte présent dans l'entreprise, cet architecte en chef des est-ce que tout le travail dans l'entreprise qui implique tels que la base de données, L'assurance-chômage etc.

• maintenant le PDG engage un nouveau développeur.

• c'est L'architecte qui indique la responsabilité des nouveaux embauchés personne basée sur les compétences de la nouvelle personne que s'il travail sur la base de données ou L'assurance-chômage, etc.

plus simple Termes::

• c'est comme l'accès de l'activité android à la ressource de l'application.

• c'est similaire à quand vous visitez un hôtel, vous voulez Petit déjeuner, Déjeuner & dîner dans l'timings, droit?

• il y a beaucoup d'autres choses que vous aimez pendant le séjour. Comment faites-vous obtenir ces choses?

• vous demandez le une personne du service d'étage pour vous apporter ces choses.

• ici, la personne au service d'étage est le contexte considérant que vous êtes le seule l'activité et de l'hôtel à votre application, enfin le petit déjeuner, le déjeuner & dîner à la ressources.

---

les choses qui impliquent le Contexte sont:

1. chargement a ressources.
2. lancement d'une nouvelle activité.
3. création de vues.
4. obtention du service système.

---

le contexte est la classe de base pour activité , Service , Application .... etc

une autre façon de décrire ceci: considérer le contexte comme éloigné d'un téléviseur et d'une chaîne dans le téléviseur sont des ressources, des services, en utilisant des intentions etc - - ici, la distance agit comme un accès pour accéder à toutes les différentes ressources en avant plan.

• Donc, à Distance a accès à des canaux tels que les ressources, les services, en utilisant les intentions etc ....
• de même ..... Quiconque a accès à distance a naturellement accès à toutes les choses telles que les ressources, les services, en utilisant les intentions etc

---

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

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

---

exemple:

TextView TV=new TextView(this);

this - > renvoie au contexte de l'activité courante.

Source

---

le sujet du contexte dans Android semble être déroutant pour beaucoup. Les gens savent juste que le contexte est nécessaire assez souvent 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 comment "obtenir" le bon contexte. Je vais essayer de démystifier l'idée de Contexte dans Android. Un traitement complet de la question est au-delà de la portée de ce post, mais je vais essayer de donner un aperçu général de sorte que vous avez une idée de ce Contexte est et comment l'utiliser. Pour comprendre ce Qu'est le contexte, regardons le code source:

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

Qu'est-ce que le contexte?

bien, le la documentation elle-même fournit une explication assez simple: la classe contextuelle 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 L'OS Android. La documentation précise en outre que le contexte " ... permet d'accéder à des ressources et à des classes spécifiques aux applications, ainsi qu'à des mises à jour pour des opérations au niveau des applications telles que les activités de lancement., radiodiffusion et réception, etc.".

vous pouvez très bien comprendre, maintenant, pourquoi le nom est contexte. C'est parce que c'est juste que. Le contexte fournit le lien ou le crochet, si vous voulez, pour une activité, un Service, ou tout autre composant, le reliant ainsi au système, permettant l'accès à l'environnement d'application globale. En d'autres termes: le contexte fournit la réponse à la question des composantes " où diable suis-je par rapport à l'app en général et comment puis-je accès/communiquer avec le reste de l'application?"Si tout cela semble un peu confus, un rapide coup d'oeil sur les méthodes exposées par la classe de contexte fournit quelques indices supplémentaires sur sa véritable nature.

voici un échantillon 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 à quiconque a accès au contexte d'accéder aux ressources de l'ensemble de l'application.

"1519570920 de Contexte", en d'autres termes, les crochets, le composant qui a une référence pour le reste de l'environnement de l'application. Les actifs (le dossier think ’/assets’ dans votre projet), par exemple, sont disponibles à travers l'application, à condition qu'une activité, un Service ou quoi que ce soit sache comment y accéder. ces ressources. Il en va de même pour getResources() qui permet de faire des choses comme getResources().getColor() qui vous connectera à la ressource colors.xml (peu importe que l'aapt permette l'accès aux ressources via le code java, c'est une question distincte).

le résultat est que Context est ce qui permet l'accès aux ressources du système et son ce qui accroche les composants dans le"plus grande application". Regardons les sous-classes de Context , les classes qui assurent la mise en œuvre de la résumé Context de la classe. La classe la plus évidente est la classe Activity . Activity hérite de ContextThemeWrapper , qui hérite de ContextWrapper , qui hérite de Context lui-même. Ces cours sont utiles à regarder pour comprendre les choses à un niveau plus profond, mais pour l'instant il suffit de savoir que ContextThemeWrapper et ContextWrapper sont à peu près ce à quoi ils ressemblent. Ils mettent en œuvre les éléments abstraits de la classe Context elle-même en "enveloppant" un contexte (le contexte actuel) et déléguer ces fonctions à ce contexte. Un exemple est utile - dans la classe ContextWrapper , la méthode abstraite getAssets de la classe Context est implémentée comme suit:

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

mBase est tout simplement un champ défini par le constructeur à un contexte spécifique. Ainsi, un contexte est enveloppé et le ContextWrapper délègue sa mise en œuvre de la méthode getAssets à ce contexte. Revenons à l'examen du Activity classe qui hérite finalement de Context pour voir comment ça fonctionne.

Vous savez probablement ce qu'est une Activité, mais à l'examen, c'est essentiellement " une seule chose que l'utilisateur peut faire. Elle s'occupe de fournir une fenêtre dans laquelle placer L'UI que l'utilisateur interagit avec'. Les développeurs familiers avec D'autres API et même les non-développeurs pourraient y voir un "écran"."C'est techniquement inexact, mais cela n'a pas d'importance pour nos objectifs. Alors, comment faire Activity et Context interagissent 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 le lancement des Activités. Si vous avez "le contexte" à partir duquel vous êtes vous commencez l'activité, vous appelez simplement startActivity(intent) , où L'intention décrit le contexte à partir duquel vous commencez une activité et l'activité que vous souhaitez commencer. C'est le familier startActivity(this, SomeOtherActivity.class) .

et this ? this est votre activité parce que la classe Activity hérite de Context . Le scoop complet est comme ceci: quand vous appelez startActivity , finalement la classe Activity exécute quelque chose comme ceci:

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

ainsi il utilise le execStartActivity de la classe Instrumentation (en fait d'une classe intérieure dans Instrumentation appelé ActivityResult ).

à ce point, nous commençons à obtenir un coup d'oeil au système de fonctionnement interne.

C'est là que OS s'occupe de tout. Comment L'Instrumentation commence-t-elle l'activité? Eh bien, le param this dans la méthode execStartActivity ci-dessus est votre activité, c'est-à-dire le contexte, et le execStartActivity utilise ce contexte.

une vue d'ensemble de 30 000 est la suivante: La classe Instrumentation garde trace d'une liste d'activités qu'elle surveille afin de faire du travail. Cette liste est utilisée pour coordonner toutes les activités et s'assurer que tout fonctionne bien dans la gestion du flux d'activités.

il y a certaines opérations que je n'ai pas entièrement examinées qui coordonnent les questions de fil et de processus. Finalement, le ActivityResult utilise une opération native - ActivityManagerNative.getDefault().startActivity() qui utilise le Context que vous avez passé dans quand vous avez appelé startActivity . Le contexte dans lequel vous avez passé est utilisé pour aider à la "résolution d'intention" si nécessaire. L'intention de la résolution est le processus par lequel le système peut déterminer la cible de l'intention, si elle n'est pas fournie. (Consulter le guide ici pour plus de détails).

et pour cela, Android doit avoir accès aux informations fournies par Context . Plus précisément, le système doit avoir accès à un ContentResolver pour pouvoir "déterminer le type MIME des données de l'intention". Cette partie sur la façon dont startActivity utilise le contexte était un peu compliqué et je ne comprends pas tout à fait les internes moi-même. Mon point principal était juste pour illustrer la façon dont l'échelle de l'application des ressources doivent être accessibles afin d'effectuer de nombreuses opérations sont essentielles pour une application. Context est ce qui donne accès à 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 prend un Context comme un argument. Lorsque vous instanciez votre Vue personnalisée vous passez dans le contexte. Pourquoi? Parce que la vue doit pouvoir avoir accès à des thèmes, des ressources et d'autres détails de configuration de la vue. Voir la configuration est en fait un bon exemple. Chaque contexte a différents paramètres (champs dans les implémentations de Context ) qui sont définis par L'OS lui-même pour des choses comme la dimension ou la densité de l'affichage. Il est facile de voir pourquoi cette information est importante pour configurer des vues, etc.

un dernier mot: Pour certaines raisons, les gens nouveaux à Android (et même les gens pas si Nouveau) semblent complètement oublier la programmation orientée objet quand il s'agit D'Android. Pour une certaine raison, 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 tout à fait cohérente si laisser aller de vos notions pré-conçues et tout simplement lire la documentation et guide de développement. Mon vrai point, cependant, alors que "obtenir le bon contexte" peut parfois être délicat, les gens paniquent sans raison parce qu'ils se trouvent 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 un design d'héritage.

on ne "ont" le contexte à l'intérieur de votre Activité grâce à votre activité elle-même hérite de Contexte. Il n'y a pas de magie à cela (sauf pour le tout le Le système D'exploitation définit lui-même divers paramètres et "configure" correctement le contexte). Donc, en mettant les problèmes de mémoire/performance de côté (par exemple, en gardant des références au contexte quand 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 un autre et il peut être transmis comme N'importe quel POJO (simple vieil objet Java). Parfois, vous pourriez avoir besoin de faire des choses intelligentes pour récupérer ce contexte, mais toute classe Java régulière qui s'étend à partir de rien d'autre que l'Objet lui-même peut être écrit d'une manière qui a accès au contexte; il suffit d'exposer une méthode publique qui prend un contexte et ensuite l'utiliser dans la classe. Cela n'a pas été conçu comme un traitement exhaustif sur le contexte ou les intérieurs Android, mais j'espère que c'est utile pour démystifier un peu le contexte.

un contexte est une poignée vers le système; il fournit des services comme la résolution de ressources, l'accès aux bases de données et aux préférences, et ainsi de suite. Une application Android a des activités. Le contexte est comme une poignée à l'environnement dans lequel votre application est actuellement en cours d'exécution. L'activité objet hérite de l'objet de Contexte.

pour plus d'informations, regardez dans Introduction au développement Android avec Android Studio - Tutorial .

tant que tu penseras de toute façon, pense grand.

Interface globale de l'information sur un environnement d'application. Il s'agit d'une classe abstraite dont l'implémentation est fournie par le système Android.

Il permet d'accéder à la demande spécifique des ressources et des classes, ainsi que le haut-niveau de l'application des opérations telles que le lancement d'activités de diffusion et de réception des intentions, etc.

ANDROID AND CONTEXT

si vous regardez à travers les différents APIs Android, vous notez que beaucoup d'entre eux prennent un objet android.content.Context comme un paramètre. Vous verrez également qu'une activité ou un Service est habituellement utilisé comme Cadre. Cela fonctionne parce que ces deux classes s'étendent du contexte.

Quel est le contexte exact?

pour la documentation de référence Android, il est un entité qui représente diverses données sur l'environnement. Il donne accès à des locaux fichiers, bases de données, Chargeurs de classe associés à l'environnement, les services y compris les services au niveau du système, et plus encore. Tout au long de ce livre, et dans l'une de vos journées- jour de codage avec Android, vous verrez le contexte transmis fréquemment. À partir de: "Android dans la Pratique" livre.

Android Contexte est un Interface qui permet d'accéder à la demande spécifique des ressources et de la classe et d'informations sur l'environnement d'application.

si votre application android était une application web, votre contexte serait quelque chose similaire à ServletContext (Je ne fais pas une comparaison exacte ici)

vos activités et vos services élargissent également le contexte hériter de toutes ces méthodes pour accéder aux informations sur l'environnement dans lequel l'application est en cours d'exécution.

exemple Simple pour comprendre context dans android:

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

dans ce scénario,

Boss – est l'application Android

Assistant – est contexte

dossiers / tasse de café-sont des ressources

nous appelons généralement contexte quand nous avons besoin d'obtenir des informations sur différentes parties de notre application comme des activités, des Applications, etc.

Certaines opérations(des choses là où l'assistant est nécessaire), où le contexte est en cause:

Chargement commun ressources Créer des vues dynamiques Affichage des messages sur les toasts Activités de lancement, etc. Différentes manières de se contexte:

getContext()

getBaseContext()

getApplicationContext()

this

• Contexte représente une poignée pour obtenir des données sur l'environnement .
• la classe de contexte elle-même est déclarée abstraite, dont l'implémentation est fournie par l'OS android.
• le Contexte est comme la télécommande de la TÉLÉVISION et du canal de la télévision, sont les ressources, services, etc.

Que pouvez-vous en faire ?

• Chargement ressources.
• lancement d'une nouvelle activité.
• Création de points de vue.
• obtention du service système.

des Moyens de les mettre en contexte :

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

il suffit de le mettre là-bas pour les débutants;

donc d'abord comprendre le contexte du mot:

en anglais-lib. cela signifie:

" les circonstances qui constituent le cadre d'un événement, d'une déclaration ou l'idée, et en termes de laquelle elle peut être pleinement comprise et évaluée."

" les parties de quelque chose écrites ou parlées qui précèdent immédiatement et suivre un mot ou un passage et clarifier son sens."

Maintenant, prenez le même compréhension de la programmation du monde:

contexte de l'état actuel de l'application ou de l'objet. Il permet aux objets nouvellement créés de comprendre ce qui s'est passé. Habituellement, vous l'appelez pour obtenir des renseignements sur une autre partie de votre programme (activité, trousse/demande)

vous pouvez obtenir le contexte en invoquant getApplicationContext() , getContext(), getBaseContext() ou this (lorsque dans l'activité classe.)

pour obtenir le contexte N'importe où dans l'application utilisez le code suivant:

créer 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 n'importe quand vous voulez le contexte d'application dans la classe de non-activité, appelez cette méthode et vous avez le contexte d'application.

Espérons que cette aide ;)

pensez-y comme la VM qui a mis en silo le processus dans l'application ou le service. L'environnement Siloé 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.

"151900920 de Contexte" est une référence à l'objet courant. Aussi le contexte permet d'accéder aux informations sur l'environnement de l'application.

La classe android.content.Context assure la connexion au système Android et les ressources du projet. Il est l'interface pour des informations globales sur l'environnement de l'application.

le contexte fournit également l'accès aux Services Android, par exemple le service de localisation.

activités et Services extension de la classe Context .

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 tout autre...

afin d'éviter les fuites de mémoire, vous devez utiliser le contexte d'application pour chaque composant qui a besoin d'un objet de contexte.... pour plus de cliquez sur ici

le Contexte est le contexte de l'état actuel de l'application ou de l'objet.Il s'agit d'une entité qui représente diverses données sur l'environnement . Contexte aide l'activité actuelle à interagir avec l'environnement android côté comme les fichiers locaux, bases de données, classe chargeurs associés à l'environnement, les services y compris les services au niveau du système, et plus encore.

un contexte est une poignée vers le système . Il offre des services comme la résolution de ressources, l'accès aux bases de données et préférences, et ainsi de suite. Une application android a des activités. C'est comme une poignée vers l'environnement dans lequel votre application est en cours d'exécution. L'activité objet hérite de l'objet de Contexte.

différentes méthodes d'invocation par lesquelles vous pouvez obtenir le contexte 1. getcontexteapplication(), 2. getContext(), 3. getBaseContext() 4. ou cela (quand on est dans la classe d'activité).

Contexte des Instances de la classe android.contenu.Contexte fournir la connexion au système Android qui exécute l'application. Par exemple, vous pouvez vérifier la taille de l'actuel dispositif d'affichage via le Contexte.

Il donne aussi accès aux ressources du projet. Il est l'interface pour des informations globales sur l'environnement de l'application.

la classe Context fournit également l'accès aux services Android, par exemple, l'alarme gestionnaire pour déclencher des événements basés sur le temps.

activités et services étendent la classe contextuelle. Ils peuvent donc être utilisés directement pour accéder au contexte.

Contexte est une interface pour des informations globales sur l'environnement de l'application. C'est une classe abstraite dont l'implémentation est fournie par le système Android .

Context permet l'accès à des ressources et à des classes spécifiques à l'application, ainsi que des 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

Interface globale de l'information sur un environnement d'application. Il s'agit d'une classe abstraite dont l'implémentation est fournie par le système Android. Il permet l'accès à des ressources et à des classes spécifiques aux applications, ainsi qu'à des appels de demandes pour des opérations au niveau des applications telles que les activités de lancement, de radiodiffusion et de réception, etc.

Instances de la classe android.contenu.Contexte fournir la connexion au système Android qui exécute l'application. Par exemple, vous pouvez vérifier la taille de l'actuel dispositif d'affichage via le Contexte.

Il donne aussi accès aux ressources du projet. Il est l'interface pour des informations globales sur l'environnement de l'application.

la classe Context fournit également l'accès aux services Android, par exemple, le gestionnaire d'alarme pour déclenchez des événements basés sur le temps.

activités et services étendent la classe contextuelle. Ils peuvent donc être utilisés directement pour accéder au contexte.

A Context est ce que la plupart d'entre nous appellerait Application . Il est fait par le système Android et est capable de faire seulement ce qu'une application est en mesure d'. 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 de nombreux points de vue.

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

Contexte Android connaître à l'activité de qui je doit aller ou agir.

1 - Toast.makeText(contexte, "Entrer dans Tous les Détails", Toast.LENGTH_SHORT).montrer(); il est utilisé dans cette. Contexte context = ActivityName.

2-activity (new Intent (context, LoginActivity.classe));

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

Boss Adjoint Analogie

permet d'avoir une petite analogie avant de plonger profondément dans la technicité du contexte

chaque patron a un assistant ou quelqu'un( garçon de courses) qui fait moins des choses importantes et plus longues pour lui. Par exemple, si ils besoin d'un fichier ou d'un café, puis un assistant sera sur exécuter. Le patron ne sera pas savoir ce qui se passe dans le fond, mais le fichier ou la tâche être livré

Donc Ici

Patron - De L'Application Android

Assistant-Contexte

Fichier ou une tasse de café - Ressources

Ce officiel Développeur Android site dit de Contexte

le Contexte est votre point d'accès ressources associées

voyons un peu de ces ressources ou tâches

• lancement d'une activité.

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

• déterminer si la permission donnée est autorisée pour un particulier processus et identifiant de l'utilisateur en cours d'exécution dans le système.

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

et ainsi de suite.

Donc, si une application Android veut démarrer une activité, il va directement à Context (point D'accès), et la classe Context lui donne les ressources(intention dans ce cas).

comme toute autre classe Context classe trop a des champs et des méthodes.

Vous pouvez en savoir plus sur Context en documentation officielle, elle couvre à peu près tout, les méthodes disponibles, les champs et même comment utiliser les champs avec les méthodes.

si vous voulez connecter contexte avec D'autres classes familières dans Android, gardez à l'esprit cette structure:

Context < ContextWrapper < Application

Contexte < ContextWrapper < ContextThemeWrapper < L'Activité

Contexte < ContextWrapper < ContextThemeWrapper < Activity < Activité de liste

Context < Contextrapper < Service

Context < Contextrapper < Service < IntentService

donc, toutes ces classes sont des contextes à leur manière. Vous pouvez lancer Service et ListActivity à Contexte si vous le souhaitez. Mais si vous regardez de plus près, certains des cours héritent thème ainsi. Dans activity ou fragment, vous souhaitez que theming soit appliqué à vos vues, mais ne vous en souciez pas Service Classe , par exemple.

j'explique la différence de contextes ici .

Putting simple, Androids Context est un gâchis que vous n'aimerez pas tant que vous n'arrêterez pas de vous inquiéter.

Android Context s sont:

• Dieu-objets.

• chose que vous voulez passer autour de toute votre application lorsque vous commencez à développer pour Android, mais évitera de le faire lorsque vous obtenez un peu plus proche de la programmation, les tests et Android lui-même.

  • manque de clarté de la dépendance.

  • source Commune de fuites de mémoire.

  • PITA pour les tests.

• contexte actuel utilisé par le système Android pour envoyer les permissions, les ressources, les préférences, les services, les émissions, les styles, montrant les dialogues et la mise en page gonflante. Et vous avez besoin de différent Context instances pour certaines choses séparées (évidemment, vous ne pouvez pas afficher un dialogue à partir d'une application ou d'un contexte de service; les layouts gonflés à partir de contextes d'application et d'activité peuvent différer).

le contexte est l'api android spécifique à chaque application-s bac à sable qui fournit l'accès aux données privées de l'application comme les ressources, la base de données, les répertoires de fichiers privés, les préférences, les paramètres ...

la plupart des données privées sont les mêmes pour toutes les activités/services/diffuseurs d'une même application.

depuis que L'application, L'activité, le Service implémentent l'interface de contexte, ils peuvent être utilisés lorsqu'un appel api a besoin d'un contexte paramètre

Context courant. Context utiliser pour faire le fonctionnement de l'écran courant. ex.

  1. getApplicationContext()

  2. getContext ()

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

Context composant (ou application) dans diverses périodes. Si je mange autant de nourriture entre 13h et 14h, alors 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 une composante (application) pour un temps particulier. Context des composants de l'application change constamment en fonction du cycle de vie sous-jacent des composants ou de l'application. Par exemple, à l'intérieur de l'onCreate () d'un Activity ,

getBaseContext() -- donne le context du Activity qui est défini (créé) par le constructeur de l'activité. getApplicationContext() -- donne la configuration Context (créé) lors de la création de l'application.

Note: <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 composant, vous appelez le contexte commun de l'ensemble de l'application.

Context continue d'être modifié par le système basé sur le cycle de vie des composants.

contexte dans Android est une interface pour l'information globale sur un environnement d'application. Il s'agit d'une classe abstraite dont l'implémentation est fournie par le système Android. Il permet l'accès à des ressources et à des classes spécifiques aux applications, ainsi qu'à des appels de demandes pour des opérations au niveau des applications telles que les activités de lancement, de radiodiffusion et de réception, etc.

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

en Java, nous disons ce mot-clé se réfère à l'état de l'objet courant de l'application.

De même, dans un alternate nous avons Context dans Android Development.

cela peut être défini explicitement ou implicitement,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();