¿Qué es "Contexto" en Android?

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. Típicamente 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() o this (cuando se encuentra en una clase que se extiende desde Context , como las clases Application, Activity, Service e IntentService).

Usos típicos del contexto:

• Creación de nuevos objetos : Creación de 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 a componentes de forma implícita : Con respecto a los proveedores de contenido, emisiones, intenciones

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

Definición de Contexto ::

• Contexto representa datos de entorno
• Proporciona acceso a cosas tales como bases de datos

Términos más simples ::

• Considere Person-X es el CEO de una empresa de software de puesta en marcha.

• Hay un arquitecto líder presente en la empresa, este arquitecto líder hace todo el trabajo en la empresa que implica, como base de datos, 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 sobre la base de las habilidades de la nueva persona que si va a trabajar en la base de datos o la interfaz de usuario, etc

Términos más simples ::

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

• Es similar a cuando usted visita un hotel, quiere desayuno, almuerzo y cena en los horarios adecuados, ¿verdad?

• Hay muchas otras cosas que te gusta durante el tiempo de estancia. ¿Cómo obtienes estas cosas?

• Pida a la persona del servicio de habitaciones que traiga estas cosas para usted.

• Aquí la persona de servicio de habitación es el contexto teniendo en cuenta que son la actividad individual y el hotel para ser su aplicación, por último el desayuno, el almuerzo y la cena tienen que ser los recursos.

Las cosas que involucran el contexto son:

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

Contexto es la clase base para Actividad , Servicio , Aplicación , etc.

Otra manera de describir esto: Considerar el contexto como remoto de una televisión y canal en la televisión son recursos, servicios, etc intenta intentar – – – Aquí el control remoto actúa como un acceso para tener acceso a todos los diferentes recursos en primer plano.

• Así que, Remote tiene acceso a canales como recursos, servicios, intentos, etc ….
• Del mismo modo ….. Quien tiene acceso al control remoto, naturalmente, tiene acceso a todas las cosas, tales como recursos, servicios, etc intentos, etc

Diferentes métodos de invocación por los que puede obtener contexto

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

Ejemplo:

 TextView TV=new TextView(this); 

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

Fuente

El tema de Contexto en Android parece ser confuso demasiado. La gente sólo sabe que el contexto es necesario con bastante frecuencia para hacer cosas básicas en Android. A veces las personas se asustan porque tratan de 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 de la cuestión está más allá del alcance de este post, pero voy a tratar de dar una visión general para que tenga una idea de lo que es el Contexto y cómo usarlo. Para entender lo que es Contexto, echemos un vistazo al código fuente:

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

¿Qué es exactamente Contexto?

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

La clase Context se declara como clase abstracta, cuya implementación es proporcionada por el sistema operativo Android. La documentación establece además que Context "… permite el acceso a recursos y clases específicos de aplicaciones, así como up-calls para operaciones a nivel de aplicación tales como actividades de lanzamiento, difusión y recepción de intentos, etc".

Usted puede entender muy bien, ahora, por qué el nombre es Contexto. Es porque es sólo eso. El Contexto proporciona el enlace o el gancho, si lo desea, para una Actividad, Servicio o cualquier otro componente, vinculándolo con el sistema, permitiendo el acceso al entorno global de la aplicación. En otras palabras: el contexto proporciona la respuesta a la pregunta de los componentes de "¿dónde demonios estoy en relación con la aplicación en general y cómo puedo acceder / comunicarse con el resto de la aplicación?" Si todo esto parece un poco confuso, un rápido Mirar los métodos expuestos por la clase Context proporciona algunas pistas más sobre su verdadera naturaleza.

Aquí hay un muestreo aleatorio 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 tener acceso a recursos de toda la aplicación.

Contexto, en otras palabras, engancha el componente que tiene una referencia a él al resto del entorno de aplicación. Los activos (carpeta 'think' / assets 'en su proyecto), por ejemplo, están disponibles en toda la aplicación, siempre que una actividad, un servicio o cualquier otra cosa sepa cómo acceder a esos recursos. Lo mismo sucede con getResources() que permite hacer cosas como getResources().getColor() que te conectará al recurso colors.xml (nunca importa que aapt permita el acceso a recursos vía código java, es un problema aparte).

El resultado es que Context es lo que permite el acceso a los recursos del sistema y lo que engancha a los componentes en la "aplicación más grande." Veamos las subclases de Context , las clases que proporcionan la implementación de la clase de Context abstracto. Activity hereda de ContextThemeWrapper , que hereda de ContextWrapper , que hereda de Context ContextWrapper clases son útiles para mirar para entender 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 Un ejemplo, es útil – en la clase ContextWrapper , el método abstracto getAssets de la clase Context Se implementa de la siguiente manera:

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

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

Usted probablemente sabe lo que es una actividad, pero para revisar – es básicamente "una sola cosa que el usuario puede hacer. Se ocupa de proporcionar una ventana en la que colocar la interfaz de usuario con la que el usuario interactúa ". Los desarrolladores que estén familiarizados con otras API e incluso con no desarrolladores podrían pensar en ello en forma vernácula como una "pantalla". Eso es técnicamente inexacto, pero no importa para nuestros propósitos. Entonces, ¿cómo interactúan la Activity y el Context y qué es exactamente lo que va 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 cual está iniciando la Actividad, simplemente llame a startActivity(intent) , donde el Intent describe el contexto desde el que inicia una Actividad y la Actividad que desea iniciar. Esta es la startActivity(this, SomeOtherActivity.class) familiar startActivity(this, SomeOtherActivity.class) .

¿Y qué es this ? this es su Actividad porque la clase Activity hereda de Context . La cucharada completa es así: Cuando llama a startActivity , en última instancia, la clase Activity ejecuta algo como esto:

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

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

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

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

Una visión general de 30.000 es la siguiente: la clase Instrumentation mantiene pistas de una lista de Actividades que está monitoreando para realizar su trabajo. Esta lista se utiliza para coordinar todas las actividades y asegurarse de que todo se ejecute sin problemas en la gestión del flujo de actividades.

Hay algunas operaciones que no he examinado completamente en qué tema de coordenadas y problemas de proceso. En última instancia, ActivityResult utiliza una operación nativa – ActivityManagerNative.getDefault().startActivity() que utiliza el Context que pasó cuando llamó startActivity . El contexto en el que pasaste es usado para ayudar en la "resolución intencional" 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 suministra. (Consulte la guía aquí para más detalles).

Y para que Android lo haga, necesita acceso a la información que es suministrada por Context . Específicamente, el sistema necesita tener acceso a un ContentResolver para que pueda "determinar el tipo MIME de los datos de la intención." Todo este bit sobre cómo startActivity hace uso del contexto fue un poco complicado y no entiendo completamente los internos. El punto principal fue sólo para ilustrar cómo los recursos de toda la aplicación deben ser accedidos con el fin de realizar muchas de las operaciones que son esenciales para una aplicación.El Context es lo que proporciona acceso a estos recursos.Un ejemplo más simple podría ser Vistas.Todos sabemos qué Crear una vista personalizada extendiendo RelativeLayout o alguna otra clase de View , debe proporcionar un constructor que tome un Context como un argumento.Al instanciar su vista personalizada pasar en el contexto.Por qué? Debido a que la vista debe ser capaz de tener Acceso a los temas, recursos y otros detalles de la configuración Ver. La configuración de la vista es realmente un gran ejemplo Cada Contexto tiene varios parámetros (campos en las implementaciones de Context ) que son establecidos por el propio sistema operativo para Cosas como la dimensión o densidad de la pantalla. Es fácil ver por qué esta información es importante para configurar Vistas, etc.

Una última palabra: Por alguna razón, la gente nueva en Android (e incluso gente no tan nueva) parece olvidarse completamente de la programación orientada a objetos cuando se trata de Android. Por alguna razón, la gente intenta doblar su desarrollo de Android a paradigmas pre-concebidos o comportamientos aprendidos.

Android tiene su propio paradigma y un cierto patrón que es realmente bastante consistente si deja de lado sus nociones preconcebidas y simplemente lee la documentación y la guía del dev. Mi punto real, sin embargo, mientras que "conseguir el contexto adecuado" a veces puede ser difícil, la gente injustamente pánico porque se encuentran con una situación en la que necesitan el contexto y creen que no lo tienen. Una vez más, Java es un lenguaje orientado a objetos con un diseño de herencia.

Sólo "tiene" el contexto dentro de su Actividad porque su propia actividad hereda de Contexto. No hay magia (a excepción de todas las cosas que el sistema operativo hace por sí mismo para establecer varios parámetros y para "configurar" correctamente su contexto). Así, dejando de lado los problemas de memoria / rendimiento (por ejemplo, mantener referencias al contexto cuando no lo necesitas o hacerlo de una manera que tenga consecuencias negativas en la memoria, etc.), Contexto es un objeto como cualquier otro y se puede pasar alrededor Al igual que cualquier POJO (Plain Old Java Object). A veces es posible que necesites hacer cosas inteligentes para recuperar ese contexto, pero cualquier clase Java normal que se extienda desde nada más que Objeto mismo 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 en Contexto o Android, pero espero que sea útil para desmitificar Contexto un poco.

Un contexto es un identificador para el 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. Es como un identificador para el entorno en el que se ejecuta 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 .

Siempre y cuando su va a estar pensando de todos modos, pensar en grande.

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

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

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

¿Cuál es el contexto exactamente? Según la documentación de referencia de Android, es una entidad que representa varios datos de entorno. Proporciona acceso a archivos locales, bases de datos, cargadores de clases asociados al entorno, servicios que incluyen servicios a nivel de sistema y más. A lo largo de este libro, y en su codificación cotidiana con Android, verá que el Contexto pasa con frecuencia. De: "Android en la práctica" libro.

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

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

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

Ejemplo simple para entender el context en android:

Cada jefe tiene un asistente para cuidar, hacer todas las tareas menos importantes y que consumen mucho tiempo. Si un archivo o una taza de café es necesario, el ayudante está en la carrera. Algunos jefes apenas saben lo que está pasando en la oficina, así que preguntan a sus asistentes sobre esto también. Ellos hacen un poco de trabajo ellos mismos, pero para la mayoría de otras cosas que necesitan ayuda de sus asistentes.

En este escenario,

Boss – es la aplicación de Android

Asistente – es el contexto

Archivos / taza de café – son recursos

Generalmente llamamos al contexto cuando necesitamos obtener información sobre diferentes partes de nuestra aplicación como Actividades, Aplicaciones, etc.

Algunas operaciones (las cosas donde el asistente es necesario) donde el contexto está involucrado:

Carga de 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 

Piense en ello como la máquina virtual que ha siled el proceso de la aplicación o servicio se está ejecutando pulg El entorno de siled tiene acceso a un montón de información del sistema subyacente y ciertos recursos permitidos. Necesitas ese contexto para obtener esos servicios.

Simplemente poniéndolo ahí para principiantes;

Así que primero entiendo 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 los cuales puede ser plenamente comprendido y evaluado".

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

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

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

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

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

Crea una nueva clase AppContext dentro de tu aplicación 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 que no sea de actividad, llame a este método y tendrá contexto de aplicación.

Espero que esto ayude 😉

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.

• Contexto representa un identificador para obtener datos del entorno.
• La clase Context se declara como abstracta, cuya implementación es proporcionada por el sistema operativo android.
• El contexto es como remoto de una TV y canal en la televisión son recursos, servicios, etc.

Qué puedes hacer con eso ?

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

Formas de obtener el contexto:

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

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

El Contexto también proporciona acceso a Servicios de Android, por ejemplo, el Servicio de ubicación.

Actividades y servicios amplían la clase Context .

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

Con el fin de evitar fugas de memoria que debe utilizar el contexto de la aplicación para todos los componentes que necesita un objeto de contexto …. para más haga clic aquí

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

Contexto es el contexto del estado actual de la aplicación / objeto. Es una entidad que representa varios datos de entorno. El contexto ayuda a la actividad actual a interactuar con el entorno android lateral, 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 la resolución de recursos, la obtención de acceso a bases de datos y preferencias, etc. Una aplicación para Android tiene actividades. Es como un identificador para el entorno en el que se ejecuta su aplicación. El objeto de actividad hereda el objeto Contexto.

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

Contexto es Instancias de la clase android.content.Context proporciona la conexión al sistema Android que ejecuta la aplicación. Por ejemplo, puede comprobar 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 obtener 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 los servicios amplían la clase Context. Por lo tanto, pueden ser utilizados directamente para acceder al Contexto.

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 sistema Android .

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

Aquí está el 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 información, puede visitar http://developer.android.com/reference/android/content/Context.html

Instancias de la clase android.content.Context proporcionan la conexión al sistema Android que ejecuta la aplicación. Por ejemplo, puede comprobar 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 obtener 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 los servicios amplían la clase Context. Por lo tanto, pueden ser utilizados directamente para acceder al Contexto.

Un Context es lo que la mayoría de nosotros llamaría Aplicación . Es hecho por el sistema Android y es capaz de hacer sólo lo que una aplicación es capaz de 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 tienen razón, pero decir que un Contexto es su aplicación actual le ayudará a entender lo que está poniendo en los parámetros del método.

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

Contexto <ContextWrapper <Aplicación

Contexto <ContextWrapper <ContextThemeWrapper <Actividad

Contexto <ContextWrapper <ContextThemeWrapper <Actividad <ListActivity

Contexto <ContextWrapper <Servicio

Contexto <ContextWrapper <Servicio <IntentService

Por lo tanto, todas esas clases son contextos a su manera. Puede enviar Servicio y ListActivity a Contexto si lo desea. Pero si miras de cerca, algunas de las clases heredan el tema también. En actividad o fragmento, le gustaría que el tema se aplicara a sus puntos de vista, pero no le importa . Clase de servicio , por ejemplo.

Explico la diferencia en contextos aquí .

El Contexto es el api específico de Android de Sandbox de cada aplicación que proporciona datos privados de aplicaciones de acceso como a recursos, bases de datos, archivos privados, preferencias, configuraciones …

La mayoría de los privatedata son los mismos para todas las actividades / servicios / broadcastlisteners de una aplicación.

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

Contexto significa corriente. Uso del contexto para hacer la operación para la pantalla actual. ex. 1.getApplicationContext () 2.getContext ()

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

Contexto es el contexto del estado actual de la aplicación / objeto. Es una entidad que representa varios datos de entorno. El contexto ayuda a la actividad actual a interactuar con el entorno android lateral, 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 para el sistema. Proporciona servicios como la resolución de recursos, la obtención de acceso a bases de datos y preferencias, etc. Una aplicación para Android tiene actividades. Es como un identificador para el entorno en el que se ejecuta su aplicación. El objeto de actividad hereda el objeto Contexto. Ejemplos para usos del contexto:

1. Creación de nuevos objetos: Creación de nuevas vistas, adaptadores, oyentes

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

2. Accessing Standard Common Resources: Services like LAYOUT_INFLATER_SERVICE, SharedPreferences:

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

3. Accessing Components Implicitly: Regarding content providers, broadcasts, intent

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

Difference between Activity Context and Application Context:

They are both instances of Context, but the application instance is tied to the lifecycle of the application, while the Activity instance is tied to the lifecycle of an Activity. Thus, they have access to different information about the application environment.

If you read the docs at getApplicationContext it notes that you should only use this if you need a context whose lifecycle is separate from the current context.

But in general, use the activity context unless you have a good reason not to.

Need of Context :

The documentation says that every view needs the context to access the right resources (eg the theme, strings etc.).

But why in the constructor and not through setContentView(View)?

1.Because the resources must be accessible while the view is being constructed (the constructor will need some resources to fully initialise the view).

2.This allows the flexibility of using a context that is different from the one of the current activity (imagine a view that uses some other string resources and not the ones from the current activity).

3.The designers of the Android SDK seem to have chosen that the context must be set only once and then stay the same throughout the lifetime of the view. Why context is not determined automatically at construction point?

1.Because there exists no static variable that would tell you the current global context of your application. The method getApplicationContext() is the closest to this, but it's not static, so you need an instance of the Activity object to call it.

2.The Java language provides an option to look through the call stack and find whether the View has been constructed in a Context class. But what if there are many? Or what if there are none? This method is very expensive and error prone. So the designers of the API decided that a context must be manually provided.

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

Android Context s are:

• God-objects.

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

  • Unclear dependency.

  • Common source of memory leaks.

  • PITA for testing.

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

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

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

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

This can be defined either explicitly or implicitly,

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