Statischer Weg, um 'Kontext' in Android zu bekommen?

Gibt es eine Möglichkeit, die aktuelle ContextInstanz in eine statische Methode zu integrieren?

Ich suche nach diesem Weg, weil ich es hasse, die 'Context'-Instanz jedes Mal zu speichern, wenn sie sich ändert.

Mach das:

Deklarieren Sie in der Android Manifest-Datei Folgendes.

<application android:name="com.xyz.MyApplication">

</application>

Dann schreibe die Klasse:

public class MyApplication extends Application {

    private static Context context;

    public void onCreate() {
        super.onCreate();
        MyApplication.context = getApplicationContext();
    }

    public static Context getAppContext() {
        return MyApplication.context;
    }
}

Rufen MyApplication.getAppContext()Sie jetzt überall an, um Ihren Anwendungskontext statisch abzurufen.

Die meisten Apps, die eine bequeme Methode zum Abrufen des Anwendungskontexts wünschen, erstellen eine eigene Klasse, die erweitert wird android.app.Application.

LEITEN

Sie können dies erreichen, indem Sie zuerst eine Klasse in Ihrem Projekt wie folgt erstellen:

import android.app.Application;
import android.content.Context;

public class App extends Application {

    private static Application sApplication;

    public static Application getApplication() {
        return sApplication;
    }

    public static Context getContext() {
        return getApplication().getApplicationContext();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        sApplication = this;
    }
}

Dann sollten Sie in Ihrem AndroidManifest den Namen Ihrer Klasse im Tag von AndroidManifest.xml angeben:

<application 
    ...
    android:name="com.example.App" >
    ...
</application>

Anschließend können Sie den Anwendungskontext in einer beliebigen statischen Methode wie folgt abrufen:

public static void someMethod() {
    Context context = App.getContext();
}

WARNUNG

Bevor Sie Ihrem Projekt etwas Ähnliches hinzufügen, sollten Sie überlegen, was in der Dokumentation steht:

Normalerweise muss die Anwendung nicht in Unterklassen unterteilt werden. In den meisten Situationen können statische Singletons dieselbe Funktionalität auf modularere Weise bereitstellen. Wenn Ihr Singleton einen globalen Kontext benötigt (zum Beispiel um Registrierungsempfänger zu registrieren), kann der Funktion zum Abrufen ein Kontext zugewiesen werden, der beim erstmaligen Erstellen des Singletons intern Context.getApplicationContext () verwendet.

BETRACHTUNG

Es gibt auch eine andere Möglichkeit, den Anwendungskontext mithilfe von Reflection abzurufen. Reflexion wird in Android oft herabgesetzt und ich persönlich denke, dass dies nicht in der Produktion verwendet werden sollte.

Um den Anwendungskontext abzurufen, müssen wir eine Methode für eine versteckte Klasse ( ActivityThread ) aufrufen, die seit API 1 verfügbar ist:

public static Application getApplicationUsingReflection() throws Exception {
    return (Application) Class.forName("android.app.ActivityThread")
            .getMethod("currentApplication").invoke(null, (Object[]) null);
}

Es gibt noch eine versteckte Klasse ( AppGlobals ), mit der der Anwendungskontext statisch abgerufen werden kann. Der Kontext wird verwendet, ActivityThreadsodass es wirklich keinen Unterschied zwischen der folgenden und der oben angegebenen Methode gibt:

public static Application getApplicationUsingReflection() throws Exception {
    return (Application) Class.forName("android.app.AppGlobals")
            .getMethod("getInitialApplication").invoke(null, (Object[]) null);
} 

Viel Spaß beim Codieren!

Angenommen, wir sprechen über das Abrufen des Anwendungskontexts, habe ich ihn implementiert, wie von @Rohit Ghatol vorgeschlagen. Was dann passiert ist, ist, dass es keine Garantie dafür gibt, dass der so abgerufene Kontext immer nicht null ist. Zu dem Zeitpunkt, an dem Sie es benötigen, können Sie normalerweise nicht verzögern, weil Sie einen Helfer initialisieren oder eine Ressource abrufen möchten. Die Behandlung des Nullfalls hilft Ihnen nicht weiter. Ich habe also verstanden, dass ich im Grunde gegen die Android-Architektur gekämpft habe, wie in den Dokumenten angegeben

Hinweis: Normalerweise muss die Anwendung nicht in Unterklassen unterteilt werden. In den meisten Situationen können statische Singletons dieselbe Funktionalität auf modularere Weise bereitstellen. Wenn Ihr Singleton einen globalen Kontext benötigt (zum Beispiel zum Registrieren von Broadcast-Empfängern), geben Sie Context.getApplicationContext () als Context-Argument an, wenn Sie die getInstance () -Methode Ihres Singletons aufrufen.

und erklärt von Dianne Hackborn

Der einzige Grund, warum die Anwendung als etwas existiert, von dem Sie ableiten können, ist, dass mich einer unserer Anwendungsentwickler während der Entwicklung vor 1.0 ständig daran gehindert hat, ein Anwendungsobjekt der obersten Ebene zu benötigen, von dem sie abgeleitet werden können, damit sie ein "normaleres" haben können "zu ihnen Anwendungsmodell, und ich gab schließlich nach. Ich werde es für immer bereuen, diesem nachgegeben zu haben. :) :)

Sie schlägt auch die Lösung für dieses Problem vor:

Wenn Sie einen globalen Status wünschen, der für verschiedene Teile Ihrer App freigegeben werden kann, verwenden Sie einen Singleton. [...] Und dies führt natürlicher dazu, wie Sie diese Dinge verwalten sollten - sie bei Bedarf zu initialisieren.

Ich habe also die Erweiterung von Application entfernt und den Kontext direkt an getInstance () des Singleton-Helfers übergeben, während ich einen Verweis auf den Anwendungskontext im privaten Konstruktor gespeichert habe:

private static MyHelper instance;
private final Context mContext;    

private MyHelper(@NonNull Context context) {
    mContext = context.getApplicationContext();
}

public static MyHelper getInstance(@NonNull Context context) {
    synchronized(MyHelper.class) {
        if (instance == null) {
            instance = new MyHelper(context);
        }
        return instance;
    }
}

Der Anrufer übergibt dann einen lokalen Kontext an den Helfer:

Helper.getInstance(myCtx).doSomething();

Um diese Frage richtig zu beantworten: Es gibt Möglichkeiten, statisch auf den Anwendungskontext zuzugreifen, aber alle sollten entmutigt werden, und Sie sollten es vorziehen, einen lokalen Kontext an getInstance () des Singletons zu übergeben.

Für alle Interessierten können Sie eine ausführlichere Version im fwd-Blog lesen

Nein, ich glaube nicht. Leider können Sie nicht mehr getApplicationContext()von Activityoder einer der anderen Unterklassen von anrufen Context. Auch diese Frage ist etwas verwandt.

Hier ist eine undokumentierte Möglichkeit, eine Anwendung (die ein Kontext ist) von einer beliebigen Stelle im UI-Thread abzurufen. Es basiert auf der versteckten statischen Methode ActivityThread.currentApplication(). Es sollte mindestens unter Android 4.x funktionieren.

try {
    final Class<?> activityThreadClass =
            Class.forName("android.app.ActivityThread");
    final Method method = activityThreadClass.getMethod("currentApplication");
    return (Application) method.invoke(null, (Object[]) null);
} catch (final ClassNotFoundException e) {
    // handle exception
} catch (final NoSuchMethodException e) {
    // handle exception
} catch (final IllegalArgumentException e) {
    // handle exception
} catch (final IllegalAccessException e) {
    // handle exception
} catch (final InvocationTargetException e) {
    // handle exception
}

Beachten Sie, dass diese Methode möglicherweise null zurückgibt, z. B. wenn Sie die Methode außerhalb des UI-Threads aufrufen oder die Anwendung nicht an den Thread gebunden ist.

Es ist immer noch besser, die Lösung von @RohitGhatol zu verwenden , wenn Sie den Anwendungscode ändern können.

Es hängt davon ab, wofür Sie den Kontext verwenden. Ich kann mir mindestens einen Nachteil dieser Methode vorstellen:

Wenn Sie versuchen, ein AlertDialogmit zu erstellen AlertDialog.Builder, Applicationfunktioniert der Kontext nicht. Ich glaube, Sie brauchen den Kontext für die aktuelle Activity...

Kotlin Weg :

Manifest:

<application android:name="MyApplication">

</application>

MyApplication.kt

class MyApplication: Application() {

    override fun onCreate() {
        super.onCreate()
        instance = this
    }

    companion object {
        lateinit var instance: MyApplication
            private set
    }
}

Sie können dann über auf die Unterkunft zugreifen MyApplication.instance

Wenn Sie RoboGuice verwenden möchten , können Sie den Kontext in jede gewünschte Klasse einfügen . Hier ist ein kleines Beispiel, wie es mit RoboGuice 2.0 (Beta 4 zum Zeitpunkt dieses Schreibens) gemacht wird.

import android.content.Context;
import android.os.Build;
import roboguice.inject.ContextSingleton;

import javax.inject.Inject;

@ContextSingleton
public class DataManager {
    @Inject
    public DataManager(Context context) {
            Properties properties = new Properties();
            properties.load(context.getResources().getAssets().open("data.properties"));
        } catch (IOException e) {
        }
    }
}

Ich habe das irgendwann benutzt:

ActivityThread at = ActivityThread.systemMain();
Context context = at.getSystemContext();

Dies ist ein gültiger Kontext, den ich beim Abrufen von Systemdiensten und beim Arbeiten verwendet habe.

Aber ich habe es nur in Framework- / Basismodifikationen verwendet und es nicht in Android-Anwendungen ausprobiert.

Eine Warnung , die Sie wissen müssen: Wenn Sie sich für Rundfunkempfänger in diesem Kontext registrieren, funktioniert dies nicht und Sie erhalten:

java.lang.SecurityException: Das angegebene Aufruferpaket android wird im Prozess ProcessRecord nicht ausgeführt

Kotlin

open class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        mInstance = this
    }

    companion object {
        lateinit var mInstance: MyApp
        fun getContext(): Context? {
            return mInstance.applicationContext
        }
    }
}

und Kontext wie bekommen

MyApp.mInstance

oder

MyApp.getContext()

Sie können Folgendes verwenden:

MainActivity.this.getApplicationContext();

MainActivity.java:

...
public class MainActivity ... {
    static MainActivity ma;
...
    public void onCreate(Bundle b) {
         super...
         ma=this;
         ...

Jede andere Klasse:

public ...
    public ANY_METHOD... {
         Context c = MainActivity.ma.getApplicationContext();

Wenn Sie die Manifestdatei nicht ändern möchten, können Sie den Kontext in Ihrer anfänglichen Aktivität manuell in einer statischen Variablen speichern:

public class App {
    private static Context context;

    public static void setContext(Context cntxt) {
        context = cntxt;
    }

    public static Context getContext() {
        return context;
    }
}

Und legen Sie einfach den Kontext fest, wenn Ihre Aktivität (oder Aktivitäten) beginnen:

// MainActivity

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Set Context
    App.setContext(getApplicationContext());

    // Other stuff
}

Hinweis: Wie bei allen anderen Antworten handelt es sich um einen potenziellen Speicherverlust.

Ich denke, Sie brauchen einen Körper für die getAppContext()Methode:

public static Context getAppContext()
   return MyApplication.context; 

Laut dieser Quelle können Sie Ihren eigenen Kontext erhalten, indem Sie ContextWrapper erweitern

public class SomeClass extends ContextWrapper {

    public SomeClass(Context base) {
      super(base);
    }

    public void someMethod() {
        // notice how I can use "this" for Context
        // this works because this class has it's own Context just like an Activity or Service
        startActivity(this, SomeRealActivity.class);

        //would require context too
        File cacheDir = getCacheDir();
    }
}

JavaDoc für ContextWrapper

Proxy-Implementierung von Context, die einfach alle Aufrufe an einen anderen Context delegiert. Kann in Unterklassen unterteilt werden, um das Verhalten zu ändern, ohne den ursprünglichen Kontext zu ändern.

Wenn Sie aus irgendeinem Grund einen Anwendungskontext in einer Klasse wünschen, nicht nur in solchen, die die Anwendung / Aktivität erweitern, möglicherweise für einige Factory- oder Hilfsklassen. Sie können Ihrer App den folgenden Singleton hinzufügen.

public class GlobalAppContextSingleton {
    private static GlobalAppContextSingleton mInstance;
    private Context context;

    public static GlobalAppContextSingleton getInstance() {
        if (mInstance == null) mInstance = getSync();
        return mInstance;
    }

    private static synchronized GlobalAppContextSingleton getSync() {
        if (mInstance == null) mInstance = 
                new GlobalAppContextSingleton();
        return mInstance;
    }

    public void initialize(Context context) {
        this.context = context;
    }

    public Context getApplicationContext() {
        return context;
    }
}

Initialisieren Sie es dann in onCreate Ihrer Anwendungsklasse mit

GlobalAppContextSingleton.getInstance().initialize(this);

Verwenden Sie es überall, indem Sie anrufen

GlobalAppContextSingleton.getInstance().getApplicationContext()

Ich empfehle diesen Ansatz jedoch nur für den Anwendungskontext. Da es zu Speicherlecks kommen kann.

Ich verwende eine Variation des Singleton-Entwurfsmusters, um mir dabei zu helfen.

import android.app.Activity;
import android.content.Context;

public class ApplicationContextSingleton {
    private static Activity gContext;

    public static void setContext( Activity activity) {
        gContext = activity;
    }

    public static Activity getActivity() {
        return gContext;
    }

    public static Context getContext() {
        return gContext;
    }
}

Ich rufe dann ApplicationContextSingleton.setContext( this );in meinem activity.onCreate () und ApplicationContextSingleton.setContext( null );in onDestroy () ;

Ich habe gerade ein von jQuery inspiriertes Framework für Android namens Vapor API veröffentlicht , das die App-Entwicklung vereinfachen soll.

Die zentrale $ Fassadenklasse verwaltet einen WeakReference(Link zu einem großartigen Java-Blog-Beitrag von Ethan Nicholas) zum aktuellen ActivityKontext, den Sie abrufen können, indem Sie Folgendes aufrufen:

$.act()

EIN WeakReference verwaltet eine Referenz, ohne zu verhindern, dass die Garbage Collection das ursprüngliche Objekt zurückfordert, sodass Sie kein Problem mit Speicherlecks haben sollten.

Der Nachteil ist natürlich, dass Sie das Risiko $.act()eingehen, null zurückzugeben. Ich bin jedoch noch nicht auf dieses Szenario gestoßen, daher ist es vielleicht nur ein minimales Risiko, das es wert ist, erwähnt zu werden.

Sie können den Kontext auch manuell festlegen, wenn Sie ihn nicht verwenden VaporActivity als ActivityKlasse verwenden:

$.act(Activity);

Auch ein Großteil der Vapor-API- Frameworks diesen gespeicherten Kontext von Natur aus, was bedeuten kann, dass Sie ihn überhaupt nicht selbst speichern müssen, wenn Sie sich für die Verwendung des Frameworks entscheiden. Schauen Sie sich die Website anWeitere Informationen und Beispiele finden .

Ich hoffe das hilft :)

Rohits Antwort scheint richtig zu sein. Beachten Sie jedoch, dass AndroidStudios "Instant Run" meines Wissens davon abhängt, dass static ContextIhr Code keine Attribute enthält.

Wenn Sie in Kotlin Context / App Context in das Begleitobjekt einfügen, wird weiterhin eine Warnung ausgegeben Do not place Android context classes in static fields; this is a memory leak (and also breaks Instant Run)

oder wenn Sie so etwas verwenden:

    companion object {
        lateinit var instance: MyApp
    }

Es täuscht nur die Flusen, den Speicherverlust nicht zu entdecken. Die App-Instanz kann immer noch einen Speicherverlust erzeugen, da die Anwendungsklasse und ihr Nachkomme ein Kontext sind.

Alternativ können Sie eine funktionale Schnittstelle oder funktionale Eigenschaften verwenden, um Ihren App-Kontext abzurufen.

Erstellen Sie einfach eine Objektklasse:

object CoreHelper {
    lateinit var contextGetter: () -> Context
}

oder Sie könnten es sicherer verwenden, indem Sie den Typ nullable verwenden:

object CoreHelper {
    var contextGetter: (() -> Context)? = null
}

und fügen Sie in Ihrer App-Klasse diese Zeile hinzu:

class MyApp: Application() {

    override fun onCreate() {
        super.onCreate()
        CoreHelper.contextGetter = {
            this
        }
    }
}

und deklarieren Sie in Ihrem Manifest den App-Namen zu . MyApp

    <application
            android:name=".MyApp"

Wenn Sie den Kontext erhalten möchten, rufen Sie einfach an:

CoreHelper.contextGetter()

// or if you use the nullable version
CoreHelper.contextGetter?.invoke()

Hoffe es wird helfen.

Versuchen Sie so etwas

import androidx.appcompat.app.AppCompatActivity;  
import android.content.Context; 
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    private static Context context;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        context = getApplicationContext();
    }

    public static void getContext(View view){
        Toast.makeText(context, "Got my context!",
                    Toast.LENGTH_LONG).show();    
    }
}