J'ai un fragment (F1) avec une méthode publique comme celle-ci

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

et oui quand je l'appelle (à partir de l'activité), c'est nul ...

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

Ce doit être quelque chose que je fais très mal, mais je ne sais pas ce que c'est

commit planifie la transaction, c'est-à-dire qu'elle ne se produit pas tout de suite mais est planifiée comme un travail sur le thread principal la prochaine fois que le thread principal est prêt.

Je suggère d'ajouter un

onAttach(Activity activity)

méthode à votre Fragmentet en mettant un point d'arrêt dessus et en voyant quand il est appelé par rapport à votre appel asd(). Vous verrez qu'il est appelé après la méthode où vous faites l'appel aux asd()sorties. L' onAttachappel est l'endroit où le Fragmentest attaché à son activité et à partir de ce point getActivity()retournera non nul (nb il y a aussi un onDetach()appel).

Le mieux pour s'en débarrasser est de conserver la référence d'activité lorsque onAttach est appelé et d'utiliser la référence d'activité là où c'est nécessaire, par exemple

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

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

Cela se produit lorsque vous appelez getActivity()un autre thread qui s'est terminé après la suppression du fragment. Le cas typique est l'appel getActivity()(par exemple pour a Toast) lorsqu'une requête HTTP est terminée ( onResponsepar exemple).

Pour éviter cela, vous pouvez définir un nom de champ mActivityet l'utiliser à la place de getActivity(). Ce champ peut être initialisé dans la méthode onAttach () de Fragment comme suit:

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

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

Dans mes projets, je définis généralement une classe de base pour tous mes fragments avec cette fonctionnalité:

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

Bon codage,

Les autres réponses qui suggèrent de garder une référence à l'activité dans onAttach suggèrent simplement un pansement au problème réel. Lorsque getActivity renvoie null, cela signifie que le fragment n'est pas attaché à l'activité. Le plus souvent, cela se produit lorsque l'activité a disparu en raison de la rotation ou de la fin de l'activité, mais que le fragment a toujours une sorte d'écouteur de rappel enregistré. Lorsque l'auditeur est appelé, si vous devez faire quelque chose avec l'activité mais que l'activité a disparu, vous ne pouvez pas faire grand-chose. Dans votre code, vous devez simplement vérifiergetActivity() != nullet si ce n'est pas là, ne faites rien. Si vous conservez une référence à l'activité qui a disparu, vous empêchez l'activité d'être récupérée. Toutes les actions de l'interface utilisateur que vous pourriez essayer de faire ne seront pas vues par l'utilisateur. Je peux imaginer des situations où, dans l'écouteur de rappel, vous voudrez peut-être avoir un contexte pour quelque chose de non lié à l'interface utilisateur, dans ces cas, il est probablement plus logique d'obtenir le contexte de l'application. Notez que la seule raison pour laquelle l' onAttachastuce n'est pas une grosse fuite de mémoire est que normalement après l'exécution de l'écouteur de rappel, il ne sera plus nécessaire et peut être récupéré avec le fragment, toutes ses vues et le contexte d'activité. Si voussetRetainInstance(true) il y a un plus grand risque de fuite de mémoire car le champ Activité sera également conservé mais après la rotation, cela pourrait être l'activité précédente et non l'actuelle.

Depuis le niveau 23 d'API Android, onAttach (activité d'activité) est obsolète. Vous devez utiliser onAttach (contexte de contexte). http://developer.android.com/reference/android/app/Fragment.html#onAttach(android.app.Activity)

L'activité est un contexte, donc si vous pouvez simplement vérifier le contexte est une activité et la cast si nécessaire.

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

    Activity a;

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

}

PJL a raison. J'ai utilisé sa suggestion et voici ce que j'ai fait:

1. variables globales définies pour le fragment:

   private final Object attachingActivityLock = new Object();

   private boolean syncVariable = false;

2. mis en œuvre

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

3. J'ai terminé ma fonction, où j'ai besoin d'appeler getActivity (), dans thread, car si elle s'exécutait sur le thread principal, je bloquerais le thread avec l'étape 4. et onAttach () ne serait jamais appelé.

    Thread processImage = new Thread(new Runnable() {

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

4. dans ma fonction où j'ai besoin d'appeler getActivity (), je l'utilise (avant l'appel getActivity ())

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

Si vous avez des mises à jour de l'interface utilisateur, n'oubliez pas de les exécuter sur le fil de l'interface utilisateur. J'ai besoin de mettre à jour ImgeView donc j'ai fait:

image.post(new Runnable() {

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

L'ordre dans lequel les rappels sont appelés après commit ():

1. Quelle que soit la méthode que vous appelez manuellement juste après commit ()
2. onAttach ()
3. onCreateView ()
4. onActivityCreated ()

J'avais besoin de faire un travail qui impliquait des vues, donc onAttach () ne fonctionnait pas pour moi; il s'est écrasé. J'ai donc déplacé une partie de mon code qui définissait certains paramètres dans une méthode appelée juste après commit () (1.), puis l'autre partie du code qui gérait la vue à l'intérieur de onCreateView () (3.).

J'utilise OkHttp et je viens de faire face à ce problème.

Pour la première partie, @thucnguyen était sur la bonne voie .

Cela s'est produit lorsque vous appelez getActivity () dans un autre thread qui s'est terminé après la suppression du fragment. Le cas typique est l'appel de getActivity () (par exemple pour un Toast) lorsqu'une requête HTTP est terminée (dans onResponse par exemple).

Certains appels HTTP étaient en cours d'exécution même après la fermeture de l'activité (car cela peut prendre un certain temps pour qu'une requête HTTP soit terminée). J'ai ensuite HttpCallbackessayé de mettre à jour certains champs Fragment et j'ai obtenu une nullexception en essayant de le faire getActivity().

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

IMO, la solution est d' empêcher les rappels de se produire lorsque le fragment n'est plus en vie (et ce n'est pas seulement avec Okhttp).

Le correctif: la prévention.

Si vous regardez le cycle de vie des fragments (plus d'informations ici ), vous remarquerez qu'il existe des méthodes onAttach(Context context)et onDetach(). Ceux-ci sont appelés après que le fragment appartient à une activité et juste avant de cesser de l'être respectivement.

Cela signifie que nous pouvons empêcher ce rappel de se produire en le contrôlant dans la onDetachméthode.

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

Où appelez-vous cette fonction? Si vous l'appelez dans le constructeur de Fragment, il retournera null.

Appelez simplement getActivity()lorsque la méthode onCreateView()est exécutée.

Faites comme suit. Je pense que cela vous sera 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

}

Ceux qui ont encore le problème avec onAttach (activité d'activité), il vient de changer en contexte -

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

Dans la plupart des cas, la sauvegarde du contexte vous suffira - par exemple, si vous voulez faire getResources (), vous pouvez le faire directement à partir du contexte. Si vous devez encore intégrer le contexte à votre activité, faites-le -

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

Comme suggéré par user1868713.

Vous pouvez utiliser onAttach ou si vous ne voulez pas mettre onAttach partout, vous pouvez mettre une méthode qui retourne ApplicationContext sur la classe App principale:

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

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

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

Après cela, vous pouvez le réutiliser partout dans tout votre projet, comme ceci:

App.getContext().getString(id)

S'il vous plaît laissez-moi savoir si cela ne fonctionne pas pour vous.

Une autre bonne solution serait d'utiliser LiveData d'Android avec l'architecture MVVM. Vous définiriez un objet LiveData dans votre ViewModel et l'observeriez dans votre fragment, et lorsque la valeur LiveData est modifiée, il avertirait votre observateur (fragment dans ce cas) uniquement si votre fragment est à l'état actif, il serait donc garanti que vous ferait fonctionner votre interface utilisateur et accéder à l'activité uniquement lorsque votre fragment est à l'état actif. C'est l'un des avantages de LiveData

Bien sûr, lorsque cette question a été posée pour la première fois, il n'y avait pas de LiveData. Je laisse cette réponse ici parce que, comme je le vois, il y a toujours ce problème et cela pourrait être utile à quelqu'un.

Appelez la méthode getActivity () dans onActivityCreated ()