En la programación de Android, ¿qué es exactamente una Contextclase y para qué se utiliza?

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

En pocas palabras:

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

Usted puede obtener el contexto invocando getApplicationContext(), getContext(), getBaseContext()o this(cuando en una clase que se extiende desde Context, tales como la aplicación, Actividad, Clases de servicio y IntentService).

Usos típicos del contexto:

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

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

• Acceso a recursos comunes estándar : servicios como LAYOUT_INFLATER_SERVICE, SharedPreferences:

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

• Acceso implícito a los componentes : con respecto a los proveedores de contenido, transmisiones, 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 (ejemplo 1)

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

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

• Ahora el CEO contrata a un nuevo desarrollador.

• Es el Arquitecto quien le dice a la responsabilidad de la persona recién contratada, basándose en las habilidades de la nueva persona, si trabajará en la base de datos o la interfaz de usuario, etc.

Términos más simples (ejemplo 2)

• Es como el acceso de la actividad de Android a los recursos de la aplicación.

• Es similar a cuando visitas un hotel, quieres desayuno, almuerzo y cena en los horarios adecuados, ¿verdad?

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

• Le pides a la persona del servicio de habitaciones que te traiga estas cosas.

• Aquí la persona del servicio de habitaciones es el contexto considerando que usted es la actividad individual 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 los recursos, los servicios, el uso de intenciones, etc.

• Entonces, Remote tiene acceso a canales como recursos, servicios, uso de intenciones, etc.

• Del mismo modo ... Quien tiene acceso al control remoto, naturalmente, tiene acceso a todas las cosas, como recursos, servicios, uso de intenciones, etc.

Diferentes métodos por los cuales puedes obtener contexto

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

Ejemplo:

TextView tv = new TextView(this);

La palabra clave se thisrefiere al contexto de la actividad actual.

Fuente

El tema del 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 requiere el Contexto y no saben cómo "obtener" el Contexto correcto. Voy a tratar de desmitificar la idea de Context en Android. Un tratamiento completo del problema está más allá del alcance de esta publicación, pero intentaré dar una visión general para que tenga una idea de qué es Context 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 el contexto?

Bueno, la documentación en sí misma proporciona una explicación bastante sencilla: la clase Context es una "Interfaz con información global sobre un entorno de aplicación".

La clase Context misma se declara como clase abstracta, cuya implementación es proporcionada por el sistema operativo Android. La documentación establece además que el Contexto "... permite el acceso a recursos y clases específicos de la aplicación, así como también llamadas ascendentes para operaciones a nivel de aplicación, como actividades de lanzamiento, difusión y recepción de intenciones, etc.".

Ahora puedes entender muy bien por qué el nombre es Contexto. Es porque es solo eso. El Contexto proporciona el enlace o enlace, 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 aplicación global. En otras palabras: el Contexto proporciona la respuesta a la pregunta de los componentes de "¿dónde diablos estoy en relación con la aplicación en general y cómo accedo / me comunico con el resto de la aplicación?" Si todo esto parece un poco confuso, un vistazo rápido a los métodos expuestos por la clase Context 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 en común todos estos métodos? Todos permiten que quien 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 resto 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 lo getResources()que permite hacer cosas como las getResources().getColor()que lo conectarán al colors.xmlrecurso (no importa que aapt habilite el acceso a los recursos a través del código java, eso es un problema separado).

El resultado es que Contextes lo que permite el acceso a los recursos del sistema y es lo que conecta los componentes a la "aplicación mayor". Veamos las subclases de Contextlas clases que proporcionan la implementación de la Contextclase abstracta . La clase más obvia es la Activityclase. ActivityHereda de ContextThemeWrapper, que hereda de ContextWrapper, que hereda de Contextsí misma. Esas clases son útiles para comprender las cosas a un nivel más profundo, pero por ahora es suficiente saber eso ContextThemeWrappery ContextWrapperson más o menos como suenan. Implementan los elementos abstractos de Contextclasificarse a sí mismo "envolviendo" un contexto (el contexto real) y delegando esas funciones a ese contexto. Un ejemplo es útil - en elContextWrapperclase, el método abstracto getAssetsde la Contextclase se implementa de la siguiente manera:

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

mBasees simplemente un campo establecido por el constructor en un contexto específico. Entonces se envuelve un contexto y los ContextWrapperdelegados implementan el método getAssets en ese contexto. Volvamos al examen de la Activityclase que finalmente hereda Contextpara ver cómo funciona todo esto.

Probablemente sepa lo que es una Actividad, pero para revisar, básicamente es 'una sola cosa que el usuario puede hacer. Se encarga de proporcionar una ventana en la que colocar la interfaz de usuario con la que el usuario interactúa '. Los desarrolladores familiarizados con otras API e incluso los que no son desarrolladores pueden pensarlo vernáculamente como una "pantalla". Eso es técnicamente inexacto, pero no importa para nuestros propósitos. Entonces, ¿cómo hacer Activityy Contextinteractúan y qué es exactamente lo que está pasando 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 startActivity(intent), donde la Intención describe el contexto desde el cual está iniciando una Actividad y la Actividad que desea comenzar. Este es el familiar startActivity(this, SomeOtherActivity.class).

Y lo que es this? thises su actividad porque la Activityclase hereda de Context. La primicia completa es así: cuando llamas startActivity, finalmente la Activityclase ejecuta algo como esto:

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

Por lo tanto, utiliza el execStartActivityde la Instrumentationclase (en realidad de una clase interna Instrumentationllamada ActivityResult).

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

Aquí es donde el sistema operativo realmente maneja todo. Entonces, ¿cómo la instrumentación inicia la actividad exactamente? Bueno, el parámetro thisen el execStartActivitymétodo anterior es su Actividad, es decir, el Contexto, y execStartActivityhace uso de este contexto.

Una visión general de 30,000 es la siguiente: la clase Instrumentation realiza un seguimiento de una lista de Actividades que está monitoreando para hacer su trabajo. Esta lista se utiliza para coordinar todas las actividades y asegurarse de que todo funcione sin problemas en la gestión del flujo de actividades.

Hay algunas operaciones que no he analizado por completo en las que se coordinan los hilos y los problemas del proceso. En última instancia, ActivityResultutiliza una operación nativa, ActivityManagerNative.getDefault().startActivity()que utiliza la Contextque pasó cuando llamó startActivity. El contexto que pasó se utiliza para ayudar en la "resolución de intenciones" si es necesario. La resolución de intención es el proceso mediante el cual el sistema puede determinar el objetivo de la intención si no se proporciona. (Consulte la guía aquí para más detalles).

Y para que Android haga esto, necesita acceso a la información que le proporciona Context. Específicamente, el sistema necesita acceder a un sistema ContentResolverpara poder "determinar el tipo MIME de los datos de la intención". Todo esto acerca de cómo startActivityhacer uso del contexto fue un poco complicado y no entiendo completamente las partes internas. Mi punto principal fue solo para ilustrar cómo se necesita acceder a los recursos de toda la aplicación para realizar muchas de las operaciones que son esenciales para una aplicación. ContextEs lo que proporciona acceso a estos recursos. Un ejemplo más simple podría ser Vistas. Todos sabemos lo que crea un Vista personalizada extendiendo RelativeLayouto alguna otra Viewclase, debe proporcionar un constructor que tome unContextcomo argumento Cuando crea una instancia de su Vista personalizada, la pasa en el contexto. ¿Por qué? Porque la Vista debe poder tener acceso a temas, recursos y otros detalles de configuración de la Vista. Ver configuración es en realidad un gran ejemplo. Cada contexto tiene varios parámetros (campos en Contextlas implementaciones) que el sistema operativo establece para cosas como la dimensión o la 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 no tan nuevas) parecen olvidarse por completo de la programación orientada a objetos cuando se trata de Android. Por alguna razón, las personas intentan doblar su desarrollo de Android a paradigmas preconcebidos o comportamientos aprendidos.

Android tiene su propio paradigma y un cierto patrón que en realidad es bastante consistente si deja de lado sus nociones preconcebidas y simplemente lee la documentación y la guía de desarrollo. Sin embargo, mi verdadero punto de vista, mientras que "obtener el contexto correcto" a veces puede ser complicado, la gente se asusta injustificadamente porque se encuentran 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 misma hereda del Contexto. No tiene magia (excepto por todo lo que hace el sistema operativo por sí solo para establecer varios parámetros y para "configurar" correctamente su contexto). Entonces, dejando a un lado los problemas de memoria / rendimiento (por ejemplo, manteniendo referencias al contexto cuando no es necesario o haciéndolo de una manera que tenga consecuencias negativas en la memoria, etc.), el contexto es un objeto como cualquier otro y se puede transmitir al igual que cualquier POJO (Objeto Java antiguo simple). A veces es posible que necesite hacer cosas inteligentes para recuperar ese contexto, pero cualquier clase de Java normal que se extienda desde nada más que el Objeto en sí puede escribirse de una manera que tenga acceso al contexto; simplemente exponga un método público que tome un contexto y luego úselo en esa clase según sea necesario.

Un contexto es un identificador del sistema; proporciona servicios como resolver recursos, obtener acceso a bases de datos y preferencias, etc. Una aplicación de Android tiene actividades. El contexto es como un identificador del entorno en el que se está ejecutando actualmente su 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 .

Contextes una "interfaz" para la información global sobre un entorno de aplicación. En la práctica, en Contextrealidad es una clase abstracta , cuya implementación es proporcionada por el sistema Android.

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

En la siguiente imagen, puede ver una jerarquía de clases, donde Contextestá la clase raíz de esta jerarquía. En particular, vale la pena enfatizar que Activityes un descendiente de Context.

Que es Contextexactamente

Según la documentación de referencia de Android, es una entidad que representa varios datos del entorno. Proporciona acceso a archivos locales, bases de datos, cargadores de clases asociados al entorno, servicios (incluidos los servicios a nivel de sistema) y más. A lo largo de este libro, y en su codificación diaria con Android, verá que el contexto se transmite con frecuencia.

Del libro " Android en la práctica ", pág. 60

Varias API de Android requieren un Contextparámetro

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

Ejemplo simple para entender contexten Android:

Cada jefe tiene un asistente para cuidar, para hacer todas las tareas menos importantes y que consumen mucho tiempo. Si se necesita un archivo o una taza de café, un asistente está a la fuga. Algunos jefes apenas saben lo que sucede en la oficina, por lo que también preguntan a sus asistentes sobre esto. Trabajan un poco ellos mismos, pero para la mayoría de las otras cosas necesitan la 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 el asistente) donde el contexto está involucrado:

• Cargando recursos comunes
• Crear vistas dinámicas
• Mostrar mensajes Toast
• Actividades de lanzamiento, etc.

Diferentes formas de obtener contexto:

getContext()

getBaseContext()

getApplicationContext()

this

Un contexto de Android es una interfaz (en el sentido general, no en el sentido de Java; ¡en Java, en Contextrealidad es una clase abstracta!) Que permite el acceso a recursos específicos de la aplicación y a la clase e información sobre el entorno de la aplicación.

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

Sus actividades y servicios también se extienden Context, por lo que heredan todos esos métodos para acceder a la información del entorno en la que se ejecuta la aplicación.

• Context representa un identificador para obtener datos del entorno.
• Context La clase en sí misma se declara como abstracta, cuya implementación es proporcionada por el sistema operativo Android.
• Context es como el control remoto de un televisor y los canales en la televisión son recursos, servicios, etc.

Qué puedes hacer con eso ?

• Cargando recurso.
• Lanzar una nueva actividad.
• Creando vistas.
• Obtención del servicio del sistema.

Formas de obtener contexto:

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

Solo poniéndolo allí para los novatos;

Entonces, primero entienda el contexto de Word:

En inglés-lib. significa:

"Las circunstancias que conforman el escenario de un evento, declaración o idea, y en términos de las cuales puede entenderse y evaluarse completamente".

"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 programar el mundo:

contexto del estado actual de la aplicación / objeto. Permite que los objetos recién creados entiendan lo que ha estado sucediendo. Por lo general, lo llama para obtener información sobre otra parte de su programa (actividad, paquete / aplicación)

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

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

Crea una nueva clase AppContextdentro 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 el contexto de la aplicación en una clase sin actividad, llame a este método y tendrá el contexto de la aplicación.

Espero que esto ayude ;)

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

El contexto es una referencia al objeto actual como este. También el contexto permite el acceso a la 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 para 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 extienden la Contextclase.

El contexto es 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 actual del dispositivo a través del Contexto.

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

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

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

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

Context permite el acceso a recursos y clases específicos de la aplicación, así como llamadas para operaciones a nivel de aplicación 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 obtener más detalles, puede visitar http://developer.android.com/reference/android/content/Context.html

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 la actividad (para el contexto de la actividad) o cualquier otro ...

Para evitar pérdidas 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 del entorno. El contexto ayuda a la actividad actual a interactuar con el entorno externo 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 identificador del sistema. Proporciona servicios como resolver recursos, obtener acceso a bases de datos y preferencias, etc. Una aplicación de Android tiene actividades. Es como un identificador del entorno en el que se ejecuta actualmente su aplicación. El objeto de actividad hereda el objeto Context.

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 significa que Android debe saber en qué actividad debo realizar o actuar.

1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); se usa en esto. Context context = ActivityName.this;

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

en este contexto significa de qué actividad quieres ir a otra actividad. context o ActivityName.this es más rápido que getContext y getApplicatinContext.

A Contextes lo que la mayoría de nosotros llamaríamos Aplicación . Está hecho por el sistema Android y solo puede hacer lo que una aplicación puede hacer. En Tomcat, un contexto también es 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 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 de jefe

Tengamos una pequeña analogía antes de sumergirnos profundamente en el tecnicismo del contexto

Todo jefe tiene un asistente o alguien (chico de los recados) que hace cosas menos importantes y que consumen más tiempo por él. Por ejemplo, si necesitan un archivo o un café, entonces un asistente estará corriendo. El jefe no sabrá lo que sucede en segundo plano, pero el archivo o la tarea se entregarán

So Here
Boss -
Asistente de aplicaciones de Android -
Archivo de contexto o taza de café - Recurso

Qué dice el sitio oficial para desarrolladores de Android sobre Context

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

Veamos algunos de esos recursos o tareas

• Lanzar una actividad.

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

• Determinar si el permiso otorgado está permitido para un proceso particular e ID de usuario que se ejecuta en el sistema.

• Verificar si se le ha otorgado un permiso particular.

Y así.
Entonces, si una aplicación de Android desea iniciar una actividad, va directamente a Context(Punto de acceso) y la Contextclase le devuelve los recursos (Intención en este caso).

Al igual que cualquier otra clase, la Contextclase también tiene campos y métodos.
Puede explorar más sobre la Contextdocumentación oficial, cubre casi todo, los métodos disponibles, los campos e incluso cómo usar los campos con los métodos.

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 actual del dispositivo a través del Contexto.

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

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

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

Si desea conectar Context con otras clases familiares en Android, tenga en cuenta esta estructura:

Contexto <ContextWrapper <Aplicación

Context <ContextWrapper <ContextThemeWrapper <Actividad

Context <ContextWrapper <ContextThemeWrapper <Actividad <ListActivity

Contexto <ContextWrapper <Servicio

Contexto <ContextWrapper <Servicio <IntentService

Entonces, todas esas clases son contextos a su manera. Puede emitir Service y ListActivity to Context si lo desea. Pero si observa de cerca, algunas de las clases también heredan el tema. En actividad o fragmento, le gustaría que se aplicara el tema a sus vistas, pero no le importa , por ejemplo, la clase de servicio .

Explico la diferencia en contextos aquí .

En pocas palabras, los androides Contextes un desastre que no te encantará hasta que dejes de preocuparte.

Android Contexts son:

• Dios-objetos.

• Cosa que desea transmitir toda su aplicación cuando comienza a desarrollar para Android, pero evitará hacerlo cuando se acerque un poco más a la programación, las pruebas y el propio Android.

  • Dependencia poco clara.

  • Fuente común de pérdidas de memoria.

  • PITA para pruebas.

• Contexto real utilizado por el sistema Android para enviar permisos, recursos, preferencias, servicios, transmisiones, estilos, mostrar cuadros de diálogo e inflar diseños. Y necesita diferentes Contextinstancias para algunas cosas separadas (obviamente, no puede mostrar un diálogo desde un contexto de aplicación o servicio; los diseños inflados desde los contextos de aplicación y actividad pueden diferir).

The Context es la API específica de Android para cada Sandbox de aplicaciones que proporciona acceso a datos privados de la aplicación, como recursos, bases de datos, directorios de archivos privados, preferencias, configuraciones ...

La mayoría de los datos privados son los mismos para todas las actividades / servicios / escuchas de difusión de una aplicación.

Dado que la aplicación, la actividad y el servicio implementan la interfaz de contexto, se pueden usar cuando una llamada API necesita un parámetro de contexto

Contextsignifica componente (o aplicación) en varios períodos de tiempo. Si como tanta comida entre la 1 y las 2 de la tarde, mi contexto de ese tiempo se usa para acceder a todos los métodos (o recursos) que uso durante ese tiempo. El contenido es un componente (aplicación) para un tiempo particular. Contextde los componentes de la aplicación sigue cambiando en función del ciclo de vida subyacente de los componentes o la aplicación. Por ejemplo, dentro de onCreate () de un Activity,

getBaseContext()- da el contextde lo Activityque se establece (creado) por el constructor de la actividad. getApplicationContext()- da la Contextconfiguración (creada) durante la creación de la aplicación.

Nota: <application>contiene todos los componentes de Android.

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

Significa que cuando llamas getApplicationContext()desde cualquier componente, estás llamando al contexto común de toda la aplicación.

Context sigue siendo modificado por el sistema en función del ciclo de vida de los componentes.

Piense en Context como una caja con diferentes recursos: cadena, colores y fuentes. Si necesita un recurso, recurra a este cuadro. Cuando gira la pantalla, este cuadro cambia porque la orientación cambia a horizontal.

 Contextsignifica corriente. Contextutilizar para hacer la operación para la pantalla actual. ex.
  1. getApplicationContext ()
  2. getContext ()

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

Grandes explicaciones! Para complementar todo lo anterior, encontré este de MindOrks muy útil, incluso muestra algunos casos de uso básicos para que su mente funcione:

Comprender el contexto en la aplicación de Android

En Java, decimos que esta palabra clave se refiere al estado del objeto actual de la aplicación.
Del mismo modo, en una alternativa que tenemos Contexten el desarrollo de Android.

Esto se puede definir explícita o implícitamente,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Este atributo declara a qué actividad se asocia este diseño de forma predeterminada .