Fragmento MyFragment no adjunto a la actividad

Me he enfrentado a dos escenarios diferentes aquí:

1) Cuando quiero que la tarea asíncrona termine de todos modos: imagine que mi onPostExecute almacena los datos recibidos y luego llama a un oyente para actualizar las vistas, por lo que, para ser más eficiente, quiero que la tarea termine de todos modos para tener los datos listos cuando el usuario regrese. En este caso suelo hacer esto:

@Override
protected void onPostExecute(void result) {
    // do whatever you do to save data
    if (this.getView() != null) {
        // update views
    }
}

2) Cuando quiero que la tarea asíncrona solo termine cuando las vistas se puedan actualizar: el caso que está proponiendo aquí, la tarea solo actualiza vistas, no se necesita almacenamiento de datos, por lo que no tiene ni idea de que la tarea termine si las vistas ya no se muestran. Hago esto:

@Override
protected void onStop() {
    // notice here that I keep a reference to the task being executed as a class member:
    if (this.myTask != null && this.myTask.getStatus() == Status.RUNNING) this.myTask.cancel(true);
    super.onStop();
}

No he encontrado ningún problema con esto, aunque también uso una forma (tal vez) más compleja que incluye el lanzamiento de tareas desde la actividad en lugar de los fragmentos.

¡Ojalá esto ayude a alguien! :)

El problema es que está intentando acceder a recursos (en este caso, cadenas) usando getResources().getString (), que intentará obtener los recursos de la Actividad. Vea este código fuente de la clase Fragment:

 /**
  * Return <code>getActivity().getResources()</code>.
  */
 final public Resources getResources() {
     if (mHost == null) {
         throw new IllegalStateException("Fragment " + this + " not attached to Activity");
     }
     return mHost.getContext().getResources();
 }

mHost es el objeto que contiene su Actividad.

Debido a que la Actividad puede no estar adjunta, tu llamada a getResources() lanzará una Excepción.

La solución aceptada en mi humilde opinión no es el camino a seguir, ya que solo está ocultando el problema. La forma correcta es solo para obtener los recursos de otro lugar que siempre se garantiza que existen, como el contexto de la aplicación:

youApplicationObject.getResources().getString(...)

El problema con su código es la forma en que está utilizando la AsyncTask, porque cuando gira la pantalla durante su hilo de suspensión:

Thread.sleep(2000) 

La AsyncTask sigue funcionando, es porque no cancelaste la instancia AsyncTask correctamente en onDestroy() antes de que el fragmento se reconstruya (cuando rotes) y cuando esta misma instancia AsyncTask (después de rotar) se ejecuta onPostExecute (), esto intenta encontrar los recursos con getResources () con la instancia de fragmento anterior (una instancia no válida):

getResources().getString(R.string.app_name)

Que es equivalente a:

MyFragment.this.getResources().getString(R.string.app_name)

Así que la solución final es administrar la instancia de AsyncTask (para cancelar si esto sigue funcionando) antes de que el fragmento se reconstruya cuando gire la pantalla, y si se cancela durante la transición, reinicie la AsyncTask después de la reconstrucción con la ayuda de una bandera booleana:

public class MyFragment extends SherlockFragment {

    private MyAsyncTask myAsyncTask = null;
    private boolean myAsyncTaskIsRunning = true;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if(savedInstanceState!=null) {
            myAsyncTaskIsRunning = savedInstanceState.getBoolean("myAsyncTaskIsRunning");
        }
        if(myAsyncTaskIsRunning) {
            myAsyncTask = new MyAsyncTask();
            myAsyncTask.execute();
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putBoolean("myAsyncTaskIsRunning",myAsyncTaskIsRunning);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if(myAsyncTask!=null) myAsyncTask.cancel(true);
        myAsyncTask = null;

    }

    public class MyAsyncTask extends AsyncTask<Void, Void, Void>() {

        public MyAsyncTask(){}

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            myAsyncTaskIsRunning = true;
        }
        @Override
        protected Void doInBackground(Void... params) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException ex) {}
            return null;
        }

        @Override
        protected void onPostExecute(Void result){
            getResources().getString(R.string.app_name);
            myAsyncTaskIsRunning = false;
            myAsyncTask = null;
        }

    }
}

Su solución es bastante truco para esto y fuga de fragmento de la actividad.

Por lo tanto, en el caso de getResource o cualquier cosa que dependa del contexto de la actividad que acceda desde el fragmento, siempre se verifica el estado de la actividad y el estado de los fragmentos de la siguiente manera

 Activity activity = getActivity(); 
    if(activity != null && isAdded())

         getResources().getString(R.string.no_internet_error_msg);
//Or any other depends on activity context to be live like dailog


        }
    }

Me enfrenté al mismo problema que acabo de añadir la instancia singletone para obtener el recurso como se refiere por Erick

MainFragmentActivity.defaultInstance().getResources().getString(R.string.app_name);

También puedes usar

getActivity().getResources().getString(R.string.app_name);

Espero que esto ayude.

if (getActivity() == null) return;

Funciona también en algunos casos. Solo rompe la ejecución de código de ella y asegúrese de que la aplicación no se bloquee

Me enfrenté a problemas similares cuando la actividad de configuración de la aplicación con las preferencias cargadas era visible. Si cambiara una de las preferencias y luego hiciera que el contenido de la pantalla girara y cambiara la preferencia nuevamente, se bloquearía con un mensaje de que el fragmento (mi clase de preferencias) no estaba adjunto a una actividad.

Al depurar parecía que el método onCreate() de PreferencesFragment estaba siendo llamado dos veces cuando el contenido de display giraba. Eso fue extraño. ya es suficiente. Luego agregué la comprobación isAdded () fuera del bloque donde indicaría el bloqueo y resolvió el problema.

Aquí está el código del receptor que actualiza el resumen de preferencias para mostrar la nueva entrada. Se encuentra en el método onCreate() de mi clase Preferences que extiende la clase PreferenceFragment:

public static class Preferences extends PreferenceFragment {
    SharedPreferences.OnSharedPreferenceChangeListener listener;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        // ...
        listener = new SharedPreferences.OnSharedPreferenceChangeListener() {
            @Override
            public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
                // check if the fragment has been added to the activity yet (necessary to avoid crashes)
                if (isAdded()) {
                    // for the preferences of type "list" set the summary to be the entry of the selected item
                    if (key.equals(getString(R.string.pref_fileviewer_textsize))) {
                        ListPreference listPref = (ListPreference) findPreference(key);
                        listPref.setSummary("Display file content with a text size of " + listPref.getEntry());
                    } else if (key.equals(getString(R.string.pref_fileviewer_segmentsize))) {
                        ListPreference listPref = (ListPreference) findPreference(key);
                        listPref.setSummary("Show " + listPref.getEntry() + " bytes of a file at once");
                    }
                }
            }
        };
        // ...
    }

¡Espero que esto ayude a otros!

Si extiende la clase Application y mantiene un objeto de contexto 'global' estático, de la siguiente manera, entonces puede usar eso en lugar de la actividad para cargar un recurso de cadena.

public class MyApplication extends Application {
    public static Context GLOBAL_APP_CONTEXT;

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

Si usa esto, puede salirse con la suya con Toast y la carga de recursos sin preocuparse por los ciclos de vida.

En mi caso, los métodos de fragmento se han llamado después de

getActivity().onBackPressed();

Un post antiguo, pero me sorprendió la respuesta más votada.

La solución adecuada para esto debería ser cancelar la asynctask en onStop (o donde sea apropiado en tu fragmento). De esta manera no introducirás una fuga de memoria (una asynctask manteniendo una referencia a tu fragmento destruido) y tendrás un mejor control de lo que está pasando en tu fragmento.

@Override
public void onStop() {
    super.onStop();
    mYourAsyncTask.cancel(true);
}