start - intent bundle android
Diferencia entre getContext(), getApplicationContext(), getBaseContext() y "this" (8)
¿Cuál es la diferencia entre getContext() , getApplicationContext() , getBaseContext() y " this "?
Aunque esta es una pregunta simple, no puedo entender la diferencia básica entre ellos. Por favor dé algunos ejemplos fáciles si es posible.
getApplicationContext () : devuelve el contexto para todas las actividades que se ejecutan en la aplicación.
getBaseContext () : si desea acceder al contexto desde otro contexto dentro de la aplicación, puede acceder.
getContext () : devuelve la vista de contexto solo la actividad en ejecución actual.
De esta docs
Entendí que debes usar:
Trate de usar la aplicación de contexto en lugar de una actividad de contexto
La mayoría de las respuestas ya cubren getContext() y getApplicationContext() pero rara vez se explica getBaseContext () .
El método getBaseContext() solo es relevante cuando tienes un ContextWrapper . Android proporciona una clase ContextWrapper que se crea en torno a un Context existente utilizando:
ContextWrapper wrapper = new ContextWrapper(context);
La ventaja de utilizar un ContextWrapper es que le permite "modificar el comportamiento sin cambiar el contexto original". Por ejemplo, si tiene una actividad llamada myActivity , puede crear una View con un tema diferente al de myActivity :
ContextWrapper customTheme = new ContextWrapper(myActivity) {
@Override
public Resources.Theme getTheme() {
return someTheme;
}
}
View myView = new MyView(customTheme);
ContextWrapper es realmente poderoso porque le permite anular la mayoría de las funciones proporcionadas por Context incluido el código para acceder a los recursos (por ejemplo, openFileInput() , getString() ), interactuar con otros componentes (por ejemplo, sendBroadcast() , registerReceiver() ), solicitar permisos (por ejemplo, checkCallingOrSelfPermission() ) y resolviendo las ubicaciones del sistema de archivos (por ejemplo, getFilesDir() ). ContextWrapper es realmente útil para solucionar problemas específicos del dispositivo / versión o para aplicar personalizaciones ContextWrapper a componentes como las Vistas que requieren un contexto.
El método getBaseContext () se puede usar para acceder al contexto "base" que el ContextWrapper envuelve. Es posible que deba acceder al contexto "base" si necesita, por ejemplo, verificar si se trata de un Service , Activity o Application :
public class CustomToast {
public void makeText(Context context, int resId, int duration) {
while (context instanceof ContextWrapper) {
context = context.baseContext();
}
if (context instanceof Service)) {
throw new RuntimeException("Cannot call this from a service");
}
...
}
}
O si necesita llamar a la versión "desenvuelta" de un método:
class MyCustomWrapper extends ContextWrapper {
@Override
public Drawable getWallpaper() {
if (BuildInfo.DEBUG) {
return mDebugBackground;
} else {
return getBaseContext().getWallpaper();
}
}
}
La pregunta "cuál es el contexto" es una de las preguntas más difíciles en el universo de Android.
El contexto define los métodos que acceden a los recursos del sistema, recuperan los activos estáticos de la aplicación, verifican los permisos, realizan manipulaciones de la interfaz de usuario y muchos más. En esencia, Context es un ejemplo del anti-patrón de Dios Objeto en producción.
Cuando se trata de qué tipo de Context debemos usar, se vuelve muy complicado porque, excepto por ser un Objeto de Dios, el árbol jerárquico de las subclases de Context viola brutalmente el Principio de Sustitución de Liskov.
Esta publicación de blog intenta resumir la aplicabilidad de las clases de Context en diferentes situaciones.
Permítame copiar la tabla principal de esa publicación para completarla:
+----------------------------+-------------+----------+---------+-----------------+-------------------+ | | Application | Activity | Service | ContentProvider | BroadcastReceiver | +----------------------------+-------------+----------+---------+-----------------+-------------------+ | Show a Dialog | NO | YES | NO | NO | NO | | Start an Activity | NO¹ | YES | NO¹ | NO¹ | NO¹ | | Layout Inflation | NO² | YES | NO² | NO² | NO² | | Start a Service | YES | YES | YES | YES | YES | | Bind to a Service | YES | YES | YES | YES | NO | | Send a Broadcast | YES | YES | YES | YES | YES | | Register BroadcastReceiver | YES | YES | YES | YES | NO³ | | Load Resource Values | YES | YES | YES | YES | YES | +----------------------------+-------------+----------+---------+-----------------+-------------------+
- Una aplicación puede iniciar una actividad desde aquí, pero requiere que se cree una nueva tarea. Esto puede ajustarse a casos de uso específicos, pero puede crear comportamientos no estándar de la contraportada en su aplicación y generalmente no se recomienda o se considera una buena práctica.
- Esto es legal, pero la inflación se realizará con el tema predeterminado para el sistema en el que se está ejecutando, no con lo que se define en su aplicación.
- Se permite si el receptor es nulo, que se utiliza para obtener el valor actual de una emisión fija, en Android 4.2 y superior.
Context proporciona información sobre la Actvity o la Application a los componentes recién creados.
El Context relevante se debe proporcionar a los componentes recién creados (ya sea el contexto de la aplicación o el contexto de la actividad)
Dado que la Activity es una subclase de Context , uno puede usar this para obtener el contexto de esa actividad
getApplicationContext ()
Esto se usa para nivel de aplicación y se refiere a todas las actividades.
getContext () y getBaseContext ()
es muy probable que se refieran solo a la actividad actual que está en vivo.
esta
Se refiere siempre al objeto de la clase actual.
View.getContext(): devuelve el contexto en el que se está ejecutando actualmente la vista. Por lo general, la actividad actualmente activa.Activity.getApplicationContext(): devuelve el contexto para toda la aplicación (el proceso en el que se ejecutan todas las Actividades). Use esto en lugar del contexto de la Actividad actual si necesita un contexto vinculado al ciclo de vida de toda la aplicación, no solo la Actividad actual.ContextWrapper.getBaseContext(): si necesita acceder a un Contexto desde otro contexto, use un ContextWrapper. Se accede al Contexto al que se hace referencia desde dentro de ContextWrapper a través de getBaseContext ().