En pocas palabras:

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(), getContext(), getBaseContext() or this (cuando en una clase que se extiende desde Context, como las clases Application, Activity, Service e IntentService).

Usos típicos del contexto:

• Creando nuevos objetos: Creación de nuevas vistas, adaptadores, oyentes:

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

• Acceder a recursos comunes estándar: Servicios como LAYOUT_INFLATER_SERVICE, SharedPreferences:

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

• Accediendo a componentes implícitamente: En cuanto a proveedores de contenido, retransmisiones, intención

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

Definición de contexto

• El contexto representa datos ambientales
• Proporciona acceso a cosas como bases de datos.

Términos más simples (ejemplo 1)

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

• Hay un arquitecto líder presente en la empresa, este arquitecto líder hace todo el trabajo en la empresa que involucra, 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 en función de las habilidades de la nueva persona que si trabajará 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 le gustan durante el tiempo de estadía. ¿Cómo consigues estas cosas?

• Le pide a la persona del servicio de habitaciones que le traiga estas cosas.

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

Las cosas que involucran el contexto son:

1. Cargando un recurso.
2. Lanzamiento de una nueva actividad.
3. Creando vistas.
4. obtención del servicio del sistema.

El contexto es la clase base para Actividad, Servicio, Solicitud, Etc.

Otra forma de describir esto: considere el contexto como remoto de un televisor y los canales en el televisor son recursos, servicios, intenciones de uso, etc. - - - Aquí el control remoto actúa como un acceso para obtener acceso a todos los diferentes recursos en primer plano.

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

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

Diferentes métodos mediante los cuales puede obtener contexto.

• getApplicationContext()
• getContext()
• getBaseContext()
• or this (cuando en la clase de actividad)

Ejemplo:

TextView tv = new TextView(this);

La palabra clave this se refiere 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 intentar 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 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 el contexto?

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

La clase Context en sí se declara como una clase abstracta, cuya implementación es proporcionada por el sistema operativo Android. La documentación proporciona además que Contexto "... 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, transmisión y recepción de intenciones, etc.".

Ahora puede comprender muy bien 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, 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, 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 ellos permiten que quien tenga acceso al contexto pueda acceder a los recursos de toda la aplicación.

El contexto, en otras palabras, enlaza el componente que tiene una referencia al resto del entorno de la aplicación. Los activos (piense en la carpeta '/ activos' de 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 va para getResources() que nos permite hacer cosas como getResources().getColor() que te enganchará en el colors.xml resource (no importa que aapt habilite el acceso a los recursos a través del código java, ese es un problema aparte).

El resultado es que Context es lo que permite el acceso a los recursos del sistema y es lo que enlaza los componentes en la "gran aplicación". Veamos las subclases de Context, las clases que proporcionan la implementación del resumen Context clase. La clase más obvia es la Activity clase. Activity hereda de ContextThemeWrapper, que hereda de ContextWrapper, que hereda de Context sí mismo. Es útil mirar esas clases 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 parecen. Implementan los elementos abstractos de la Context clase en sí misma "envolviendo" un contexto (el contexto real) y delegando esas funciones a ese contexto. Un ejemplo es útil: en el ContextWrapper clase, el método abstracto getAssets del desplegable Context La clase se implementa de la siguiente manera:

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

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

Probablemente sepa qué es una actividad, pero para revisar, 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 que estén familiarizados con otras API e incluso los que no son desarrolladores pueden pensar en ella como una "pantalla". Eso es técnicamente inexacto, pero no importa para nuestros propósitos. Entonces, ¿cómo Activity y Context interactuar y qué sucede exactamente 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 cual está iniciando la Actividad, simplemente llame 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 familiar startActivity(this, SomeOtherActivity.class).

Y lo que es this? this es tu actividad porque el Activity la clase hereda de Context. La primicia completa es así: Cuando llamas startActivity, en última instancia el Activity class ejecuta algo como esto:

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

Entonces utiliza el execStartActivity del desplegable Instrumentation clase (en realidad de una clase interna en Instrumentation , que son ActivityResult).

En este punto, estamos empezando a echar un vistazo a los componentes internos del sistema.

Aquí es donde el sistema operativo realmente maneja todo. Entonces, ¿cómo inicia Instrumentación la actividad exactamente? Bueno, el param this en el capítulo respecto a la execStartActivity El método anterior es su actividad, es decir, el contexto, y el execStartActivity hace uso de este contexto.

Una descripción general de 30,000 es la siguiente: la clase de Instrumentación mantiene un registro 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 completamente y que coordinan los problemas de proceso y subproceso. En última instancia, el ActivityResult usa una operación nativa - ActivityManagerNative.getDefault().startActivity() que utiliza el Context que pasaste cuando llamaste startActivity. El contexto que pasó se utiliza para ayudar en la "resolución de intenciones" si es necesario. La resolución de intenciones 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 acceder a la información proporcionada por Context. Específicamente, el sistema necesita acceder a un ContentResolver para que pueda "determinar el tipo MIME de los datos de la intención". Todo esto sobre cómo startActivity Hace uso del contexto fue un poco complicado y yo mismo no entiendo completamente los aspectos internos. Mi 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. Context es lo que proporciona acceso a estos recursos. Un ejemplo más simple podría ser Vistas. Todos sabemos lo que crea una Vista personalizada al extender RelativeLayout o alguna otra View clase, debe proporcionar un constructor que tome una 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 la Vista. Ver la configuración es en realidad un gran ejemplo. Cada contexto tiene varios parámetros (campos en Contextimplementaciones) que establece el propio sistema operativo para aspectos 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 que son nuevas en Android (e incluso las que no son 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. Mi punto real, sin embargo, aunque “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 "tienes" el contexto dentro de tu Actividad porque tu actividad en sí misma hereda del Contexto. No tiene nada de mágico (excepto por todas las cosas que el sistema operativo hace por sí mismo para establecer varios parámetros y "configurar" correctamente su contexto). Por lo tanto, dejando de 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 como cualquier POJO (Objeto simple de Java antiguo). 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 Object 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 lo use en esa clase según sea necesario. Esto no pretendía ser un tratamiento exhaustivo sobre el contexto o los componentes internos de Android, pero espero que sea útil para desmitificar un poco el contexto.

Un contexto es un identificador del sistema; proporciona servicios como la resolución de recursos, la obtención de 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 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.

Context es una "interfaz" para la información global sobre un entorno de aplicación. En la práctica, Context es en realidad un 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 llamadas ascendentes para operaciones a nivel de la aplicación, como actividades de lanzamiento, transmisión y recepción de intents, etc.

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

Qué está haciendo Context ¿exactamente?

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

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

Varias API de Android requieren un Context como parámetro

Si observa las distintas API de Android, notará que muchas de ellas toman un android.content.Context objeto como parámetro. También verá que una actividad o un servicio se suele utilizar como Context. Esto funciona porque ambas clases se extienden desde Context.

Ejemplo simple de entender context en android:

Cada jefe tiene un asistente del que cuidar, para hacer todas las tareas menos importantes y que requieren más tiempo. Si se necesita una lima o una taza de café, un asistente está huyendo. 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,

Jefe - es la aplicación de Android

Asistente - es un contexto

Archivos / Taza de café - son recursos

Por lo general, 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
• Creando vistas dinámicas
• Visualización de mensajes de tostadas
• Actividades de lanzamiento, etc.

Diferentes formas de obtener contexto:

getContext()

getBaseContext()

getApplicationContext()

this

Un androide Contexto es un 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í).

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

• Context representa un identificador para obtener datos del entorno.
• Context la propia clase 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.
• Lanzamiento de una nueva actividad.
• Creando vistas.
• Obtención del servicio del sistema.

Maneras de obtener contexto:

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

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

Entonces, primero comprenda el contexto de la palabra:

En inglés-lib. significa:

"Las circunstancias que forman el escenario de un evento, declaración o idea, y en términos de las cuales se puede entender y evaluar completamente"

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

Ahora lleve el mismo entendimiento 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() or this (cuando está en la clase de actividad).

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

Crear nueva clase AppContext dentro de su 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 máquina virtual 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. Necesita ese contexto para acceder a esos servicios.

El contexto es una referencia al objeto actual como este. Además, el contexto permite acceder 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 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.

Actividades y Servicios amplían el Context clase.

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

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

El contexto son 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 para 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 los servicios amplían la clase de contexto. Por lo tanto, se pueden utilizar 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 pérdida de memoria, debe usar el contexto de la aplicación para cada componente que necesite un objeto de contexto ... para más 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 está ejecutando la aplicación. El objeto de actividad hereda el objeto Context.

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

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 usó 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. Esto es más rápido que getContext y getApplicatinContext.

A Context es lo que la mayoría de nosotros llamaríamos Solicitud. Está hecho por el sistema Android y solo puede hacer lo que una aplicación puede hacer. 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 probablemente tengan razón, pero decir que un Contexto es su aplicación actual lo ayudará a comprender lo que está ingresando en los parámetros del método.

Poniendo androides simples Context es un desastre que no te encantará hasta que dejes de preocuparte.

Android Contexts son:

• Dios-objetos.

• Cosa que querrás pasar por toda tu aplicación cuando estés empezando a desarrollar para Android, pero evitarás hacerlo cuando te acerques un poco más a la programación, las pruebas y al 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 y aumentar el diseño. Y necesitas diferente Context instancias para algunas cosas separadas (obviamente, no puede mostrar un diálogo de una aplicación o contexto de servicio; los diseños inflados de contextos de aplicación y actividad pueden diferir).

Analogía del asistente de jefe

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

Cada jefe tiene un asistente o alguien (chico de los recados) que hace cosas menos importantes y que requieren más tiempo para él. Por ejemplo, si necesitan un archivo o un café, un asistente se pondrá en marcha. El jefe no sabrá lo que está sucediendo en segundo plano, pero se entregará el archivo o la tarea.

Así que aquí
Boss - Aplicación para Android
Asistente - Contexto
Archivo o taza de café - Recurso

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

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

Veamos algunos de estos 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 está permitido para un proceso en particular y la ID de usuario que se ejecuta en el sistema.

• Comprobando si se le ha concedido un permiso en particular.

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

Como cualquier otra clase Context la clase tiene campos y métodos.
Puede explorar más sobre Context en la documentación oficial, cubre prácticamente todo, métodos disponibles, campos e incluso cómo usar campos con 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 del dispositivo actual 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 servicios de Android, por ejemplo, el administrador de alarmas para activar eventos basados ​​en el tiempo.

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

El contexto es la api específica de Android para cada aplicación-s Salvadera 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 transmisión 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

Si quieres conectarte Contexto con otras clases familiares en Android, tenga en cuenta esta estructura:

Context <ContextWrapper <Aplicación

Context <ContextWrapper <ContextThemeWrapper <Actividad

Context <ContextWrapper <ContextThemeWrapper <Actividad <ListActivity

Context <ContextWrapper <Servicio

Contexto <ContextWrapper <Servicio <IntentService

Entonces, todas esas clases son contextos a su manera. Puedes emitir Servicio y ListaActividad a Contexto 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 la temática se aplicara a sus vistas, pero no le importa. Servicio clase, por ejemplo.

Explico la diferencia de contextos aquí.

Context significa componente (o aplicación) en varios períodos de tiempo. Si como tanta comida entre la 1 y las 2 pm, entonces 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) de un tiempo determinado. La Context de los componentes de la aplicación sigue 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 context de la Activity que es establecido (creado) por el constructor de actividad. getApplicationContext() - da el Context setup (creado) 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, cuando llamas getApplicationContext() desde el interior de cualquier componente, está 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 el contexto como una caja con diferentes recursos: cadenas, colores y fuentes. Si necesita un recurso, vaya a este cuadro. Cuando gira la pantalla, este cuadro cambia porque la orientación cambia a horizontal.

 Context significa corriente. Context utilizar para realizar la operación de la pantalla actual. ex.
  1. getApplicationContext ()
  2. getContext ()

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

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

Si quieres saber qué es el contexto, debes 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 está 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 proporciona una lista de funcionalidades para 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:

El contexto es una capa (interfaz) que se encuentra detrás de su componente (Actividad, Aplicación ...) y el ciclo de vida del componente, que proporciona acceso a varias funcionalidades que son compatibles con el entorno de la aplicación y el marco de Android.

En Java, decimos este palabra clave se refiere al estado del objeto actual de la aplicación.
De manera similar, en una alternativa tenemos Context en Desarrollo de Android.

Esto se puede definir de forma explícita o implícita,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Este atributo declara con qué actividad está asociado este diseño por defecto.