Modo statico per ottenere "Contesto" su Android?

C'è un modo per ottenere l' Contextistanza corrente all'interno di un metodo statico?

Sto cercando in quel modo perché odio salvare l'istanza 'Context' ogni volta che cambia.

Fai questo:

Nel file manifest di Android, dichiarare quanto segue.

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

</application>

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

Ora chiama ovunque MyApplication.getAppContext()per ottenere staticamente il contesto dell'applicazione.

La maggior parte delle app che desiderano un metodo conveniente per ottenere il contesto dell'applicazione creano la propria classe che si estende android.app.Application.

GUIDA

Puoi farlo creando prima una classe nel tuo progetto come la seguente:

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

Quindi, nel tuo AndroidManifest devi specificare il nome della tua classe nel tag di AndroidManifest.xml:

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

È quindi possibile recuperare il contesto dell'applicazione in qualsiasi metodo statico utilizzando quanto segue:

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

AVVERTIMENTO

Prima di aggiungere qualcosa come sopra al tuo progetto, dovresti considerare cosa dice la documentazione:

Normalmente non è necessario sottoclassare l'Applicazione. Nella maggior parte dei casi, i singoli statici possono fornire la stessa funzionalità in un modo più modulare. Se il tuo singleton necessita di un contesto globale (ad esempio per registrare i ricevitori di trasmissione), alla funzione per recuperarlo può essere assegnato un contesto che utilizza internamente Context.getApplicationContext () quando costruisce il singleton per la prima volta.

RIFLESSIONE

C'è anche un altro modo per ottenere il contesto dell'applicazione usando reflection. La riflessione viene spesso trascurata su Android e personalmente penso che questo non debba essere usato in produzione.

Per recuperare il contesto dell'applicazione, è necessario richiamare un metodo su una classe nascosta ( ActivityThread ) che è disponibile dall'API 1:

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

Esiste un'altra classe nascosta ( AppGlobals ) che fornisce un modo per ottenere il contesto dell'applicazione in modo statico. Ottiene il contesto usando ActivityThreadquindi non c'è davvero alcuna differenza tra il seguente metodo e quello pubblicato sopra:

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

Buona programmazione!

Supponendo che stiamo parlando di ottenere il contesto dell'applicazione, l'ho implementato come suggerito dall'estensione dell'applicazione @Rohit Ghatol. Ciò che è accaduto allora è che non esiste alcuna garanzia che il contesto recuperato in questo modo sarà sempre non nullo. Nel momento in cui ne hai bisogno, è di solito perché vuoi inizializzare un aiutante, o ottenere una risorsa, che non puoi ritardare in tempo; la gestione del caso null non ti aiuterà. Quindi ho capito che stavo fondamentalmente combattendo contro l'architettura Android, come affermato nei documenti

Nota: normalmente non è necessario sottoclassare l'Applicazione. Nella maggior parte dei casi, i singoli statici possono fornire la stessa funzionalità in un modo più modulare. Se il tuo singleton necessita di un contesto globale (ad esempio per registrare i ricevitori di trasmissione), includi Context.getApplicationContext () come argomento Context quando invochi il metodo getInstance () del tuo singleton.

e spiegato da Dianne Hackborn

L'unica ragione per cui l'applicazione esiste come qualcosa da cui puoi derivare è perché durante lo sviluppo pre-1.0 uno dei nostri sviluppatori di applicazioni mi ha continuamente infastidito sulla necessità di avere un oggetto di applicazione di livello superiore da cui possano derivare in modo da poter avere un "più normale "a loro modello di applicazione, e alla fine mi sono arreso. Mi pentirò per sempre di averlo abbandonato. :)

Sta anche suggerendo la soluzione a questo problema:

Se quello che vuoi è uno stato globale che può essere condiviso tra diverse parti della tua app, usa un singleton. [...] E questo porta più naturalmente a come dovresti gestire queste cose - inizializzandole su richiesta.

quindi quello che ho fatto è stato sbarazzarmi dell'estensione dell'applicazione e passare il contesto direttamente al getInstance () dell'helper singleton, salvando un riferimento al contesto dell'applicazione nel costruttore privato:

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

il chiamante passerà quindi un contesto locale all'helper:

Helper.getInstance(myCtx).doSomething();

Quindi, per rispondere correttamente a questa domanda: ci sono modi per accedere staticamente al contesto dell'applicazione, ma tutti dovrebbero essere scoraggiati e dovresti preferire passare un contesto locale a getInstance () del singleton.

Per chiunque sia interessato, puoi leggere una versione più dettagliata sul blog di fwd

No, non credo che ci sia. Sfortunatamente, sei bloccato a chiamare getApplicationContext()da Activityo una delle altre sottoclassi di Context. Inoltre, questa domanda è in qualche modo correlata.

Ecco un modo non documentato per ottenere un'applicazione (che è un contesto) da qualsiasi punto del thread dell'interfaccia utente. Si basa sul metodo statico nascosto ActivityThread.currentApplication(). Dovrebbe funzionare almeno su 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
}

Si noti che è possibile che questo metodo restituisca null, ad esempio quando si chiama il metodo al di fuori del thread dell'interfaccia utente o l'applicazione non è associata al thread.

È ancora meglio usare la soluzione di @RohitGhatol se è possibile modificare il codice dell'applicazione.

Dipende da cosa stai usando il contesto. Posso pensare ad almeno uno svantaggio di quel metodo:

Se stai cercando di creare un AlertDialogcon AlertDialog.Builder, il Applicationcontesto non funzionerà. Credo che tu abbia bisogno del contesto per l'attuale Activity...

Modo di Kotlin :

Manifesto:

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

È quindi possibile accedere alla proprietà tramite MyApplication.instance

Se sei aperto all'utilizzo di RoboGuice , puoi inserire il contesto in qualsiasi classe desideri. Ecco un piccolo esempio di come farlo con RoboGuice 2.0 (beta 4 al momento in cui scrivo)

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

L'ho usato ad un certo punto:

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

Questo è un contesto valido che ho usato per ottenere i servizi di sistema e funzionare.

Ma l'ho usato solo nelle modifiche al framework / base e non l'ho provato nelle applicazioni Android.

Un avvertimento che devi sapere: quando ti registri per i ricevitori broadcast in questo contesto, non funzionerà e otterrai:

java.lang.SecurityException: dato il pacchetto chiamante android non è in esecuzione 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
        }
    }
}

e ottieni un contesto simile

MyApp.mInstance

o

MyApp.getContext()

È possibile utilizzare quanto segue:

MainActivity.this.getApplicationContext();

MainActivity.java:

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

Qualsiasi altra classe:

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

Se non desideri modificare il file manifest, puoi archiviare manualmente il contesto in una variabile statica nella tua attività iniziale:

public class App {
    private static Context context;

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

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

E basta impostare il contesto all'avvio della tua attività (o attività):

// MainActivity

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

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

    // Other stuff
}

Nota: come tutte le altre risposte, questa è una potenziale perdita di memoria.

Penso che tu abbia bisogno di un corpo per il getAppContext()metodo:

public static Context getAppContext()
   return MyApplication.context; 

Secondo questa fonte è possibile ottenere il proprio contesto estendendo 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 per ContextWrapper

Implementazione proxy del contesto che delega semplicemente tutte le sue chiamate a un altro contesto. Può essere sottoclassato per modificare il comportamento senza cambiare il contesto originale.

Se per qualche motivo si desidera il contesto dell'applicazione in qualsiasi classe, non solo quelle che estendono l'applicazione / attività, forse per alcune classi factory o helper. Puoi aggiungere il seguente singleton alla tua app.

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

quindi inizializzalo in onCreate della tua classe di applicazione con

GlobalAppContextSingleton.getInstance().initialize(this);

usalo ovunque chiamando

GlobalAppContextSingleton.getInstance().getApplicationContext()

Non consiglio questo approccio a tutto tranne che al contesto dell'applicazione. Poiché può causare perdite di memoria.

Uso una variante del modello di progettazione Singleton per aiutarmi in questo.

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

Chiamo quindi ApplicationContextSingleton.setContext( this );in my activity.onCreate () e ApplicationContextSingleton.setContext( null );in onDestroy () ;

Ho appena rilasciato un framework ispirato a jQuery per Android chiamato Vapor API che mira a semplificare lo sviluppo di app.

La $classe di facciata centrale mantiene un WeakReference(link al fantastico post sul blog Java su questo di Ethan Nicholas) al Activitycontesto attuale che puoi recuperare chiamando:

$.act()

UN WeakReference mantiene un riferimento senza impedire alla garbage collection di recuperare l'oggetto originale, quindi non dovresti avere problemi con le perdite di memoria.

Il rovescio della medaglia ovviamente è che si corre il rischio che $.act()potrebbe restituire null. Non ho ancora incontrato questo scenario, quindi è forse solo un rischio minimo, degno di nota.

Puoi anche impostare il contesto manualmente se non stai usando VaporActivitycome Activityclasse:

$.act(Activity);

Inoltre, gran parte del framework API di Vapor utilizza intrinsecamente questo contesto memorizzato, il che potrebbe significare che non è necessario memorizzarlo da soli se si decide di utilizzare il framework. Dai un'occhiata al sito per ulteriori informazioni e campioni.

Spero che aiuti :)

La risposta di Rohit sembra corretta. Tuttavia, tieni presente che "Instant Run" di AndroidStudio dipende dal fatto di non avere static Contextattributi nel tuo codice, per quanto ne so.

in Kotlin, mettere Contesto / Contesto app nell'oggetto associato produce comunque un avviso Do not place Android context classes in static fields; this is a memory leak (and also breaks Instant Run)

o se usi qualcosa del genere:

    companion object {
        lateinit var instance: MyApp
    }

Sta semplicemente ingannando la lanugine per non scoprire la perdita di memoria, l'istanza dell'App può ancora produrre perdita di memoria, poiché la classe Application e il suo discendente è un contesto.

In alternativa, puoi utilizzare l'interfaccia funzionale o le proprietà funzionali per aiutarti a ottenere il contesto della tua app.

Basta creare una classe di oggetti:

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

o potresti usarlo in modo più sicuro usando il tipo nullable:

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

e nella tua classe App aggiungi questa riga:

class MyApp: Application() {

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

e nel tuo manifest dichiarare il nome dell'app a . MyApp

    <application
            android:name=".MyApp"

Quando vuoi ottenere il contesto, chiama semplicemente:

CoreHelper.contextGetter()

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

Spero che possa aiutare.

Prova qualcosa del genere

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