Diferencia entre getContext(), getApplicationContext(), getBaseContext() y "este"

Question

¿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, da algunos ejemplos fáciles si es posible.

Answer 1

• View.getContext(): Devuelve el contexto de la vista se está ejecutando actualmente en lo general, la actividad activa en ese momento..

• Activity.getApplicationContext(): Devuelve el contexto para toda la aplicación (el proceso en el que se ejecutan todas las actividades dentro de de). Use esto en lugar del contexto de actividad actual si necesita un contexto relacionado con el ciclo de vida de la aplicación completa, no solo con la actividad actual .

• ContextWrapper.getBaseContext(): Si necesita acceder a un Contexto desde otro contexto, usa ContextWrapper. El contexto al que se hace referencia desde dentro de ContextWrapper se accede a través de getBaseContext().

Answer 2

Context proporciona información sobre el ActvityApplication o de componentes de nueva creación.

Relevante Context debe proporcionarse a los componentes de nueva creación (ya sea contexto de aplicación o de contexto de actividad)

Desde Activity es una subclase de Context, se puede utilizar this para obtener el contexto de que la actividad

Answer 3

getApplicationContext() - Devuelve el contexto de todas las actividades que se ejecutan en la aplicación.

getBaseContext() - Si desea acceder a Context desde otro contexto dentro de la aplicación puede acceder.

getContext() - Devuelve la vista de contexto solo la actividad de ejecución actual.

Answer 4

De esta docs

Me entiende que se debe utilizar:

intente utilizar el contexto de la aplicación en lugar de un contexto de la actividad

Answer 5

mayoría de las respuestas ya cubren getContext() y getApplicationContext() pero getBaseContext() rara vez se explica.

El método getBaseContext() solo es relevante cuando tiene un ContextWrapper. Android proporciona una clase ContextWrapper que se crea en torno a un Context existente mediante:

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 continuación, puede crear un View con un tema diferente que myActivity:

ContextWrapper customTheme = new ContextWrapper(myActivity) { 
    @Override 
    public Resources.Theme getTheme() { 
    return someTheme; 
    } 
} 
View myView = new MyView(customTheme); 

ContextWrapper es realmente de gran alcance, ya que le permite anular la mayoría de las funciones proporcionadas por Context incluyendo 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 resolver las ubicaciones del sistema de archivos (por ejemplo, getFilesDir()). ContextWrapper es realmente útil para evitar problemas específicos de dispositivos/versiones o para aplicar personalizaciones únicas a componentes como Vistas que requieren un contexto.

El método getBaseContext() se puede utilizar para acceder al contexto "base" que se ajusta al ContextWrapper. Es posible que necesite acceder al contexto “base”, si es necesario, por ejemplo, comprobar 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 es necesario llamar a la versión de “envolver” de un método:

class MyCustomWrapper extends ContextWrapper { 
    @Override 
    public Drawable getWallpaper() { 
    if (BuildInfo.DEBUG) { 
     return mDebugBackground; 
    } else { 
     return getBaseContext().getWallpaper(); 
    } 
    } 
} 

Answer 6

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 de Dios Objeto anti-patrón en la producción.

Cuando se trata de qué tipo de Context debemos usar, se hace muy complicado porque a excepción de ser Dios objetos, el árbol de jerarquía de Context subclases viola principio de sustitución de liskov brutalmente.

This blog post intenta resumir la aplicabilidad de las clases Context en diferentes situaciones.

Déjame copiar la tabla principal de ese cargo por la totalidad:

+----------------------------+-------------+----------+---------+-----------------+-------------------+ 
|       | 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    | 
+----------------------------+-------------+----------+---------+-----------------+-------------------+ 

1. una aplicación puede iniciar una actividad de aquí, pero requiere que se cree una nueva tarea. Esto puede adaptarse a casos de uso específicos, pero puede crear comportamientos de backstack no estándar en su aplicación y generalmente no se recomienda ni se considera una buena práctica.
2. Esto es legal, pero la inflación se realizará con el tema predeterminado para el sistema en el que se está ejecutando, no lo que está definido en su aplicación.
3. 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.

— screenshot

Answer 7

getApplicationContext()

esto se utiliza para el nivel de aplicación y se refiere a todas las actividades.

getContext() y getBaseContext()

es muy probablemente mismas .these están reffered única actividad actual, que es en vivo.

este

es referir objeto de la clase actual siempre.