Android Singleton avec contexte global

Selon la documentation Android, il est écrit:

Il n’y a normalement pas besoin de sous-classe Application. Dans la plupart des cas, 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 permettant de le récupérer peut recevoir un contexte qui utilise en interne Context.getApplicationContext() lors de la première construction du singleton.

Comment puis-je créer un singleton statique qui a un contexte global pour qu’il puisse survivre à l’activité en cours dans mon application? Est-ce suffisant d’avoir un contexte statique qui fait référence à getApplicationContext ()?

une autre édition à la question:

ces derniers temps (à partir de 2016 et plus tard) ce que je faisais, et je suggère à tout développeur de le faire en tant que:

Utilisez Dagger2, utilisez simplement Dagger 2. Où que vous ayez besoin d’un Context vous faites:

 @Inject Context context;

et c’est tout. Pendant ce temps, injectez toutes les autres choses qui seraient un singleton.

édité / amélioré réponse:

parce que cette réponse devient un peu plus populaire, je vais améliorer ma propre réponse avec un exemple de code de ce que j’ai utilisé récemment (à partir de juillet 2014).

Commencez par faire en sorte que l’application garde une référence à elle-même.

 public class App extends Application { private static App instance; public static App get() { return instance; } @Override public void onCreate() { super.onCreate(); instance = this; } }

puis, sur tout singleton qui a besoin d’accéder au context je charge paresseusement les singles d’une manière sûre en utilisant la double vérification de la synchronisation, comme expliqué ici https://stackoverflow.com/a/11165926/906362

 private static SingletonDemo instance; public static SingletonDemo get() { if(instance == null) instance = getSync(); return instance; } private static synchronized SingletonDemo getSync() { if(instance == null) instance = new SingletonDemo(); return instance; } private SingletonDemo(){ // here you can directly access the Application context calling App.get(); }

réponse originale:

ce que la documentation suggère est d’utiliser un modèle de singleton normal

  public class SingletonDemo { private static SingletonDemo instance = null; private SingletonDemo() { } public static SingletonDemo getInstance() { if (instance == null) { instance = new SingletonDemo (); } return instance; } }

et y inclure une méthode comme celle-ci:

  private Context context; init(Context context){ this.context = context.getApplicationContext(); }

et rappelez-vous d’appeler cela pour initialiser le singleton.

La différence entre l’approche applicative et l’approche Singleton et la raison pour laquelle le Singleton est meilleur est sur la documentation de la same functionality in a more modular way

J’ai une telle classe dans mon application:

 public class ApplicationContext { private Context appContext; private ApplicationContext(){} public void init(Context context){ if(appContext == null){ appContext = context; } } private Context getContext(){ return appContext; } public static Context get(){ return getInstance().getContext(); } private static ApplicationContext instance; public static ApplicationContext getInstance(){ return instance == null ? (instance = new ApplicationContext()): instance; } }

et puis par exemple dans l’activité de lancement l’initialiser:

 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //init ApplicationContext.getInstance().init(getApplicationContext()); //use via ApplicationContext.get() assert(getApplicationContext() == ApplicationContext.get()); }