java.lang.IllegalStateException: vous ne Pouvez pas effectuer cette action après onSaveInstanceState

Je suis en utilisant la bibliothèque de prise en charge pour mon application. Dans mon FragmentActivity je suis en utilisant une AsyncTask pour le téléchargement de données à partir d'internet. Dans le onPreExecute() méthode que j'ai ajouter un Fragment et dans le onPostExecute() la méthode je l'enlever de nouveau. Lorsque l'orientation est modifiée entre les deux, je reçois l'exception mentionnée ci-dessus. Veuillez prendre un regard sur les détails:

private class onFriendAddedAsyncTask extends AsyncTask<String, Void, String> {
    DummyFragment dummyFragment; 
    FragmentManager fm;
    FragmentTransaction ft;

@Override
protected void onPreExecute() {
    Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute");
    dummyFragment = DummyFragment.newInstance();
    fm = getSupportFragmentManager();
    ft = fm.beginTransaction();
    ft.add(dummyFragment, "dummy_fragment");
    ft.commit();
}

@Override
protected void onPostExecute(String result) {
    Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute");
    ft = fm.beginTransaction();
    ft.remove(dummyFragment);
    ft.commit();
}

@Override
protected String doInBackground(String... name) {
    Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/doInBackground");
    ...
}

- Je obtenir suivantes LogCut:

01-05 23:54:19.958: V/MyFragmentActivity(12783): onFriendAddedAsyncTask/onPreExecute
01-05 23:54:19.968: V/DummyFragment(12783): onAttach
01-05 23:54:19.968: V/DummyFragment(12783): onCreate
01-05 23:54:19.968: V/MyFragmentActivity(12783): onFriendAddedAsyncTask/doInBackground
01-05 23:54:19.973: V/DummyFragment(12783): onCreateView
01-05 23:54:19.973: V/DummyFragment(12783): onActivityCreated
01-05 23:54:19.973: V/DummyFragment(12783): onStart
01-05 23:54:19.973: V/DummyFragment(12783): onResume
01-05 23:54:21.933: V/MyFragmentActivity(12783): onSaveInstanceState
01-05 23:54:21.933: V/DummyFragment(12783): onSaveInstanceState
01-05 23:54:21.933: V/MyFragmentActivity(12783): onPause
01-05 23:54:21.933: V/DummyFragment(12783): onPause
01-05 23:54:21.938: V/MyFragmentActivity(12783): onStop
01-05 23:54:21.938: V/DummyFragment(12783): onStop
01-05 23:54:21.938: V/MyFragmentActivity(12783): onDestroy
01-05 23:54:21.938: V/DummyFragment(12783): onDestroyView
01-05 23:54:21.938: V/DummyFragment(12783): onDestroy
01-05 23:54:21.938: V/DummyFragment(12783): onDetach
01-05 23:54:21.978: V/MyFragmentActivity(12783): onCreate
01-05 23:54:21.978: V/DummyFragment(12783): onAttach
01-05 23:54:21.978: V/DummyFragment(12783): onCreate
01-05 23:54:22.263: V/MyFragmentActivity(12783): onStart
01-05 23:54:22.313: V/DummyFragment(12783): onCreateView
01-05 23:54:22.313: V/DummyFragment(12783): onActivityCreated
01-05 23:54:22.313: V/DummyFragment(12783): onStart
01-05 23:54:22.323: V/MyFragmentActivity(12783): onResume
01-05 23:54:22.323: V/MyFragmentActivity(12783): onPostResume
01-05 23:54:22.323: V/MyFragmentActivity(12783): onResumeFragments
01-05 23:54:22.323: V/DummyFragment(12783): onResume
01-05 23:54:27.123: V/MyFragmentActivity(12783): onFriendAddedAsyncTask/onPostExecute
01-05 23:54:27.123: D/AndroidRuntime(12783): Shutting down VM
01-05 23:54:27.123: W/dalvikvm(12783): threadid=1: thread exiting with uncaught exception (group=0x4001d7d0)
01-05 23:54:27.138: E/AndroidRuntime(12783): FATAL EXCEPTION: main
01-05 23:54:27.138: E/AndroidRuntime(12783): java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1314)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1325)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:548)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:532)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at com.xyz.dummy.MyFragmentActivity$onFriendAddedAsyncTask.onPostExecute(MyFragmentActivity.java:447)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at com.xyz.dummy.MyFragmentActivity$onFriendAddedAsyncTask.onPostExecute(MyFragmentActivity.java:1)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.os.AsyncTask.finish(AsyncTask.java:417)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.os.AsyncTask.access$300(AsyncTask.java:127)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.os.AsyncTask$InternalHandler.handleMessage(AsyncTask.java:429)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.os.Handler.dispatchMessage(Handler.java:99)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.os.Looper.loop(Looper.java:123)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at android.app.ActivityThread.main(ActivityThread.java:4627)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at java.lang.reflect.Method.invokeNative(Native Method)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at java.lang.reflect.Method.invoke(Method.java:521)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:858)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
01-05 23:54:27.138: E/AndroidRuntime(12783):    at dalvik.system.NativeStart.main(Native Method)

Dans d'autres threads sur des problèmes similaires à la raison semble être que la onPostExecute méthode est appelée avant la onResume() la méthode est appelée. Mais j'ai l'exception même si onResume() est appelée avant.

Quelqu'un sait quel est le problème?

L'Activité ressemble à ceci:

public class MyFragmentActivity extends FragmentActivity implements OnFriendSelectedListener, OnFriendAddedListener, OnFriendOptionSelectedListener, LoaderCallbacks<Cursor> {
@Override
public void onCreate(Bundle savedInstanceState) {
Log.v("MyFragmentActivity", "onCreate");
super.onCreate(savedInstanceState);
setContentView(R.layout.fragment_activity_layout);
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
FriendListFragment friendListFragment = (FriendListFragment)fm.findFragmentById(R.id.friend_list_fragment_layout);
if (friendListFragment == null) {
friendListFragment = new FriendListFragment(); 
ft.add(R.id.friend_list_fragment_layout, friendListFragment);
ft.commit();
fm.executePendingTransactions();
startService(new Intent(this, MyIntentService.class));
getSupportLoaderManager().initLoader(CHECK_EMPTY_DATABASE, null, this);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.fragment_activity_options_menu, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
super.onOptionsItemSelected(item);
switch (item.getItemId()) {
case R.id.add_friend_menu_item:
AddFriendDialogFragment addFriendDialogFragment = AddFriendDialogFragment.newInstance();
addFriendDialogFragment.show(getSupportFragmentManager(), "add_friend_dialog_fragment");
return true;
default:
return false;
}
}
@Override
public void onFriendAdded(String name) {
name = name.trim();
if (name.length() > 0) {
new onFriendAddedAsyncTask().execute(name);
}
}

Lors de l'utilisation de commitAllowingStateLoss() j'obtiens l'exception suivante:

01-06 14:54:29.548: E/AndroidRuntime(18020): FATAL EXCEPTION: main
01-06 14:54:29.548: E/AndroidRuntime(18020): java.lang.IllegalStateException: Activity has been destroyed
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1329)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:548)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.support.v4.app.BackStackRecord.commitAllowingStateLoss(BackStackRecord.java:536)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at com.xyz.dummy.FadiaFragmentActivity$onFriendAddedAsyncTask.onPostExecute(FadiaFragmentActivity.java:461)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at com.xyz.dummy.FadiaFragmentActivity$onFriendAddedAsyncTask.onPostExecute(FadiaFragmentActivity.java:1)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.os.AsyncTask.finish(AsyncTask.java:417)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.os.AsyncTask.access$300(AsyncTask.java:127)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.os.AsyncTask$InternalHandler.handleMessage(AsyncTask.java:429)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.os.Handler.dispatchMessage(Handler.java:99)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.os.Looper.loop(Looper.java:123)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at android.app.ActivityThread.main(ActivityThread.java:4627)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at java.lang.reflect.Method.invokeNative(Native Method)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at java.lang.reflect.Method.invoke(Method.java:521)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:858)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
01-06 14:54:29.548: E/AndroidRuntime(18020):    at dalvik.system.NativeStart.main(Native Method)

Je reçois le même IllegalStateExeption lorsque je mettre en œuvre le AsynTask comme suit, parce que le findFragmentById() la méthode retourne un pointeur null.

private class onFriendAddedAsyncTask extends AsyncTask<String, Void, String> {
protected void onPreExecute() {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute");
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = DummyFragment.newInstance();
ft.add(R.id.dummy_fragment_layout, dummyFragment);
ft.commit();
}
protected void onPostExecute(String result) {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute");
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = (DummyFragment) fm.findFragmentById(R.id.dummy_fragment_layout);
ft.remove(dummyFragment);
ft.commitAllowingStateLoss();
}

Dans la prochaine étape, j'utilise un gestionnaire pour l'ajout et la suppression de la DummyFragment. De plus, j'ai ajouté un peu plus de la sortie de débogage.

private class onFriendAddedAsyncTask extends AsyncTask<String, Void, String> {
@Override
protected void onPreExecute() {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager());
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager().findFragmentById(R.id.dummy_fragment_layout));
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager().findFragmentById(R.id.friend_list_fragment_layout));
new Handler().post(new Runnable() {
public void run() {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager());
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager().findFragmentById(R.id.dummy_fragment_layout));
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPreExecute " + getSupportFragmentManager().findFragmentById(R.id.friend_list_fragment_layout));
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = DummyFragment.newInstance();
ft.add(R.id.dummy_fragment_layout, dummyFragment);
ft.commit();
}
});
@Override
protected void onPostExecute(String result) {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager());
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager().findFragmentById(R.id.dummy_fragment_layout));
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager().findFragmentById(R.id.friend_list_fragment_layout));
new Handler().post(new Runnable() {
public void run() {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager());
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager().findFragmentById(R.id.dummy_fragment_layout));
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute " + getSupportFragmentManager().findFragmentById(R.id.friend_list_fragment_layout));
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = (DummyFragment) fm.findFragmentById(R.id.dummy_fragment_layout);
ft.remove(dummyFragment);
ft.commitAllowingStateLoss();
}
});

- Je obtenir suivantes LogCut:

01-07 19:00:17.273: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute FragmentManager{45e384a8 in MyFragmentActivity{45e38358}}
01-07 19:00:17.273: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute null
01-07 19:00:17.273: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute FriendListFragment{45e38ab0 #0 id=0x7f0a0002}
01-07 19:00:17.283: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute FragmentManager{45e384a8 in MyFragmentActivity{45e38358}}
01-07 19:00:17.288: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/doInBackground
01-07 19:00:17.288: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute null
01-07 19:00:17.288: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPreExecute FriendListFragment{45e38ab0 #0 id=0x7f0a0002}
01-07 19:00:17.308: V/DummyFragment(4124): onAttach DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:17.308: V/DummyFragment(4124): onCreate DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:17.308: V/DummyFragment(4124): onCreateView DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:17.308: V/DummyFragment(4124): onActivityCreated DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:17.308: V/DummyFragment(4124): onStart DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:17.313: V/DummyFragment(4124): onResume DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.098: V/MyFragmentActivity(4124): onSaveInstanceState DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.098: V/DummyFragment(4124): onSaveInstanceState DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.098: V/MyFragmentActivity(4124): onPause DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.098: V/DummyFragment(4124): onPause DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.103: V/MyFragmentActivity(4124): onStop DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.103: V/DummyFragment(4124): onStop DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.103: V/MyFragmentActivity(4124): onDestroy DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.103: V/DummyFragment(4124): onDestroyView DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.108: V/DummyFragment(4124): onDestroy DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.113: V/DummyFragment(4124): onDetach DummyFragment{45dd7498 #2 id=0x7f0a0004}
01-07 19:00:18.138: V/MyFragmentActivity(4124): onCreate
01-07 19:00:18.138: V/FriendListFragment(4124): FriendListFragment
01-07 19:00:18.138: V/FriendListFragment(4124): onAttach FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.138: V/FriendListFragment(4124): onCreate FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.148: V/DummyFragment(4124): onAttach DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.153: V/DummyFragment(4124): onCreate DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.523: V/MyFragmentActivity(4124): onStart DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.543: V/FriendListFragment(4124): onActivityCreated FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.548: V/DummyFragment(4124): onCreateView DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.548: V/DummyFragment(4124): onActivityCreated DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.548: V/FriendListFragment(4124): onLoadFinished FragmentManager{45d8e478 in MyFragmentActivity{45e4a6d8}}
01-07 19:00:18.548: V/FriendListFragment(4124): onLoadFinished FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.553: V/DummyFragment(4124): onStart DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.553: V/FriendListFragment(4124): onLoadFinished FragmentManager{45d8e478 in MyFragmentActivity{45e4a6d8}}
01-07 19:00:18.553: V/FriendListFragment(4124): onLoadFinished FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.558: V/MyFragmentActivity(4124): onResume DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.558: V/MyFragmentActivity(4124): onPostResume DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.558: V/MyFragmentActivity(4124): onResumeFragments DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.558: V/FriendListFragment(4124): onResume FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.563: V/FriendListFragment(4124): onCreateLoader FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.563: V/DummyFragment(4124): onResume DummyFragment{45d7d1a0 #2 id=0x7f0a0004}
01-07 19:00:18.723: V/FriendListFragment(4124): onLoadFinished FragmentManager{45d8e478 in MyFragmentActivity{45e4a6d8}}
01-07 19:00:18.723: V/FriendListFragment(4124): onLoadFinished FriendListFragment{45e4a7f8 #0 id=0x7f0a0002}
01-07 19:00:18.893: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute FragmentManager{45e384a8 in null}}
01-07 19:00:18.893: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute null
01-07 19:00:18.893: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute null
01-07 19:00:18.923: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute FragmentManager{45e384a8 in null}}
01-07 19:00:18.923: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute null
01-07 19:00:18.923: V/MyFragmentActivity(4124): onFriendAddedAsyncTask/onPostExecute null
01-07 19:00:18.928: D/AndroidRuntime(4124): Shutting down VM
01-07 19:00:18.928: W/dalvikvm(4124): threadid=1: thread exiting with uncaught exception (group=0x4001d7d0)
01-07 19:00:18.938: E/AndroidRuntime(4124): FATAL EXCEPTION: main
01-07 19:00:18.938: E/AndroidRuntime(4124): java.lang.IllegalStateException: Activity has been destroyed
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1329)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:548)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.support.v4.app.BackStackRecord.commitAllowingStateLoss(BackStackRecord.java:536)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at com.xyz.dummy.MyFragmentActivity$onFriendAddedAsyncTask$2.run(MyFragmentActivity.java:476)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.os.Handler.handleCallback(Handler.java:587)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.os.Handler.dispatchMessage(Handler.java:92)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.os.Looper.loop(Looper.java:123)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at android.app.ActivityThread.main(ActivityThread.java:4627)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at java.lang.reflect.Method.invokeNative(Native Method)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at java.lang.reflect.Method.invoke(Method.java:521)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:858)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
01-07 19:00:18.938: E/AndroidRuntime(4124):     at dalvik.system.NativeStart.main(Native Method)

Dans onPreExecute() la FriendListFragment a l'id=0x7f0a0002. À l'intérieur du gestionnaire de la DummyFragment est créé avec id=0x7f0a0004. Dans onPostExecute() les deux Identifiants sont nulles.
Dans onPreExecute() l'adresse de MyFragmentActivity est 45e38358. mais dans onPostExecute() c'est la valeur null. Mais dans les deux méthodes les FragmentManager adresse est 45e384a8.
Je suppose que onPostExecute utilise une défaillance de FragmentManager. Mais pourquoi?

  • J'ai eu ce problème une fois résolu par le remplacement de la commettre avec cette: commitAllowingStateLoss(), pouvez-vous essayer cela?
  • J'ai déjà essayé, mais sans succès. Selon le LogCat le Fragment doit être dans le bon état.
  • Pouvez-vous s'il vous plaît poster votre code d'Activité?
  • Lorsque j'utilise commitAllowingStateLoss (), je reçois un autre exception (voir ci-dessus).
  • Est le DummyFragment mis à retenir c'est l'exemple? Avez-vous essayé de modifier le onPostExecute à des fins de recherche est la DummyFragment instance à l'aide de la "dummy_fragment" tag?
  • Je demandais juste au sujet de setRetainInstance, ne l'utilisez pas. Avez-vous essayé la dernière recommandation pour la onPostExecute()(ce: DummyFragment df = getSupportFragmentManager().findFragmentByTag("dummy_fragment");FragmentTransaction ft = getSupportFragmentManager().beginTransaction(); ft.remove(df); ft.commit();)?
  • J'ai essayé, mais sans succès.
  • Je suis juste en train de lire lien et lien. Mais il semble que c'est un problème différent.
  • Il est dangereux de s'engager FragmentTransactions à partir de l'intérieur de rappel asynchrone des méthodes telles que onPostExecute(). Voir la fin de cette blog pour une discussion des raisons pour lesquelles cela est vrai.
  • Pour être parfaitement honnête, montrant une boîte de dialogue au début d'une AsyncTask et de le rejeter quand il se termine n'est pas idéal pour l'expérience de l'utilisateur. Si possible, vous devriez éviter de le faire (il suffit de montrer une durée indéterminée dialogue spinner contenu sur l'écran de la vue est beaucoup moins janky).
  • Pour ceux d'entre vous qui sont toujours à la recherche d'une solution... voir cette blog à propos de ce sujet pour plus d'informations.
  • J'ai eu cette exception récemment: Mon cas est que je fais une requête HTTP vers le serveur dans la méthode onCreate de l'Activité principale. La demande va dans le doInBackground de l'AsyncTask. Le résultat de ceci est traitée dans runOnUiThread de l'activité, où je passe la réponse dans le bundle à un fragment que je montre dans une transaction. Chaque chose est bien, mais quand je de minimiser sur la première requête (réduire lorsque l'écran de démarrage de l'activité est sur le point de lancer cette activité principale), Quand je les optimiser, de cette exception. J'ai manipulé l'exception en affichant le message dans la boîte de dialogue à l'utilisateur d'essayer de nouveau.
  • double possible de l'obtention de "l'exception IllegalStateException: vous ne Pouvez pas effectuer cette action après onSaveInstanceState"

InformationsquelleAutor |
  1. 97

    Vous devriez faire la transaction dans un Handler comme suit:

    @Override
protected void onPostExecute(String result) {
Log.v("MyFragmentActivity", "onFriendAddedAsyncTask/onPostExecute");
new Handler().post(new Runnable() {
public void run() {
fm = getSupportFragmentManager();
ft = fm.beginTransaction();
ft.remove(dummyFragment);
ft.commit();
}
});
}
    • Il ne l'aide pas. Le comportement est le même comme avant.
    • veuillez avez-vous été en mesure de résoudre le problème? J'ai une situation très semblable link
    • Non, je suis toujours à la recherche d'une solution
    • La raison en est que vous coulez votre Activity parce que vous êtes en gardant une référence à la FragmentManager. Essayez mon edit au-dessus de laquelle doivent exiger la FragmentManager et assurez-vous de définir fm lorsque votre Activity est détruit.
    • Aussi avec le gestionnaire, il ne fonctionne pas. Je suppose que c'est parce que getSupportFragmentManager() retourne la vieille, mais pas de référence. Veuillez voir ci-dessus pour plus de détails.
    • Comment gardez-vous la référence up-to-date? Pensez-vous utiliser d'autres attacher/détacher méthodes pour mettre à jour la référence?
    • Considérer ce code: private static WeakReference<FragmentActivity> mActivity = null;
    • En un mot WeakReference vous empêche de fuite de l'activité... vous avez besoin d'appeler mActivity.get() à réellement obtenir de l'instance, et il sera nulle si l'activité a été détruit. Pour ce faire, vous aurez besoin d'écrire mActivity = new WeakReference<FragmentActivity>(this); - une bonne place est dans onCreate() - dont la mise à jour de la référence.
    • Pour ceux d'entre vous qui sont toujours à la recherche d'une solution... voir cette blog à propos de ce sujet pour plus d'informations.
    • Excelent Blog @AlexLockwood! Qui a résolu mon problème tout en éduquant moi :). Merci!
    • Merci homme, vous êtes un héros pour moi... rien n'a fonctionné que votre réponse. maintenir le bon travail
    • quelqu'un peut-il m'aider dans stackoverflow.com/questions/43617600/...
    • Grand. Il a résolu mon problème. Mais quelqu'un pourrait-il expliquer de quelle manière?
    • Je vous suggère de lire ceci pour comprendre l'Activité des états de mieux - androidclarified.wordpress.com/2018/06/13/...

    InformationsquelleAutor Oleg Vaskevich
  2. 53

    Grâce Oleg Vaskevich. À l'aide d'un WeakReference de la FragmentActivity résolu le problème. Mon code ressemble à ceci maintenant:

    public class MyFragmentActivity extends FragmentActivity implements OnFriendAddedListener {
private static WeakReference<MyFragmentActivity> wrActivity = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
wrActivity = new WeakReference<MyFragmentActivity>(this);
...
private class onFriendAddedAsyncTask extends AsyncTask<String, Void, String> {
@Override
protected void onPreExecute() {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = DummyFragment.newInstance();
ft.add(R.id.dummy_fragment_layout, dummyFragment);
ft.commit();
}
@Override
protected void onPostExecute(String result) {
final Activity activity = wrActivity.get();
if (activity != null && !activity.isFinishing()) {
FragmentManager fm = activity.getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = (DummyFragment) fm.findFragmentById(R.id.dummy_fragment_layout);
ft.remove(dummyFragment);
ft.commitAllowingStateLoss();
}
}
    • la référence faible idée est en effet très intelligent, cela permettrait à l'objet d'être facilement nettoyée si nécessaire. thumbs up samo!
    • Pourquoi statique est utilisé ici ? Que faire si j'utilise MyFragmentActivity mActivity = this ? Avec statique & WeakReference
    • Référence statique est assez mauvais génie, vous devriez plutôt une cravate de votre asynchtask pour le cycle de vie et l'annuler si nécessaire
    InformationsquelleAutor
  3. 36

    Je crois que la bonne réponse à cette question est la méthode suivante.

    public abstract int commitAllowingStateLoss ()

    Commit (), mais permet de s'engager à être exécuté après une activité
    l'état est enregistré. C'est dangereux parce que la validation ne peut être perdue si
    l'activité doit ensuite être restauré à partir de son état, ce qui devrait
    seulement être utilisé pour les cas où il est d'accord pour l'INTERFACE utilisateur de l'état de changer
    de façon inattendue sur l'utilisateur.

    La description ci-dessus se rapporte à cette méthode.

    protected void onSaveInstanceState(android.os.Bundle outState)

    Ce problème se produit précisément lorsque l'appareil passe en mode veille.

    http://developer.android.com/reference/android/app/FragmentTransaction.html

    InformationsquelleAutor
  4. 24

    Court Et Solution de travail :

    Suivez Les Étapes Simples :

    Étape 1 : Remplacer onSaveInstanceState de l'état dans le fragment. Et supprimer super méthode d'elle.

    @Override
public void onSaveInstanceState(Bundle outState) {
}

    Étape 2 : Utilisation CommitAllowingStateLoss(); au lieu de commit(); tout fragment opérations.

    fragmentTransaction.commitAllowingStateLoss();
    • Merci. Cela fonctionne pour moi, mais je sais que ce n'est pas la meilleure solution.
    • retrait de super méthode, également désactive l'enregistrement de votre fragment unis.
    • Merci beaucoup.c'était la génération d'une exception, cette solution a bien fonctionné..
    InformationsquelleAutor
  5. 10

    Vérifier si l'activité isFinishing() avant de montrer le fragment.

    Exemple:

    if(!isFinishing()) {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction ft = fm.beginTransaction();
DummyFragment dummyFragment = DummyFragment.newInstance();
ft.add(R.id.dummy_fragment_layout, dummyFragment);
ft.commitAllowingStateLoss();
}
    InformationsquelleAutor
  6. 5

    J'ai eu un problème similaire que j'ai fixée par le déplacement du fragment de code de transaction de onResume() en onStart().

    Pour être plus précis: Mon application est un lanceur. Après avoir appuyé sur l'Android à la Maison de bouton, l'utilisateur peut choisir un lanceur jusqu'à ce que sa décision est souvenu. Quand il va "revenir" à ce point-e. g. en tapant dans la zone grisâtre) l'application s'est écrasé.

    Peut-être que cela aide quelqu'un.

    InformationsquelleAutor
  7. 2

    Qui s'est passé pour moi, parce que j'étais en invoquant commit() de sous-fragment qui avait une fuite d'activité. Elle a gardé de l'activité en tant que propriété et sur une rotation de l'activité de la variable n'a pas été mis à jour par onAttach(); j'essayais Donc de valider une transaction sur zombie Activité par conservés (setRetainInstance(true);) fragment.

    InformationsquelleAutor
  8. 2

    La raison pour laquelle l'exception est la re-création de la FragmentActivity lors de l'exécution de la AsyncTask et l'accès à la précédente, détruit FragmentActivity dans onPostExecute() par la suite.

    Le problème est d'obtenir une référence valide pour la nouvelle FragmentActivity. Il n'existe pas de méthode pour cela ni getActivity() ni findById() ou quelque chose de similaire. Ce forum est plein de threads en fonction de cette question (par exemple, recherche pour "Activity context in onPostExecute"). Certains d'entre eux décrivent des solutions de contournement (jusqu'à maintenant, je n'ai pas trouvé une bonne).

    Il serait peut-être une meilleure solution pour utiliser un Service pour mon but.

    InformationsquelleAutor
  9. 2

    Il y a une autre solution (PAS la meilleure solution) pour ce problème, mais il fonctionne. À l'aide de drapeau que vous pouvez le manipuler, comme ci-dessous

    /**
* Flag to avoid "java.lang.IllegalStateException: Can not perform this action after
* onSaveInstanceState". Avoid Fragment transaction until onRestoreInstanceState or onResume
* gets called.
*/
private boolean isOnSaveInstanceStateCalled = false;
@Override
public void onRestoreInstanceState(final Bundle bundle) {
.....
isOnSaveInstanceStateCalled = false;
.....
}
@Override
public void onSaveInstanceState(final Bundle outState) {
.....
isOnSaveInstanceStateCalled = true;
.....
}
@Override
public void onResume() {
super.onResume();
isOnSaveInstanceStateCalled = false;
.....
}

    Et vous pouvez le vérifier boolean valeur tout en faisant fragment de transaction.

    private void fragmentReplace(Fragment fragment, String fragmentTag){
if (!isOnSaveInstanceStateCalled) {
getSupportFragmentManager()
.beginTransaction()
.replace(R.id.layout_container, fragment, fragmentTag)
.commit();
}
}
    InformationsquelleAutor
  10. 2

    Utilisation commitAllowingStateLoss() au lieu de commit().

    lorsque vous utilisez commit() il peut lever une exception si l'état de perte se produit mais commitAllowingStateLoss() enregistre la transaction de l'état sans perte ce qui ne veut pas lever une exception si l'état de la perte se produit.

    InformationsquelleAutor
  11. 1

    Pour ce que ça vaut la peine; j'ai eu cette erreur sur une application services en cours d'exécution en arrière-plan. Sur l'un d'eux d'un délai d'attente de dialogue à l'utilisateur. Ce dialogue a été la question de l'origine de l'erreur si l'application n'était plus en cours d'exécution en arrière-plan.

    Dans notre cas, montrant le dialogue n'était pas utile lorsque l'application est en arrière-plan, donc nous avons juste gardé la trace (boolean marqué onPause fr onResume) et ensuite seulement afficher la boîte de dialogue lorsque l'application est en fait visible pour l'utilisateur.

    InformationsquelleAutor
  12. 1

    Solution 1:
    remplacer onSaveInstanceState() et retirer le super appel à elle.

    @Override
public void onSaveInstanceState(Bundle outState) {
}

    Solution 2:
    remplacer onSaveInstanceState() et supprimer votre fragment avant le super appel

    @Override
public void onSaveInstanceState(Bundle outState) {
//TODO: Add code to remove fragment here
super.onSaveInstanceState(outState);
}
    InformationsquelleAutor
  13. 1

    Ce problème se produit lorsqu'un processus tente de manipuler une Activité dont la onStop() a été appelé. Ce n'est pas nécessairement lié au fragment de la transaction, mais également d'autres méthodes comme la onBackPressed().

    En plus de AsyncTask, une autre source de ce problème est l'égarement de bus modèle d'abonnement. Habituellement Événement Bus ou RxBus de l'abonnement est enregistré au cours de l'Activité onCreate et de inscrit dans onDestroy. Si un nouveau le début de l'Activité et publie un événement intercepté par les abonnés de l'Activité précédente, alors il peut produire cette erreur. Si cela arrive, alors la seule solution est de déplacer l'inscription d'abonnement et de l'enregistrement à onStart() et onStop().

    InformationsquelleAutor
  14. 0

    Mon application a un fragment de chargement dans les 3 secondes, mais lorsque le premier écran s'apprête à montrer, je presse le bouton de la maison et de reprendre l'exécuter, il montre la même erreur, donc Il modifier mon code et il s'est très lisse:

    new Handler().post(new Runnable() {
public void run() {
if (saveIns == null) {
mFragment = new Fragment_S1_loading();
getFragmentManager().beginTransaction()
.replace(R.id.container, mFragment).commit();
}
getActionBar().hide();
//Loading screen in 3 secs:
mCountDownTimerLoading = new CountDownTimer(3000, 1000) {
@Override
public void onTick(long millisUntilFinished) {
}
@Override
public void onFinish() {
if (saveIns == null) {//TODO bug when start app and press home
//button
getFragmentManager()
.beginTransaction()
.replace(R.id.container,
new Fragment_S2_sesstion1()).commitAllowingStateLoss();
}
getActionBar().show();
}
}.start();
}
});

    REMARQUE: ajouter commitAllowingStateLoss() au lieu de commit()

    InformationsquelleAutor
  15. 0

    À partir de l'appui de version de bibliothèque 24.0.0 vous pouvez appeler FragmentTransaction.commitNow() méthode qui commet cette opération de façon synchrone au lieu de l'appeler commit() suivie par executePendingTransactions()

    InformationsquelleAutor
  16. 0

    IllegalStateException est rencontré, si vous avez commis aucun fragment de transaction après l'activité a perdu de son Activité n'est pas au premier plan. C'est couramment rencontrés lorsque vous essayez de valider tout fragment dans AsyncTask ou après une demande du réseau.

    Pour éviter ce blocage, vous avez juste besoin de retarder tout fragment de la transaction jusqu'à l'état d'activité est rétabli. Voici comment il est fait

    Déclarer deux variables booléennes

    public class MainActivity extends AppCompatActivity {
//Boolean variable to mark if the transaction is safe
private boolean isTransactionSafe;
//Boolean variable to mark if there is any transaction pending
private boolean isTransactionPending;

    Maintenant dans onPostResume() et onPause nous avons mis et retirés de notre variable booléenne isTransactionSafe. L'idée est de marquer trasnsaction sûr que lorsque l'activité est en premier plan, alors il n'ya aucune chance de stateloss.

    /*
onPostResume is called only when the activity's state is completely restored. In this we will
set our boolean variable to true. Indicating that transaction is safe now
*/
public void onPostResume(){
super.onPostResume();
isTransactionSafe=true;
}
/*
onPause is called just before the activity moves to background and also before onSaveInstanceState. In this
we will mark the transaction as unsafe
*/
public void onPause(){
super.onPause();
isTransactionSafe=false;
}
private void commitFragment(){
if(isTransactionSafe) {
MyFragment myFragment = new MyFragment();
FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.add(R.id.frame, myFragment);
fragmentTransaction.commit();
}
}

    Ce que nous avons fait jusqu'à présent, permettra d'économiser de l'exception IllegalStateException mais nos transactions seront perdues si elles sont faites après l'activité se déplace à l'arrière-plan, un peu comme commitAllowStateloss(). Pour cela, nous avons isTransactionPending variable booléenne

    public void onPostResume(){
super.onPostResume();
isTransactionSafe=true;
/* Here after the activity is restored we check if there is any transaction pending from
the last restoration
*/
if (isTransactionPending) {
commitFragment();
}
}
private void commitFragment(){
if(isTransactionSafe) {
MyFragment myFragment = new MyFragment();
FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.add(R.id.frame, myFragment);
fragmentTransaction.commit();
isTransactionPending=false;
}else {
/*
If any transaction is not done because the activity is in background. We set the
isTransactionPending variable to true so that we can pick this up when we come back to
foreground
*/
isTransactionPending=true;
}
}

    Cet article explique en détail pourquoi cette exception est détectée et compare les différentes méthodes pour le résoudre . Hautement recommandé

    InformationsquelleAutor
  17. 0

    J'ai eu la même exception et j'ai essayé beaucoup de extrait que j'ai trouvé ici, sur ce stackoverflow discussion, mais pas de fragments de code a fonctionné pour moi.

    Mais j'ai été en mesure de résoudre tous les problèmes, je vais partager avec vous les solutions :

    • Dans une Première partie : j'ai essayé de montrer un DialogFragment sur une Activité, mais à partir d'une autre classe java. Puis par la vérification de l'attribut de l'instance, j'ai trouvé que c'était un vieux instance de l'Activité, il n'était pas en cours d'exécution de l'Activité.
      [Plus précisément, j'ai été à l'aide d'une douille.io, et j'ai oublié de faire une prise de courant.off("exemple",par exemple) ... donc il attaché à un vieil exemple de l'activité. ]

    • Dans une Seconde partie : j'ai essayé de montrer un DialogFragment dans une Activité, quand je reviens avec une intention, mais quand j'ai regardé mes logs, j'ai vu que quand il a essayé de montrer le fragment de l'activité n'était pas encore dans la méthode onStart, de sorte qu'il s'est écrasé l'application, car il n'a pas trouver la classe d'Activité pour afficher le fragment sur elle.

    Quelques conseils : vérifiez auprès de certains attributs si vous n'êtes pas en utilisant une ancienne version de votre activité avec lequel vous essayez de montrer votre fragment, ou de vérifier l'activité du cycle de vie, avant de montrer votre fragment et être sûr que vous êtes en démarrage ou onResume avant de le montrer.

    J'espère que ces explications vous aideront.

    InformationsquelleAutor