Activité et fragments de cycle de vie et changements d'orientation

J'ai eu très étrange problèmes avec Fragments et les changements d'orientation qui ont été à l'origine de la force de ferme et ne suit pas une logique.

J'ai créé un simple Activity et Fragment cycle de vie de l'application de débogage qui, tout simplement, met en œuvre à chaque étape de la L'activité du cycle de vie et Fragment du cycle de vie par la déclaration de l'appel à la logcat.

Voici les TestActivity et TestFragment classes:

TestActivity

public class TestActivity extends Activity {
    Context ct = null;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Log.e("ACT", "onCreate called");

        ct = getApplicationContext();

        FrameLayout fl = new FrameLayout(ct);
        fl.setId(1000);

        TestFragment tf = new TestFragment();
        getFragmentManager().beginTransaction().add(fl.getId(), tf, "").commit();

        setContentView(fl);
    }

    @Override
    protected void onStart() {
        Log.e("ACT", "onStart called");
        super.onStart();
    }

    @Override
    protected void onResume() {
        Log.e("ACT", "onResume called");
        super.onResume();
    }

    @Override
    protected void onPause() {
        Log.e("ACT", "onPause called");
        super.onPause();
    }

    @Override
    protected void onStop() {
        Log.e("ACT", "onStop called");
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        Log.e("ACT", "onDestroy called");
        super.onDestroy();
    }

    @Override
    protected void onRestart() {
        Log.e("ACT", "onRestart called");
        super.onRestart();
    }
}

TestFragment

public class TestFragment extends Fragment {
Context ctFrag = null;
@Override
public void onAttach(Activity activity) {
Log.e("FRAG", "onAttach called");
super.onAttach(activity);
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.e("FRAG", "onCreate called");
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
Log.e("FRAG", "onCreateView called");
ctFrag = ((TestActivity) getActivity()).ct;
TextView tv = new TextView(ctFrag);
tv.setText("My test TextView");
return tv;
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
Log.e("FRAG", "onActivityCreated called");
super.onActivityCreated(savedInstanceState);
}
@Override
public void onStart() {
Log.e("FRAG", "onStart called");
super.onStart();
}
@Override
public void onResume() {
Log.e("FRAG", "onResume called");
super.onResume();
}
@Override
public void onPause() {
Log.e("FRAG", "onPause called");
super.onPause();
}
@Override
public void onStop() {
Log.e("FRAG", "onStop called");
super.onStop();
}
@Override
public void onDestroyView() {
Log.e("FRAG", "onDestroyView called");
super.onDestroyView();
}
@Override
public void onDestroy() {
Log.e("FRAG", "onDestroy called");
super.onDestroy();
}
@Override
public void onDetach() {
Log.e("FRAG", "onDetach called");
super.onDetach();
}
}

Sur l'initialisation, le Logcat de sortie suit l'ordre attendu (démarrer Activitylorsque le Fragment est attaché, son cycle de vie appelle arrive, etc):

01-29 10:12:50.270: E/ACT(3321): onCreate called
01-29 10:12:50.760: E/FRAG(3321): onAttach called
01-29 10:12:50.760: E/FRAG(3321): onCreate called
01-29 10:12:50.760: E/FRAG(3321): onCreateView called
01-29 10:12:50.770: E/FRAG(3321): onActivityCreated called
01-29 10:12:50.770: E/ACT(3321): onStart called
01-29 10:12:50.770: E/FRAG(3321): onStart called
01-29 10:12:50.770: E/ACT(3321): onResume called
01-29 10:12:50.770: E/FRAG(3321): onResume called

Mais la question est, quand un changement d'orientation se produit, le Android Documentation dit que:

Quand un tel changement se produit, Android redémarrage de l'Activité en cours (onDestroy() est appelée, suivie par onCreate())

Qui suggèrent qu'il devrait arrêter le Activity et de son contenu, comme le cycle de vie suggère (et il le fait), MAIS ensuite, passer par le même processus ordonné de recréer la Activity dans la nouvelle orientation. Cette n'est pas arriver et il semble que la Fragment est tenté d'être recréé et puis un nouveau est créé dans l'activité de loisirs.

01-29 10:17:52.249: E/FRAG(3321): onPause called
01-29 10:17:52.259: E/ACT(3321): onPause called
01-29 10:17:52.269: E/FRAG(3321): onStop called
01-29 10:17:52.269: E/ACT(3321): onStop called
01-29 10:17:52.279: E/FRAG(3321): onDestroyView called
01-29 10:17:52.299: E/FRAG(3321): onDestroy called
01-29 10:17:52.299: E/FRAG(3321): onDetach called
01-29 10:17:52.299: E/ACT(3321): onDestroy called
01-29 10:17:52.650: E/FRAG(3321): onAttach called
01-29 10:17:52.650: E/FRAG(3321): onCreate called
01-29 10:17:52.650: E/ACT(3321): onCreate called
01-29 10:17:53.020: E/FRAG(3321): onCreateView called
01-29 10:17:53.020: E/FRAG(3321): onActivityCreated called
01-29 10:17:53.030: E/FRAG(3321): onAttach called
01-29 10:17:53.030: E/FRAG(3321): onCreate called
01-29 10:17:53.030: E/FRAG(3321): onCreateView called
01-29 10:17:53.030: E/FRAG(3321): onActivityCreated called
01-29 10:17:53.060: E/ACT(3321): onStart called
01-29 10:17:53.060: E/FRAG(3321): onStart called
01-29 10:17:53.060: E/FRAG(3321): onStart called
01-29 10:17:53.060: E/ACT(3321): onResume called
01-29 10:17:53.060: E/FRAG(3321): onResume called
01-29 10:17:53.060: E/FRAG(3321): onResume called

Évidemment, il ya beaucoup de solutions pour résoudre ce problème, mais ma question est pourquoi est-ce possible? Pourquoi un Fragment référence maintenu et recréé quand il est censé faire partie de la Activity qui est censé être complètement détruits et recréés? Je peux justifier que par Fragments intentionnellement étant distincte des activités. Mais ce qui causait les problèmes, est pourquoi est à l'origine Fragment attaché et recréé avant la Activity est? Il ne semble tout simplement pas à suivre la logique du cycle de vie que le reste de l'Android de processus.

source d'informationauteur B T

10

Cela se produit parce que l'activité des appels onSaveInstanceState(Bundle) avant d'être détruit. Par défaut, l'activité est de sauver les états de ses fragments dans cette méthode.

Plus tard, lorsque l'activité est re-créé, le vieux fragments sont recréés dans l'activité onCreate(Bundle savedInstanceState) méthode.

Vous pourriez vouloir vérifier le code source ici et ici pour mieux comprendre ce comportement.
1

C'est parce que vous ajoutez le fragment de nouveau et de nouveau en activité est recréée. Vous pouvez utiliser le code ci-dessous dans l'activité de la méthode onCreate pour éviter de loisirs de fragment:
```
if(savedInstanceState == null) 
{
mFragmentManager = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = mFragmentManager.beginTransaction();
FragmentOne fragment = new FragmentOne();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();
}
```
Lorsqu'une config changement se produit, l'ancien Fragment n'est pas détruit -- il ajoute lui-même de retour à l'Activité quand il est recréé.

Vous devez vous connecter pour publier un commentaire.