Vous utilisez le contexte d'application partout?

Dans une application Android, y a-t-il un problème avec l'approche suivante:

public class MyApp extends android.app.Application {

    private static MyApp instance;

    public MyApp() {
        instance = this;
    }

    public static Context getContext() {
        return instance;
    }

}

et le passer partout (par exemple SQLiteOpenHelper) où le contexte est requis (et non pas une fuite bien sûr)?

Il y a quelques problèmes potentiels avec cette approche, bien que dans de nombreuses circonstances (comme votre exemple), cela fonctionnera bien.

En particulier, vous devez être prudent lorsque vous traitez avec tout ce qui concerne le GUIqui nécessite un Context. Par exemple, si vous passez le contexte d'application dans le, LayoutInflatervous obtiendrez une exception. De manière générale, votre approche est excellente: c'est une bonne pratique d'utiliser un Activity's Contextdedans Activity, et Application Contextquand vous passez un contexte au-delà de la portée d'un Activitypour éviter les fuites de mémoire .

En outre, comme alternative à votre modèle, vous pouvez utiliser le raccourci pour appeler getApplicationContext()un Contextobjet (tel qu'une activité) pour obtenir le contexte d'application.

D'après mon expérience, cette approche ne devrait pas être nécessaire. Si vous avez besoin du contexte pour quoi que ce soit, vous pouvez généralement l'obtenir via un appel à View.getContext () et en utilisant le Contextobtenu, vous pouvez appeler Context.getApplicationContext () pour obtenir le Applicationcontexte. Si vous essayez d'obtenir le Applicationcontexte à partir d'un, Activityvous pouvez toujours appeler Activity.getApplication () qui devrait pouvoir être transmis comme Contextnécessaire pour un appel à SQLiteOpenHelper().

Dans l'ensemble, il ne semble pas y avoir de problème avec votre approche pour cette situation, mais lorsque vous traitez, Contextassurez-vous de ne pas laisser fuir la mémoire, comme décrit sur le blog officiel des développeurs Android de Google .

Certaines personnes ont demandé: comment le singleton peut-il renvoyer un pointeur nul? Je réponds à cette question. (Je ne peux pas répondre dans un commentaire car j'ai besoin de poster du code.)

Il peut retourner null entre deux événements: (1) la classe est chargée et (2) l'objet de cette classe est créé. Voici un exemple:

class X {
    static X xinstance;
    static Y yinstance = Y.yinstance;
    X() {xinstance=this;}
}
class Y {
    static X xinstance = X.xinstance;
    static Y yinstance;
    Y() {yinstance=this;}
}

public class A {
    public static void main(String[] p) {
    X x = new X();
    Y y = new Y();
    System.out.println("x:"+X.xinstance+" y:"+Y.yinstance);
    System.out.println("x:"+Y.xinstance+" y:"+X.yinstance);
    }
}

Exécutons le code:

$ javac A.java 
$ java A
x:X@a63599 y:Y@9036e
x:null y:null

La deuxième ligne montre que Y.xinstance et X.yinstance sont nuls ; ils sont nuls car les variables X.xinstance et Y.yinstance ont été lues quand elles étaient nulles.

Cela peut-il être corrigé? Oui,

class X {
    static Y y = Y.getInstance();
    static X theinstance;
    static X getInstance() {if(theinstance==null) {theinstance = new X();} return theinstance;}
}
class Y {
    static X x = X.getInstance();
    static Y theinstance;
    static Y getInstance() {if(theinstance==null) {theinstance = new Y();} return theinstance;}
}

public class A {
    public static void main(String[] p) {
    System.out.println("x:"+X.getInstance()+" y:"+Y.getInstance());
    System.out.println("x:"+Y.x+" y:"+X.y);
    }
}

et ce code ne montre aucune anomalie:

$ javac A.java 
$ java A
x:X@1c059f6 y:Y@152506e
x:X@1c059f6 y:Y@152506e

MAIS ce n'est pas une option pour l' Applicationobjet Android : le programmeur ne contrôle pas l'heure de sa création.

Encore une fois: la différence entre le premier exemple et le second est que le deuxième exemple crée une instance si le pointeur statique est nul. Mais un programmeur ne peut pas créer l' objet d'application Android avant que le système ne décide de le faire.

MISE À JOUR

Un autre exemple déroutant où se trouvent des champs statiques initialisés null.

Main.java :

enum MyEnum {
    FIRST,SECOND;
    private static String prefix="<", suffix=">";
    String myName;
    MyEnum() {
        myName = makeMyName();
    }
    String makeMyName() {
        return prefix + name() + suffix;
    }
    String getMyName() {
        return myName;
    }
}
public class Main {
    public static void main(String args[]) {
        System.out.println("first: "+MyEnum.FIRST+" second: "+MyEnum.SECOND);
        System.out.println("first: "+MyEnum.FIRST.makeMyName()+" second: "+MyEnum.SECOND.makeMyName());
        System.out.println("first: "+MyEnum.FIRST.getMyName()+" second: "+MyEnum.SECOND.getMyName());
    }
}

Et vous obtenez:

$ javac Main.java
$ java Main
first: FIRST second: SECOND
first: <FIRST> second: <SECOND>
first: nullFIRSTnull second: nullSECONDnull

Notez que vous ne pouvez pas déplacer la déclaration de variable statique d'une ligne vers le haut, le code ne sera pas compilé.

Classe d'application:

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

public class MyApplication extends Application {

    private static Context mContext;

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

    public static Context getAppContext() {
        return mContext;
    }

}

Déclarez l'application dans AndroidManifest:

<application android:name=".MyApplication"
    ...
/>

Usage:

MyApplication.getAppContext()

Vous essayez de créer un wrapper pour obtenir le contexte d'application et il est possible qu'il renvoie un nullpointeur " ".

Selon ma compréhension, je suppose que sa meilleure approche pour appeler l'un des 2 Context.getApplicationContext() ou Activity.getApplication().

C'est une bonne approche. Je l'utilise moi aussi. Je suggérerais simplement de remplacer onCreatepour définir le singleton au lieu d'utiliser un constructeur.

Et puisque vous avez mentionné SQLiteOpenHelper:onCreate () vous pouvez également ouvrir la base de données.

Personnellement, je pense que la documentation s'est trompée en disant qu'il n'y a normalement pas besoin de sous-classer Application . Je pense que le contraire est vrai: vous devez toujours sous-classe Application.

J'utiliserais le contexte d'application pour obtenir un service système dans le constructeur. Cela facilite les tests et bénéficie de la composition

public class MyActivity extends Activity {

    private final NotificationManager notificationManager;

    public MyActivity() {
       this(MyApp.getContext().getSystemService(NOTIFICATION_SERVICE));
    }

    public MyActivity(NotificationManager notificationManager) {
       this.notificationManager = notificationManager;
    }

    // onCreate etc

}

La classe de test utiliserait alors le constructeur surchargé.

Android utiliserait le constructeur par défaut.

J'aime ça, mais je suggérerais plutôt un singleton:

package com.mobidrone;

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

public class ApplicationContext extends Application
{
    private static ApplicationContext instance = null;

    private ApplicationContext()
    {
        instance = this;
    }

    public static Context getInstance()
    {
        if (null == instance)
        {
            instance = new ApplicationContext();
        }

        return instance;
    }
}

J'utilise la même approche, je suggère d'écrire un peu mieux le singleton:

public static MyApp getInstance() {

    if (instance == null) {
        synchronized (MyApp.class) {
            if (instance == null) {
                instance = new MyApp ();
            }
        }
    }

    return instance;
}

mais je n'utilise pas partout, j'utilise getContext()et getApplicationContext()où je peux le faire!