Ho un frammento (F1) con un metodo pubblico come questo

public void asd() {
    if (getActivity() == null) {
        Log.d("yes","it is null");
    }
}

e sì quando lo chiamo (dall'attività), è null ...

FragmentTransaction transaction1 = getSupportFragmentManager().beginTransaction();
F1 f1 = new F1();
transaction1.replace(R.id.upperPart, f1);
transaction1.commit();
f1.asd();

Deve essere qualcosa che sto facendo molto male, ma non so cosa sia

commit pianifica la transazione, ovvero non avviene immediatamente ma è pianificata come lavoro sul thread principale la volta successiva che il thread principale è pronto.

Suggerirei di aggiungere un

onAttach(Activity activity)

metodo al tuo Fragmente mettere un punto di interruzione su di esso e vedere quando viene chiamato in relazione alla tua chiamata asd(). Vedrai che viene chiamato dopo il metodo in cui effettui la chiamata per asd()uscire. La onAttachchiamata è dove il Fragmentè collegato alla sua attività e da questo punto getActivity()restituirà un valore non nullo (nb c'è anche una onDetach()chiamata).

Il modo migliore per sbarazzarsi di questo è mantenere il riferimento all'attività quando viene chiamato onAttach e utilizzare il riferimento all'attività dove necessario, ad es.

@Override
public void onAttach(Context context) {
    super.onAttach(activity);
    mContext = context;
}

@Override
public void onDetach() {
    super.onDetach();
    mContext = null;
}

Questo è successo quando hai chiamato getActivity()un altro thread che è terminato dopo che il frammento è stato rimosso. Il caso tipico è chiamare getActivity()(es. Per a Toast) al termine di una richiesta HTTP ( onResponsead esempio).

Per evitare ciò, è possibile definire un nome campo mActivitye usarlo al posto di getActivity(). Questo campo può essere inizializzato nel metodo onAttach () del frammento come segue:

@Override
public void onAttach(Context context) {
    super.onAttach(context);

    if (context instanceof Activity){
        mActivity =(Activity) context;
    }
}

Nei miei progetti, di solito definisco una classe base per tutti i miei frammenti con questa funzione:

public abstract class BaseFragment extends Fragment {

    protected FragmentActivity mActivity;

    @Override
public void onAttach(Context context) {
    super.onAttach(context);

    if (context instanceof Activity){
        mActivity =(Activity) context;
    }
}
}

Buona programmazione,

Le altre risposte che suggeriscono di mantenere un riferimento all'attività in onAttach stanno solo suggerendo un cerotto al problema reale. Quando getActivity restituisce null significa che il frammento non è collegato all'attività. Più comunemente questo accade quando l'attività è andata via a causa della rotazione o l'attività è finita, ma il frammento ha ancora un qualche tipo di listener di callback registrato. Quando l'ascoltatore viene chiamato se devi fare qualcosa con l'Attività ma l'Attività è sparita non c'è molto che puoi fare. Nel tuo codice dovresti solo controllaregetActivity() != nulle se non è lì, allora non fare nulla. Se si mantiene un riferimento all'attività che è andata, si sta impedendo che l'attività venga raccolta in modo inutile. Qualsiasi operazione dell'interfaccia utente che potresti provare a fare non verrà visualizzata dall'utente. Posso immaginare alcune situazioni in cui nel listener di callback potresti voler avere un contesto per qualcosa di non UI, in quei casi probabilmente ha più senso ottenere il contesto dell'applicazione. Si noti che l'unica ragione per cui il onAttachtrucco non è una grande perdita di memoria è perché normalmente dopo l'esecuzione del listener di callback non sarà più necessario e può essere spazzato via insieme al frammento, a tutte le sue viste e al contesto delle attività. Se tusetRetainInstance(true) c'è una maggiore possibilità di perdita di memoria perché anche il campo Attività verrà mantenuto, ma dopo la rotazione potrebbe essere l'attività precedente non quella corrente.

Dal livello API 23 di Android, onAttach (Attività attività) è diventato obsoleto. È necessario utilizzare onAttach (contesto di contesto). http://developer.android.com/reference/android/app/Fragment.html#onAttach(android.app.Activity)

L'attività è un contesto, quindi se puoi semplicemente controllare il contesto è un'attività e lanciarla se necessario.

@Override
public void onAttach(Context context) {
    super.onAttach(context);

    Activity a;

    if (context instanceof Activity){
        a=(Activity) context;
    }

}

PJL ha ragione. Ho usato il suo suggerimento e questo è quello che ho fatto:

1. variabili globali definite per frammento:

   private final Object attachingActivityLock = new Object();

   private boolean syncVariable = false;

2. implementato

@Override
public void onAttach(Activity activity) {
  super.onAttach(activity);
  synchronized (attachingActivityLock) {
      syncVariable = true;
      attachingActivityLock.notifyAll();
  }
}

3 Ho concluso la mia funzione, dove ho bisogno di chiamare getActivity (), nel thread, perché se fosse eseguito sul thread principale, bloccherei il thread con il passaggio 4. e onAttach () non verrebbe mai chiamato.

    Thread processImage = new Thread(new Runnable() {

        @Override
        public void run() {
            processImage();
        }
    });
    processImage.start();

4 nella mia funzione in cui devo chiamare getActivity (), lo uso (prima della chiamata getActivity ())

    synchronized (attachingActivityLock) {
        while(!syncVariable){
            try {
                attachingActivityLock.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

Se si dispone di alcuni aggiornamenti dell'interfaccia utente, ricordarsi di eseguirli sul thread dell'interfaccia utente. Devo aggiornare ImgeView, quindi ho fatto:

image.post(new Runnable() {

    @Override
    public void run() {
        image.setImageBitmap(imageToShow);
    }
});

L'ordine in cui vengono richiamati i callback dopo commit ():

1. Qualunque metodo tu chiami manualmente subito dopo commit ()
2. onAttach ()
3. onCreateView ()
4. onActivityCreated ()

Avevo bisogno di fare un lavoro che coinvolgesse alcune viste, quindi onAttach () non ha funzionato per me; si è rotto. Quindi ho spostato parte del mio codice che stava impostando alcuni parametri all'interno di un metodo chiamato subito dopo commit () (1.), quindi l'altra parte del codice che gestiva la vista all'interno di onCreateView () (3.).

Sto usando OkHttp e ho appena affrontato questo problema.

Per la prima parte, @thucnguyen era sulla buona strada .

Questo si è verificato quando si chiama getActivity () in un altro thread terminato dopo la rimozione del frammento. Il caso tipico è chiamare getActivity () (es. Per un Toast) al termine di una richiesta HTTP (ad esempio in onResponse).

Alcune chiamate HTTP venivano eseguite anche dopo che l'attività era stata chiusa (perché il completamento di una richiesta HTTP può richiedere del tempo). Poi, attraverso il HttpCallbacktentativo di aggiornare alcuni campi Frammento e ho ottenuto nullun'eccezione quando ho provato a farlo getActivity().

http.newCall(request).enqueue(new Callback(...
  onResponse(Call call, Response response) {
    ...
    getActivity().runOnUiThread(...) // <-- getActivity() was null when it had been destroyed already

La soluzione IMO è impedire che si verifichino callback quando il frammento non è più in vita (e non solo con Okhttp).

La correzione: prevenzione.

Se dai un'occhiata al ciclo di vita dei frammenti (maggiori informazioni qui ), noterai che ci sono onAttach(Context context)e onDetach()metodi. Questi vengono chiamati dopo che il frammento appartiene a un'attività e poco prima di smettere di esserlo, rispettivamente.

Ciò significa che possiamo impedire che il callback avvenga controllandolo nel onDetachmetodo.

@Override
public void onAttach(Context context) {
    super.onAttach(context);

    // Initialize HTTP we're going to use later.
    http = new OkHttpClient.Builder().build();
}

@Override
public void onDetach() {
    super.onDetach();

    // We don't want to receive any more information about the current HTTP calls after this point.
    // With Okhttp we can simply cancel the on-going ones (credits to https://github.com/square/okhttp/issues/2205#issuecomment-169363942).
    for (Call call : http.dispatcher().queuedCalls()) {
        call.cancel();
    }
    for (Call call : http.dispatcher().runningCalls()) {
        call.cancel();
    }
}

Come si chiama questa funzione? Se lo chiami nel costruttore di Fragment, tornerà null.

Basta chiamare getActivity()quando onCreateView()viene eseguito il metodo .

Fai come segue. Penso che ti sarà utile.

private boolean isVisibleToUser = false;
private boolean isExecutedOnce = false;


@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View root = inflater.inflate(R.layout.fragment_my, container, false);
    if (isVisibleToUser && !isExecutedOnce) {
        executeWithActivity(getActivity());
    }
    return root;
}

@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
    super.setUserVisibleHint(isVisibleToUser);
    this.isVisibleToUser = isVisibleToUser;
    if (isVisibleToUser && getActivity()!=null) {
        isExecutedOnce =true;
        executeWithActivity(getActivity());
    }
}


private void executeWithActivity(Activity activity){
    //Do what you have to do when page is loaded with activity

}

Coloro che hanno ancora il problema con onAttach (Attività attività), è appena cambiato in Contesto -

    @Override
public void onAttach(Context context) {
    super.onAttach(context);
    this.context = context;
}

Nella maggior parte dei casi, salvare il contesto sarà sufficiente per te, ad esempio se vuoi ottenere getResources () puoi farlo direttamente dal contesto. Se hai ancora bisogno di inserire il contesto nella tua attività, fallo -

 @Override
public void onAttach(Context context) {
    super.onAttach(context);
    mActivity a; //Your activity class - will probably be a global var.
    if (context instanceof mActivity){
        a=(mActivity) context;
    }
}

Come suggerito dall'utente1868713.

Puoi usare onAttach o se non vuoi mettere onAttach ovunque quindi puoi mettere un metodo che restituisce ApplicationContext sulla classe principale dell'app:

public class App {
    ...  
    private static Context context;

    @Override
    public void onCreate() {
        super.onCreate();
        context = this;
    }

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

Dopodiché puoi riutilizzarlo ovunque in tutto il tuo progetto, in questo modo:

App.getContext().getString(id)

Per favore fatemi sapere se questo non funziona per voi.

Un'altra buona soluzione sarebbe utilizzare LiveData di Android con architettura MVVM. Definiresti un oggetto LiveData all'interno di ViewModel e lo osserveresti nel tuo frammento, e quando il valore di LiveData viene modificato, notificherebbe il tuo osservatore (frammento in questo caso) solo se il tuo frammento è in stato attivo, quindi sarebbe garantito che tu farebbe funzionare la tua UI e accederà all'attività solo quando il tuo frammento è in stato attivo. Questo è un vantaggio offerto da LiveData

Naturalmente quando questa domanda è stata posta per la prima volta, non esisteva LiveData. Lascio qui questa risposta perché, come vedo, c'è ancora questo problema e potrebbe essere utile a qualcuno.

Chiama il metodo getActivity () all'interno di onActivityCreated ()