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

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

respuesta

Poniéndolo simplemente:

Como sugiere el nombre, es el contexto del estado actual de la aplicación/objeto. Permite que los objetos recién creados comprendan 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).

Puede obtener el contexto invocando getApplicationContext(), o getContext()( cuando se encuentra en una clase que se extiende desde , como las clases Aplicación, Actividad, Servicio e IntentService).getBaseContext()thisContext

Usos típicos del contexto:

  • Creando nuevos objetos : Creando 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*);
    
  • 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 tales como bases de datos.

Términos más simples (ejemplo 1)

  • 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 implica, como la base de datos, la interfaz de usuario, etc.

  • Ahora el CEO contrata a un nuevo desarrollador.

  • Es el arquitecto quien indica la responsabilidad de la persona recién contratada en función de las habilidades de la nueva persona, ya sea que trabaje en la base de datos o en la interfaz de usuario, etc.

Términos más simples (ejemplo 2)

  • Es como acceder a 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 estancia. ¿Cómo consigues 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, ya que usted es la única actividad y el hotel es su aplicación; finalmente, el desayuno, el almuerzo y la cena deben ser los recursos.


Las cosas que involucran contexto son:

  1. Cargando un recurso.
  2. Lanzamiento de una nueva actividad.
  3. Creación de vistas.
  4. obtener el 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 los canales en el televisor son recursos, servicios, intentos de uso, etc. - - - Aquí el control remoto actúa como un acceso para acceder a todos los diferentes recursos en primer plano.

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

  • Del mismo modo... Cualquiera que tenga acceso a control remoto, naturalmente, tiene acceso a todas las cosas, como recursos, servicios, intentos de uso, 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 thisse refiere al contexto de la actividad actual.

Fuente


El tema de Contexto en Android parece ser confuso para muchos. La gente simplemente sabe que Context 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 Contexto en Android. Un tratamiento completo del problema está más allá del alcance de esta publicación, pero intentaré brindar una descripción general para que tenga una idea de qué es Contexto y cómo usarlo. Para entender qué es Context, 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 la información global sobre un entorno de aplicación".

La clase Context en sí misma se declara como una clase abstracta, cuya implementación la proporciona el sistema operativo Android. La documentación también establece que Context "...permite el acceso a recursos y clases específicos de la aplicación, así como llamadas ascendentes para operaciones a nivel de aplicación, como actividades de lanzamiento, intentos de transmisión y recepción, etc.".

Puedes entender muy bien, ahora, por qué el nombre es Contexto. Es porque es solo eso. El Contexto proporciona el vínculo o enlace, por así decirlo, para una Actividad, Servicio o cualquier otro componente, vinculándolo así al sistema, permitiendo 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, una mirada rápida 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 cualquiera que tenga acceso al Contexto pueda acceder a los recursos de toda la aplicación.

El contexto, en otras palabras, conecta el componente que tiene una referencia con el 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 getResources()which nos permite hacer cosas como las getResources().getColor()que lo conectarán con el colors.xmlrecurso (no importa que aapt permita el acceso a los recursos a través del código Java, ese es un tema aparte).

El resultado es que eso Contextes lo que permite el acceso a los recursos del sistema y es lo que engancha los componentes en la "gran aplicación". Veamos las subclases de Context, las clases que proporcionan la implementación de la clase abstracta Context. La clase más obvia es la Activityclase. Activityhereda from ContextThemeWrapper, que hereda de ContextWrapper, que hereda de Contextsí mismo. Esas clases son útiles para entender 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 la Contextclase en sí "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 para un contexto específico. Por lo tanto, se envuelve un contexto y se ContextWrapperdelega su implementación del método getAssets en ese contexto. Volvamos a examinar la Activityclase de la que finalmente se hereda Contextpara ver cómo funciona todo esto.

Probablemente sepa qué es una actividad, pero para repasar, es básicamente "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 interactúa el usuario. Los desarrolladores familiarizados con otras API e incluso los que no son desarrolladores pueden pensar en ella vernáculamente como una "pantalla". Eso es técnicamente inexacto, pero no importa para nuestros propósitos. Entonces, ¿cómo interactúan Activityy Contextqué sucede exactamente en su relación de herencia?

Una vez más, 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 la intención describe el contexto desde el que está iniciando una actividad y la actividad que le gustaría comenzar. Este es el conocido startActivity(this, SomeOtherActivity.class).

¿Y qué es this? thises su Actividad porque la Activityclase hereda de Context. La primicia completa es así: cuando llamas startActivity, en última instancia, la Activityclase ejecuta algo como esto:

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

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

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

Aquí es donde el sistema operativo realmente maneja todo. Entonces, ¿cómo inicia Instrumentación 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 descripción general de 30,000 es la siguiente: la clase de Instrumentación 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 investigado completamente y que coordinan problemas de subprocesos y procesos. En última instancia, ActivityResultusa una operación nativa, ActivityManagerNative.getDefault().startActivity()que usa el Contextque pasó cuando llamó startActivity. El contexto que pasó se usa para ayudar en la "resolución de intenciones" si es necesario. La resolución de la 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 obtener más detalles).

Y para que Android pueda hacer esto, necesita acceso a la información proporcionada por Context. Específicamente, el sistema necesita acceder a un ContentResolverpara que pueda "determinar el tipo MIME de los datos de la intención". Todo esto sobre cómo startActivityhace uso del contexto fue un poco complicado y yo mismo no entiendo completamente las partes internas. Mi punto principal fue solo para ilustrar cómo es necesario 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 creas Vista personalizada extendiendo RelativeLayouto alguna otra Viewclase, debe proporcionar un constructor que tome unContextcomo 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 la Vista. La configuración de vista es en realidad un gran ejemplo. Cada contexto tiene varios parámetros (campos en Contextlas implementaciones de ) que establece el propio sistema operativo 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 palabra final: 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 adaptar 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 punto real es que, si bien "obtener el contexto correcto" a veces puede ser complicado, las personas entran en pánico injustificadamente porque se encuentran en 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 en sí misma hereda de Contexto. No hay magia en ello (excepto por todas las cosas que hace el sistema operativo por sí mismo para establecer varios parámetros y "configurar" correctamente su contexto). Entonces, dejando de lado los problemas de memoria/rendimiento (por ejemplo, mantener referencias al contexto cuando no es necesario o hacerlo de una manera que tenga consecuencias negativas en la memoria, etc.), el contexto es un objeto como cualquier otro y se puede pasar. como cualquier POJO (Plain Old Java Object). A veces, es posible que deba hacer cosas inteligentes para recuperar ese contexto, pero cualquier clase Java normal que se extienda desde nada más que el propio Objeto se puede escribir de una manera que tenga acceso al contexto; simplemente exponga un método público que tome un contexto y luego lo use 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 ejecuta actualmente su aplicación. El objeto de actividad hereda el objeto de contexto.

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

Contextes una "interfaz" a la información global sobre un entorno de aplicación. En la práctica, Contextes en realidad una clase abstracta , cuya implementación la proporciona el sistema Android.

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

En la siguiente imagen, puede ver una jerarquía de clases, donde Contextse encuentra la clase raíz de esta jerarquía. En particular, vale la pena recalcar que Activityes descendiente de Context.

Diagrama de actividad

¿Qué es Contextexactamente?

Per the Android reference documentation, it's an entity that represents various environment data. It provides access to local files, databases, class loaders associated to the environment, services (including system-level services), and more. Throughout this book, and in your day-to-day coding with Android, you'll see the Context passed around frequently.

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

Varias API de Android requieren un Contextparámetro as

Si observa las diversas 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 archivo Context. Esto funciona porque ambas clases se extienden desde Context.

Ejemplo simple para entender contexten android:

Cada jefe tiene un asistente al que 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 carrera. Algunos jefes apenas saben lo que sucede en la oficina, por lo que también preguntan a sus asistentes sobre esto. Ellos mismos hacen algunos trabajos, 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 un 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 está involucrado el contexto:

  • Cargando recursos comunes
  • Creación de vistas dinámicas
  • Visualización de 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, Context¡es en realidad una clase abstracta!) que permite el acceso a recursos y clases específicos de la aplicación 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 algo similar a 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 el que se ejecuta la aplicación.

  • Contextrepresenta un identificador para obtener datos del entorno.
  • ContextLa clase en sí se declara como abstracta, cuya implementación la proporciona el sistema operativo Android.
  • Contextes como el control remoto de un televisor y los canales en el televisor son recursos, servicios, etc. ingrese la descripción de la imagen aquí

Qué puedes hacer con eso ?

  • Cargando recurso.
  • Lanzamiento de una nueva actividad.
  • Creación de vistas.
  • Obtención de servicio del sistema.

Formas de obtener contexto:

  • getApplicationContext()
  • getContext()
  • getBaseContext()ingrese la descripción de la imagen aquíingrese la descripción de la imagen aquí

Simplemente poniéndolo a disposición de los novatos;

Así que primero entienda el contexto de la palabra:

En inglés-lib. significa:

"The circumstances that form the setting for an event, statement, or idea, and in terms of which it can be fully understood and assessed."

"The parts of something written or spoken that immediately precede and follow a word or passage and clarify its meaning."

Ahora lleve la misma comprensión al mundo de la programación:

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

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 la 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 del sistema subyacente y ciertos recursos permitidos. Necesitas 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.Contextproporciona 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.

Actividades y Servicios amplían la Contextclase.

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

Contextpermite el acceso a recursos y clases específicos de la aplicación, así como llamadas para operaciones a nivel de la aplicación, comolaunching 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 son instancias de la clase android.content.Context que 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 brinda 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 Contexto. Por lo tanto, pueden usarse directamente para acceder al Contexto.

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 la fuga 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 del 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 Contexto.

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

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 por 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.

El contexto significa que Android sabe en qué actividad debo realizar o actuar.

1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); se utiliza en este. 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. Esto es más rápido que getContext y getApplicatinContext.

Analogía del asistente del jefe

Hagamos una pequeña analogía antes de profundizar en el tecnicismo de Contexto

Every Boss has an assistant or someone( errand boy) who does less important and more time-consuming things for him. For example, if they need a file or coffee then an assistant will be on run. Boss will not know what is going on in the background but the file or the task will be delivered

So Here
Boss - Android Application
Assistant - Context
File or cup of coffee - Resource

Lo que dice el sitio oficial de desarrolladores de Android sobre Context

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

Veamos algunos de tales recursos o tareas

  • Lanzamiento de 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 está permitido para un proceso e ID de usuario en particular que se ejecutan en el sistema.

  • Comprobación de si se le ha concedido un permiso en particular.

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

Como cualquier otra clase , la Contextclase tiene campos y métodos.
Puede explorar más Contexten la documentación oficial, cubre casi todo, métodos disponibles, campos e incluso cómo usar campos con métodos.

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

Los Android Contextson:

  • Dios-objetos.

  • Algo que desea pasar por todas sus aplicaciones 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 fugas de memoria.

    • PITA para pruebas.

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

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 brinda 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 Contexto. Por lo tanto, pueden usarse directamente para acceder al Contexto.

El contexto es la API específica de Android para cada Sandbox de la aplicación 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 y oyentes de una aplicación.

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

El contexto es una clase abstracta proporcionada por Android y, como tal, su trabajo es unir el código de su aplicación con el sistema Android . A través de clases que heredan de Contexto (actividades, servicios y su aplicación), su aplicación obtiene la capacidad de acceder a recursos y funcionalidades a las que solo puede acceder el sistema operativo.

Cuando el sistema operativo crea una instancia de los objetos descendientes del contexto (a través de un mecanismo de creación de instancias controlado por el sistema operativo, como "intentos") , el sistema operativo los administra y, como tales, obtienen un ciclo de vida.

Para cualquier otra cosa, pasar un contexto como parámetro en las llamadas a métodos permite que este método use el contexto como un canal de comunicación con el sistema operativo, para llegar al sistema operativo y pedirle que realice alguna acción o devuelva algún recurso.

Visualizando el Contexto junto con el Manifiesto

ingrese la descripción de la imagen aquí

Para visualizar el Contexto y el Manifiesto de Android en acción, la centralita de un antiguo centro de llamadas es una gran analogía.

La base es el sistema Android, donde emergen todos los cables que conectan todos los componentes de la aplicación de cada aplicación en ejecución.

  1. Cada "aplicación de panel de control" contiene algunos desagües, que representan las declaraciones de los componentes del manifiesto de la aplicación. Entonces, a través de declaraciones de manifiesto, el sistema Android aprende sobre la existencia de estos desagües para que pueda conectar un nuevo cable de contexto creando objetos a través de intentos.

  2. Cada cable representa un contexto de Android conectado a algún componente ejecutable de la aplicación o a la propia aplicación. Puede usar un cable existente, ya que está conectado con el sistema Android, para solicitar todo tipo de cosas que deben pasar por el sistema operativo para que se realicen.

  3. Puede suponer que cuando se destruye una actividad, su cable se desconecta. Mientras que cuando se construye otra actividad (u otro componente), emerge un nuevo cable y se conecta al desagüe declarado en el manifiesto correcto.

He escrito un artículo completo que explica cómo Context acopla su aplicación al sistema Android :

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

Context < ContextWrapper < Application

Context < ContextWrapper < ContextThemeWrapper < Activity

Context < ContextWrapper < ContextThemeWrapper < Activity < ListActivity

Context < ContextWrapper < Service

Context < ContextWrapper < Service < IntentService

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

Explico la diferencia en los contextos aquí .

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 momento determinado. Los Contextcomponentes de la aplicación siguen cambiando según el ciclo de vida subyacente de los componentes o la aplicación. Por ejemplo, dentro de onCreate() de un Activity,

getBaseContext()-- da el contextde Activityque es establecido (creado) por el constructor de la actividad. getApplicationContext()-- proporciona 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 llama getApplicationContext()desde el interior de cualquier componente, está llamando al contexto común de toda la aplicación.

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

Piense en Contexto como una caja con diferentes recursos: cadenas, colores y fuentes. Si necesitas algún recurso, recurres a este recuadro. Cuando gira la pantalla, este cuadro cambia porque la orientación cambia a horizontal.

para obtener más detalles sobre el contexto, lea este artículo. Lo explicaré brevemente.

Si quiere saber qué es el contexto, debe saber qué hace...
por ejemplo , getContext() es uno de los métodos que recuperan el contexto. En getContext(), el contexto está vinculado a una actividad y su ciclo de vida. Podemos imaginar el contexto como una capa que se encuentra detrás de la actividad y vivirá mientras viva la actividad. En el momento en que la Actividad muera, el Contexto también lo hará. este método da una lista de funcionalidades a la actividad, como:

Load Resource Values,
Layout Inflation,
Start an Activity,
Show a Dialog,
Start a Service,
Bind to a Service,
Send a Broadcast,
Register BroadcastReceiver.

ahora imagina que:

Context is a layer(interface) which stands behind its component (Activity, Application…) and component’s lifecycle, which provides access to various functionalities which are supported by application environment and Android framework.

¿Qué es Contextexactamente?

Per the Android reference documentation, it's an entity that represents various environment data. It provides access to local files, databases, class loaders associated to the environment, services (including system-level services), and more. Throughout this book, and in your day-to-day coding with Android, you'll see the Context passed around frequently.

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

Varias API de Android requieren un Contextparámetro as

Si observa las diversas 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 archivo Context. Esto funciona porque ambas clases se extienden desde Context.

 Contextsignifica actual. Contextuse para hacer la operación para la pantalla actual. ex.
  1. obtenerContextoAplicación()
  2. obtenerContexto()

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