Unterschied zwischen getContext() , getApplicationContext() , getBaseContext() und “this”

Was ist der Unterschied zwischen getContext() , getApplicationContext() , getBaseContext() und “this“?

Obwohl dies eine einfache Frage ist, kann ich den grundlegenden Unterschied zwischen ihnen nicht verstehen. Bitte geben Sie, wenn möglich, einige einfache Beispiele.

• View.getContext(): Gibt den Kontext zurück, in dem die Ansicht derzeit ausgeführt wird. Normalerweise die derzeit aktive Aktivität.

• Activity.getApplicationContext(): Gibt den Kontext für die gesamte Anwendung zurück (den Prozess, in dem alle Aktivitäten ausgeführt werden). Verwenden Sie dies anstelle des aktuellen Aktivitätskontexts, wenn Sie einen Kontext benötigen, der an den Lebenszyklus der gesamten Anwendung und nicht nur an die aktuelle Aktivität gebunden ist.

• ContextWrapper.getBaseContext(): Wenn Sie Zugriff auf einen Kontext aus einem anderen Kontext heraus benötigen, verwenden Sie einen ContextWrapper. Auf den Kontext, auf den innerhalb dieses ContextWrappers verwiesen wird, wird über getBaseContext() zugegriffen.

Die meisten Antworten decken bereits ab getContext() und getApplicationContext() aber getBaseContext() wird selten erklärt.

Die Methode getBaseContext() ist nur relevant, wenn Sie eine haben ContextWrapper. Android bietet eine ContextWrapper Klasse, die um eine vorhandene herum erstellt wird Context mit:

ContextWrapper wrapper = new ContextWrapper(context);

Der Vorteil der Verwendung von a ContextWrapper ist, dass Sie damit „das Verhalten ändern können, ohne den ursprünglichen Kontext zu ändern“. Zum Beispiel, wenn Sie eine Aktivität mit dem Namen haben myActivity dann kann ein erstellen View mit einem anderen Thema als myActivity:

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

ContextWrapper ist wirklich leistungsfähig, weil Sie damit die meisten Funktionen überschreiben können, die von bereitgestellt werden Context einschließlich Code für den Zugriff auf Ressourcen (z openFileInput(), getString()), interagieren mit anderen Komponenten (z sendBroadcast(), registerReceiver()), fordert Berechtigungen an (z checkCallingOrSelfPermission()) und das Auflösen von Dateisystemspeicherorten (z getFilesDir()). ContextWrapper ist wirklich nützlich, um geräte-/versionsspezifische Probleme zu umgehen oder um einmalige Anpassungen auf Komponenten wie Ansichten anzuwenden, die einen Kontext erfordern.

Die Methode getBaseContext() kann verwendet werden, um auf den „Basis“-Kontext zuzugreifen, den die ContextWrapper umschlingt. Möglicherweise müssen Sie auf den „Basis“-Kontext zugreifen, wenn Sie beispielsweise überprüfen müssen, ob es sich um eine Service, Activity oder 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");
    }
    ...
  }
}

Oder wenn Sie die „ausgepackte“ Version einer Methode aufrufen müssen:

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

Die Frage „What the Context is“ ist eine der schwierigsten Fragen im Android-Universum.

Kontext definiert Methoden, die auf Systemressourcen zugreifen, statische Assets der Anwendung abrufen, Berechtigungen prüfen, UI-Manipulationen durchführen und vieles mehr. Im Wesentlichen, Context ist ein Beispiel für God Object Anti-Pattern in der Produktion.

Wenn es um welche Art geht Context sollten wir verwenden, wird es sehr kompliziert, denn abgesehen davon, dass es Gottobjekt ist, ist der Hierarchiebaum von Context Unterklassen verletzt das Liskov-Substitutionsprinzip brutal.

Dieser Blogbeitrag (jetzt von Wayback Machine) versucht zusammenzufassen Context Klassen Anwendbarkeit in verschiedenen Situationen.

Lassen Sie mich der Vollständigkeit halber die Haupttabelle aus diesem Beitrag kopieren:

+----------------------------+-------------+----------+---------+-----------------+-------------------+
|                            | 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. Eine Anwendung KANN von hier aus eine Aktivität starten, erfordert jedoch, dass eine neue Aufgabe erstellt wird. Dies kann für bestimmte Anwendungsfälle geeignet sein, kann jedoch zu einem nicht standardmäßigen Backstack-Verhalten in Ihrer Anwendung führen und wird im Allgemeinen nicht empfohlen oder als bewährte Methode angesehen.
2. Dies ist legal, aber die Inflation wird mit dem Standarddesign für das System durchgeführt, auf dem Sie ausgeführt werden, und nicht mit dem, was in Ihrer Anwendung definiert ist.
3. Zulässig, wenn der Empfänger null ist, was zum Abrufen des aktuellen Werts einer Sticky-Übertragung unter Android 4.2 und höher verwendet wird.

getApplicationContext() – Gibt den Kontext für alle Aktivitäten zurück, die in der Anwendung ausgeführt werden.

getBaseContext() – Wenn Sie von einem anderen Kontext innerhalb der Anwendung auf Kontext zugreifen möchten, können Sie darauf zugreifen.

getContext() – Gibt in der Kontextansicht nur die aktuelle laufende Aktivität zurück.

Context gibt Auskunft über die Actvity oder Application zu neu erstellten Komponenten.

Relevant Context sollen neu erstellten Komponenten bereitgestellt werden (egal ob Anwendungskontext oder Aktivitätskontext)

Seit Activity ist eine Unterklasse von Contextkann man verwenden this um den Kontext dieser Aktivität zu erhalten

getApplicationContext()

dies wird für die Anwendungsebene verwendet und bezieht sich auf alle Aktivitäten.

getContext() und getBaseContext()

ist höchstwahrscheinlich gleich. Diese beziehen sich nur auf aktuelle Aktivitäten, die live sind.

Das

bezieht sich immer auf das aktuelle Klassenobjekt.

this: aktuelles Klassenobjekt

getContext(): Gibt den Kontext für die aktuelle Live-Aktivität zurück

getApplicationContext(): gibt alle Aktivitäten zurück, die in der Anwendung ausgeführt werden