Avviso: non collocare classi di contesto Android in campi statici; questa è una perdita di memoria (e interrompe anche Instant Run)

Android Studio:

Non collocare classi di contesto Android in campi statici; questa è una perdita di memoria (e interrompe anche Instant Run)

Quindi 2 domande:

# 1 Come si chiama a startServiceda un metodo statico senza una variabile statica per il contesto?
# 2 Come si invia un localBroadcast da un metodo statico (lo stesso)?

Esempi:

public static void log(int iLogLevel, String sRequest, String sData) {
    if(iLogLevel > 0) {

        Intent intent = new Intent(mContext, LogService.class);
        intent.putExtra("UPDATE_MAIN_ACTIVITY_VIEW", "UPDATE_MAIN_ACTIVITY_VIEW");
        mContext.startService(intent);
    }
}

o

        Intent intent = new Intent(MAIN_ACTIVITY_RECEIVER_INTENT);
        intent.putExtra(MAIN_ACTIVITY_REQUEST_FOR_UPDATE, sRequest));
        intent.putExtra(MAIN_ACTIVITY_DATA_FOR_VIEW, sData);
        intent.putExtra(MAIN_ACTIVITY_LOG_LEVEL, iLogLevel);
        LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);

Quale sarebbe il modo corretto per farlo senza utilizzare mContext?

NOTA: Penso che la mia domanda principale potrebbe essere come passare il contesto a una classe da cui vive il metodo chiamante.

Passalo semplicemente come parametro al tuo metodo. Non ha senso creare un'istanza statica di Contextsolo allo scopo di avviare un file Intent.

Ecco come dovrebbe apparire il tuo metodo:

public static void log(int iLogLevel, String sRequest, String sData, Context ctx) {
    if(iLogLevel > 0) {

        Intent intent = new Intent(ctx, LogService.class);
        intent1.putExtra("UPDATE_MAIN_ACTIVITY_VIEW", "UPDATE_MAIN_ACTIVITY_VIEW");
        ctx.startService(intent);
    }
}

Aggiornamento dai commenti sulla domanda: sovrapponi il contesto dall'attività iniziale (tramite parametri del costruttore o parametri del metodo) fino al punto in cui ne hai bisogno.

Assicurati solo di passare context.getApplicationContext () o chiamare getApplicationContext () su qualsiasi contesto passato tramite metodi / costruttore al tuo singleton se decidi di memorizzarlo in qualsiasi campo membro.

Esempio di prova di idiota (anche se qualcuno passasse un'attività, afferrerà il contesto dell'app e lo userà per istanziare il singleton):

public static synchronized RestClient getInstance(Context context) {
    if (mInstance == null) {
        mInstance = new RestClient(context.getApplicationContext());
    }
    return mInstance;
}

getApplicationContext () secondo la documentazione: "Restituisce il contesto del singolo oggetto Application globale del processo corrente."

Significa che il contesto restituito da "getApplicationContext ()" vivrà attraverso l'intero processo e quindi non importa se memorizzi un riferimento statico ovunque poiché sarà sempre lì durante il runtime della tua app (e sopravviverà a qualsiasi oggetto / singleton istanziati da esso).

Confrontalo con il contesto all'interno di viste / attività che contengono grandi quantità di dati, se perdi un contesto detenuto da un'attività, il sistema non sarà in grado di liberare quella risorsa che ovviamente non è buona.

Un riferimento a un'attività in base al suo contesto dovrebbe vivere lo stesso ciclo di vita dell'attività stessa, altrimenti manterrà il contesto in ostaggio causando una perdita di memoria (che è la ragione dietro l'avviso di lanugine).

EDIT: Per il ragazzo che picchia l'esempio dei documenti sopra, c'è anche una sezione di commenti nel codice su ciò che ho appena scritto:

    // getApplicationContext() is key, it keeps you from leaking the
    // Activity or BroadcastReceiver if someone passes one in.

È solo un avvertimento. Non preoccuparti. Se si desidera utilizzare un contesto dell'applicazione, è possibile salvarlo in una classe "singleton", che viene utilizzata per salvare tutta la classe singleton nel progetto.

Nel tuo caso non ha molto senso averlo come campo statico ma non credo che sia un male in tutti i casi. Se ora cosa stai facendo puoi avere un campo statico con contesto e annullarlo in seguito. Sto creando un'istanza statica per la mia classe modello principale che ha un contesto all'interno, il contesto dell'applicazione non il contesto dell'attività e inoltre ho un campo di istanza statica della classe contenente attività che ho annullato durante la distruzione. Non vedo che ho una perdita di memoria. Quindi se qualche ragazzo intelligente pensa che io abbia torto sentiti libero di commentare ...

Anche Instant Run funziona bene qui ...

Utilizzare WeakReferenceper memorizzare il contesto nelle classi Singleton e l'avviso sparirà

private WeakReference<Context> context;

//Private contructor
private WidgetManager(Context context) {
    this.context = new WeakReference<>(context);
}

//Singleton
public static WidgetManager getInstance(Context context) {
    if (null == widgetManager) {
        widgetManager = new WidgetManager(context);
    }
    return widgetManager;
}

Ora puoi accedere a Context come

  if (context.get() instanceof MainActivity) {
            ((MainActivity) context.get()).startActivityForResult(pickIntent, CODE_REQUEST_PICK_APPWIDGET);
        }

In genere, evitare di definire i campi di contesto come statici. L'avviso stesso spiega il motivo: è una perdita di memoria. Tuttavia, interrompere la corsa istantanea potrebbe non essere il problema più grande del pianeta.

Ora, ci sono due scenari in cui dovresti ricevere questo avviso. Per un esempio (il più ovvio):

public static Context ctx;

E poi c'è quello un po 'più complicato, in cui il contesto è racchiuso in una classe:

public class Example{
    public Context ctx;
    //Constructor omitted for brievety 
}

E quella classe è definita statica da qualche parte:

public static Example example;

E riceverai l'avvertimento.

La soluzione in sé è abbastanza semplice: non posizionare i campi di contesto in istanze statiche , sia che si tratti di una classe wrapping, sia che la dichiari statica direttamente.

E la soluzione all'avviso è semplice: non posizionare il campo in modo statico. Nel tuo caso, passa il contesto come istanza al metodo. Per le classi in cui vengono effettuate più chiamate Context, utilizzare un costruttore per passare il contesto (o un'attività per quella materia) alla classe.

_{Nota che è un avvertimento, non un errore. Se per qualsiasi motivo hai bisogno di un contesto statico, puoi farlo. Anche se crei una perdita di memoria quando lo fai.}

Se ti assicuri che sia un contesto dell'applicazione. Importa. Aggiungi questo

@SuppressLint("StaticFieldLeak")