No busques más por todo internet ya que has llegado al lugar justo, contamos con la respuesta que necesitas hallar pero sin complicaciones.
Solución:
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() o this (cuando en una clase que se extiende desde Context, como las clases Aplicación, Actividad, Servicio 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, transmisiones, 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:
- Cargando un recurso.
- Lanzamiento de una nueva actividad.
- Creando vistas.
- 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()- o
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 true naturaleza.
Aquí hay una muestra aleatoria de esos métodos:
getAssets()getResources()getPackageManager()getString()getSharedPrefsFile()
¿Qué tienen todos estos métodos en común? 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’ 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 va para getResources() que nos permite hacer cosas como getResources().getColor() que te enganchará en el colors.xml recurso (no importa que aapt permite el acceso a 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 del 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 desde el 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. Entonces 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 familiarizados con otras API e incluso los que no son desarrolladores pueden pensar en ella en forma vernácula 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, finalmente el Activity class ejecuta algo como esto:
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
Entonces utiliza el execStartActivity desde el Instrumentation clase (en realidad de una clase interna en Instrumentation llamado ActivityResult).
En este punto, estamos comenzando a echar un vistazo a las partes internas del sistema.
Aquí es donde el sistema operativo realmente maneja todo. Entonces, ¿cómo inicia Instrumentación la actividad exactamente? Bueno, el param this en el 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 usa 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é esto La 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). Entonces, 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í 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. 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.