¿Qué es ‘Contexto’ en Android?

En la progtwigción de Android, ¿qué es exactamente una clase de Context y para qué se utiliza?

Lo leí en el sitio del desarrollador, pero no puedo entenderlo claramente.

Poniéndolo simplemente:

Como su nombre indica, es el contexto del estado actual de la aplicación / objeto. Permite que los objetos recién creados comprendan lo que ha estado sucediendo. Normalmente lo llama para obtener información sobre otra parte de su progtwig (actividad y paquete / aplicación).

Puede obtener el contexto invocando getApplicationContext() , getContext() , getBaseContext() o this (cuando está en una clase que se extiende desde Context , como las clases Application, Activity, Service y IntentService).

Usos típicos del contexto:

  • Creando nuevos objetos : Creando nuevas vistas, adaptadores, oyentes:

     TextView tv = new TextView(getContext()); ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...); 
  • Acceder a los recursos comunes estándar : servicios como LAYOUT_INFLATER_SERVICE, SharedPreferences:

     context.getSystemService(LAYOUT_INFLATER_SERVICE) getApplicationContext().getSharedPreferences(*name*, *mode*); 
  • Acceder a los componentes implícitamente : con respecto a los proveedores de contenido, las transmisiones, la intención

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

Definición de contexto ::

  • El contexto representa los datos del entorno
  • Proporciona acceso a cosas como bases de datos

Términos más simples ::

  • Considere que Person-X es el CEO de una empresa de software de nueva creación.

  • Hay un arquitecto principal presente en la empresa, este arquitecto principal hace todo el trabajo en la empresa, que incluye bases de datos, interfaz de usuario, etc.

  • Ahora el CEO contrata un nuevo desarrollador.

  • Es el Arquitecto quien le dice a la persona recientemente contratada la responsabilidad basada en las habilidades de la nueva persona, ya sea que trabaje en la Base de Datos o en la IU, etc.

Términos más simples ::

  • Es como el acceso de la actividad de Android al recurso de la aplicación.

  • Es similar a cuando visitas un hotel, quieres desayunar, almorzar y cenar en los horarios adecuados, ¿verdad?

  • Hay muchas otras cosas que te gustan durante el tiempo de estadía. ¿Cómo consigues estas cosas?

  • Usted le pide a la persona del servicio de habitación que traiga estas cosas por usted.

  • Aquí la persona del servicio de habitaciones es el contexto considerando que usted es la única actividad y el hotel como su aplicación, finalmente el desayuno, el almuerzo y la cena tienen que ser los recursos.


Las cosas que involucran contexto son:

  1. Cargando un recurso
  2. Lanzar una nueva actividad.
  3. Creando vistas.
  4. obteniendo servicio del sistema

El contexto es la clase base para Actividad , Servicio , Aplicación … etc.

Otra forma de describir esto: Considere el contexto como remoto de un televisor y un canal en la televisión son recursos, servicios, uso de intenciones, etc. – – – Aquí el control remoto actúa como un acceso para obtener acceso a todos los recursos diferentes en primer plano.

  • Entonces, Remote tiene acceso a canales tales como recursos, servicios, uso de intenciones, etc.
  • Del mismo modo ….. Quien tiene acceso a control remoto, naturalmente, tiene acceso a todas las cosas, tales como recursos, servicios, uso de intenciones, etc.

Diferentes métodos mediante los cuales puedes obtener contexto

  • getApplicationContext()
  • getContext()
  • getBaseContext()
  • o this (cuando está en la clase de actividad)

Ejemplo:

 TextView TV=new TextView(this); 

this -> se refiere al contexto de la actividad actual.

Fuente


El tema de Contexto en Android parece ser confuso para muchos. La gente simplemente sabe que el Contexto se necesita con bastante frecuencia para hacer cosas básicas en Android. Las personas a veces entran en pánico porque intentan realizar alguna operación que requiera el contexto y no saben cómo “obtener” el contexto correcto. Voy a tratar de desmitificar la idea de Contexto en Android. El tratamiento completo del problema está más allá del scope de esta publicación, pero trataré de ofrecer una descripción general para que tenga una idea de qué es el contexto y cómo usarlo. Para entender qué es el contexto, echemos un vistazo al código fuente:

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

¿Qué es exactamente Contexto?

Bueno, la documentación en sí proporciona una explicación bastante sencilla: la clase Contexto es una “Interfaz para información global sobre un entorno de aplicación”.

La clase de contexto en sí se declara como clase abstracta, cuya implementación es proporcionada por el sistema operativo Android. La documentación proporciona además que Context “… permite el acceso a clases y recursos específicos de la aplicación, así como también llamadas para operaciones de nivel de aplicación, como actividades de inicio, transmisión y recepción de bashs, etc.”.

Puede entender muy bien, ahora, por qué el nombre es Contexto. Es porque es solo eso. El Contexto proporciona el enlace o gancho, si lo desea, para una Actividad, Servicio o cualquier otro componente, lo que lo vincula al sistema, lo que permite el acceso al entorno de la aplicación global. En otras palabras: el contexto proporciona la respuesta a la pregunta de los componentes “¿dónde diablos estoy en relación con la aplicación en general y cómo accedo / me comunico con el rest de la aplicación?” Si todo esto parece un poco confuso, una rápida ver los métodos expuestos por la clase de Contexto proporciona algunas pistas adicionales sobre su verdadera naturaleza.

Aquí hay una muestra aleatoria de esos métodos:

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

¿Qué tienen todos estos métodos en común? Todos ellos permiten que cualquiera que tenga acceso al Contexto pueda acceder a los recursos de toda la aplicación.

El contexto, en otras palabras, engancha el componente que tiene una referencia al rest del entorno de la aplicación. Los activos (piense en la carpeta ‘/ assets’ en su proyecto), por ejemplo, están disponibles en toda la aplicación, siempre que una Actividad, Servicio o lo que sea sepa cómo acceder a esos recursos. Lo mismo ocurre con getResources() que permite hacer cosas como getResources().getColor() que lo enganchará al recurso colors.xml (no importa que aapt permita el acceso a los recursos a través del código java, eso es un problema aparte).

El resultado es que el Context es lo que permite el acceso a los recursos del sistema y lo que engancha los componentes en la “aplicación mayor”. Veamos las subclases de Context , las clases que proporcionan la implementación de la clase Context abstracto. Clase de Activity la Activity hereda de ContextThemeWrapper , que hereda de ContextWrapper , que hereda del Context mismo. Esas clases son útiles para comprender las cosas a un nivel más profundo, pero por ahora es suficiente saber que ContextThemeWrapper y ContextWrapper son más o menos lo que En realidad, implementan los elementos abstractos de la clase Context “envolviendo” un contexto (el contexto real) y delegando esas funciones a ese contexto. Un ejemplo es útil: en la clase ContextWrapper , el método abstracto getAssets de la clase Context se implementa de la siguiente manera:

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

mBase es simplemente un campo establecido por el constructor para un contexto específico. Entonces se envuelve un contexto y ContextWrapper delega su implementación del método getAssets en ese contexto. Volvamos a examinar la clase Activity que finalmente hereda de Context para ver cómo funciona todo esto.

Usted probablemente sabe lo que es una Actividad, pero para revisarla, básicamente es ‘algo único que el usuario puede hacer. Se encarga de proporcionar una ventana en la que colocar la UI con la que el usuario interactúa ‘. Los desarrolladores familiarizados con otras API e incluso con los no desarrolladores podrían pensarlo de manera vernácula como una “pantalla”. Eso es técnicamente incorrecto, pero no tiene importancia para nuestros propósitos. Entonces, ¿cómo interactúan la Activity y el Context y qué es exactamente lo que está sucediendo en su relación de herencia?

Nuevamente, es útil mirar ejemplos específicos. Todos sabemos cómo lanzar Actividades. Siempre que tenga “el contexto” desde el que está iniciando la Actividad, simplemente llame a startActivity(intent) , donde Intent describe el contexto desde el cual está comenzando una Actividad y la Actividad que le gustaría comenzar. Esta es la familiar startActivity(this, SomeOtherActivity.class) .

Y que es this ? this es su Actividad porque la clase Activity hereda de Context . La primicia completa es la siguiente: cuando llamas a startActivity , en última instancia, la clase Activity ejecuta algo como esto:

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

Por lo tanto, utiliza la execStartActivity de la clase Instrumentation (en realidad, de una clase interna en Instrumentation llamada ActivityResult ).

En este punto, estamos comenzando a echar un vistazo a las partes internas del sistema.

Aquí es donde OS realmente maneja todo. Entonces, ¿cómo inicia la Instrumentación la Actividad exactamente? Bien, el parámetro this en el método execStartActivity anterior es su Actividad, es decir, el Contexto, y la actividad execStartActivity hace uso de este contexto.

Una descripción general de 30,000 es la siguiente: la clase de Instrumentación mantiene un seguimiento de una lista de Actividades que está monitoreando para hacer su trabajo. Esta lista se usa para coordinar todas las actividades y asegurarse de que todo funcione sin problemas al administrar el flujo de actividades.

Hay algunas operaciones que no he examinado completamente en las que se coordinan los problemas de hilo y proceso. En última instancia, ActivityResult utiliza una operación nativa: ActivityManagerNative.getDefault().startActivity() que usa el Context que startActivity cuando llamó a startActivity . El contexto que pasó se usa para ayudar en la “resolución de intención” si es necesario. La resolución intencionada es el proceso mediante el cual el sistema puede determinar el objective de la intención si no se proporciona. (Vea la guía aquí para más detalles).

Y para que Android lo haga, necesita acceder a la información que proporciona Context . Específicamente, el sistema necesita acceder a un ContentResolver para poder “determinar el tipo MIME de los datos del bash”. Todo este bit sobre cómo startActivity hace uso del contexto fue un poco complicado y no entiendo completamente las startActivity internas. El punto principal fue simplemente ilustrar cómo se debe acceder a los recursos de toda la aplicación para realizar muchas de las operaciones que son esenciales para una aplicación. El Context es lo que proporciona acceso a estos recursos. Un ejemplo más simple podría ser Vistas. Todos sabemos qué Si crea una Vista personalizada extendiendo RelativeLayout o alguna otra clase de View , debe proporcionar un constructor que tome un Context como argumento. Cuando crea una instancia de su Vista personalizada, pasa en el contexto. ¿Por qué? Porque la Vista debe poder tener acceso a temas, recursos y otros detalles de configuración de Vista. La configuración de vista es en realidad un gran ejemplo. Cada contexto tiene varios parámetros (campos en las implementaciones de Context ) que el propio sistema operativo establece para cosas como la dimensión o densidad de la pantalla. Es fácil ver por qué esta información es importante para configurar vistas, etc.

Una última palabra: por alguna razón, las personas nuevas en Android (e incluso las personas que no son tan nuevas) parecen olvidarse por completo de la progtwigción orientada a objetos cuando se trata de Android. Por algún motivo, las personas intentan adaptar su desarrollo de Android a paradigmas preconcebidos o comportamientos aprendidos.

Android tiene su propio paradigma y un cierto patrón que es bastante consistente si deja de lado sus ideas preconcebidas y simplemente lee la documentación y la guía de desarrollo. Mi punto real, sin embargo, mientras que “obtener el contexto correcto” a veces puede ser complicado, las personas se aterran injustificadamente porque se topan con una situación en la que necesitan el contexto y piensan que no lo tienen. Una vez más, Java es un lenguaje orientado a objetos con un diseño de herencia.

Solo “tiene” el contexto dentro de su Actividad porque su actividad hereda de Contexto. No tiene magia (excepto por todas las cosas que el sistema operativo hace por sí solo para establecer varios parámetros y para “configurar” correctamente su contexto). Por lo tanto, dejando de lado los problemas de memoria / rendimiento (por ejemplo, manteniendo referencias al contexto cuando no lo necesita o hacerlo de una manera que tiene consecuencias negativas en la memoria, etc.), el contexto es un objeto como cualquier otro y puede transmitirse como cualquier POJO (Objeto simple de Java). En ocasiones, es posible que necesite hacer cosas inteligentes para recuperar ese contexto, pero cualquier clase regular de Java que se extienda desde otra cosa que no sea Object se puede escribir de forma que tenga acceso al contexto; simplemente exponga un método público que toma un contexto y luego úselo en esa clase según sea necesario. Esto no fue pensado como un tratamiento exhaustivo en el contexto o el interior de Android, pero espero que sea útil para desmitificar el contexto un poco.

Un contexto es un controlador para el sistema; proporciona servicios como la resolución de recursos, la obtención de acceso a bases de datos y preferencias, y más. Una aplicación de Android tiene actividades. El contexto es similar al manejador del entorno en el que se está ejecutando la aplicación. El objeto de actividad hereda el objeto Contexto.

Para obtener más información, consulte Introducción al desarrollo de Android con Android Studio – Tutorial .

Mientras sigas pensando de todos modos, piensa en grande.

Interfaz con información global sobre un entorno de aplicación. Esta es una clase abstracta cuya implementación es proporcionada por el sistema Android.

Permite el acceso a clases y recursos específicos de la aplicación, así como a llamadas para operaciones a nivel de aplicación, como actividades de inicio, transmisión y recepción de bashs, etc.

Diagrama de actividad

ANDROID Y CONTEXTO

Si observa las distintas API de Android, notará que muchos de ellos toman un objeto android.content.Context como parámetro. También verá que una Actividad o un Servicio se usa generalmente como un Contexto. Esto funciona porque ambas clases se extienden desde Contexto.

¿Cuál es el contexto exactamente?

Según la documentación de referencia de Android, es una entidad que representa varios datos de entorno. Proporciona acceso a archivos locales, bases de datos, cargadores de clases asociados al entorno, servicios que incluyen servicios a nivel de sistema y más. A lo largo de este libro, y en su encoding diaria con Android, verá que el contexto se transmite con frecuencia. De: libro “Android in Practice”.

Un contexto de Android es una interfaz que permite el acceso a los recursos específicos de la aplicación, la clase y la información sobre el entorno de la aplicación.

Si su aplicación de Android era una aplicación web, su contexto sería algo similar a ServletContext (no estoy haciendo una comparación exacta aquí)

Sus actividades y servicios también amplían el contexto para que hereden todos esos métodos para acceder a la información del entorno en el que se ejecuta la aplicación.

Ejemplo simple para entender el context en Android:

Cada jefe tiene un asistente que cuidar, para hacer todas las tareas menos importantes y lentas. Si se necesita un archivo o una taza de café, el asistente está en la carrera. Algunos jefes apenas saben lo que está sucediendo en la oficina, por lo que preguntan a sus asistentes sobre esto también. Trabajan ellos mismos, pero para la mayoría de las cosas necesitan ayuda de sus asistentes.

En este escenario,

Boss – es la aplicación de Android

Asistente – es contexto

Archivos / Taza de café – son recursos

Generalmente llamamos contexto cuando necesitamos obtener información sobre diferentes partes de nuestra aplicación, como actividades, aplicaciones, etc.

Algunas operaciones (cosas donde se necesita ayudante) donde el contexto está involucrado:

Carga de recursos comunes Creación de vistas dinámicas Visualización de mensajes de Toast Ejecución de actividades, etc. Diferentes formas de obtener el contexto:

 getContext() getBaseContext() getApplicationContext() this 
  • El contexto representa un identificador para obtener datos del entorno.
  • La clase de contexto en sí misma se declara como abstracta, cuya implementación es proporcionada por el sistema operativo Android.
  • El contexto es como el control remoto de un televisor y los canales en la televisión son recursos, servicios, etc. enter image description here

Qué puedes hacer con eso ?

  • Cargando recurso.
  • Lanzar una nueva actividad.
  • Creando vistas.
  • Obteniendo el servicio del sistema.

Formas de obtener contexto:

  • getApplicationContext()
  • getContext()
  • getBaseContext() enter image description here enter image description here

Solo ponerlo para novatos;

Entonces, primero entiende el contexto de Word:

En inglés-lib. significa:

“Las circunstancias que forman el escenario para un evento, statement o idea, y en términos de los cuales puede ser completamente entendido y evaluado”.

“Las partes de algo escrito o hablado que inmediatamente preceden y siguen una palabra o pasaje y aclaran su significado”.

Ahora tome la misma comprensión para el mundo de la progtwigción:

contexto del estado actual de la aplicación / objeto. Permite que los objetos recién creados comprendan lo que ha estado sucediendo. Normalmente lo llamas para obtener información sobre otra parte de tu progtwig (actividad, paquete / aplicación)

Puede obtener el contexto invocando getApplicationContext() , getContext(), getBaseContext() o this (cuando está en la clase de actividad).

Para obtener el contexto en cualquier lugar en la aplicación use el siguiente código:

Crea nueva clase de AppContext dentro de tu aplicación de 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; } } 

Ahora, cada vez que desee un contexto de aplicación en una clase que no sea de actividad, llame a este método y tendrá contexto de aplicación.

Espero que esto ayude 😉

Piense en ello como la VM que ha configurado el proceso en el que se ejecuta la aplicación o el servicio. El entorno en silos tiene acceso a una gran cantidad de información subyacente del sistema y ciertos recursos permitidos. Necesita ese contexto para obtener esos servicios.

El contexto es una referencia al objeto actual como este. También el contexto permite el acceso a información sobre el entorno de la aplicación.

La clase android.content.Context proporciona la conexión al sistema Android y los recursos del proyecto. Es la interfaz a la información global sobre el entorno de la aplicación.

El contexto también proporciona acceso a los servicios de Android, por ejemplo, el servicio de ubicación.

Las actividades y servicios amplían la clase de Context .

El contexto es básicamente para acceder a los recursos y obtener los detalles del entorno de la aplicación (para el contexto de la aplicación) o actividad (para el contexto de la actividad) o cualquier otro …

Para evitar la pérdida de memoria, debe usar el contexto de la aplicación para cada componente que necesite un objeto de contexto …. para obtener más información, haga clic aquí

El contexto es el contexto del estado actual de la aplicación / objeto. Es una entidad que representa varios datos de entorno. El contexto ayuda a la actividad actual a interactuar con el entorno lateral de Android, como archivos locales, bases de datos, cargadores de clases asociados al entorno, servicios que incluyen servicios a nivel de sistema, y ​​más.

Un contexto es un controlador para el sistema. Proporciona servicios como la resolución de recursos, la obtención de acceso a bases de datos y preferencias, y más. Una aplicación de Android tiene actividades. Es como un identificador para el entorno en el que se está ejecutando su aplicación actualmente. El objeto de actividad hereda el objeto Contexto.

Diferentes métodos de invocación mediante los cuales puede obtener el contexto 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. o esto (cuando está en la clase de actividad).

El contexto es Instancias de la clase android.content.Context proporciona la conexión al sistema Android que ejecuta la aplicación. Por ejemplo, puede verificar el tamaño de la pantalla del dispositivo actual a través del contexto.

También da acceso a los recursos del proyecto. Es la interfaz a la información global sobre el entorno de la aplicación.

La clase Context también proporciona acceso a servicios de Android, por ejemplo, el administrador de alarmas para activar eventos basados ​​en el tiempo.

Las actividades y servicios amplían la clase Contexto. Por lo tanto, se pueden usar directamente para acceder al contexto.

El contexto es una interfaz para información global sobre un entorno de aplicación. Es una clase abstracta cuya implementación es proporcionada por el sistema Android .

Context permite el acceso a clases y recursos específicos de la aplicación, así como también llamadas para operaciones a nivel de aplicación tales como launching activities, broadcasting and receiving intents, etc.

Aquí hay un ejemplo

  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. */ 

Para más detalles, puede visitar http://developer.android.com/reference/android/content/Context.html

Interfaz con información global sobre un entorno de aplicación. Esta es una clase abstracta cuya implementación es proporcionada por el sistema Android. Permite el acceso a clases y recursos específicos de la aplicación, así como a llamadas para operaciones a nivel de aplicación, como actividades de inicio, transmisión y recepción de bashs, etc.

Las instancias de la clase android.content.Context proporcionan la conexión al sistema Android que ejecuta la aplicación. Por ejemplo, puede verificar el tamaño de la pantalla del dispositivo actual a través del contexto.

También da acceso a los recursos del proyecto. Es la interfaz a la información global sobre el entorno de la aplicación.

La clase Context también proporciona acceso a servicios de Android, por ejemplo, el administrador de alarmas para activar eventos basados ​​en el tiempo.

Las actividades y servicios amplían la clase Contexto. Por lo tanto, se pueden usar directamente para acceder al contexto.

Un Context es lo que la mayoría de nosotros llamaría Aplicación . Está hecho por el sistema Android y solo puede hacer lo que una aplicación puede. En Tomcat, un Contexto es también lo que yo llamaría una aplicación.

Hay un contexto que contiene muchas actividades, cada actividad puede tener muchas vistas.

Obviamente, algunos dirán que no encaja debido a esto o aquello y que probablemente tengan razón, pero decir que un contexto es su aplicación actual lo ayudará a comprender lo que está poniendo en los parámetros del método.

Analista Asistente Boss

Tengamos una pequeña analogía antes de profundizar en la tecnicidad de Context

Cada Jefe tiene un asistente o alguien (chico de los recados) que hace cosas menos importantes y que consumen más tiempo para él. Por ejemplo, si necesitan un archivo o café, un asistente estará en funcionamiento. Boss no sabrá qué está sucediendo en el fondo, pero el archivo o la tarea se entregarán

Entonces aquí
Boss – Aplicación para Android
Asistente – Contexto
Archivo o taza de café – Recurso

Qué sitio oficial de Android Developper dice sobre Contexto

El contexto es su punto de acceso para los recursos relacionados con la aplicación

Veamos algunos de esos recursos o tareas

  • Lanzar una actividad.

  • Obtener una ruta absoluta al directorio de caché específico de la aplicación en el sistema de archivos.

  • Determinar si el permiso otorgado se permite para un proceso en particular y una identificación de usuario ejecutándose en el sistema.

  • Verificando si se te ha otorgado un permiso particular.

Y así.
Entonces, si la aplicación de Android desea iniciar una actividad, va directamente al Context (punto de acceso), y la clase de Context le devuelve los recursos (en este caso, bash).

Al igual que cualquier otra clase, la clase de Context también tiene campos y métodos.
Puede explorar más sobre el Context en la documentación oficial, cubre prácticamente todo, los métodos disponibles, los campos e incluso cómo usar los campos con los métodos.

El contexto significa que Android sabrá en qué actividad debo ir o actuar.

1 – Toast.makeText (contexto, “Ingresar todos los detalles”, Toast.LENGTH_SHORT) .show (); usó en esto. Contexto context = ActivityName.this;

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

in this context means from which activity you wanna go to other activity. context or ActivityName.this is faster then , getContext and getApplicatinContext.

If you want to connect Context with other familiar classes in Android, keep in mind this structure:

Context < ContextWrapper < Application

Context < ContextWrapper < ContextThemeWrapper < Activity

Context < ContextWrapper < ContextThemeWrapper < Activity < ListActivity

Context < ContextWrapper < Service

Context < ContextWrapper < Service < IntentService

So, all of those classes are contexts in their own way. You can cast Service and ListActivity to Context if you wish. But if you look closely, some of the classes inherit theme as well. In activity or fragment, you would like theming to be applied to your views, but don’t care about it Service class, for instance.

I explain the difference in contexts here .

Putting simple, Androids Context is a mess that you won’t love until you stop worrying about.

Android Context s are:

  • God-objects.

  • Thing that you want to pass around all your application when you are starting developing for Android, but will avoid doing it when you get a little bit closer to programming, testing and Android itself.

    • Unclear dependency.

    • Common source of memory leaks.

    • PITA for testing.

  • Actual context used by Android system to dispatch permissions, resources, preferences, services, broadcasts, styles, showing dialogs and inflating layout. And you need different Context instances for some separate things (obviously, you can’t show a dialog from an application or service context; layouts inflated from application and activity contexts may differ).

The Context is the android specific api to each app-s Sandbox that provides access app private data like to resources, database, private filedirectories, preferences, settings …

Most of the privatedata are the same for all activities/services/broadcastlisteners of one application.

Since Application, Activity, Service implement the Context interface they can be used where an api call needs a Context parameter

Context means current. Context use to do operation for current screen. ex.
1. getApplicationContext()
2. getContext()

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

Context means component (or application) in various time-period. If I do eat so many food between 1 to 2 pm then my context of that time is used to access all methods (or resources) that I use during that time. Content is an component (application) for particular time. Context of components of application keeps changing based on the underlying lifecycle of the components or application. For instance, inside the onCreate() of an Activity ,

getBaseContext() — gives the context of the Activity that is set (created) by the constructor of activity. getApplicationContext() — gives the Context setup (created) during the creation of application.

Note: holds all Android Components.

   ..   ..   ..   ..   

It means, when you call getApplicationContext() from inside whatever component, you are calling the common context of the whole application.

Context keeps being modified by the system based on the lifecycle of components.

Context in Android is an interface to global information about an application environment. This is an abstract class whose implementation is provided by the Android system. It allows access to application-specific resources and classes, as well as up-calls for application-level operations such as launching activities, broadcasting and receiving intents, etc.

This attribute declares which activity this layout is associated with by default .

In Java, we say this keyword refers to the state of the current object of the application.
Similarly, in an alternate we have Context in Android Development.

This can be defined either explicitly or implicitly,

 Context con = this; getApplicationContext(); getBaseContext(); getContext();