Manière statique d'obtenir le «contexte» dans Android?

Existe-t-il un moyen d'obtenir l' Contextinstance actuelle dans une méthode statique?

Je cherche de cette façon parce que je déteste enregistrer l'instance "Context" à chaque fois qu'elle change.

Faites ceci:

Dans le fichier manifeste Android, déclarez ce qui suit.

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

</application>

Écrivez ensuite la classe:

public class MyApplication extends Application {

    private static Context context;

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

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

Maintenant, appelez partout MyApplication.getAppContext()pour obtenir le contexte de votre application de manière statique.

La majorité des applications qui souhaitent une méthode pratique pour obtenir le contexte d'application créent leur propre classe qui s'étend android.app.Application.

GUIDER

Vous pouvez accomplir cela en créant d'abord une classe dans votre projet comme suit:

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;
    }
}

Ensuite, dans votre AndroidManifest, vous devez spécifier le nom de votre classe dans la balise AndroidManifest.xml:

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

Vous pouvez ensuite récupérer le contexte d'application dans n'importe quelle méthode statique à l'aide de ce qui suit:

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

ATTENTION

Avant d'ajouter quelque chose comme ce qui précède à votre projet, vous devez considérer ce que dit la documentation:

Il n'est normalement pas nécessaire de sous-classer Application. Dans la plupart des situations, les singletons statiques peuvent fournir les mêmes fonctionnalités de manière plus modulaire. Si votre singleton a besoin d'un contexte global (par exemple pour enregistrer des récepteurs de diffusion), la fonction pour le récupérer peut recevoir un contexte qui utilise en interne Context.getApplicationContext () lors de la première construction du singleton.

RÉFLEXION

Il existe également une autre façon d'obtenir le contexte de l'application à l'aide de la réflexion. La réflexion est souvent méprisée dans Android et je pense personnellement que cela ne devrait pas être utilisé en production.

Pour récupérer le contexte de l'application, nous devons appeler une méthode sur une classe cachée ( ActivityThread ) qui est disponible depuis l'API 1:

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

Il existe une autre classe cachée ( AppGlobals ) qui fournit un moyen d'obtenir le contexte d'application de manière statique. Il obtient le contexte en utilisant ActivityThreaddonc il n'y a vraiment aucune différence entre la méthode suivante et celle publiée ci-dessus:

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

Bon codage!

En supposant que nous parlons d'obtenir le contexte d'application, je l'ai implémenté comme suggéré par @Rohit Ghatol étendant l'application. Ce qui s'est passé alors, c'est qu'il n'y a aucune garantie que le contexte récupéré de cette manière sera toujours non nul. Au moment où vous en avez besoin, c'est généralement parce que vous voulez initialiser un assistant, ou obtenir une ressource, que vous ne pouvez pas retarder dans le temps; la gestion du cas nul ne vous aidera pas. J'ai donc compris que je me battais essentiellement contre l'architecture Android, comme indiqué dans la documentation

Remarque: Il n'est normalement pas nécessaire de sous-classer Application. Dans la plupart des situations, les singletons statiques peuvent fournir les mêmes fonctionnalités de manière plus modulaire. Si votre singleton a besoin d'un contexte global (par exemple pour enregistrer des récepteurs de diffusion), incluez Context.getApplicationContext () comme argument Context lors de l'appel de la méthode getInstance () de votre singleton.

et expliqué par Dianne Hackborn

La seule raison pour laquelle Application existe comme quelque chose dont vous pouvez dériver est parce que pendant le développement pré-1.0, l'un de nos développeurs d'applications me continuait à me déranger d'avoir besoin d'avoir un objet d'application de niveau supérieur dont ils pouvaient dériver afin d'avoir une image plus "normale". "Pour eux, le modèle d'application, et j'ai finalement cédé. Je regretterai à jamais de céder sur celui-là. :)

Elle propose également la solution à ce problème:

Si vous voulez un état global pouvant être partagé entre différentes parties de votre application, utilisez un singleton. [...] Et cela mène plus naturellement à la façon dont vous devriez gérer ces choses - en les initialisant à la demande.

donc ce que j'ai fait était de me débarrasser de l'extension d'Application et de passer le contexte directement à getInstance () de l'assistant singleton, tout en enregistrant une référence au contexte d'application dans le constructeur privé:

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;
    }
}

l'appelant transmettra ensuite un contexte local à l'assistant:

Helper.getInstance(myCtx).doSomething();

Donc, pour répondre correctement à cette question: il existe des moyens d'accéder statiquement au contexte d'application, mais ils doivent tous être découragés, et vous devriez préférer passer un contexte local à getInstance () du singleton.

Pour toute personne intéressée, vous pouvez lire une version plus détaillée sur le blog fwd

Non, je ne pense pas. Malheureusement, vous êtes bloqué getApplicationContext()depuis Activityou l'une des autres sous-classes de Context. En outre, cette question est quelque peu liée.

Voici une façon non documentée d'obtenir une application (qui est un contexte) de n'importe où dans le thread d'interface utilisateur. Il repose sur la méthode statique cachée ActivityThread.currentApplication(). Cela devrait fonctionner au moins sur Android 4.x.

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
}

Notez qu'il est possible que cette méthode retourne null, par exemple lorsque vous appelez la méthode en dehors du thread d'interface utilisateur, ou que l'application n'est pas liée au thread.

Il est toujours préférable d'utiliser la solution de @RohitGhatol si vous pouvez changer le code d'application.

Cela dépend de ce pour quoi vous utilisez le contexte. Je peux penser à au moins un inconvénient de cette méthode:

Si vous essayez de créer un AlertDialogavec AlertDialog.Builder, le Applicationcontexte ne fonctionnera pas. Je crois que vous avez besoin du contexte du courant Activity...

Façon Kotlin :

Manifeste:

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

Vous pouvez ensuite accéder à la propriété via MyApplication.instance

Si vous êtes prêt à utiliser RoboGuice , vous pouvez injecter le contexte dans la classe de votre choix . Voici un petit échantillon de la façon de le faire avec RoboGuice 2.0 (beta 4 au moment de la rédaction de cet article)

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) {
        }
    }
}

Je l'ai utilisé à un moment donné:

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

C'est un contexte valide que j'ai utilisé pour obtenir des services système et travailler.

Mais, je ne l'ai utilisé que dans les modifications de framework / base et je ne l'ai pas essayé dans les applications Android.

Un avertissement que vous devez savoir: lors de votre inscription à des récepteurs de diffusion dans ce contexte, cela ne fonctionnera pas et vous obtiendrez:

java.lang.SecurityException: Étant donné que le package d'appelant android n'est pas en cours d'exécution dans le processus ProcessRecord

Kotlin

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

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

et obtenez le contexte comme

MyApp.mInstance

ou

MyApp.getContext()

Vous pouvez utiliser les éléments suivants:

MainActivity.this.getApplicationContext();

MainActivity.java:

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

Toute autre classe:

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

Si vous ne souhaitez pas modifier le fichier manifeste, vous pouvez stocker manuellement le contexte dans une variable statique dans votre activité initiale:

public class App {
    private static Context context;

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

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

Et définissez simplement le contexte lorsque votre activité (ou vos activités) commence:

// MainActivity

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

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

    // Other stuff
}

Remarque: comme toutes les autres réponses, il s'agit d'une fuite de mémoire potentielle.

Je pense que vous avez besoin d'un corps pour la getAppContext()méthode:

public static Context getAppContext()
   return MyApplication.context; 

Selon cette source, vous pouvez obtenir votre propre contexte en étendant ContextWrapper

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 pour ContextWrapper

Implémentation proxy de Context qui délègue simplement tous ses appels à un autre Context. Peut être sous-classé pour modifier le comportement sans changer le contexte d'origine.

Si, pour une raison quelconque, vous voulez le contexte d'application dans n'importe quelle classe, pas seulement ceux qui étendent l'application / l'activité, peut-être pour certaines classes d'usine ou d'assistance. Vous pouvez ajouter le singleton suivant à votre application.

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;
    }
}

puis l'initialiser dans onCreate de votre classe d'application avec

GlobalAppContextSingleton.getInstance().initialize(this);

utilisez-le n'importe où en appelant

GlobalAppContextSingleton.getInstance().getApplicationContext()

Je ne recommande cependant pas cette approche à autre chose qu'au contexte d'application. Comme cela peut provoquer des fuites de mémoire.

J'utilise une variation du modèle de conception Singleton pour m'aider avec cela.

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;
    }
}

Je demande alors ApplicationContextSingleton.setContext( this );à mon activity.onCreate () et ApplicationContextSingleton.setContext( null );dans OnDestroy () ;

Je viens de publier un framework inspiré de jQuery pour Android appelé Vapor API qui vise à simplifier le développement d'applications.

La $classe de façade centrale maintient un WeakReference(lien vers un impressionnant article de blog Java à ce sujet par Ethan Nicholas) sur le Activitycontexte actuel que vous pouvez récupérer en appelant:

$.act()

A WeakReferenceconserve une référence sans empêcher la récupération de place de récupérer l'objet d'origine, vous ne devriez donc pas avoir de problème avec les fuites de mémoire.

L'inconvénient est bien sûr que vous courez le risque qui $.act()pourrait retourner nul. Je n'ai pas encore rencontré ce scénario, donc c'est peut-être juste un risque minimal, qui mérite d'être mentionné.

Vous pouvez également définir le contexte manuellement si vous n'utilisez pas VaporActivityvotre Activityclasse:

$.act(Activity);

En outre, une grande partie du cadre de l' API Vapor utilise ce contexte stocké de manière inhérente, ce qui pourrait signifier que vous n'avez pas besoin de le stocker vous-même du tout si vous décidez d'utiliser le cadre. Consultez le site pour plus d'informations et d'échantillons.

J'espère que ça aide :)

La réponse de Rohit semble correcte. Cependant, sachez que "Instant Run" d'AndroidStudio dépend de ne pas avoir d' static Contextattributs dans votre code, pour autant que je sache.

dans Kotlin, mettre Context / App Context dans un objet compagnon produit toujours un avertissement Do not place Android context classes in static fields; this is a memory leak (and also breaks Instant Run)

ou si vous utilisez quelque chose comme ça:

    companion object {
        lateinit var instance: MyApp
    }

C'est simplement duper les peluches pour ne pas découvrir la fuite de mémoire, l'instance App peut toujours produire une fuite de mémoire, car la classe Application et son descendant est un contexte.

Vous pouvez également utiliser une interface fonctionnelle ou des propriétés fonctionnelles pour vous aider à obtenir le contexte de votre application.

Créez simplement une classe d'objets:

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

ou vous pouvez l'utiliser plus en toute sécurité en utilisant le type nullable:

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

et dans votre classe App, ajoutez cette ligne:

class MyApp: Application() {

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

et dans votre manifeste, déclarez le nom de l'application . MyApp

    <application
            android:name=".MyApp"

Lorsque vous voulez obtenir le contexte, appelez simplement:

CoreHelper.contextGetter()

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

J'espère que cela vous aidera.

Essayez quelque chose comme ça

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();    
    }
}