Question Qu'est-ce que 'Contexte' sur Android?


Dans la programmation Android, qu'est-ce qu'un Context classe et à quoi sert-elle?

J'ai lu à ce sujet sur le site de développeur, mais je suis incapable de le comprendre clairement.


1576
2017-08-26 06:12


origine


Réponses:


En mettant simplement:

Comme son nom l'indique, c'est le 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 règle générale, vous l'appelez 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 s'étend de Context, comme les classes Application, Activity, Service et IntentService).

Utilisations typiques du contexte:

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

    TextView tv = new TextView(getContext());
    ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
    
  • Accéder aux ressources communes standard: Services tels que LAYOUT_INFLATER_SERVICE, SharedPreferences:

    context.getSystemService(LAYOUT_INFLATER_SERVICE)
    getApplicationContext().getSharedPreferences(*name*, *mode*);
    
  • Accès aux composants implicitement: En ce qui concerne les fournisseurs de contenu, les émissions, l'intention

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

1239
2017-08-26 06:32



Définition du contexte ::

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

Termes plus simples ::

  • Considérons Person-X est le PDG d'une entreprise de logiciels de démarrage.

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

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

  • C'est l'architecte qui confie la responsabilité des nouveaux embauchés personne basée sur les compétences de la nouvelle personne que ce soit travailler sur la base de données ou l'interface utilisateur, etc.

Termes plus simples ::

  • C'est comme l'accès de l'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 dîner dans les horaires appropriés, non?

  • Il y a beaucoup d'autres choses que vous aimez pendant le temps de séjour. Comment tu obtenir ces choses?

  • Vous demandez à la personne au service d'étage d'apporter ces choses pour vous.

  • Ici, le room-service est le contexte considérant que vous êtes le activité unique et l'hôtel pour être votre application, enfin le petit déjeuner, le déjeuner et le dîner doit être les ressources.


Les choses qui impliquent le contexte sont:

  1. Chargement d'une ressource
  2. Lancer une nouvelle activité
  3. Créer des vues
  4. obtenir le service du système.

Le contexte est la classe de base pour Activité, Un service, Application .... etc

Une autre façon de décrire ceci: Considérer le contexte comme distant d'une télévision et des chaînes dans la télévision sont les ressources, les services, l'utilisation des intentions etc - Ici la télécommande agit comme un accès pour avoir accès à toutes les ressources au premier plan.

  • Ainsi, Remote a accès à des canaux tels que les ressources, les services, l'utilisation des intentions, etc.
  • De même ... Celui qui a accès à distance a naturellement accès à toutes les choses telles que les ressources, les services, l'utilisation des 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);

this -> fait référence au contexte de l'activité en cours.


408
2017-08-20 05:25



La source


Le sujet de Contexte dans Android semble être source de confusion 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 qu'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 dépasse la portée de ce post, 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 comment l'utiliser. Pour comprendre ce qu'est le contexte, jetons un coup d'oeil au code source:

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

Qu'est-ce que c'est exactement Context? 

Eh bien, la documentation elle-même fournit une explication assez simple: La classe Context est une "Interface vers des informations globales sur un environnement d'application".

La classe Context elle-même est déclarée en tant que classe abstraite, dont la mise en œuvre est fournie par le système d'exploitation Android. La documentation prévoit en outre que Context "... permet d'accéder à des ressources et à des classes spécifiques aux applications, ainsi qu'à des appels-up pour des opérations au niveau des applications telles que des activités de lancement, de diffusion et de réception, etc."

Vous pouvez très bien comprendre, maintenant, pourquoi le nom est Contexte. C'est parce que c'est juste ça. 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 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 confus, un rapide Regardez les méthodes exposées par la classe Context fournit d'autres indices sur sa véritable 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 ceux qui ont accès au contexte de pouvoir accéder aux ressources à l'échelle de l'application.

En d'autres termes, le contexte accroche le composant qui fait référence au reste de l'environnement d'application. Le dossier assets (think '/ assets' dans votre projet), par exemple, est disponible dans toute l'application, à condition qu'une activité, un service ou autre sache comment accéder à ces ressources. De même pour getResources() ce qui permet de faire des choses comme getResources().getColor() qui vous accrocher dans le colors.xml ressource (tout simplement que aapt permet l'accès aux ressources via le code java, c'est un problème distinct).

Le résultat est que Context est ce qui permet l'accès aux ressources du système et ce qui relie les composants dans la "plus grande application". Regardons les sous-classes de Context, les classes qui fournissent la mise en œuvre du résumé Context classe. La classe la plus évidente est la Activity classe. Activityhérite de ContextThemeWrapper, qui hérite de ContextWrapper, qui hérite de Context lui-même. Ces classes 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 qu'ils ressemblent. Ils mettent en œuvre les éléments abstraits de la Context classer lui-même en "enveloppant" un contexte (le contexte réel) et en déléguant ces fonctions à ce contexte.  Un exemple est utile - dans le ContextWrapper classe, la méthode abstraite getAssets du Context La classe 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. Donc, un contexte est enveloppé et le ContextWrapper délègue son implémentation de la méthode getAssets à ce contexte. Revenons à l'examen de la Activity classe qui hérite finalement de Context pour voir comment tout cela fonctionne.

Vous savez probablement ce qu'est une activité, mais pour l'examiner, c'est essentiellement une 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 des non-développeurs peuvent le considérer comme un «écran». C'est techniquement inexact, mais cela n'a pas d'importance pour nos objectifs. Alors, comment faire Activity et Context interagir et ce qui se passe exactement dans leur relation d'héritage?

Encore une fois, il est utile de regarder des exemples spécifiques. Nous savons tous comment lancer des activités. Pourvu que vous ayez "le contexte" à partir duquel vous commencez 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. C'est le familier startActivity(this, SomeOtherActivity.class).

Et qu'est ce qui est this? this est votre activité parce que le Activity la classe hérite de Context. Le scoop complet est comme ceci: Quand vous appelez startActivity, finalement le Activity La classe exécute quelque chose comme ceci:

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

Donc, il utilise le execStartActivity du Instrumentation classe (en fait d'une classe interne Instrumentation appelé ActivityResult).

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

C'est là que l'OS gère réellement tout. Alors, comment l'instrumentation démarre-t-elle exactement l'activité? Eh bien, le param this dans le execStartActivity la méthode ci-dessus est votre activité, c'est-à-dire le contexte, et execStartActivity fait usage de ce contexte.

Une vue d'ensemble de 30 000 est la suivante: la classe Instrumentation conserve les pistes d'une liste d'activités qu'il surveille afin de faire son travail. Cette liste est utilisée pour coordonner toutes les activités et s'assurer que tout se passe bien dans la gestion du flux des activités.

Il y a quelques opérations que je n'ai pas complètement examinées dans quel fil de coordination et problèmes de processus. En fin de compte, le ActivityResult utilise une opération native - ActivityManagerNative.getDefault().startActivity() qui utilise le Context que tu es passé quand tu as appelé startActivity. Le contexte que vous avez passé 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 Android pour ce faire, il a besoin d'accéder à l'information qui est fournie par Context. Plus précisément, le système doit accéder à un ContentResolver il peut donc "déterminer le type MIME des données de l'intention". Tout cela sur la façon dont startActivity utilise le contexte était un peu compliqué et je ne comprends pas complètement les internes moi-même. Mon objectif principal était simplement d'illustrer comment les ressources à l'échelle de l'application doivent être accessibles pour effectuer de nombreuses opérations qui sont essentielles à une application. Context est ce qui donne accès à ces ressources.  Un exemple plus simple pourrait être Views. Nous savons tous ce que vous créez une vue personnalisée en étendant RelativeLayout ou un autre View classe, vous devez fournir un constructeur qui prend 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, ressources et autres détails de configuration de View. La configuration de vue est en fait un bon exemple. Chaque Contexte a divers paramètres (champs dans ContextImplémentations) qui sont définies 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 la mise en place des vues, etc.

Un dernier mot:  Pour une raison inconnue, les utilisateurs d'Android (et même les gens pas si nouveaux) semblent complètement oublier la programmation orientée objet quand il s'agit d'Android. Pour une raison quelconque, les gens essaient de faire passer 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 difficile, les gens paniquent de façon injustifiée parce qu'ils se retrouvent dans une situation où ils ont besoin du contexte et pensent qu'ils ne l'ont pas. Une fois de plus, Java est un langage orienté objet avec un design d'héritage.

Vous n'avez "que" le contexte à l'intérieur de votre activité car votre activité elle-même hérite du contexte. Il n'y a pas de magie (sauf pour tout ce que l'OS fait par lui-même pour définir différents paramètres et pour "configurer" correctement votre contexte). Donc, mettre de côté les problèmes de mémoire / performance (par exemple tenir des références au contexte quand vous n'avez pas besoin ou le faire d'une manière qui a des conséquences négatives sur la mémoire, etc.), Contexte est un objet comme un autre et peut être passé comme n'importe quel POJO (Plain Old Java Object). Parfois, vous pourriez avoir besoin de faire des choses intelligentes pour récupérer ce contexte, mais n'importe quelle classe Java régulière qui s'étend à partir de rien d'autre que Object lui-même peut être écrite d'une manière qui a accès au contexte; exposer simplement une méthode publique qui prend un contexte, puis l'utiliser dans cette classe si nécessaire. Cela n'a pas été conçu comme un traitement exhaustif sur les composants internes Context ou Android, mais j'espère qu'il sera utile pour démystifier un peu le contexte.


255
2018-04-30 13:44



Un contexte est un handle pour le système; Il fournit des services tels que la résolution des ressources, l'accès aux bases de données et aux préférences, etc. Le contexte est comme un descripteur de l'environnement dans lequel votre application s'exécute actuellement. L'objet activity hérite de l'objet Context.

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


100
2017-08-26 06:33



Tant que vous allez penser de toute façon, pensez grand.

Interface avec des informations globales sur un environnement d'application. C'est une classe abstraite dont la mise en œuvre est assurée par le système Android.

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

Activity diagram


64
2017-12-28 08:05



ANDROID ET CONTEXTE

Si vous regardez à travers les différentes API Android, vous aurez remarquez que beaucoup d'entre eux prennent un android.content.Context objet en tant que paramètre. Vous verrez également qu'une activité ou un service est généralement utilisé comme Le contexte. Cela fonctionne parce que ces deux classes s'étendent à partir du contexte.

Quel est le contexte exactement?

Par la documentation de référence Android, c'est un entité qui représente diverses données d'environnement. Il donne accès à des locaux des fichiers, des bases de données, des chargeurs de classe associés à l'environnement, des services, y compris des services au niveau du système, et plus encore. Tout au long de ce livre, et dans votre journée à jour codant avec Android, vous verrez le contexte circuler fréquemment. Extrait du livre "Android in Practice".


57
2018-04-28 10:14



Un Android Le contexte est un Interface Cela permet d'accéder à des ressources spécifiques aux applications et à des classes et informations sur l'environnement d'application.

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

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


36
2017-08-26 06:40



Exemple simple pour comprendre context dans android:

Chaque patron a un assistant à charge, pour effectuer toutes les tâches moins importantes et plus longues. Si un fichier ou une tasse de café est nécessaire, l'assistant est en fuite. Certains patrons savent à peine ce qui se passe dans le bureau, alors ils demandent à leurs assistants à ce sujet aussi. Ils travaillent 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

Fichiers / tasse de café - sont des ressources

Nous appelons généralement le contexte lorsque nous avons besoin d'informations sur les 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éer des vues dynamiques Affichage des messages Toast Lancement d'activités, etc. Différentes façons d'obtenir du contexte:

getContext()

getBaseContext()

getApplicationContext()

this

26
2018-05-02 12:37