Androide. Fragment getActivity () a veces devuelve null

Ok, sé que esta pregunta está realmente resuelta, pero decidí compartir mi solución para esto. He creado la clase padre abstracta para mi Fragment:

public abstract class ABaseFragment extends Fragment{

    protected IActivityEnabledListener aeListener;

    protected interface IActivityEnabledListener{
        void onActivityEnabled(FragmentActivity activity);
    }

    protected void getAvailableActivity(IActivityEnabledListener listener){
        if (getActivity() == null){
            aeListener = listener;

        } else {
            listener.onActivityEnabled(getActivity());
        }
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) activity);
            aeListener = null;
        }
    }

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

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) context);
            aeListener = null;
        }
    }
}

Como se puede ver, he añadido un oyente por lo que, cada vez que voy a necesitar para obtener Fragments Activity en lugar del estándar getActivity(), tendré que llamar a

 getAvailableActivity(new IActivityEnabledListener() {
        @Override
        public void onActivityEnabled(FragmentActivity activity) {
            // Do manipulations with your activity
        }
    });

Lo mejor para deshacerse de esto es mantener la referencia de actividad cuando se llama onAttach y usar la referencia de actividad donde sea necesario, por ejemplo,

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

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

Editado, ya que onAttach(Activity) está depreciado y ahora onAttach(Context) se está utilizando

No llame a métodos dentro del fragmento que requieren getActivity() hasta que se inicie en la actividad principal.

private MyFragment myFragment;


public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);

    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    myFragment = new MyFragment();

    ft.add(android.R.id.content, youtubeListFragment).commit();

    //Other init calls
    //...
}


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

    //Call your Fragment functions that uses getActivity()
    myFragment.onPageSelected();
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    // run the code making use of getActivity() from here
}

He estado luchando contra este tipo de problema durante un tiempo, y creo que he encontrado una solución confiable.

Es bastante difícil saber con certeza que this.getActivity() no va a devolver null para un Fragment, especialmente si se trata de cualquier tipo de comportamiento de red que le da a su código tiempo suficiente para retirar referencias Activity.

En la solución a continuación, declaro una pequeña clase de administración llamada ActivityBuffer. Esencialmente, este class trata de mantener un referencia confiable a un Activity propietario, y prometiendo ejecutar Runnables dentro de un contexto Activity válido siempre que haya una referencia válida disponible. Los Runnable s están programados para la ejecución en el subproceso de la interfaz de usuario inmediatamente si el Context está disponible, de lo contrario la ejecución se pospone hasta que Context esté listo.

/** A class which maintains a list of transactions to occur when Context becomes available. */
public final class ActivityBuffer {

    /** A class which defines operations to execute once there's an available Context. */
    public interface IRunnable {
        /** Executes when there's an available Context. Ideally, will it operate immediately. */
        void run(final Activity pActivity);
    }

    /* Member Variables. */
    private       Activity        mActivity;
    private final List<IRunnable> mRunnables;

    /** Constructor. */
    public ActivityBuffer() {
        // Initialize Member Variables.
        this.mActivity  = null;
        this.mRunnables = new ArrayList<IRunnable>();
    }

    /** Executes the Runnable if there's an available Context. Otherwise, defers execution until it becomes available. */
    public final void safely(final IRunnable pRunnable) {
        // Synchronize along the current instance.
        synchronized(this) {
            // Do we have a context available?
            if(this.isContextAvailable()) {
                // Fetch the Activity.
                final Activity lActivity = this.getActivity();
                // Execute the Runnable along the Activity.
                lActivity.runOnUiThread(new Runnable() { @Override public final void run() { pRunnable.run(lActivity); } });
            }
            else {
                // Buffer the Runnable so that it's ready to receive a valid reference.
                this.getRunnables().add(pRunnable);
            }
        }
    }

    /** Called to inform the ActivityBuffer that there's an available Activity reference. */
    public final void onContextGained(final Activity pActivity) {
        // Synchronize along ourself.
        synchronized(this) {
            // Update the Activity reference.
            this.setActivity(pActivity);
            // Are there any Runnables awaiting execution?
            if(!this.getRunnables().isEmpty()) {
                // Iterate the Runnables.
                for(final IRunnable lRunnable : this.getRunnables()) {
                    // Execute the Runnable on the UI Thread.
                    pActivity.runOnUiThread(new Runnable() { @Override public final void run() {
                        // Execute the Runnable.
                        lRunnable.run(pActivity);
                    } });
                }
                // Empty the Runnables.
                this.getRunnables().clear();
            }
        }
    }

    /** Called to inform the ActivityBuffer that the Context has been lost. */
    public final void onContextLost() {
        // Synchronize along ourself.
        synchronized(this) {
            // Remove the Context reference.
            this.setActivity(null);
        }
    }

    /** Defines whether there's a safe Context available for the ActivityBuffer. */
    public final boolean isContextAvailable() {
        // Synchronize upon ourself.
        synchronized(this) {
            // Return the state of the Activity reference.
            return (this.getActivity() != null);
        }
    }

    /* Getters and Setters. */
    private final void setActivity(final Activity pActivity) {
        this.mActivity = pActivity;
    }

    private final Activity getActivity() {
        return this.mActivity;
    }

    private final List<IRunnable> getRunnables() {
        return this.mRunnables;
    }

}

En términos de su implementación, debemos tener cuidado de aplicar los métodos del ciclo de vida para que coincidan con el comportamiento descrito anteriormente por Pawan M :

public class BaseFragment extends Fragment {

    /* Member Variables. */
    private ActivityBuffer mActivityBuffer;

    public BaseFragment() {
        // Implement the Parent.
        super();
        // Allocate the ActivityBuffer.
        this.mActivityBuffer = new ActivityBuffer();
    }

    @Override
    public final void onAttach(final Context pContext) {
        // Handle as usual.
        super.onAttach(pContext);
        // Is the Context an Activity?
        if(pContext instanceof Activity) {
            // Cast Accordingly.
            final Activity lActivity = (Activity)pContext;
            // Inform the ActivityBuffer.
            this.getActivityBuffer().onContextGained(lActivity);
        }
    }

    @Deprecated @Override
    public final void onAttach(final Activity pActivity) {
        // Handle as usual.
        super.onAttach(pActivity);
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextGained(pActivity);
    }

    @Override
    public final void onDetach() {
        // Handle as usual.
        super.onDetach();
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextLost();
    }

    /* Getters. */
    public final ActivityBuffer getActivityBuffer() {
        return this.mActivityBuffer;
    }

}

Finalmente, en cualquier área dentro de su Fragment que se extiende BaseFragment que no es confiable acerca de una llamada a getActivity(), simplemente haga una llamada a this.getActivityBuffer().safely(...) y declare un ActivityBuffer.IRunnable para la tarea!

El contenido de su void run(final Activity pActivity) está garantizado para ejecutarse a lo largo del subproceso de la interfaz de usuario.

Sé que esta es una vieja pregunta, pero creo que debo darle mi respuesta porque mi problema no fue resuelto por otros.

En primer lugar : estaba agregando fragmentos dinámicamente usando fragmentTransactions. Segundo: mis fragmentos fueron modificados usando AsyncTasks (consultas de base de datos en un servidor). Tercero: mi fragmento no fue instanciado al inicio de la actividad Cuarto: utilicé una instanciación de fragmentos personalizada "create or load it" para obtener la variable fragment. Cuarto: la actividad fue recreada debido a cambio de orientación

El problema era que quería "eliminar" el fragmento debido a la respuesta de la consulta, pero el fragmento se creó incorrectamente justo antes. No se por qué, probablemente debido al "commit" que se hizo más tarde, el fragmento no se agregó todavía cuando era el momento de eliminarlo. Por lo tanto getActivity() estaba devolviendo null.

Solución : 1) Tuve que comprobar que estaba tratando correctamente de encontrar la primera instancia del fragmento antes de crear uno nuevo 2)tuve que poner serRetainInstance (true) en ese fragmento para mantenerlo a través del cambio de orientación (no se necesita backstack, por lo tanto, no hay problema) 3) En lugar de "recrear o obtener un fragmento antiguo" justo antes de "eliminarlo", pongo directamente el fragmento al inicio de la actividad. Instanciarla al inicio de la actividad en lugar de "cargar" (o instanciar) la variable fragment antes de eliminarla evitó problemas con getActivity.